Attachment #69049 for issue #111066

View | Details | Raw Unified | Return to issue 111066
Collapse All | Expand All

Lines 192-199 Link Here

(-)a/binfilter/bf_sc/source/ui/unoobj/sc_defltuno.cxx (-2 / +2 lines)
192	if ( aValue >>= aLocale )	192	if ( aValue >>= aLocale )
193	{	193	{
194	LanguageType eNew;	194	LanguageType eNew;
195	if (aLocale.Language.getLength() \|\| aLocale.Country.getLength())	195	if (aLocale.Language.getLength() \|\| aLocale.Country.getLength() \|\| aLocale.Variant.getLength())
196	eNew = MsLangId::convertIsoNamesToLanguage( aLocale.Language, aLocale.Country );	196	eNew = MsLangId::convertIsoNamesToLanguage( aLocale.Language, aLocale.Country, aLocale.Variant );
197	else	197	else
198	eNew = LANGUAGE_NONE;	198	eNew = LANGUAGE_NONE;
199		199

Lines 1878-1885 Link Here

(-)a/binfilter/bf_svx/source/items/svx_textitem.cxx (-2 / +2 lines)
1878	/N/ if(!(rVal >>= aLocale))	1878	/N/ if(!(rVal >>= aLocale))
1879	/N/ return sal_False;	1879	/N/ return sal_False;
1880	/N/	1880	/N/
1881	/N/ if (aLocale.Language.getLength() \|\| aLocale.Country.getLength())	1881	/N/ if (aLocale.Language.getLength() \|\| aLocale.Country.getLength() \|\| aLocale.Variant.getLength())
1882	/N/ SetValue(MsLangId::convertIsoNamesToLanguage( aLocale.Language, aLocale.Country ));	1882	/N/ SetValue(MsLangId::convertIsoNamesToLanguage( aLocale.Language, aLocale.Country, aLocale.Variant ));
1883	/N/ else	1883	/N/ else
1884	/N/ SetValue(LANGUAGE_NONE);	1884	/N/ SetValue(LANGUAGE_NONE);
1885	/N/ }	1885	/N/ }




{
	if ( nLang != LANGUAGE_SYSTEM )
	{
		OUString aLanguageTag, aRegionTag, aOtherTags;
		MsLangId::convertLanguageToIsoNames( (LanguageType)nLang, aLanguageTag, aRegionTag, aOtherTags );

		if (aLanguageTag.getLength())
		{
			rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_LANGUAGE, aLanguageTag );
		}
		if (aRegionTag.getLength())
		{
			rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_COUNTRY, aRegionTag );
		}
		if (aOtherTags.getLength())
		{
			rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_LANGUAGE_TAGS, aOtherTags );
		}
	}
}

//	pLocaleData->setLocale( rLocale );
//	String sCurString = pLocaleData->getCurrSymbol();

	LanguageType nLang = MsLangId::convertIsoNamesToLanguage( rLocale.Language, rLocale.Country, rLocale.Variant );
	pFormatter->ChangeIntl( nLang );
	String sCurString, sDummy;
	pFormatter->GetCompatibilityCurrency( sCurString, sDummy );




	XML_TOK_STYLE_ATTR_NAME,
	XML_TOK_STYLE_ATTR_LANGUAGE,
	XML_TOK_STYLE_ATTR_COUNTRY,
	XML_TOK_STYLE_ATTR_LANGUAGE_TAGS,
	XML_TOK_STYLE_ATTR_TITLE,
	XML_TOK_STYLE_ATTR_AUTOMATIC_ORDER,
	XML_TOK_STYLE_ATTR_FORMAT_SOURCE,

	XML_TOK_ELEM_ATTR_MIN_DENOMINATOR_DIGITS,
	XML_TOK_ELEM_ATTR_LANGUAGE,
	XML_TOK_ELEM_ATTR_COUNTRY,
	XML_TOK_ELEM_ATTR_LANGUAGE_TAGS,
	XML_TOK_ELEM_ATTR_STYLE,
	XML_TOK_ELEM_ATTR_TEXTUAL,
	XML_TOK_ELEM_ATTR_CALENDAR

	{ XML_NAMESPACE_STYLE,  XML_NAME,			 	   XML_TOK_STYLE_ATTR_NAME					},
	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE,		 	   XML_TOK_STYLE_ATTR_LANGUAGE				},
	{ XML_NAMESPACE_NUMBER, XML_COUNTRY,		 	   XML_TOK_STYLE_ATTR_COUNTRY				},
	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE_TAGS,	 	   XML_TOK_STYLE_ATTR_LANGUAGE_TAGS			},
	{ XML_NAMESPACE_NUMBER, XML_TITLE,			 	   XML_TOK_STYLE_ATTR_TITLE					},
	{ XML_NAMESPACE_NUMBER, XML_AUTOMATIC_ORDER, 	   XML_TOK_STYLE_ATTR_AUTOMATIC_ORDER		},
	{ XML_NAMESPACE_NUMBER, XML_FORMAT_SOURCE, 	       XML_TOK_STYLE_ATTR_FORMAT_SOURCE			},

	{ XML_NAMESPACE_NUMBER, XML_MIN_DENOMINATOR_DIGITS,  XML_TOK_ELEM_ATTR_MIN_DENOMINATOR_DIGITS },
	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE,			 	 XML_TOK_ELEM_ATTR_LANGUAGE				},
	{ XML_NAMESPACE_NUMBER, XML_COUNTRY,			 	 XML_TOK_ELEM_ATTR_COUNTRY				},
	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE_TAGS,		 	 XML_TOK_ELEM_ATTR_LANGUAGE_TAGS		},
	{ XML_NAMESPACE_NUMBER, XML_STYLE,				 	 XML_TOK_ELEM_ATTR_STYLE				},
	{ XML_NAMESPACE_NUMBER, XML_TEXTUAL,			 	 XML_TOK_ELEM_ATTR_TEXTUAL				},
	{ XML_NAMESPACE_NUMBER, XML_CALENDAR,			 	 XML_TOK_ELEM_ATTR_CALENDAR				},

	bLong( FALSE ),
	bTextual( FALSE )
{
	OUString sLanguageTag, sRegionTag, sOtherTags;
	sal_Int32 nAttrVal;
	sal_Bool bAttrBool;
	sal_uInt16 nAttrEnum;

					aNumInfo.nDenomDigits = nAttrVal;
				break;
			case XML_TOK_ELEM_ATTR_LANGUAGE:
				sLanguageTag = sValue;
				break;
			case XML_TOK_ELEM_ATTR_COUNTRY:
				sRegionTag = sValue;
				break;
			case XML_TOK_ELEM_ATTR_LANGUAGE_TAGS:
				sOtherTags = sValue;
				break;
			case XML_TOK_ELEM_ATTR_STYLE:
				if ( SvXMLUnitConverter::convertEnum( nAttrEnum, sValue, aStyleValueMap ) )

		}
	}

	if ( sLanguageTag.getLength() || sRegionTag.getLength() || sOtherTags.getLength() )
	{
		nElementLang = MsLangId::convertIsoNamesToLanguage( sLanguageTag, sRegionTag, sOtherTags );
		if ( nElementLang == LANGUAGE_DONTKNOW )
			nElementLang = LANGUAGE_SYSTEM;			//! error handling for invalid locales?
	}

	eDateSecs( XML_DEA_NONE ),
	bDateNoDefault( sal_False )
{
	OUString sLanguageTag, sRegionTag, sOtherTags;
    ::com::sun::star::i18n::NativeNumberXmlAttributes aNatNumAttr;
	sal_Bool bAttrBool;
	sal_uInt16 nAttrEnum;

//				aName = sValue;
				break;
			case XML_TOK_STYLE_ATTR_LANGUAGE:
				sLanguageTag = sValue;
				break;
			case XML_TOK_STYLE_ATTR_COUNTRY:
				sRegionTag = sValue;
				break;
			case XML_TOK_STYLE_ATTR_LANGUAGE_TAGS:
				sOtherTags = sValue;
				break;
			case XML_TOK_STYLE_ATTR_TITLE:
				sFormatTitle = sValue;

		}
	}

	if ( sLanguageTag.getLength() || sRegionTag.getLength() || sOtherTags.getLength() )
	{
		nFormatLang = MsLangId::convertIsoNamesToLanguage( sLanguageTag, sRegionTag, sOtherTags );
		if ( nFormatLang == LANGUAGE_DONTKNOW )
			nFormatLang = LANGUAGE_SYSTEM;			//! error handling for invalid locales?
	}

            aFormatCode.appendAscii( RTL_CONSTASCII_STRINGPARAM( "[NatNum" ) );
            aFormatCode.append( nNatNum, 10 );

            LanguageType eLang = MsLangId::convertIsoNamesToLanguage( 
                aNatNumAttr.Locale.Language, aNatNumAttr.Locale.Country, aNatNumAttr.Locale.Variant );
            if ( eLang == LANGUAGE_DONTKNOW )
                eLang = LANGUAGE_SYSTEM;            //! error handling for invalid locales?
            if ( eLang != nFormatLang && eLang != LANGUAGE_SYSTEM )

Lines 998-1003 Link Here

(-)a/binfilter/inc/bf_xmloff/xmltoken.hxx (+3 lines)
998	XML_LANGUAGE,	998	XML_LANGUAGE,
999	XML_LANGUAGE_ASIAN,	999	XML_LANGUAGE_ASIAN,
1000	XML_LANGUAGE_COMPLEX,	1000	XML_LANGUAGE_COMPLEX,
		1001	XML_LANGUAGE_TAGS,
		1002	XML_LANGUAGE_TAGS_ASIAN,
		1003	XML_LANGUAGE_TAGS_COMPLEX,
1001	XML_LASER,	1004	XML_LASER,
1002	XML_LAST_COLUMN_SPANNED,	1005	XML_LAST_COLUMN_SPANNED,
1003	XML_LAST_PAGE,	1006	XML_LAST_PAGE,





    public:
    
        /** @short seperates LANGUAGE and COUNTRY part of an ISO formated Locale. */
        static const sal_Unicode SEPERATOR_LC;
        
        /** @short seperates COUNTRY and VARIANT part of an ISO formated Locale. */
        static const sal_Unicode SEPERATOR_CV;
        
        /** @short seperates COUNTRY and VARIANT part of an ISO formated Locale.
            @descr Its true for some linux derivates only :-( */
        static const sal_Unicode SEPERATOR_CV_LINUX;
        
        /** @short some predefined Locale objects. */
        static const Locale EN_US();
        static const Locale EN();
        static const Locale DE_DE();
        static const Locale DE_CH();
        static const Locale DE_AT();
        static const Locale AR();
        static const Locale CA();
        static const Locale CS();
        static const Locale DA();
        static const Locale EL();
        static const Locale ES();
        static const Locale FI();
        static const Locale FR();
        static const Locale HE();
        static const Locale HI_IN();
        static const Locale HU();
        static const Locale IT();
        static const Locale JA();
        static const Locale KO();
        static const Locale NL();
        static const Locale PL();
        static const Locale PT();
        static const Locale PT_BR();
        static const Locale RU();
        static const Locale SK();
        static const Locale SL();
        static const Locale SV();
        static const Locale TH();
        static const Locale TR();
        static const Locale X_DEFAULT();
        static const Locale X_COMMENT();
        static const Locale X_TRANSLATE();
        static const Locale X_NOTRANSLATE();
        static const Locale ZH_CN();
        static const Locale ZH_TW();
                            
    //-------------------------------------------
    // types

            throw(MalFormedLocaleException);
            
        //---------------------------------------
        /** @short      search for the next possible fallback locale.
        
            @descr      Instead of getFallback(vector<>, string) this method
                        uses the given locale and decide by using an algorithm
                        which locale can be the next possible one.
                        
                        Algorithm:
                        - if locale has country return language only
                        - if locale different "en-US" return "en-US"
                        - if locale "en-US" return "en"
                        
            @param      aLocale [in/out]!
                        the incoming value will be used to start
                        search for a possible fallback ...
                        and in case such fallback was found this parameter
                        will be used for return too.

            @return     TRUE if the parameter aLocale contains a new fallback value;
                        FALSE otherwise.                        
         */
        static sal_Bool getFallback(Locale& aLocale);            

        //---------------------------------------
        /** @short      assign elements of another locale
                        to this instance.
                        




namespace comphelper{

//-----------------------------------------------
/** seperates LANGUAGE and COUNTRY part of an ISO formated Locale. */
const sal_Unicode SEPERATOR_LC       = (sal_Unicode)'-';
/** seperates COUNTRY and VARIANT part of an ISO formated Locale. */
const sal_Unicode SEPERATOR_CV       = (sal_Unicode)'_';
/** seperates COUNTRY and VARIANT part of an ISO formated Locale.
 *  It's true for some linux derivates only :-( */
const sal_Unicode SEPERATOR_CV_LINUX = (sal_Unicode)'.';

//-----------------------------------------------
const Locale Locale::X_DEFAULT()

}

//-----------------------------------------------
const Locale Locale::EN()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("en"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::EN_US()
{
    static Locale aLocale(

}

//-----------------------------------------------
const Locale Locale::DE_DE()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("de"),
                    ::rtl::OUString::createFromAscii("DE"));
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::DE_CH()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("de"),
                    ::rtl::OUString::createFromAscii("CH"));
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::DE_AT()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("de"),
                    ::rtl::OUString::createFromAscii("AT"));
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::AR()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("ar"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::CA()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("ca"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::CS()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("cs"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::DA()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("da"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::EL()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("el"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::ES()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("es"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::FI()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("fi"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::FR()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("fr"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::HE()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("he"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::HI_IN()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("hi"),
                    ::rtl::OUString::createFromAscii("IN"));
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::HU()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("hu"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::IT()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("it"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::JA()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("ja"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::KO()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("ko"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::NL()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("nl"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::PL()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("pl"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::PT()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("pt"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::PT_BR()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("pt"),
                    ::rtl::OUString::createFromAscii("BR"));
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::RU()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("ru"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::SK()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("sk"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::SL()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("sl"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::SV()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("sv"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::TH()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("th"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::TR()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("tr"),
                    ::rtl::OUString());
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::X_COMMENT()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("x"),
                    ::rtl::OUString::createFromAscii("comment"));
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::X_TRANSLATE()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("x"),
                    ::rtl::OUString::createFromAscii("translate"));
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::X_NOTRANSLATE()
{
    static Locale aLocale(

}

//-----------------------------------------------
const Locale Locale::ZH_CN()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("zh"),
                    ::rtl::OUString::createFromAscii("CN"));
    return aLocale;                    
}

//-----------------------------------------------
const Locale Locale::ZH_TW()
{
    static Locale aLocale(
                    ::rtl::OUString::createFromAscii("zh"),
                    ::rtl::OUString::createFromAscii("TW"));
    return aLocale;                    
}

//-----------------------------------------------
Locale::Locale(const ::rtl::OUString& sISO)
    throw(Locale::MalFormedLocaleException)
{

}

//-----------------------------------------------
sal_Bool Locale::getFallback(Locale& aLocale)
{
    // a)
    // this was our last fallback!
    // break any further calls to this method ...
    if (aLocale.equals(X_NOTRANSLATE()))
        return sal_False;

    // b)
    // switch from X_DEFAULT to X_NOTRANSLATE
    // next time we will go to a)
    if (aLocale.equals(X_DEFAULT()))
    {
        aLocale = X_NOTRANSLATE();
        return sal_True;
    }

    // c)
    // switch from EN to X_DEFAULT
    // next time we will go to b)
    if (aLocale.equals(EN()))
    {
        aLocale = X_DEFAULT();
        return sal_True;
    }

    // d) remove country from incoming locale
    //    e.g. "de-DE" => "de" or "en-US" => "en"!
    if (aLocale.getCountry().getLength())
    {
        aLocale.setCountry(::rtl::OUString());
        return sal_True;
    }
    
    // e) "en-US" possible?
    if (!aLocale.equals(EN_US()))
    {
        aLocale = EN_US();
        return sal_True;
    }

    // f) no more fallbacks    
    return sal_False;
}            

//-----------------------------------------------
void  Locale::operator=(const Locale& rCopy)
{
    // Take over these values without checking ...

Lines 1-3 Link Here

(-)a/configmgr/prj/build.lst (-1 / +1 lines)
1	cg configmgr : BOOST:boost comphelper cppu cppuhelper offuh sal salhelper stlport NULL	1	cg configmgr : BOOST:boost comphelper cppu cppuhelper i18npool offuh sal salhelper stlport NULL
2	cg configmgr\inc nmake - all cg_inc NULL	2	cg configmgr\inc nmake - all cg_inc NULL
3	cg configmgr\source nmake - all cg_source cg_inc NULL	3	cg configmgr\source nmake - all cg_source cg_inc NULL




#! /bin/sh
# From configure.in Revision: 1.290  .
# Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.65.
#
#
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
# Inc.
#
#
# This configure script is free software; the Free Software Foundation
# gives unlimited permission to copy, distribute and modify it.
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##

# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi


as_nl='
'
export as_nl
# Printing a long string crashes Solaris 7 /usr/bin/printf.
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
# Prefer a ksh shell builtin over an external printf program on Solaris,
# but without wasting forks for bash or zsh.
if test -z "$BASH_VERSION$ZSH_VERSION" \
    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='print -r --'
  as_echo_n='print -rn --'
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='printf %s\n'
  as_echo_n='printf %s'
else
  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
    as_echo_n='/usr/ucb/echo -n'
  else
    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
    as_echo_n_body='eval
      arg=$1;
      case $arg in #(
      *"$as_nl"*)
	expr "X$arg" : "X\\(.*\\)$as_nl";
	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
      esac;
      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
    '
    export as_echo_n_body
    as_echo_n='sh -c $as_echo_n_body as_echo'
  fi
  export as_echo_body
  as_echo='sh -c $as_echo_body as_echo'
fi

# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
  PATH_SEPARATOR=:
  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
      PATH_SEPARATOR=';'
  }
fi


# IFS
# We need space, tab and new line, in precisely that order.  Quoting is
# there to prevent editors from complaining about space-tab.
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
# splitting by setting IFS to empty value.)
IFS=" ""	$as_nl"

# Find who we are.  Look in the path if we contain no directory separator.
case $0 in #((
  *[\\/]* ) as_myself=$0 ;;
  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
  done
IFS=$as_save_IFS

     ;;
esac
# We did not find ourselves, most probably we were run as `sh COMMAND'
# in which case we are not to be found in the path.
if test "x$as_myself" = x; then
  as_myself=$0
fi
if test ! -f "$as_myself"; then
  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
  exit 1
fi

# Unset variables that we do not need and which cause bugs (e.g. in
# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
# suppresses any "Segmentation fault" message there.  '((' could
# trigger a bug in pdksh 5.2.14.
for as_var in BASH_ENV ENV MAIL MAILPATH
do eval test x\${$as_var+set} = xset \
  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
PS1='$ '
PS2='> '
PS4='+ '

# NLS nuisances.
LC_ALL=C
export LC_ALL
LANGUAGE=C
export LANGUAGE

# CDPATH.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

if test "x$CONFIG_SHELL" = x; then
  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '\${1+\"\$@\"}'='\"\$@\"'
  setopt NO_GLOB_SUBST
else
  case \`(set -o) 2>/dev/null\` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi
"
  as_required="as_fn_return () { (exit \$1); }
as_fn_success () { as_fn_return 0; }
as_fn_failure () { as_fn_return 1; }
as_fn_ret_success () { return 0; }
as_fn_ret_failure () { return 1; }

exitcode=0
as_fn_success || { exitcode=1; echo as_fn_success failed.; }
as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :

else
  exitcode=1; echo positional parameters were not saved.
fi
test x\$exitcode = x0 || exit 1"
  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
test \$(( 1 + 1 )) = 2 || exit 1"
  if (eval "$as_required") 2>/dev/null; then :
  as_have_required=yes
else
  as_have_required=no
fi
  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :

else
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
as_found=false
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  as_found=:
  case $as_dir in #(
	 /*)
	   for as_base in sh bash ksh sh5; do
	     # Try only shells that exist, to save several forks.
	     as_shell=$as_dir/$as_base
	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
  CONFIG_SHELL=$as_shell as_have_required=yes
		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
  break 2
fi
fi
	   done;;
       esac
  as_found=false
done
$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
  CONFIG_SHELL=$SHELL as_have_required=yes
fi; }
IFS=$as_save_IFS


      if test "x$CONFIG_SHELL" != x; then :
  # We cannot yet assume a decent shell, so we have to provide a
	# neutralization value for shells without unset; and this also
	# works around shells that cannot unset nonexistent variables.
	BASH_ENV=/dev/null
	ENV=/dev/null
	(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
	export CONFIG_SHELL
	exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
fi

    if test x$as_have_required = xno; then :
  $as_echo "$0: This script requires a shell more modern than all"
  $as_echo "$0: the shells that I found on your system."
  if test x${ZSH_VERSION+set} = xset ; then
    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
  else
    $as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
$0: including any error possibly output before this
$0: message. Then install a modern shell, or manually run
$0: the script under such a shell if you do have one."
  fi
  exit 1
fi
fi
fi
SHELL=${CONFIG_SHELL-/bin/sh}
export SHELL
# Unset more variables known to interfere with behavior of common tools.
CLICOLOR_FORCE= GREP_OPTIONS=
unset CLICOLOR_FORCE GREP_OPTIONS

## --------------------- ##
## M4sh Shell Functions. ##
## --------------------- ##
# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
  { eval $1=; unset $1;}
}
as_unset=as_fn_unset

# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
  return $1
} # as_fn_set_status

# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
  set +e
  as_fn_set_status $1
  exit $1
} # as_fn_exit

# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{

  case $as_dir in #(
  -*) as_dir=./$as_dir;;
  esac
  test -d "$as_dir" || eval $as_mkdir_p || {
    as_dirs=
    while :; do
      case $as_dir in #(
      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
      *) as_qdir=$as_dir;;
      esac
      as_dirs="'$as_qdir' $as_dirs"
      as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_dir" : 'X\(//\)[^/]' \| \
	 X"$as_dir" : 'X\(//\)$' \| \
	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
      test -d "$as_dir" && break
    done
    test -z "$as_dirs" || eval "mkdir $as_dirs"
  } || test -d "$as_dir" || as_fn_error "cannot create directory $as_dir"


} # as_fn_mkdir_p
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
  eval 'as_fn_append ()
  {
    eval $1+=\$2
  }'
else
  as_fn_append ()
  {
    eval $1=\$$1\$2
  }
fi # as_fn_append

# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
  eval 'as_fn_arith ()
  {
    as_val=$(( $* ))
  }'
else
  as_fn_arith ()
  {
    as_val=`expr "$@" || test $? -eq 1`
  }
fi # as_fn_arith


# as_fn_error ERROR [LINENO LOG_FD]
# ---------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with status $?, using 1 if that was 0.
as_fn_error ()
{
  as_status=$?; test $as_status -eq 0 && as_status=1
  if test "$3"; then
    as_lineno=${as_lineno-"$2"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    $as_echo "$as_me:${as_lineno-$LINENO}: error: $1" >&$3
  fi
  $as_echo "$as_me: error: $1" >&2
  as_fn_exit $as_status
} # as_fn_error

if expr a : '\(a\)' >/dev/null 2>&1 &&
   test "X`expr 00001 : '.*\(...\)'`" = X001; then
  as_expr=expr
else
  as_expr=false
fi

if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
  as_basename=basename
else
  as_basename=false
fi

if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
  as_dirname=dirname
else
  as_dirname=false
fi

as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
	 X"$0" : 'X\(//\)$' \| \
	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X/"$0" |
    sed '/^.*\/\([^/][^/]*\)\/*$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`

# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'

as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits


  as_lineno_1=$LINENO as_lineno_1a=$LINENO
  as_lineno_2=$LINENO as_lineno_2a=$LINENO
  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
  sed -n '
    p
    /[$]LINENO/=
  ' <$as_myself |
  rm -f conf$$.sh
fi


  as_lineno_1=$LINENO
  as_lineno_2=$LINENO
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
  test "x$as_lineno_1" != "x$as_lineno_2" &&
  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
  # Find who we are.  Look in the path if we contain no path at all
  # relative or not.
  case $0 in
    *[\\/]* ) as_myself=$0 ;;
    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
done

       ;;
  esac
  # We did not find ourselves, most probably we were run as `sh COMMAND'
  # in which case we are not to be found in the path.
  if test "x$as_myself" = x; then
    as_myself=$0
  fi
  if test ! -f "$as_myself"; then
    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
   { (exit 1); exit 1; }; }
  fi
  case $CONFIG_SHELL in
  '')
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  for as_base in sh bash ksh sh5; do
	 case $as_dir in
	 /*)
	   if ("$as_dir/$as_base" -c '
  as_lineno_1=$LINENO
  as_lineno_2=$LINENO
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
  test "x$as_lineno_1" != "x$as_lineno_2" &&
  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
	     $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
	     $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
	     CONFIG_SHELL=$as_dir/$as_base
	     export CONFIG_SHELL
	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}
	   fi;;
	 esac
       done
done
;;
  esac

  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
  # uniformly replaced by the line number.  The first 'sed' inserts a
  # line-number line before each line; the second 'sed' does the real
  # work.  The second script uses 'N' to pair each line-number line
  # with the numbered line, and appends trailing '-' during
  # substitution so that $LINENO is not a special case at line end.
  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
  sed '=' <$as_myself |
    sed '
      s/[$]LINENO.*/&-/
      t lineno
      b
      :lineno
      N
      :loop
      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
      t loop
      s/-\n.*//
      s,^['$as_cr_digits']*\n,,
    ' >$as_me.lineno &&
  chmod +x "$as_me.lineno" ||
    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
   { (exit 1); exit 1; }; }

  # Don't try to exec as it changes $[0], causing all sort of problems
  # (the dirname of $[0] is not the place where we might find the
  # original and so on.  Autoconf is especially sensitive to this).
  . "./$as_me.lineno"
  # Exit status is that of the last command.
  exit
}

ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in #(((((
-n*)
  case `echo 'xy\c'` in
  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
  xy)  ECHO_C='\c';;
  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
       ECHO_T='	';;
  esac;;
*)
  ECHO_N='-n';;
esac
fi

rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
  rm -f conf$$.dir/conf$$.file
else
  rm -f conf$$.dir
  mkdir conf$$.dir 2>/dev/null
fi
if (echo >conf$$.file) 2>/dev/null; then
  if ln -s conf$$.file conf$$ 2>/dev/null; then
    as_ln_s='ln -s'
    # ... but there are two gotchas:
    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
    # In both cases, we have to default to `cp -p'.
    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
      as_ln_s='cp -p'
  elif ln conf$$.file conf$$ 2>/dev/null; then
    as_ln_s=ln
  else
    as_ln_s='cp -p'
  fi
    as_ln_s='ln -s'
  fi
elif ln conf$$.file conf$$ 2>/dev/null; then
  as_ln_s=ln
else
  as_ln_s='cp -p'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null

if mkdir -p . 2>/dev/null; then
  as_mkdir_p='mkdir -p "$as_dir"'
else
  test -d ./-p && rmdir ./-p
  as_mkdir_p=false
fi

if test -x / >/dev/null 2>&1; then
  as_test_x='test -x'
else
  if ls -dL / >/dev/null 2>&1; then
    as_ls_L_option=L
  else
    as_ls_L_option=
  fi
  as_test_x='
    eval sh -c '\''
      if test -d "$1"; then
	test -d "$1/.";
      else
	case $1 in #(
	-*)set "./$1";;
	esac;
	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
	???[sx]*):;;*)false;;esac;fi
    '\'' sh
  '
fi
as_executable_p=$as_test_x

# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"


test -n "$DJDIR" || exec 7<&0 </dev/null
exec 6>&1
as_nl='
'
IFS=" 	$as_nl"

# CDPATH.
$as_unset CDPATH


# Name of the host.
# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
# so uname gets run too.
ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`

exec 6>&1

#
# Initializations.
#
ac_default_prefix=/usr/local
ac_clean_files=
ac_config_libobj_dir=.
LIBOBJS=
cross_compiling=no
subdirs=
MFLAGS=
MAKEFLAGS=
SHELL=${CONFIG_SHELL-/bin/sh}

# Maximum number of lines to put in a shell here document.
# This variable seems obsolete.  It should probably be removed, and
# only ac_max_sed_lines should be used.
: ${ac_max_here_lines=38}

# Identity of this package.
PACKAGE_NAME=

PACKAGE_VERSION=
PACKAGE_STRING=
PACKAGE_BUGREPORT=
PACKAGE_URL=

# Factoring default headers for most tests.
ac_includes_default="\
#include <stdio.h>
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#ifdef HAVE_SYS_STAT_H
# include <sys/stat.h>
#endif
#ifdef STDC_HEADERS
# include <stdlib.h>
# include <stddef.h>
#else
# ifdef HAVE_STDLIB_H
#  include <stdlib.h>
# endif
#endif
#ifdef HAVE_STRING_H
# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
#  include <memory.h>
# endif
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#ifdef HAVE_INTTYPES_H
# include <inttypes.h>
#endif
#ifdef HAVE_STDINT_H
# include <stdint.h>
#endif
#ifdef HAVE_UNISTD_H
#if HAVE_UNISTD_H
# include <unistd.h>
#endif"

ac_subst_vars='LTLIBOBJS
LIBOBJS
BUILD_TYPE
LOCAL_SOLVER
VERBOSE
ENABLE_LAYOUT
ENABLE_STATIC_GTK
UNIXWRAPPERNAME
OOO_VENDOR
ABOUT_BITMAPS
INTRO_BITMAPS
WITH_DICT
WITH_POOR_HELP_LOCALIZATIONS
WITH_LANG
ANT_LIB
ANT_HOME
ANT
XINERAMA_LINK
USE_XINERAMA
SCPDEFS
WITHOUT_AFMS
WITHOUT_PPDS
WITH_FONTS
ENABLE_KAB
ENABLE_EVOAB2
GOBJECT_LIBS
GOBJECT_CFLAGS
ENABLE_LOCKDOWN
KDE4_LIBS
KDE4_CFLAGS
MOC4
KDE_LIBS
KDE_CFLAGS
MOC
COMMONS_LOGGING_JAR
COMMONS_HTTPCLIENT_JAR
COMMONS_LANG_JAR
COMMONS_CODEC_JAR
SYSTEM_APACHE_COMMONS
LIBSERIALIZER_JAR
LIBFONTS_JAR
LIBREPOSITORY_JAR
LIBFORMULA_JAR
LIBLOADER_JAR
LIBLAYOUT_JAR
LIBBASE_JAR
JFREEREPORT_JAR
FLUTE_JAR
LIBXML_JAR
SAC_JAR
SYSTEM_JFREEREPORT
ENABLE_REPORTBUILDER
SERVLETAPI_JAR
SYSTEM_SERVLETAPI
ENABLE_MEDIAWIKI
SYSTEM_POPPLER
ENABLE_PDFIMPORT
POPPLER_LIBS
POPPLER_CFLAGS
ENABLE_PRESENTER_SCREEN
ENABLE_MINIMIZER
ENABLE_PRESENTER_EXTRA_UI
ENABLE_OPENGL
SYSTEM_CAIRO
BUILD_PIXMAN
ENABLE_CAIRO
CAIRO_LIBS
CAIRO_CFLAGS
ENABLE_SYSTRAY_GTK
ENABLE_DBUS
ENABLE_GIO
GIO_LIBS
GIO_CFLAGS
DBUS_LIBS
DBUS_CFLAGS
GTK_LIBS
GTK_CFLAGS
ENABLE_GNOMEVFS
GNOMEVFS_LIBS
GNOMEVFS_CFLAGS
ENABLE_GCONF
GCONF_LIBS
GCONF_CFLAGS
ENABLE_KDE4
ENABLE_KDE
ENABLE_GTK
ZIP_HOME
UNZIP
ZIP
ASM_HOME
ML_EXE
CYGWIN_PATH
GNUPATCH
GNUCP
PATCH
FLEX
BISON
NSIS_PATH
DIRECTXSDK_LIB
DIRECTXSDK_HOME
WINDOWS_VISTA_PSDK
PSDK_HOME
SYSTEM_LPSOLVE
SYSTEM_MYTHES
HYPHEN_LIB
SYSTEM_HYPH
SYSTEM_HUNSPELL
HUNSPELL_LIBS
HUNSPELL_CFLAGS
SYSTEM_REDLAND
REDLAND_LIBS
REDLAND_CFLAGS
AGG_VERSION
SYSTEM_AGG
AGG_LIBS
AGG_CFLAGS
ENABLE_AGG
SYSTEM_OPENSSL
OPENSSL_LIBS
OPENSSL_CFLAGS
NEON_VERSION
SYSTEM_NEON
NEON_LIBS
NEON_CFLAGS
DISABLE_NEON
ENABLE_RANDR
XRANDR_DLOPEN
XRANDR_LIBS
XRANDR_CFLAGS
XRENDER_LINK
SYSTEM_XRENDER_HEADERS
DISABLE_XAW
XAU_LIBS
XLIB
XINC
X_EXTRA_LIBS
X_LIBS
X_PRE_LIBS
X_CFLAGS
XMKMF
SYSTEM_GRAPHITE
ENABLE_GRAPHITE
GRAPHITE_LIBS
GRAPHITE_CFLAGS
SYSTEM_ICU
SYSTEM_GENCMN
SYSTEM_GENCCODE
SYSTEM_GENBRK
SYSTEM_SANE_HEADER
MOZ_LDAP_CFLAGS
MOZ_LIB_XPCOM
MOZ_LIB
MOZ_INC
MOZ_FLAVOUR
SYSTEM_MOZILLA
MOZILLABUILD
ENABLE_NSS_MODULE
BUILD_MOZAB
MOZLIBREQ_LIBS
MOZLIBREQ_CFLAGS
MOZGTK2_LIBS
MOZGTK2_CFLAGS
MOZILLA_TOOLKIT
MOZILLA_VERSION
MOZILLAXPCOM_LIBS
MOZILLAXPCOM_CFLAGS
NSPR_LIB
MOZ_NSPR_LIBS
MOZ_NSPR_CFLAGS
NSS_LIB
MOZ_NSS_LIBS
MOZ_NSS_CFLAGS
WITH_OPENLDAP
WITH_LDAP
WITH_MOZILLA
SYSTEM_ODBC_HEADERS
SYSTEM_VIGRA
SYSTEM_BOOST
CURL_LIBS
CURL_CFLAGS
SYSTEM_CURL
CURLCONFIG
SAXON_JAR
SYSTEM_SAXON
SERIALIZER_JAR
BSH_JAR
SYSTEM_BSH
HSQLDB_JAR
SYSTEM_HSQLDB
SYSTEM_MYSQL_CPPCONN
LIBMYSQL_PATH
MYSQL_DEFINES
MYSQL_LIB
MYSQL_INC
SYSTEM_MYSQL
MYSQLCONFIG
ENABLE_MYSQLC
LUCENE_ANALYZERS_JAR
LUCENE_CORE_JAR
SYSTEM_LUCENE
DB_JAR
DB_INCLUDES
DB_VERSION
SYSTEM_DB
HOME
PYTHON_LIBS
PYTHON_CFLAGS
SYSTEM_PYTHON
BZIP2
pkgpyexecdir
pyexecdir
pkgpythondir
pythondir
PYTHON_PLATFORM
PYTHON_EXEC_PREFIX
PYTHON_PREFIX
PYTHON_VERSION
PYTHON
SYSTEM_LIBXML
LIBXML_LIBS
LIBXML_CFLAGS
SYSTEM_LIBXSLT
XSLTPROC
LIBXSLT_LIBS
LIBXSLT_CFLAGS
USE_FT_EMBOLDEN
FREETYPE_LIBS
FREETYPE_CFLAGS
SYSTEM_LIBWPD
LIBWPD_LIBS
LIBWPD_CFLAGS
PKG_CONFIG
SYSTEM_EXPAT
SYSTEM_JPEG
SYSTEM_ZLIB
SYSTEM_STDLIBS
BUILD_QADEVOOO
BUILD_UNOWINREG
MINGWSTRIP
MINGWCXX
GPERF
RPM
PKGFORMAT
BUILD_EPM
PKGMK
DPKG
EPM
BUILD_DMAKE
DMAKE
JAVAFLAGS
JDK
JAVA_HOME
JAVAAOTCOMPILER
AWTLIB
JAVADOC
JAVACISGCJ
JAVACOMPILER
JAVAINTERPRETER
SOLAR_JAVA
BUILD_VER_STRING
ALLOC
HAVE_GCC_VISIBILITY_FEATURE
CCACHE
USE_CCACHE
USE_SYSTEM_STL
STLPORT_VER
STLPORT4
EXCEPTIONS
MINGW_GXXDLL
MINGW_GCCDLL
MINGW_SHARED_GXXLIB
MINGW_GCCLIB_EH
MINGW_SHARED_GCCLIB
MINGW_CLIB_DIR
MINGW_BACKWARD_INCLUDE_PATH
MINGW_LIB_INCLUDE_PATH
GXX_INCLUDE_PATH
CRYPT_LINK
PAM_LINK
NEW_SHADOW_API
PAM
VBA_EXTENSION
ENABLE_VBA
LFS_CFLAGS
WORDS_BIGENDIAN
SIZEOF_LONG
CXXCPP
ac_ct_CXX
CXXFLAGS
CXX
CPP
FRAME_HOME
CSC_PATH
MIDL_PATH
USE_MINGW
COMEX
MSPDB_PATH
PERL
HAVE_LD_HASH_STYLE
_cc
GNUMAKE
NO_HIDS
ENABLE_PCH
HAVE_LD_BSYMBOLIC_FUNCTIONS
GCCVER
COMPATH
OBJEXT
EXEEXT
ac_ct_CC
CPPFLAGS
LDFLAGS
CFLAGS
CC
GCC_HOME
SHELLPATH
WITH_MINGWIN
USE_SHELL
THES_SYSTEM_DIR
HYPH_SYSTEM_DIR
DICT_SYSTEM_DIR
SYSTEM_DICTS
WITH_MYSPELL_DICTS
ENABLE_RPATH
DISABLE_ATL
DISABLE_ACTIVEX
ENABLE_DIRECTX
WITH_BINFILTER
ENABLE_FONTCONFIG
ENABLE_CUPS
DISABLE_STRIP
ENABLE_SYMBOLS
PROEXT
PROFULLSWITCH
PRODUCT
ENABLE_DEBUG
ENABLE_WERROR
VC_STANDARD
ENABLE_CRASHDUMP
PTHREAD_LIBS
PTHREAD_CFLAGS
OSVERSION
GNUTAR
target_os
target_vendor
target_cpu
target
host_os
host_vendor
host_cpu
host
build_os
build_vendor
build_cpu
build
SOURCEVERSION
UPD
_solenv
LOCAL_SOLENV
SED
AWK
EGREP
GREP
target_alias
host_alias
build_alias
LIBS
ECHO_T
ECHO_N
ECHO_C
DEFS
mandir
localedir
libdir
psdir
pdfdir
dvidir
htmldir
infodir
docdir
oldincludedir
includedir
localstatedir
sharedstatedir
sysconfdir
datadir
datarootdir
libexecdir
sbindir
bindir
program_transform_name
prefix
exec_prefix
PACKAGE_URL
PACKAGE_BUGREPORT
PACKAGE_STRING
PACKAGE_VERSION
PACKAGE_TARNAME
PACKAGE_NAME
PATH_SEPARATOR
SHELL'
ac_subst_files=''
ac_user_opts='
enable_option_checking
with_gnu_patch
with_agg
with_gnu_cp
enable_graphite
with_system_graphite
enable_ldap
with_openldap
enable_lockdown
enable_vba
with_vba_package_format
enable_pch
enable_hids
enable_mozilla
with_fonts
with_ppds
with_afms
enable_epm
with_epm
with_package_format
enable_odk
enable_qadevooo
enable_mathmldtd
enable_evolution2
with_system_stdlibs
enable_cups
enable_fontconfig
enable_directx
enable_activex
enable_atl
enable_symbols
enable_strip_solver
enable_werror
enable_debug
enable_dbgutil
enable_crashdump
enable_cl_standard
enable_gtk
enable_systray
enable_cairo
with_system_cairo
enable_opengl
enable_dbus
enable_gconf
enable_gnome_vfs
enable_gio
enable_static_gtk
enable_layout
enable_build_mozilla
with_mozilla_version
with_mozilla_toolkit
enable_nss_module
enable_kde
enable_kdeab
enable_kde4
enable_binfilter
enable_rpath
enable_pam
enable_pam_link
enable_crypt_link
enable_xrender_link
enable_randr
enable_randr_link
with_myspell_dicts
with_system_dicts
with_external_dict_dir
with_external_hyph_dir
with_external_thes_dir
with_system_libs
with_system_headers
with_system_jars
with_system_zlib
with_system_openssl
with_system_jpeg
with_system_expat
with_system_libwpd
with_system_libxml
with_system_python
with_system_icu
with_system_poppler
with_system_db
with_system_lucene
with_lucene_core_jar
with_lucene_analyzers_jar
enable_mysql_connector
with_system_mysql
with_libmysql_path
with_system_mysql_cppconn
with_system_hsqldb
with_hsqldb_jar
with_system_beanshell
with_beanshell_jar
enable_presenter_extra_ui
enable_minimizer
enable_presenter_console
enable_pdfimport
enable_wiki_publisher
with_commons_codec_jar
with_commons_lang_jar
with_commons_httpclient_jar
with_commons_logging_jar
with_servlet_api_jar
enable_report_builder
with_system_jfreereport
with_sac_jar
with_libxml_jar
with_flute_jar
with_jfreereport_jar
with_liblayout_jar
with_libloader_jar
with_libformula_jar
with_librepository_jar
with_libfonts_jar
with_libserializer_jar
with_libbase_jar
with_system_saxon
with_saxon_jar
with_system_libxslt
with_system_odbc
with_system_sane
with_system_xrender
with_system_curl
with_system_boost
with_system_vigra
enable_neon
enable_Xaw
with_system_neon
with_system_agg
with_system_hunspell
with_system_mythes
with_system_altlinuxhyph
with_system_lpsolve
with_system_mozilla
with_stlport
with_jdk_home
with_gxx_include_path
with_java
enable_gcjaot
with_ant_home
with_perl_home
with_cl_home
with_mspdb_path
with_midl_path
with_csc_path
with_nsis_path
with_frame_home
with_psdk_home
with_directx_home
with_mozilla_build
with_local_solenv
with_local_solver
enable_check_only
enable_ccache_skip
with_lang
with_poor_help_localizations
with_dict
with_intro_bitmaps
with_about_bitmaps
with_vendor
with_unix_wrapper
with_asm_home
with_os_version
with_unzip_home
with_zip_home
with_mingwin
with_use_shell
with_build_version
with_alloc
enable_verbose
enable_largefile
with_x
'
      ac_precious_vars='build_alias
host_alias
target_alias
CC
CFLAGS
LDFLAGS
LIBS
CPPFLAGS
CPP
CXX
CXXFLAGS
CCC
CXXCPP
XMKMF'


# Initialize some variables set by options.
ac_init_help=
ac_init_version=false
ac_unrecognized_opts=
ac_unrecognized_sep=
# The variables have the same names as the options, with
# dashes changed to underlines.
cache_file=/dev/null

# and all the variables that are supposed to be based on exec_prefix
# by default will actually change.
# Use braces instead of parens because sh, perl, etc. also accept them.
# (The list follows the same order as the GNU Coding Standards.)
bindir='${exec_prefix}/bin'
sbindir='${exec_prefix}/sbin'
libexecdir='${exec_prefix}/libexec'
datarootdir='${prefix}/share'
datadir='${datarootdir}'
sysconfdir='${prefix}/etc'
sharedstatedir='${prefix}/com'
localstatedir='${prefix}/var'
libdir='${exec_prefix}/lib'
includedir='${prefix}/include'
oldincludedir='/usr/include'
docdir='${datarootdir}/doc/${PACKAGE}'
infodir='${datarootdir}/info'
htmldir='${docdir}'
dvidir='${docdir}'
pdfdir='${docdir}'
psdir='${docdir}'
libdir='${exec_prefix}/lib'
localedir='${datarootdir}/locale'
mandir='${datarootdir}/man'

ac_prev=
ac_dashdash=
for ac_option
do
  # If the previous option needs an argument, assign it.
  if test -n "$ac_prev"; then
    eval $ac_prev=\$ac_option
    ac_prev=
    continue
  fi

  case $ac_option in
  *=*)	ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
  *)	ac_optarg=yes ;;
  esac

  # Accept the important Cygnus configure options, so we can diagnose typos.

  case $ac_dashdash$ac_option in
  --)
    ac_dashdash=yes ;;

  -bindir | --bindir | --bindi | --bind | --bin | --bi)
    ac_prev=bindir ;;

  --config-cache | -C)
    cache_file=config.cache ;;

  -datadir | --datadir | --datadi | --datad)
    ac_prev=datadir ;;
  -datadir=* | --datadir=* | --datadi=* | --datad=*)
  | --da=*)
    datadir=$ac_optarg ;;

  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
  | --dataroo | --dataro | --datar)
    ac_prev=datarootdir ;;
  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
    datarootdir=$ac_optarg ;;

  -disable-* | --disable-*)
    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error "invalid feature name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"enable_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval enable_$ac_useropt=no ;;

  -docdir | --docdir | --docdi | --doc | --do)
    ac_prev=docdir ;;
  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
    docdir=$ac_optarg ;;

  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
    ac_prev=dvidir ;;
  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
    dvidir=$ac_optarg ;;

  -enable-* | --enable-*)
    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error "invalid feature name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"enable_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval enable_$ac_useropt=\$ac_optarg ;;

  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \

  -host=* | --host=* | --hos=* | --ho=*)
    host_alias=$ac_optarg ;;

  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
    ac_prev=htmldir ;;
  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
  | --ht=*)
    htmldir=$ac_optarg ;;

  -includedir | --includedir | --includedi | --included | --include \
  | --includ | --inclu | --incl | --inc)
    ac_prev=includedir ;;

  | --libexe=* | --libex=* | --libe=*)
    libexecdir=$ac_optarg ;;

  -localedir | --localedir | --localedi | --localed | --locale)
    ac_prev=localedir ;;
  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
    localedir=$ac_optarg ;;

  -localstatedir | --localstatedir | --localstatedi | --localstated \
  | --localstate | --localstat | --localsta | --localst | --locals)
  | --locals | --local | --loca | --loc | --lo)
    ac_prev=localstatedir ;;
  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
    localstatedir=$ac_optarg ;;

  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)

  | --progr-tra=* | --program-tr=* | --program-t=*)
    program_transform_name=$ac_optarg ;;

  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
    ac_prev=pdfdir ;;
  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
    pdfdir=$ac_optarg ;;

  -psdir | --psdir | --psdi | --psd | --ps)
    ac_prev=psdir ;;
  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
    psdir=$ac_optarg ;;

  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil)
    silent=yes ;;

    ac_init_version=: ;;

  -with-* | --with-*)
    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error "invalid package name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"with_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval with_$ac_useropt=\$ac_optarg ;;

  -without-* | --without-*)
    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error "invalid package name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"with_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval with_$ac_useropt=no ;;

  --x)
    # Obsolete; use --with-x.

  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
    x_libraries=$ac_optarg ;;

  -*) as_fn_error "unrecognized option: \`$ac_option'
Try \`$0 --help' for more information."
   { (exit 1); exit 1; }; }
    ;;

  *=*)
    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
    # Reject names that are not valid shell variable names.
    case $ac_envvar in #(
      '' | [0-9]* | *[!_$as_cr_alnum]* )
      as_fn_error "invalid variable name: \`$ac_envvar'" ;;
    esac
    eval $ac_envvar=\$ac_optarg
    export $ac_envvar ;;

  *)
    # FIXME: should be removed in autoconf 3.0.
    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
    ;;



if test -n "$ac_prev"; then
  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
  as_fn_error "missing argument to $ac_option"
fi

if test -n "$ac_unrecognized_opts"; then
  case $enable_option_checking in
    no) ;;
    fatal) as_fn_error "unrecognized options: $ac_unrecognized_opts" ;;
    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
  esac
fi

# Check all directory arguments for consistency.
for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
		datadir sysconfdir sharedstatedir localstatedir includedir \
		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
		libdir localedir mandir
do
  eval ac_val=\$$ac_var
  # Remove trailing slashes.
  case $ac_val in
    */ )
      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
      eval $ac_var=\$ac_val;;
  esac
  # Be sure to have absolute directory names.

# Be sure to have absolute paths.
for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
	      localstatedir libdir includedir oldincludedir infodir mandir
do
  eval ac_val=$`echo $ac_var`
  case $ac_val in
    [\\/$]* | ?:[\\/]* )  continue;;
    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
   { (exit 1); exit 1; }; };;
  esac
  as_fn_error "expected an absolute directory name for --$ac_var: $ac_val"
done

# There might be people who depend on the old broken behavior: `$host'

if test "x$host_alias" != x; then
  if test "x$build_alias" = x; then
    cross_compiling=maybe
    $as_echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
    If a cross compiler is detected then cross compile mode will be used." >&2
  elif test "x$build_alias" != "x$host_alias"; then
    cross_compiling=yes

test "$silent" = yes && exec 6>/dev/null


ac_pwd=`pwd` && test -n "$ac_pwd" &&
ac_ls_di=`ls -di .` &&
ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
  as_fn_error "working directory cannot be determined"
test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
  as_fn_error "pwd does not report name of working directory"


# Find the source files, if location was not specified.
if test -z "$srcdir"; then
  ac_srcdir_defaulted=yes
  # Try the directory containing this script, then the parent directory.
  ac_confdir=`$as_dirname -- "$as_myself" ||
$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_myself" : 'X\(//\)[^/]' \| \
	 X"$as_myself" : 'X\(//\)$' \| \
	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_myself" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
  srcdir=$ac_confdir
  if test ! -r "$srcdir/$ac_unique_file"; then
    srcdir=..
  fi
else
  ac_srcdir_defaulted=no
fi
if test ! -r "$srcdir/$ac_unique_file"; then
  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
  as_fn_error "cannot find sources ($ac_unique_file) in $srcdir"
fi
ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
ac_abs_confdir=`(
	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error "$ac_msg"
	pwd)`
# When building in place, set srcdir=.
if test "$ac_abs_confdir" = "$ac_pwd"; then
  srcdir=.
fi
# Remove unnecessary trailing slashes from srcdir.
# Double slashes in file names in object file debugging info
# mess up M-x gdb in Emacs.
case $srcdir in
*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
esac
for ac_var in $ac_precious_vars; do
  eval ac_env_${ac_var}_set=\${${ac_var}+set}
  eval ac_env_${ac_var}_value=\$${ac_var}
  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
  eval ac_cv_env_${ac_var}_value=\$${ac_var}
done
ac_cv_env_target_alias_value=$target_alias
ac_env_CC_set=${CC+set}
ac_env_CC_value=$CC
ac_cv_env_CC_set=${CC+set}
ac_cv_env_CC_value=$CC
ac_env_CFLAGS_set=${CFLAGS+set}
ac_env_CFLAGS_value=$CFLAGS
ac_cv_env_CFLAGS_set=${CFLAGS+set}
ac_cv_env_CFLAGS_value=$CFLAGS
ac_env_LDFLAGS_set=${LDFLAGS+set}
ac_env_LDFLAGS_value=$LDFLAGS
ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
ac_cv_env_LDFLAGS_value=$LDFLAGS
ac_env_CPPFLAGS_set=${CPPFLAGS+set}
ac_env_CPPFLAGS_value=$CPPFLAGS
ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
ac_cv_env_CPPFLAGS_value=$CPPFLAGS
ac_env_CPP_set=${CPP+set}
ac_env_CPP_value=$CPP
ac_cv_env_CPP_set=${CPP+set}
ac_cv_env_CPP_value=$CPP
ac_env_CXX_set=${CXX+set}
ac_env_CXX_value=$CXX
ac_cv_env_CXX_set=${CXX+set}
ac_cv_env_CXX_value=$CXX
ac_env_CXXFLAGS_set=${CXXFLAGS+set}
ac_env_CXXFLAGS_value=$CXXFLAGS
ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
ac_cv_env_CXXFLAGS_value=$CXXFLAGS
ac_env_CXXCPP_set=${CXXCPP+set}
ac_env_CXXCPP_value=$CXXCPP
ac_cv_env_CXXCPP_set=${CXXCPP+set}
ac_cv_env_CXXCPP_value=$CXXCPP

#
# Report the --help message.

  -n, --no-create         do not create output files
      --srcdir=DIR        find the sources in DIR [configure dir or \`..']

_ACEOF

  cat <<_ACEOF
Installation directories:
  --prefix=PREFIX         install architecture-independent files in PREFIX
                          [$ac_default_prefix]
  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
                          [PREFIX]

By default, \`make install' will install all the files in
\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify

For better control, use the options below.

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]
  --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]
  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
  --infodir=DIR           info documentation [DATAROOTDIR/info]
  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
  --mandir=DIR            man documentation [DATAROOTDIR/man]
  --docdir=DIR            documentation root [DATAROOTDIR/doc/PACKAGE]
  --htmldir=DIR           html documentation [DOCDIR]
  --dvidir=DIR            dvi documentation [DOCDIR]
  --pdfdir=DIR            pdf documentation [DOCDIR]
  --psdir=DIR             ps documentation [DOCDIR]
_ACEOF

  cat <<\_ACEOF

  cat <<\_ACEOF

Optional Features:
  --disable-option-checking  ignore unrecognized --enable/--with options
  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
  --enable-graphite       Enables the compilation of Graphite smart font rendering

  CFLAGS      C compiler flags
  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
              nonstandard directory <lib dir>
  LIBS        libraries to pass to the linker, e.g. -l<library>
  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
              you have headers in a nonstandard directory <include dir>
  CPP         C preprocessor
  CXX         C++ compiler command
  CXXFLAGS    C++ compiler flags
  CXXCPP      C++ preprocessor
  XMKMF       Path to xmkmf, Makefile generator for X Window System

Use these variables to override the choices made by `configure' or to help
it to find libraries and programs with nonstandard names/locations.

Report bugs to the package provider.
_ACEOF
ac_status=$?
fi

if test "$ac_init_help" = "recursive"; then
  # If there are subdirs, report their specific --help.
  ac_popdir=`pwd`
  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
    test -d "$ac_dir" ||
      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
      continue
    ac_builddir=.

case "$ac_dir" in
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
*)
  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
  # A ".." for each directory in $ac_dir_suffix.
  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
  case $ac_top_builddir_sub in
  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
  esac ;;
esac
ac_abs_top_builddir=$ac_pwd
ac_abs_builddir=$ac_pwd$ac_dir_suffix
# for backward compatibility:
ac_top_builddir=$ac_top_build_prefix

case $srcdir in
  .)  # We are building in place.
    ac_srcdir=.
    ac_top_srcdir=$ac_top_builddir_sub
    ac_abs_top_srcdir=$ac_pwd ;;
  [\\/]* | ?:[\\/]* )  # Absolute name.
    ac_srcdir=$srcdir$ac_dir_suffix;
    ac_top_srcdir=$srcdir
    ac_abs_top_srcdir=$srcdir ;;
  *) # Relative name.
    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
    ac_top_srcdir=$ac_top_build_prefix$srcdir
    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
esac
ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix

    cd "$ac_dir" || { ac_status=$?; continue; }
    # Check for guested configure.
    if test -f "$ac_srcdir/configure.gnu"; then
      echo &&
      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
    elif test -f "$ac_srcdir/configure"; then
      echo &&
      $SHELL "$ac_srcdir/configure" --help=recursive
    else
      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
    fi || ac_status=$?
    cd "$ac_pwd" || { ac_status=$?; break; }
  done
fi

test -n "$ac_init_help" && exit $ac_status
    ac_top_srcdir=$ac_top_builddir$srcdir ;;
esac

# Do not use `cd foo && pwd` to compute absolute paths, because
# the directories may not exist.
case `pwd` in
.) ac_abs_builddir="$ac_dir";;
*)
  case "$ac_dir" in
  .) ac_abs_builddir=`pwd`;;
  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
  *) ac_abs_builddir=`pwd`/"$ac_dir";;
  esac;;
esac
case $ac_abs_builddir in
.) ac_abs_top_builddir=${ac_top_builddir}.;;
*)
  case ${ac_top_builddir}. in
  .) ac_abs_top_builddir=$ac_abs_builddir;;
  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
  esac;;
esac
case $ac_abs_builddir in
.) ac_abs_srcdir=$ac_srcdir;;
*)
  case $ac_srcdir in
  .) ac_abs_srcdir=$ac_abs_builddir;;
  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
  esac;;
esac
case $ac_abs_builddir in
.) ac_abs_top_srcdir=$ac_top_srcdir;;
*)
  case $ac_top_srcdir in
  .) ac_abs_top_srcdir=$ac_abs_builddir;;
  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
  esac;;
esac

    cd $ac_dir
    # Check for guested configure; otherwise get Cygnus style configure.
    if test -f $ac_srcdir/configure.gnu; then
      echo
      $SHELL $ac_srcdir/configure.gnu  --help=recursive
    elif test -f $ac_srcdir/configure; then
      echo
      $SHELL $ac_srcdir/configure  --help=recursive
    elif test -f $ac_srcdir/configure.ac ||
	   test -f $ac_srcdir/configure.in; then
      echo
      $ac_configure --help
    else
      echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
    fi
    cd $ac_popdir
  done
fi

test -n "$ac_init_help" && exit 0
if $ac_init_version; then
  cat <<\_ACEOF
configure
generated by GNU Autoconf 2.65

Copyright (C) 2009 Free Software Foundation, Inc.
This configure script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it.
_ACEOF
  exit
fi

## ------------------------ ##
## Autoconf initialization. ##
## ------------------------ ##

# ac_fn_c_try_compile LINENO
# --------------------------
# Try to compile conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_compile ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  rm -f conftest.$ac_objext
  if { { ac_try="$ac_compile"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compile") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && {
	 test -z "$ac_c_werror_flag" ||
	 test ! -s conftest.err
       } && test -s conftest.$ac_objext; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

	ac_retval=1
fi
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
  as_fn_set_status $ac_retval

} # ac_fn_c_try_compile

# ac_fn_c_try_link LINENO
# -----------------------
# Try to link conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_link ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  rm -f conftest.$ac_objext conftest$ac_exeext
  if { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && {
	 test -z "$ac_c_werror_flag" ||
	 test ! -s conftest.err
       } && test -s conftest$ac_exeext && {
	 test "$cross_compiling" = yes ||
	 $as_test_x conftest$ac_exeext
       }; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

	ac_retval=1
fi
  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
  # interfere with the next link command; also delete a directory that is
  # left behind by Apple's compiler.  We do this before executing the actions.
  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
  as_fn_set_status $ac_retval

} # ac_fn_c_try_link

# ac_fn_c_try_cpp LINENO
# ----------------------
# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_cpp ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if { { ac_try="$ac_cpp conftest.$ac_ext"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } >/dev/null && {
	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
	 test ! -s conftest.err
       }; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

    ac_retval=1
fi
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
  as_fn_set_status $ac_retval

} # ac_fn_c_try_cpp

# ac_fn_c_try_run LINENO
# ----------------------
# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
# that executables *can* be run.
ac_fn_c_try_run ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
  { { case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_try") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; }; then :
  ac_retval=0
else
  $as_echo "$as_me: program exited with status $ac_status" >&5
       $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

       ac_retval=$ac_status
fi
  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
  as_fn_set_status $ac_retval

} # ac_fn_c_try_run

# ac_fn_cxx_try_compile LINENO
# ----------------------------
# Try to compile conftest.$ac_ext, and return whether this succeeded.
ac_fn_cxx_try_compile ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  rm -f conftest.$ac_objext
  if { { ac_try="$ac_compile"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compile") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && {
	 test -z "$ac_cxx_werror_flag" ||
	 test ! -s conftest.err
       } && test -s conftest.$ac_objext; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

	ac_retval=1
fi
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
  as_fn_set_status $ac_retval

} # ac_fn_cxx_try_compile

# ac_fn_cxx_try_cpp LINENO
# ------------------------
# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
ac_fn_cxx_try_cpp ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if { { ac_try="$ac_cpp conftest.$ac_ext"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } >/dev/null && {
	 test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
	 test ! -s conftest.err
       }; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

    ac_retval=1
fi
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
  as_fn_set_status $ac_retval

} # ac_fn_cxx_try_cpp

# ac_fn_c_compute_int LINENO EXPR VAR INCLUDES
# --------------------------------------------
# Tries to find the compile-time value of EXPR in a program that includes
# INCLUDES, setting VAR accordingly. Returns whether the value could be
# computed
ac_fn_c_compute_int ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if test "$cross_compiling" = yes; then
    # Depending upon the size, compute the lo and hi bounds.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
int
main ()
{
static int test_array [1 - 2 * !(($2) >= 0)];
test_array [0] = 0

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_lo=0 ac_mid=0
  while :; do
    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
int
main ()
{
static int test_array [1 - 2 * !(($2) <= $ac_mid)];
test_array [0] = 0

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_hi=$ac_mid; break
else
  as_fn_arith $ac_mid + 1 && ac_lo=$as_val
			if test $ac_lo -le $ac_mid; then
			  ac_lo= ac_hi=
			  break
			fi
			as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  done
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
int
main ()
{
static int test_array [1 - 2 * !(($2) < 0)];
test_array [0] = 0

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_hi=-1 ac_mid=-1
  while :; do
    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
int
main ()
{
static int test_array [1 - 2 * !(($2) >= $ac_mid)];
test_array [0] = 0

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_lo=$ac_mid; break
else
  as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
			if test $ac_mid -le $ac_hi; then
			  ac_lo= ac_hi=
			  break
			fi
			as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  done
else
  ac_lo= ac_hi=
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
# Binary search between lo and hi bounds.
while test "x$ac_lo" != "x$ac_hi"; do
  as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
int
main ()
{
static int test_array [1 - 2 * !(($2) <= $ac_mid)];
test_array [0] = 0

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_hi=$ac_mid
else
  as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
done
case $ac_lo in #((
?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
'') ac_retval=1 ;;
esac
  else
    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
static long int longval () { return $2; }
static unsigned long int ulongval () { return $2; }
#include <stdio.h>
#include <stdlib.h>
int
main ()
{

  FILE *f = fopen ("conftest.val", "w");
  if (! f)
    return 1;
  if (($2) < 0)
    {
      long int i = longval ();
      if (i != ($2))
	return 1;
      fprintf (f, "%ld", i);
    }
  else
    {
      unsigned long int i = ulongval ();
      if (i != ($2))
	return 1;
      fprintf (f, "%lu", i);
    }
  /* Do not output a trailing newline, as this causes \r\n confusion
     on some platforms.  */
  return ferror (f) || fclose (f) != 0;

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
  echo >>conftest.val; read $3 <conftest.val; ac_retval=0
else
  ac_retval=1
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
rm -f conftest.val

  fi
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
  as_fn_set_status $ac_retval

} # ac_fn_c_compute_int

# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
# -------------------------------------------------------
# Tests whether HEADER exists and can be compiled using the include files in
# INCLUDES, setting the cache variable VAR accordingly.
ac_fn_c_check_header_compile ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
#include <$2>
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  eval "$3=yes"
else
  eval "$3=no"
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}

} # ac_fn_c_check_header_compile

# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
# -------------------------------------------------------
# Tests whether HEADER exists, giving a warning if it cannot be compiled using
# the include files in INCLUDES and setting the cache variable VAR
# accordingly.
ac_fn_c_check_header_mongrel ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
else
  # Is the header compilable?
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
$as_echo_n "checking $2 usability... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
#include <$2>
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_header_compiler=yes
else
  ac_header_compiler=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
$as_echo "$ac_header_compiler" >&6; }

# Is the header present?
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
$as_echo_n "checking $2 presence... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <$2>
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
  ac_header_preproc=yes
else
  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
$as_echo "$ac_header_preproc" >&6; }

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
  yes:no: )
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
    ;;
  no:yes:* )
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
    ;;
esac
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  eval "$3=\$ac_header_compiler"
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
fi
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}

} # ac_fn_c_check_header_mongrel

# ac_fn_cxx_try_link LINENO
# -------------------------
# Try to link conftest.$ac_ext, and return whether this succeeded.
ac_fn_cxx_try_link ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  rm -f conftest.$ac_objext conftest$ac_exeext
  if { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && {
	 test -z "$ac_cxx_werror_flag" ||
	 test ! -s conftest.err
       } && test -s conftest$ac_exeext && {
	 test "$cross_compiling" = yes ||
	 $as_test_x conftest$ac_exeext
       }; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

	ac_retval=1
fi
  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
  # interfere with the next link command; also delete a directory that is
  # left behind by Apple's compiler.  We do this before executing the actions.
  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
  as_fn_set_status $ac_retval

} # ac_fn_cxx_try_link

# ac_fn_c_check_func LINENO FUNC VAR
# ----------------------------------
# Tests whether FUNC exists, setting the cache variable VAR accordingly
ac_fn_c_check_func ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
/* Define $2 to an innocuous variant, in case <limits.h> declares $2.
   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
#define $2 innocuous_$2

/* System header to define __stub macros and hopefully few prototypes,
    which can conflict with char $2 (); below.
    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
    <limits.h> exists even on freestanding compilers.  */

#ifdef __STDC__
# include <limits.h>
#else
# include <assert.h>
#endif

#undef $2

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char $2 ();
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined __stub_$2 || defined __stub___$2
choke me
#endif

int
main ()
{
return $2 ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  eval "$3=yes"
else
  eval "$3=no"
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}

} # ac_fn_c_check_func

# ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
# ---------------------------------------------------------
# Tests whether HEADER exists, giving a warning if it cannot be compiled using
# the include files in INCLUDES and setting the cache variable VAR
# accordingly.
ac_fn_cxx_check_header_mongrel ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
else
  # Is the header compilable?
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
$as_echo_n "checking $2 usability... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
#include <$2>
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  ac_header_compiler=yes
else
  ac_header_compiler=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
$as_echo "$ac_header_compiler" >&6; }

# Is the header present?
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
$as_echo_n "checking $2 presence... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <$2>
_ACEOF
if ac_fn_cxx_try_cpp "$LINENO"; then :
  ac_header_preproc=yes
else
  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
$as_echo "$ac_header_preproc" >&6; }

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
  yes:no: )
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
    ;;
  no:yes:* )
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
    ;;
esac
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  eval "$3=\$ac_header_compiler"
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
fi
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}

} # ac_fn_cxx_check_header_mongrel

# ac_fn_cxx_try_run LINENO
# ------------------------
# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
# that executables *can* be run.
ac_fn_cxx_try_run ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
  { { case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_try") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; }; then :
  ac_retval=0
else
  $as_echo "$as_me: program exited with status $ac_status" >&5
       $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

       ac_retval=$ac_status
fi
  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
  as_fn_set_status $ac_retval

} # ac_fn_cxx_try_run

# ac_fn_c_check_member LINENO AGGR MEMBER VAR INCLUDES
# ----------------------------------------------------
# Tries to find if the field MEMBER exists in type AGGR, after including
# INCLUDES, setting cache variable VAR accordingly.
ac_fn_c_check_member ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2.$3" >&5
$as_echo_n "checking for $2.$3... " >&6; }
if { as_var=$4; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$5
int
main ()
{
static $2 ac_aggr;
if (ac_aggr.$3)
return 0;
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  eval "$4=yes"
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$5
int
main ()
{
static $2 ac_aggr;
if (sizeof ac_aggr.$3)
return 0;
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  eval "$4=yes"
else
  eval "$4=no"
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
eval ac_res=\$$4
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}

} # ac_fn_c_check_member
cat >config.log <<_ACEOF
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.

It was created by $as_me, which was
generated by GNU Autoconf 2.65.  Invocation command line was

  $ $0 $@

_ACEOF
exec 5>>config.log
{
cat <<_ASUNAME
## --------- ##

/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    $as_echo "PATH: $as_dir"
  done
IFS=$as_save_IFS

} >&5


ac_configure_args=
ac_configure_args0=
ac_configure_args1=
ac_sep=
ac_must_keep_next=false
for ac_pass in 1 2
do

    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
    | -silent | --silent | --silen | --sile | --sil)
      continue ;;
    *\'*)
      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
    esac
    case $ac_pass in
    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
    2)
      as_fn_append ac_configure_args1 " '$ac_arg'"
      if test $ac_must_keep_next = true; then
	ac_must_keep_next=false # Got value, back to normal.
      else

	  -* ) ac_must_keep_next=true ;;
	esac
      fi
      as_fn_append ac_configure_args " '$ac_arg'"
      # Get rid of the leading space.
      ac_sep=" "
      ;;
    esac
  done
done
{ ac_configure_args0=; unset ac_configure_args0;}
{ ac_configure_args1=; unset ac_configure_args1;}

# When interrupted or exit'd, cleanup temporary files, and complete
# config.log.  We remove comments because anyway the quotes in there
# would cause problems or look ugly.
# WARNING: Use '\'' to represent an apostrophe within the trap.
# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
trap 'exit_status=$?
  # Save into config.log some information that might help in debugging.
  {

_ASBOX
    echo
    # The following way of writing the cache mishandles newlines in values,
(
  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
    eval ac_val=\$$ac_var
    case $ac_val in #(
    *${as_nl}*)
      case $ac_var in #(
      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
      esac
      case $ac_var in #(
      _ | IFS | as_nl) ;; #(
      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
      *) { eval $ac_var=; unset $ac_var;} ;;
      esac ;;
    esac
  done
  (set) 2>&1 |
    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
    *${as_nl}ac_space=\ *)
      sed -n \
	"s/'\''/'\''\\\\'\'''\''/g;
	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
      ;; #(
    *)
      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
      ;;
    esac |
    sort
)
      ;;
    esac;
}
    echo

    cat <<\_ASBOX

    echo
    for ac_var in $ac_subst_vars
    do
      eval ac_val=\$$ac_var
      case $ac_val in
      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
      esac
      $as_echo "$ac_var='\''$ac_val'\''"
    done | sort
    echo

    if test -n "$ac_subst_files"; then
      cat <<\_ASBOX
## ------------------- ##
## File substitutions. ##
## ------------------- ##
_ASBOX
      echo
      for ac_var in $ac_subst_files
      do
	eval ac_val=\$$ac_var
	case $ac_val in
	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
	esac
	$as_echo "$ac_var='\''$ac_val'\''"
      done | sort
      echo
    fi

## ----------- ##
_ASBOX
      echo
      cat confdefs.h
      echo
    fi
    test "$ac_signal" != 0 &&
      $as_echo "$as_me: caught signal $ac_signal"
    $as_echo "$as_me: exit $exit_status"
  } >&5
  rm -f core *.core core.conftest.* &&
    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
    exit $exit_status
' 0
for ac_signal in 1 2 13 15; do
  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
done
ac_signal=0

# confdefs.h avoids OS command line length limits that DEFS can exceed.
rm -f -r conftest* confdefs.h

$as_echo "/* confdefs.h */" > confdefs.h

# Predefined preprocessor variables.


#define PACKAGE_NAME "$PACKAGE_NAME"
_ACEOF


cat >>confdefs.h <<_ACEOF
#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
_ACEOF


cat >>confdefs.h <<_ACEOF
#define PACKAGE_VERSION "$PACKAGE_VERSION"
_ACEOF


cat >>confdefs.h <<_ACEOF
#define PACKAGE_STRING "$PACKAGE_STRING"
_ACEOF


cat >>confdefs.h <<_ACEOF
#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_URL "$PACKAGE_URL"
_ACEOF


# Let the site file select an alternate cache file if it wants to.
# Prefer an explicitly selected file to automatically selected ones.
ac_site_file1=NONE
ac_site_file2=NONE
if test -n "$CONFIG_SITE"; then
  ac_site_file1=$CONFIG_SITE
elif test "x$prefix" != xNONE; then
  ac_site_file1=$prefix/share/config.site
  ac_site_file2=$prefix/etc/config.site
else
  ac_site_file1=$ac_default_prefix/share/config.site
  ac_site_file2=$ac_default_prefix/etc/config.site
fi
for ac_site_file in "$ac_site_file1" "$ac_site_file2"
do
  test "x$ac_site_file" = xNONE && continue
  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
$as_echo "$as_me: loading site script $ac_site_file" >&6;}
    sed 's/^/| /' "$ac_site_file" >&5
    . "$ac_site_file"
  fi
done

if test -r "$cache_file"; then
  # Some versions of bash will fail to source /dev/null (special files
  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
$as_echo "$as_me: loading cache $cache_file" >&6;}
    case $cache_file in
      [\\/]* | ?:[\\/]* ) . "$cache_file";;
      *)                      . "./$cache_file";;
    esac
  fi
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
$as_echo "$as_me: creating cache $cache_file" >&6;}
  >$cache_file
fi

# Check that the precious variables saved in the cache have kept the same
# value.
ac_cache_corrupted=false
for ac_var in $ac_precious_vars; do
	       sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
  eval ac_old_set=\$ac_cv_env_${ac_var}_set
  eval ac_new_set=\$ac_env_${ac_var}_set
  eval ac_old_val=\$ac_cv_env_${ac_var}_value
  eval ac_new_val=\$ac_env_${ac_var}_value
  case $ac_old_set,$ac_new_set in
    set,)
      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
      ac_cache_corrupted=: ;;
    ,set)
      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
      ac_cache_corrupted=: ;;
    ,);;
    *)
      if test "x$ac_old_val" != "x$ac_new_val"; then
	# differences in whitespace do not lead to failure.
	ac_old_val_w=`echo x $ac_old_val`
	ac_new_val_w=`echo x $ac_new_val`
	if test "$ac_old_val_w" != "$ac_new_val_w"; then
	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
	  ac_cache_corrupted=:
	else
	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
	  eval $ac_var=\$ac_old_val
	fi
	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
      fi;;
  esac
  # Pass precious variables to config.status.
  if test "$ac_new_set" = set; then
    case $ac_new_val in
    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
    *) ac_arg=$ac_var=$ac_new_val ;;
    esac
    case " $ac_configure_args " in
      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
    esac
  fi
done
if $ac_cache_corrupted; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
  as_fn_error "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
fi
## -------------------- ##
## Main body of script. ##
## -------------------- ##

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'

ac_compiler_gnu=$ac_cv_c_compiler_gnu



















echo "$@" >config.parms

# Check whether --with-gnu-patch was given.
if test "${with_gnu_patch+set}" = set; then :
  withval=$with_gnu_patch;
fi


# Check whether --with-agg was given.
if test "${with_agg+set}" = set; then :
  withval=$with_agg;

else
  with_agg=yes
fi


# Check whether --with-gnu-cp was given.
if test "${with_gnu_cp+set}" = set; then :
  withval=$with_gnu_cp;
fi

# Check whether --enable-graphite was given.
if test "${enable_graphite+set}" = set; then :
  enableval=$enable_graphite;
fi


# Check whether --with-system-graphite was given.
if test "${with_system_graphite+set}" = set; then :
  withval=$with_system_graphite;
fi

# Check whether --enable-ldap was given.
if test "${enable_ldap+set}" = set; then :
  enableval=$enable_ldap;
fi


# Check whether --with-openldap was given.
if test "${with_openldap+set}" = set; then :
  withval=$with_openldap;
fi

# Check whether --enable-lockdown was given.
if test "${enable_lockdown+set}" = set; then :
  enableval=$enable_lockdown;
fi

# Check whether --enable-vba was given.
if test "${enable_vba+set}" = set; then :
  enableval=$enable_vba;
fi


# Check whether --with-vba-package-format was given.
if test "${with_vba_package_format+set}" = set; then :
  withval=$with_vba_package_format;
fi

# Check whether --enable-pch was given.
if test "${enable_pch+set}" = set; then :
  enableval=$enable_pch;
fi

# Check whether --enable-hids was given.
if test "${enable_hids+set}" = set; then :
  enableval=$enable_hids;
fi

# Check whether --enable-mozilla was given.
if test "${enable_mozilla+set}" = set; then :
  enableval=$enable_mozilla;
else
  enable_mozilla="yes"
fi


# Check whether --with-fonts was given.
if test "${with_fonts+set}" = set; then :
  withval=$with_fonts;
fi


# Check whether --with-ppds was given.
if test "${with_ppds+set}" = set; then :
  withval=$with_ppds;
fi


# Check whether --with-afms was given.
if test "${with_afms+set}" = set; then :
  withval=$with_afms;
fi

# Check whether --enable-epm was given.
if test "${enable_epm+set}" = set; then :
  enableval=$enable_epm;
else
  enable_epm="yes"
fi


# Check whether --with-epm was given.
if test "${with_epm+set}" = set; then :
  withval=$with_epm;
fi


# Check whether --with-package-format was given.
if test "${with_package_format+set}" = set; then :
  withval=$with_package_format;
fi

# Check whether --enable-odk was given.
if test "${enable_odk+set}" = set; then :
  enableval=$enable_odk;
else
  enable_odk="yes"
fi

# Check whether --enable-qadevooo was given.
if test "${enable_qadevooo+set}" = set; then :
  enableval=$enable_qadevooo;
else
  enable_qadevooo="yes"
fi

# Check whether --enable-mathmldtd was given.
if test "${enable_mathmldtd+set}" = set; then :
  enableval=$enable_mathmldtd;
else
  enable_mathmldtd="yes"
fi

# Check whether --enable-evolution2 was given.
if test "${enable_evolution2+set}" = set; then :
  enableval=$enable_evolution2;
fi


# Check whether --with-system-stdlibs was given.
if test "${with_system_stdlibs+set}" = set; then :
  withval=$with_system_stdlibs;
else
  checkforstdlibproblems=yes
fi

# Check whether --enable-cups was given.
if test "${enable_cups+set}" = set; then :
  enableval=$enable_cups;
else
  enable_cups=yes
fi

# Check whether --enable-fontconfig was given.
if test "${enable_fontconfig+set}" = set; then :
  enableval=$enable_fontconfig;
else
  enable_fontconfig=yes
fi

# Check whether --enable-directx was given.
if test "${enable_directx+set}" = set; then :
  enableval=$enable_directx;
else
  enable_directx=yes
fi

# Check whether --enable-activex was given.
if test "${enable_activex+set}" = set; then :
  enableval=$enable_activex;
fi


# Check whether --enable-atl was given.
if test "${enable_atl+set}" = set; then :
  enableval=$enable_atl;
fi


# Check whether --enable-symbols was given.
if test "${enable_symbols+set}" = set; then :
  enableval=$enable_symbols;
fi

# Check whether --enable-strip-solver was given.
if test "${enable_strip_solver+set}" = set; then :
  enableval=$enable_strip_solver;
fi

# Check whether --enable-werror was given.
if test "${enable_werror+set}" = set; then :
  enableval=$enable_werror;
fi

# Check whether --enable-debug was given.
if test "${enable_debug+set}" = set; then :
  enableval=$enable_debug;
fi

# Check whether --enable-dbgutil was given.
if test "${enable_dbgutil+set}" = set; then :
  enableval=$enable_dbgutil;
fi

# Check whether --enable-crashdump was given.
if test "${enable_crashdump+set}" = set; then :
  enableval=$enable_crashdump;
fi

# Check whether --enable-cl-standard was given.
if test "${enable_cl_standard+set}" = set; then :
  enableval=$enable_cl_standard;
fi

# Check whether --enable-gtk was given.
if test "${enable_gtk+set}" = set; then :
  enableval=$enable_gtk;
else
  enable_gtk=yes
fi

# Check whether --enable-systray was given.
if test "${enable_systray+set}" = set; then :
  enableval=$enable_systray;
else
  enable_systray=yes
fi

# Check whether --enable-cairo was given.
if test "${enable_cairo+set}" = set; then :
  enableval=$enable_cairo;
else
  enable_cairo=no
fi


# Check whether --with-system-cairo was given.
if test "${with_system_cairo+set}" = set; then :
  withval=$with_system_cairo;
fi

# Check whether --enable-opengl was given.
if test "${enable_opengl+set}" = set; then :
  enableval=$enable_opengl;
else
  enable_opengl=no
fi

# Check whether --enable-dbus was given.
if test "${enable_dbus+set}" = set; then :
  enableval=$enable_dbus;
else
  enable_dbus=no
fi

# Check whether --enable-gconf was given.
if test "${enable_gconf+set}" = set; then :
  enableval=$enable_gconf;
else
  enable_gconf=yes
fi

# Check whether --enable-gnome-vfs was given.
if test "${enable_gnome_vfs+set}" = set; then :
  enableval=$enable_gnome_vfs;
else
  enable_gnome_vfs=yes
fi

# Check whether --enable-gio was given.
if test "${enable_gio+set}" = set; then :
  enableval=$enable_gio;
else
  enable_gio=no
fi

# Check whether --enable-static-gtk was given.
if test "${enable_static_gtk+set}" = set; then :
  enableval=$enable_static_gtk;
fi

# Check whether --enable-layout was given.
if test "${enable_layout+set}" = set; then :
  enableval=$enable_layout;
fi

# Check whether --enable-build-mozilla was given.
if test "${enable_build_mozilla+set}" = set; then :
  enableval=$enable_build_mozilla;
fi


# Check whether --with-mozilla-version was given.
if test "${with_mozilla_version+set}" = set; then :
  withval=$with_mozilla_version;
fi


# Check whether --with-mozilla-toolkit was given.
if test "${with_mozilla_toolkit+set}" = set; then :
  withval=$with_mozilla_toolkit;
fi

# Check whether --enable-nss_module was given.
if test "${enable_nss_module+set}" = set; then :
  enableval=$enable_nss_module;
else
  enable_nss_module=yes
fi

# Check whether --enable-kde was given.
if test "${enable_kde+set}" = set; then :
  enableval=$enable_kde;
fi

# Check whether --enable-kdeab was given.
if test "${enable_kdeab+set}" = set; then :
  enableval=$enable_kdeab;
else
  if test "$enable_kde" = "yes"; then enable_kdeab=yes; fi
fi

# Check whether --enable-kde4 was given.
if test "${enable_kde4+set}" = set; then :
  enableval=$enable_kde4;
fi

# Check whether --enable-binfilter was given.
if test "${enable_binfilter+set}" = set; then :
  enableval=$enable_binfilter;
else
  if ! test -d ./binfilter; then enable_binfilter=no; fi
fi

# Check whether --enable-rpath was given.
if test "${enable_rpath+set}" = set; then :
  enableval=$enable_rpath;
fi

# Check whether --enable-pam was given.
if test "${enable_pam+set}" = set; then :
  enableval=$enable_pam;
fi

# Check whether --enable-pam-link was given.
if test "${enable_pam_link+set}" = set; then :
  enableval=$enable_pam_link;
fi

# Check whether --enable-crypt-link was given.
if test "${enable_crypt_link+set}" = set; then :
  enableval=$enable_crypt_link;
else
  enable_crypt_link=yes
fi

# Check whether --enable-xrender-link was given.
if test "${enable_xrender_link+set}" = set; then :
  enableval=$enable_xrender_link;
fi

# Check whether --enable-randr was given.
if test "${enable_randr+set}" = set; then :
  enableval=$enable_randr;
else
  enable_randr=yes
fi

# Check whether --enable-randr-link was given.
if test "${enable_randr_link+set}" = set; then :
  enableval=$enable_randr_link;
else
  enable_randr_link=yes
fi


# Check whether --with-myspell-dicts was given.
if test "${with_myspell_dicts+set}" = set; then :
  withval=$with_myspell_dicts;
fi


# Check whether --with-system-dicts was given.
if test "${with_system_dicts+set}" = set; then :
  withval=$with_system_dicts;
fi


# Check whether --with-external-dict-dir was given.
if test "${with_external_dict_dir+set}" = set; then :
  withval=$with_external_dict_dir;
fi


# Check whether --with-external-hyph-dir was given.
if test "${with_external_hyph_dir+set}" = set; then :
  withval=$with_external_hyph_dir;
fi


# Check whether --with-external-thes-dir was given.
if test "${with_external_thes_dir+set}" = set; then :
  withval=$with_external_thes_dir;
fi


# Check whether --with-system-libs was given.
if test "${with_system_libs+set}" = set; then :
  withval=$with_system_libs;
fi


# Check whether --with-system-headers was given.
if test "${with_system_headers+set}" = set; then :
  withval=$with_system_headers;
fi


# Check whether --with-system-jars was given.
if test "${with_system_jars+set}" = set; then :
  withval=$with_system_jars;
fi


# Check whether --with-system-zlib was given.
if test "${with_system_zlib+set}" = set; then :
  withval=$with_system_zlib;
fi


# Check whether --with-system-openssl was given.
if test "${with_system_openssl+set}" = set; then :
  withval=$with_system_openssl;
fi


# Check whether --with-system-jpeg was given.
if test "${with_system_jpeg+set}" = set; then :
  withval=$with_system_jpeg;
fi


# Check whether --with-system-expat was given.
if test "${with_system_expat+set}" = set; then :
  withval=$with_system_expat;
fi


# Check whether --with-system-libwpd was given.
if test "${with_system_libwpd+set}" = set; then :
  withval=$with_system_libwpd;
fi


# Check whether --with-system-libxml was given.
if test "${with_system_libxml+set}" = set; then :
  withval=$with_system_libxml;
fi


# Check whether --with-system-python was given.
if test "${with_system_python+set}" = set; then :
  withval=$with_system_python;
fi


# Check whether --with-system-icu was given.
if test "${with_system_icu+set}" = set; then :
  withval=$with_system_icu;
fi


# Check whether --with-system-poppler was given.
if test "${with_system_poppler+set}" = set; then :
  withval=$with_system_poppler;
fi


# Check whether --with-system-db was given.
if test "${with_system_db+set}" = set; then :
  withval=$with_system_db;
fi


# Check whether --with-system-lucene was given.
if test "${with_system_lucene+set}" = set; then :
  withval=$with_system_lucene;
fi


# Check whether --with-lucene-core-jar was given.
if test "${with_lucene_core_jar+set}" = set; then :
  withval=$with_lucene_core_jar;  LUCENE_CORE_JAR="$withval"

fi


# Check whether --with-lucene-analyzers-jar was given.
if test "${with_lucene_analyzers_jar+set}" = set; then :
  withval=$with_lucene_analyzers_jar;  LUCENE_ANALYZERS_JAR="$withval"

fi

# Check whether --enable-mysql-connector was given.
if test "${enable_mysql_connector+set}" = set; then :
  enableval=$enable_mysql_connector;
fi


# Check whether --with-system-mysql was given.
if test "${with_system_mysql+set}" = set; then :
  withval=$with_system_mysql;
fi


# Check whether --with-libmysql-path was given.
if test "${with_libmysql_path+set}" = set; then :
  withval=$with_libmysql_path;
fi


# Check whether --with-system-mysql-cppconn was given.
if test "${with_system_mysql_cppconn+set}" = set; then :
  withval=$with_system_mysql_cppconn;
fi


# Check whether --with-system-hsqldb was given.
if test "${with_system_hsqldb+set}" = set; then :
  withval=$with_system_hsqldb;
fi


# Check whether --with-hsqldb-jar was given.
if test "${with_hsqldb_jar+set}" = set; then :
  withval=$with_hsqldb_jar;  HSQLDB_JAR="$withval"

fi


# Check whether --with-system-beanshell was given.
if test "${with_system_beanshell+set}" = set; then :
  withval=$with_system_beanshell;
fi


# Check whether --with-beanshell-jar was given.
if test "${with_beanshell_jar+set}" = set; then :
  withval=$with_beanshell_jar;  BSH_JAR="$withval"

fi

# Check whether --enable-presenter-extra-ui was given.
if test "${enable_presenter_extra_ui+set}" = set; then :
  enableval=$enable_presenter_extra_ui;
else
  enable_presenter_extra_ui=no
fi

# Check whether --enable-minimizer was given.
if test "${enable_minimizer+set}" = set; then :
  enableval=$enable_minimizer;
fi

# Check whether --enable-presenter-console was given.
if test "${enable_presenter_console+set}" = set; then :
  enableval=$enable_presenter_console;
fi

# Check whether --enable-pdfimport was given.
if test "${enable_pdfimport+set}" = set; then :
  enableval=$enable_pdfimport;
fi

# Check whether --enable-wiki-publisher was given.
if test "${enable_wiki_publisher+set}" = set; then :
  enableval=$enable_wiki_publisher;
fi


# Check whether --with-commons-codec-jar was given.
if test "${with_commons_codec_jar+set}" = set; then :
  withval=$with_commons_codec_jar;  COMMONS_CODEC_JAR="$withval"

fi


# Check whether --with-commons-lang-jar was given.
if test "${with_commons_lang_jar+set}" = set; then :
  withval=$with_commons_lang_jar;  COMMONS_LANG_JAR="$withval"

fi


# Check whether --with-commons-httpclient-jar was given.
if test "${with_commons_httpclient_jar+set}" = set; then :
  withval=$with_commons_httpclient_jar;  COMMONS_HTTPCLIENT_JAR="$withval"

fi


# Check whether --with-commons-logging-jar was given.
if test "${with_commons_logging_jar+set}" = set; then :
  withval=$with_commons_logging_jar;  COMMONS_LOGGING_JAR="$withval"

fi


# Check whether --with-servlet-api-jar was given.
if test "${with_servlet_api_jar+set}" = set; then :
  withval=$with_servlet_api_jar;  SERVLETAPI_JAR="$withval"

fi

# Check whether --enable-report-builder was given.
if test "${enable_report_builder+set}" = set; then :
  enableval=$enable_report_builder;
fi


# Check whether --with-system-jfreereport was given.
if test "${with_system_jfreereport+set}" = set; then :
  withval=$with_system_jfreereport;
fi


# Check whether --with-sac-jar was given.
if test "${with_sac_jar+set}" = set; then :
  withval=$with_sac_jar;  SAC_JAR="$withval"

fi


# Check whether --with-libxml-jar was given.
if test "${with_libxml_jar+set}" = set; then :
  withval=$with_libxml_jar;  LIBXML_JAR="$withval"

fi


# Check whether --with-flute-jar was given.
if test "${with_flute_jar+set}" = set; then :
  withval=$with_flute_jar;  FLUTE_JAR="$withval"

fi


# Check whether --with-jfreereport-jar was given.
if test "${with_jfreereport_jar+set}" = set; then :
  withval=$with_jfreereport_jar;  JFREEREPORT_JAR="$withval"

fi


# Check whether --with-liblayout-jar was given.
if test "${with_liblayout_jar+set}" = set; then :
  withval=$with_liblayout_jar;  LIBLAYOUT_JAR="$withval"

fi


# Check whether --with-libloader-jar was given.
if test "${with_libloader_jar+set}" = set; then :
  withval=$with_libloader_jar;  LIBLOADER_JAR="$withval"

fi


# Check whether --with-libloader-jar was given.
if test "${with_libloader_jar+set}" = set; then :
  withval=$with_libloader_jar;  LIBLOADER_JAR="$withval"

fi


# Check whether --with-libformula-jar was given.
if test "${with_libformula_jar+set}" = set; then :
  withval=$with_libformula_jar;  LIBFORMULA_JAR="$withval"

fi


# Check whether --with-librepository-jar was given.
if test "${with_librepository_jar+set}" = set; then :
  withval=$with_librepository_jar;  LIBREPOSITORY_JAR="$withval"

fi


# Check whether --with-libfonts-jar was given.
if test "${with_libfonts_jar+set}" = set; then :
  withval=$with_libfonts_jar;  LIBFONTS_JAR="$withval"

fi


# Check whether --with-libserializer-jar was given.
if test "${with_libserializer_jar+set}" = set; then :
  withval=$with_libserializer_jar;  LIBSERIALIZER_JAR="$withval"

fi


# Check whether --with-libbase-jar was given.
if test "${with_libbase_jar+set}" = set; then :
  withval=$with_libbase_jar;  LIBBASE_JAR="$withval"

fi


# Check whether --with-system-saxon was given.
if test "${with_system_saxon+set}" = set; then :
  withval=$with_system_saxon;
fi


# Check whether --with-saxon-jar was given.
if test "${with_saxon_jar+set}" = set; then :
  withval=$with_saxon_jar;  SAXON_JAR="$withval"

fi


# Check whether --with-system-libxslt was given.
if test "${with_system_libxslt+set}" = set; then :
  withval=$with_system_libxslt;
fi


# Check whether --with-system-odbc was given.
if test "${with_system_odbc+set}" = set; then :
  withval=$with_system_odbc;
fi


# Check whether --with-system-sane was given.
if test "${with_system_sane+set}" = set; then :
  withval=$with_system_sane;
fi


# Check whether --with-system-xrender was given.
if test "${with_system_xrender+set}" = set; then :
  withval=$with_system_xrender;
fi


# Check whether --with-system-curl was given.
if test "${with_system_curl+set}" = set; then :
  withval=$with_system_curl;
fi


# Check whether --with-system-boost was given.
if test "${with_system_boost+set}" = set; then :
  withval=$with_system_boost;
fi


# Check whether --with-system-vigra was given.
if test "${with_system_vigra+set}" = set; then :
  withval=$with_system_vigra;
fi

# Check whether --enable-neon was given.
if test "${enable_neon+set}" = set; then :
  enableval=$enable_neon;
fi

# Check whether --enable-Xaw was given.
if test "${enable_Xaw+set}" = set; then :
  enableval=$enable_Xaw;
fi


# Check whether --with-system-neon was given.
if test "${with_system_neon+set}" = set; then :
  withval=$with_system_neon;
fi


# Check whether --with-system-agg was given.
if test "${with_system_agg+set}" = set; then :
  withval=$with_system_agg;
fi


# Check whether --with-system-hunspell was given.
if test "${with_system_hunspell+set}" = set; then :
  withval=$with_system_hunspell;
fi


# Check whether --with-system-mythes was given.
if test "${with_system_mythes+set}" = set; then :
  withval=$with_system_mythes;
fi


# Check whether --with-system-altlinuxhyph was given.
if test "${with_system_altlinuxhyph+set}" = set; then :
  withval=$with_system_altlinuxhyph;
fi


# Check whether --with-system-lpsolve was given.
if test "${with_system_lpsolve+set}" = set; then :
  withval=$with_system_lpsolve;
fi


# Check whether --with-system-mozilla was given.
if test "${with_system_mozilla+set}" = set; then :
  withval=$with_system_mozilla; WITH_SYSTEM_MOZILLA=$withval
else
  WITH_SYSTEM_MOZILLA=no
fi


# Check whether --with-stlport was given.
if test "${with_stlport+set}" = set; then :
  withval=$with_stlport; WITH_STLPORT=$withval
else
  WITH_STLPORT=auto
fi


# Check whether --with-jdk-home was given.
if test "${with_jdk_home+set}" = set; then :
  withval=$with_jdk_home;
fi


# Check whether --with-gxx_include_path was given.
if test "${with_gxx_include_path+set}" = set; then :
  withval=$with_gxx_include_path;
fi


# Check whether --with-java was given.
if test "${with_java+set}" = set; then :
  withval=$with_java; if test "$withval" = "yes"; then WITH_JAVA=java; else WITH_JAVA=$withval; fi
else
  WITH_JAVA=java
fi

# Check whether --enable-gcjaot was given.
if test "${enable_gcjaot+set}" = set; then :
  enableval=$enable_gcjaot;
fi


# Check whether --with-ant-home was given.
if test "${with_ant_home+set}" = set; then :
  withval=$with_ant_home;
fi


# Check whether --with-perl-home was given.
if test "${with_perl_home+set}" = set; then :
  withval=$with_perl_home;
fi


# Check whether --with-cl-home was given.
if test "${with_cl_home+set}" = set; then :
  withval=$with_cl_home;
fi


# Check whether --with-mspdb-path was given.
if test "${with_mspdb_path+set}" = set; then :
  withval=$with_mspdb_path;
fi


# Check whether --with-midl-path was given.
if test "${with_midl_path+set}" = set; then :
  withval=$with_midl_path;
fi


# Check whether --with-csc-path was given.
if test "${with_csc_path+set}" = set; then :
  withval=$with_csc_path;
fi


# Check whether --with-nsis-path was given.
if test "${with_nsis_path+set}" = set; then :
  withval=$with_nsis_path;
fi


# Check whether --with-frame-home was given.
if test "${with_frame_home+set}" = set; then :
  withval=$with_frame_home;
fi


# Check whether --with-psdk-home was given.
if test "${with_psdk_home+set}" = set; then :
  withval=$with_psdk_home;
fi


# Check whether --with-directx-home was given.
if test "${with_directx_home+set}" = set; then :
  withval=$with_directx_home;
fi


# Check whether --with-mozilla-build was given.
if test "${with_mozilla_build+set}" = set; then :
  withval=$with_mozilla_build; MOZILLABUILD=$withval
fi


# Check whether --with-local-solenv was given.
if test "${with_local_solenv+set}" = set; then :
  withval=$with_local_solenv;
fi


# Check whether --with-local-solver was given.
if test "${with_local_solver+set}" = set; then :
  withval=$with_local_solver;
fi

# Check whether --enable-check-only was given.
if test "${enable_check_only+set}" = set; then :
  enableval=$enable_check_only;
fi

# Check whether --enable-ccache-skip was given.
if test "${enable_ccache_skip+set}" = set; then :
  enableval=$enable_ccache_skip;
else
  enable_ccache_skip=auto
fi


# Check whether --with-lang was given.
if test "${with_lang+set}" = set; then :
  withval=$with_lang;
fi


# Check whether --with-poor-help-localizations was given.
if test "${with_poor_help_localizations+set}" = set; then :
  withval=$with_poor_help_localizations;
fi


# Check whether --with-dict was given.
if test "${with_dict+set}" = set; then :
  withval=$with_dict;
fi


# Check whether --with-intro-bitmaps was given.
if test "${with_intro_bitmaps+set}" = set; then :
  withval=$with_intro_bitmaps;
fi


# Check whether --with-about-bitmaps was given.
if test "${with_about_bitmaps+set}" = set; then :
  withval=$with_about_bitmaps;
fi


# Check whether --with-vendor was given.
if test "${with_vendor+set}" = set; then :
  withval=$with_vendor;
fi


# Check whether --with-unix-wrapper was given.
if test "${with_unix_wrapper+set}" = set; then :
  withval=$with_unix_wrapper;
fi


# Check whether --with-asm-home was given.
if test "${with_asm_home+set}" = set; then :
  withval=$with_asm_home;
fi


# Check whether --with-os-version was given.
if test "${with_os_version+set}" = set; then :
  withval=$with_os_version;
fi


# Check whether --with-unzip-home was given.
if test "${with_unzip_home+set}" = set; then :
  withval=$with_unzip_home;
fi


# Check whether --with-zip-home was given.
if test "${with_zip_home+set}" = set; then :
  withval=$with_zip_home;
fi


# Check whether --with-mingwin was given.
if test "${with_mingwin+set}" = set; then :
  withval=$with_mingwin; WITH_MINGWIN=$withval
else
  WITH_MINGWIN=0
fi


# Check whether --with-use-shell was given.
if test "${with_use_shell+set}" = set; then :
  withval=$with_use_shell; with_use_shell=$withval
else
  with_use_shell="tcsh"
fi


# Check whether --with-build-version was given.
if test "${with_build_version+set}" = set; then :
  withval=$with_build_version; with_build_version=$withval
fi


# Check whether --with-alloc was given.
if test "${with_alloc+set}" = set; then :
  withval=$with_alloc;
fi

# Check whether --enable-verbose was given.
if test "${enable_verbose+set}" = set; then :
  enableval=$enable_verbose;
fi


BUILD_TYPE="OOo"


echo "********************************************************************"
echo ""
cat /dev/null > warn
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
if test "${ac_cv_path_GREP+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -z "$GREP"; then
  ac_path_GREP_found=false
  # Loop through the user's path and test for each of PROGNAME-LIST
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_prog in grep ggrep; do
    for ac_exec_ext in '' $ac_executable_extensions; do
      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
      { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
# Check for GNU ac_path_GREP and select it if it is found.
  # Check for GNU $ac_path_GREP
case `"$ac_path_GREP" --version 2>&1` in
*GNU*)
  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
*)
  ac_count=0
  $as_echo_n 0123456789 >"conftest.in"
  while :
  do
    cat "conftest.in" "conftest.in" >"conftest.tmp"
    mv "conftest.tmp" "conftest.in"
    cp "conftest.in" "conftest.nl"
    $as_echo 'GREP' >> "conftest.nl"
    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
    as_fn_arith $ac_count + 1 && ac_count=$as_val
    if test $ac_count -gt ${ac_path_GREP_max-0}; then
      # Best one so far, save it but keep looking for a better one
      ac_cv_path_GREP="$ac_path_GREP"
      ac_path_GREP_max=$ac_count
    fi
    # 10*(2^10) chars as input seems more than enough
    test $ac_count -gt 10 && break
  done
  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
esac

      $ac_path_GREP_found && break 3
    done
  done
  done
IFS=$as_save_IFS
  if test -z "$ac_cv_path_GREP"; then
    as_fn_error "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
  fi
else
  ac_cv_path_GREP=$GREP
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
$as_echo "$ac_cv_path_GREP" >&6; }
 GREP="$ac_cv_path_GREP"


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
$as_echo_n "checking for egrep... " >&6; }
if test "${ac_cv_path_EGREP+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
   then ac_cv_path_EGREP="$GREP -E"
   else
     if test -z "$EGREP"; then
  ac_path_EGREP_found=false
  # Loop through the user's path and test for each of PROGNAME-LIST
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_prog in egrep; do
    for ac_exec_ext in '' $ac_executable_extensions; do
      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
      { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
# Check for GNU ac_path_EGREP and select it if it is found.
  # Check for GNU $ac_path_EGREP
case `"$ac_path_EGREP" --version 2>&1` in
*GNU*)
  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
*)
  ac_count=0
  $as_echo_n 0123456789 >"conftest.in"
  while :
  do
    cat "conftest.in" "conftest.in" >"conftest.tmp"
    mv "conftest.tmp" "conftest.in"
    cp "conftest.in" "conftest.nl"
    $as_echo 'EGREP' >> "conftest.nl"
    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
    as_fn_arith $ac_count + 1 && ac_count=$as_val
    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
      # Best one so far, save it but keep looking for a better one
      ac_cv_path_EGREP="$ac_path_EGREP"
      ac_path_EGREP_max=$ac_count
    fi
    # 10*(2^10) chars as input seems more than enough
    test $ac_count -gt 10 && break
  done
  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
esac

      $ac_path_EGREP_found && break 3
    done
  done
  done
IFS=$as_save_IFS
  if test -z "$ac_cv_path_EGREP"; then
    as_fn_error "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
  fi
else
  ac_cv_path_EGREP=$EGREP
fi

   fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
$as_echo "$ac_cv_path_EGREP" >&6; }
 EGREP="$ac_cv_path_EGREP"


for ac_prog in gawk mawk nawk awk
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_AWK+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$AWK"; then
  ac_cv_prog_AWK="$AWK" # Let the user override the test.

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_prog_AWK="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
AWK=$ac_cv_prog_AWK
if test -n "$AWK"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
$as_echo "$AWK" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$AWK" && break
done

# Extract the first word of "$AWK", so it can be a program name with args.
set dummy $AWK; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_AWK+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $AWK in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
AWK=$ac_cv_path_AWK

if test -n "$AWK"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
$as_echo "$AWK" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


if test -z "$AWK"; then
   as_fn_error "install awk to run this script" "$LINENO" 5
echo "$as_me: error: install awk to run this script" >&2;}
   { (exit 1); exit 1; }; }
fi

for ac_prog in sed
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_SED+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $SED in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
SED=$ac_cv_path_SED

if test -n "$SED"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
$as_echo "$SED" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$SED" && break
done

if test -z "$SED"; then
   as_fn_error "install sed to run this script" "$LINENO" 5
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for solenv environment" >&5
$as_echo_n "checking for solenv environment... " >&6; }
echo "$as_me:$LINENO: checking for solenv environment" >&5
echo $ECHO_N "checking for solenv environment... $ECHO_C" >&6
if test -z "$with_local_solenv"; then
   LOCAL_SOLENV="DEFAULT"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: default" >&5
$as_echo "default" >&6; }
else
   LOCAL_SOLENV=$with_local_solenv
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_local_solenv" >&5
$as_echo "$with_local_solenv" >&6; }
fi



   SOURCEVERSION="`grep SOURCEVERSION= $_solenv/inc/minor.mk | $AWK -F"=" '{ print $2 }'`"

else
   as_fn_error "$_solenv/inc/minor.mk missing but needed for architecture/os detecion and proper environment script generation..." "$LINENO" 5
echo "$as_me: error: $_solenv/inc/minor.mk missing but needed for architecture/os detecion and proper environment script generation..." >&2;}
   { (exit 1); exit 1; }; }
fi

ac_aux_dir=
for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
  for ac_t in install-sh install.sh shtool; do
    if test -f "$ac_dir/$ac_t"; then
      ac_aux_dir=$ac_dir
      ac_install_sh="$ac_aux_dir/$ac_t -c"
      break 2
    fi
  done
    break
  elif test -f $ac_dir/shtool; then
    ac_aux_dir=$ac_dir
    ac_install_sh="$ac_aux_dir/shtool install -c"
    break
  fi
done
if test -z "$ac_aux_dir"; then
  as_fn_error "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5
fi

# These three variables are undocumented and unsupported,
# and are intended to be withdrawn in a future Autoconf release.
# They can cause serious problems if a builder's source tree is in a directory
# whose full name contains unusual characters.
ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.


# Make sure we can run config.sub.
$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
  as_fn_error "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
$as_echo_n "checking build system type... " >&6; }
if test "${ac_cv_build+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_build_alias=$build_alias
test "x$ac_build_alias" = x &&
  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
test "x$ac_build_alias" = x &&
  as_fn_error "cannot guess build type; you must specify one" "$LINENO" 5
ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
  as_fn_error "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
$as_echo "$ac_cv_build" >&6; }
case $ac_cv_build in
*-*-*) ;;
*) as_fn_error "invalid value of canonical build" "$LINENO" 5;;
esac
echo "$as_me:$LINENO: result: $ac_cv_build" >&5
echo "${ECHO_T}$ac_cv_build" >&6
build=$ac_cv_build
ac_save_IFS=$IFS; IFS='-'
set x $ac_cv_build
shift
build_cpu=$1
build_vendor=$2
shift; shift
# Remember, the first character of IFS is used to create $*,
# except with old shells:
build_os=$*
IFS=$ac_save_IFS
case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
$as_echo_n "checking host system type... " >&6; }
if test "${ac_cv_host+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test "x$host_alias" = x; then
  ac_cv_host=$ac_cv_build
else
  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
    as_fn_error "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
$as_echo "$ac_cv_host" >&6; }
case $ac_cv_host in
*-*-*) ;;
*) as_fn_error "invalid value of canonical host" "$LINENO" 5;;
esac
host=$ac_cv_host
ac_save_IFS=$IFS; IFS='-'
set x $ac_cv_host
shift
host_cpu=$1
host_vendor=$2
shift; shift
# Remember, the first character of IFS is used to create $*,
# except with old shells:
host_os=$*
IFS=$ac_save_IFS
case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
$as_echo_n "checking target system type... " >&6; }
if test "${ac_cv_target+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test "x$target_alias" = x; then
  ac_cv_target=$ac_cv_host
else
  ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
    as_fn_error "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
$as_echo "$ac_cv_target" >&6; }
case $ac_cv_target in
*-*-*) ;;
*) as_fn_error "invalid value of canonical target" "$LINENO" 5;;
esac
target=$ac_cv_target
ac_save_IFS=$IFS; IFS='-'
set x $ac_cv_target
shift
target_cpu=$1
target_vendor=$2
shift; shift
# Remember, the first character of IFS is used to create $*,
# except with old shells:
target_os=$*
IFS=$ac_save_IFS
case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac


# The aliases save the names the user supplied, while $host etc.

  test "$program_prefix$program_suffix$program_transform_name" = \
    NONENONEs,x,x, &&
  program_prefix=${target_alias}-

if test "$build" != "$host" -o "$build" != "$target" \
  -o "$host" != "$target"; then
	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cross-compiling by any means is not supported (yet)!" >&5
$as_echo "$as_me: WARNING: cross-compiling by any means is not supported (yet)!" >&2;}
	echo "cross-compiling by any means is not supported (yet)!" >> warn
fi

if echo "$build_os" | grep cygwin; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking Cygwin version" >&5
$as_echo_n "checking Cygwin version... " >&6; }
   CygwinVer=`uname -r`
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CygwinVer" >&5
$as_echo "$CygwinVer" >&6; }
   if test "`echo $CygwinVer | $AWK -F . '{ print $1$2 }'`" -lt "15"; then
      as_fn_error "You need at least Cygwin V1.5.x" "$LINENO" 5
echo "$as_me: error: You need at least Cygwin V1.5.x" >&2;}
   { (exit 1); exit 1; }; }
   fi
else
   CygwinVer="false"

		_os=SunOS
		# Extract the first word of "gtar", so it can be a program name with args.
set dummy gtar; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_GNUTAR+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $GNUTAR in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_GNUTAR="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
GNUTAR=$ac_cv_path_GNUTAR

if test -n "$GNUTAR"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNUTAR" >&5
$as_echo "$GNUTAR" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


		if test -z "$GNUTAR"; then
			as_fn_error "gtar (gnu tar) not found but needed. Install it (SUN Freeware package)." "$LINENO" 5
echo "$as_me: error: gtar (gnu tar) not found but needed. Install it (SUN Freeware package)." >&2;}
   { (exit 1); exit 1; }; }
		fi


						   		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the Solaris operating system release" >&5
$as_echo_n "checking the Solaris operating system release... " >&6; }
   		_os_release=`echo $build_os | $SED -e s/solaris2\.//`
		if test "$_os_release" -lt "6"; then
      			as_fn_error "use solaris >= 6 to build OpenOffice.org" "$LINENO" 5
echo "$as_me: error: use solaris >= 6 to build OpenOffice.org" >&2;}
   { (exit 1); exit 1; }; }
   		else
      			{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok ($_os_release)" >&5
$as_echo "ok ($_os_release)" >&6; }
   		fi

   		   		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the processor type" >&5
$as_echo_n "checking the processor type... " >&6; }
   		if test "$build_cpu" = "sparc" -o "$build_cpu" = "i386"; then
      			{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok ($build_cpu)" >&5
$as_echo "ok ($build_cpu)" >&6; }
   		else
      			as_fn_error "only sparc and i386 processors are supported" "$LINENO" 5
echo "$as_me: error: only sparc and i386 processors are supported" >&2;}
   { (exit 1); exit 1; }; }
   		fi
		;;
	linux-gnu*)

		test_freetype=no
		_os=Darwin
      if test "$enable_systray" = "yes" && test "$enable_gtk" != "no"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Disabling gtk-quickstarter - not supported on Mac. Use --disable-systray" >&5
$as_echo "$as_me: WARNING: Disabling gtk-quickstarter - not supported on Mac. Use --disable-systray" >&2;}
         echo "Disabling gtk-quickstarter - not supported on Mac. Use --disable-systray" >>warn
         enable_systray=no
      fi

		test_cups=yes
        test_randr=yes
		test_freetype=yes
		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the FreeBSD operating system release" >&5
$as_echo_n "checking the FreeBSD operating system release... " >&6; }
		if test -n "$with_os_version"; then
			OSVERSION="$with_os_version"
		else
			OSVERSION=`/sbin/sysctl -n kern.osreldate`
		fi
		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: found OSVERSION=$OSVERSION" >&5
$as_echo "found OSVERSION=$OSVERSION" >&6; }
		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which thread library to use" >&5
$as_echo_n "checking which thread library to use... " >&6; }
		if test "$OSVERSION" -lt "500016"; then
			PTHREAD_CFLAGS="-D_THREAD_SAFE"
			PTHREAD_LIBS="-pthread"

			PTHREAD_CFLAGS=""
			PTHREAD_LIBS="-pthread"
		fi
		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PTHREAD_LIBS" >&5
$as_echo "$PTHREAD_LIBS" >&6; }
		_os=FreeBSD
		;;
	osf)

		_os=AIX
		;;
   *)
   as_fn_error "$_os operating system is not suitable to build OpenOffice.org!" "$LINENO" 5
echo "$as_me: error: $_os operating system is not suitable to build OpenOffice.org!" >&2;}
   { (exit 1); exit 1; }; }
   ;;
esac





{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable crashdump feature" >&5
$as_echo_n "checking whether to enable crashdump feature... " >&6; }
if test "$enable_crashdump" = "yes"; then
   ENABLE_CRASHDUMP="TRUE"
   BUILD_TYPE="$BUILD_TYPE CRASHREP"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
   ENABLE_CRASHDUMP=""
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi



fi

if test "$_os" = "WINNT"; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use the standard non-optimizing compiler" >&5
$as_echo_n "checking whether to use the standard non-optimizing compiler... " >&6; }
   if test "$enable_cl_standard" = "" -o "$enable_cl_standard" = "no"; then
      VC_STANDARD=""
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   else
      VC_STANDARD="TRUE"
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   fi

fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to turn warnings to errors" >&5
$as_echo_n "checking whether to turn warnings to errors... " >&6; }
if test -n "$enable_werror" && test "$enable_werror" != "no"; then
   ENABLE_WERROR="TRUE"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Turning warnings to errors has no effect in modules or" >&5
$as_echo "$as_me: WARNING: Turning warnings to errors has no effect in modules or" >&2;}
   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: on platforms where it has been disabled explicitely" >&5
$as_echo "$as_me: WARNING: on platforms where it has been disabled explicitely" >&2;}
   echo "Turning warnings to errors has no effect in modules or on platforms where it has been disabled explicitely" >> warn
else
   ENABLE_WERROR="FALSE"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to do a debug build" >&5
$as_echo_n "checking whether to do a debug build... " >&6; }
if test -n "$enable_debug" && test "$enable_debug" != "no"; then
   ENABLE_DEBUG="TRUE"
   if test -z "$enable_symbols"; then
      enable_symbols="yes"
   fi
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
   ENABLE_DEBUG="FALSE"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build with additional debug utilities" >&5
$as_echo_n "checking whether to build with additional debug utilities... " >&6; }
if test -n "$enable_dbgutil" && test "$enable_dbgutil" != "no"; then
   PROEXT=""
   PRODUCT=""
   PROFULLSWITCH=""
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
   PRODUCT="full"
   PROFULLSWITCH="product=full"
   PROEXT=".pro"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, full product build" >&5
$as_echo "no, full product build" >&6; }
fi




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to include symbols into final build" >&5
$as_echo_n "checking whether to include symbols into final build... " >&6; }
if test -n "$enable_symbols" && test "$enable_symbols" != "no"; then
	if test "$enable_symbols" = "yes" -o "$enable_symbols" = "TRUE"; then
		ENABLE_SYMBOLS="TRUE"
		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
	else
		if test "$enable_symbols" = "SMALL" -o "$enable_symbols" = "small"; then
			ENABLE_SYMBOLS="SMALL"
			{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, small ones" >&5
$as_echo "yes, small ones" >&6; }
		else if test "$enable_symbols" != "no" ; then
			     echo enable symbols is: $enable_symbols
			     as_fn_error "--enable-symbols only accepts yes, TRUE or SMALL as parameter." "$LINENO" 5
echo "$as_me: error: --enable-symbols only accepts yes, TRUE or SMALL as parameter." >&2;}
   { (exit 1); exit 1; }; }
           	     else
              		     ENABLE_SYMBOLS=
		     fi

	fi
else
   ENABLE_SYMBOLS=
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to strip the solver or not." >&5
$as_echo_n "checking whether to strip the solver or not.... " >&6; }
if test -n "$enable_strip_solver"; then
   if test "$enable_strip_solver" = "yes"; then
      DISABLE_STRIP=
   else if test "$enable_strip_solver" = "no"; then
           DISABLE_STRIP="TRUE"
        else
           as_fn_error "--disable-strip-solver only accepts yes or no as parameter." "$LINENO" 5
echo "$as_me: error: --disable-strip-solver only accepts yes or no as parameter." >&2;}
   { (exit 1); exit 1; }; }
        fi
   fi
else

fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable native CUPS support" >&5
$as_echo_n "checking whether to enable native CUPS support... " >&6; }
if test "$test_cups" = "yes" -a \( "$enable_cups" = "yes" -o "$enable_cups" = "TRUE" \) ; then
   ENABLE_CUPS="TRUE"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
   ENABLE_CUPS=""
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable fontconfig support" >&5
$as_echo_n "checking whether to enable fontconfig support... " >&6; }
if test "$_os" != "WINNT" -a "$_os" != "Darwin" -a \( "$enable_fontconfig" = "yes" -o "$enable_fontconfig" = "TRUE" \); then
   ENABLE_FONTCONFIG="TRUE"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
   ENABLE_FONTCONFIG=""
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi



{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable filters for legacy binary file formats (StarOffice 5.2)" >&5
$as_echo_n "checking whether to enable filters for legacy binary file formats (StarOffice 5.2)... " >&6; }
if test "$enable_binfilter" = "no"; then
   WITH_BINFILTER="NO"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
   WITH_BINFILTER="YES"
   BUILD_TYPE="$BUILD_TYPE BINFILTER"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
fi


if test "$_os" = "WINNT"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use DirectX" >&5
$as_echo_n "checking whether to use DirectX... " >&6; }
   if test "$enable_directx" = "yes" -o "$enable_directx" = "TRUE" -o "$enable_directx" = ""; then
      ENABLE_DIRECTX="TRUE"
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   else
      ENABLE_DIRECTX=""
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   fi


   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use ActiveX" >&5
$as_echo_n "checking whether to use ActiveX... " >&6; }
   if test "$enable_activex" = "yes" -o "$enable_activex" = "TRUE" -o "$enable_activex" = ""; then
      DISABLE_ACTIVEX=""
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   else
      DISABLE_ACTIVEX="TRUE"
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   fi


   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use ATL" >&5
$as_echo_n "checking whether to use ATL... " >&6; }
   if test "$enable_atl" = "yes" -o "$enable_atl" = "TRUE" -o "$enable_atl" = ""; then
      DISABLE_ATL=""
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   else
      DISABLE_ATL="TRUE"
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   fi


fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use RPATH in shared libraries" >&5
$as_echo_n "checking whether to use RPATH in shared libraries... " >&6; }
if test "$enable_rpath" = "no"; then
   ENABLE_RPATH="no"
else
   ENABLE_RPATH="yes"
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_RPATH" >&5
$as_echo "$ENABLE_RPATH" >&6; }


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to include MySpell dictionaries" >&5
$as_echo_n "checking whether to include MySpell dictionaries... " >&6; }
if test -z "$with_myspell_dicts" || test "$with_myspell_dicts" = "yes"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
  WITH_MYSPELL_DICTS=YES
  BUILD_TYPE="$BUILD_TYPE DICTIONARIES"
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
  WITH_MYSPELL_DICTS=NO
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use dicts from external paths" >&5
$as_echo_n "checking whether to use dicts from external paths... " >&6; }
if test -n "$with_system_dicts" -a "$with_system_dicts" = "yes"; then
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
 SYSTEM_DICTS=YES
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for spelling dictionary directory" >&5
$as_echo_n "checking for spelling dictionary directory... " >&6; }
 if test -n "$with_external_dict_dir"; then
 	DICT_SYSTEM_DIR=file://$with_external_dict_dir
 else
 	DICT_SYSTEM_DIR=file:///usr/share/hunspell
 fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DICT_SYSTEM_DIR" >&5
$as_echo "$DICT_SYSTEM_DIR" >&6; }
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for hyphenation patterns directory" >&5
$as_echo_n "checking for hyphenation patterns directory... " >&6; }
 if test -n "$with_external_hyph_dir"; then
 	HYPH_SYSTEM_DIR=file://$with_external_hyph_dir
 else
 	HYPH_SYSTEM_DIR=file:///usr/share/hyphen
 fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HYPH_SYSTEM_DIR" >&5
$as_echo "$HYPH_SYSTEM_DIR" >&6; }
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for thesaurus directory" >&5
$as_echo_n "checking for thesaurus directory... " >&6; }
 if test -n "$with_external_thes_dir"; then
 	THES_SYSTEM_DIR=file://$with_external_thes_dir
 else
 	THES_SYSTEM_DIR=file:///usr/share/mythes
 fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $THES_SYSTEM_DIR" >&5
$as_echo "$THES_SYSTEM_DIR" >&6; }
else
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
	SYSTEM_DICTS=NO
fi






{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which shell to use" >&5
$as_echo_n "checking which shell to use... " >&6; }
echo $ECHO_N "checking which shell to use... $ECHO_C" >&6
if test $_os = "WINNT"; then
      if test "$with_use_shell" != "tcsh" -a "$with_use_shell" != "bash"; then
      as_fn_error "only \"tcsh\" or \"bash\" are supported options" "$LINENO" 5
echo "$as_me: error: only \"tcsh\" or \"bash\" are supported options" >&2;}
   { (exit 1); exit 1; }; }
   fi
                     if test -L $AWK -o -L `which awk` -o -L `which tar` -o -L `which gunzip` ; then
         as_fn_error "$AWK, awk, tar or gunzip is a cygwin symlink!
Native windows programs cannot use cygwin symlinks. Remove the symbolic
link, and copy the program to the name of the link." "$LINENO" 5
echo "$as_me: error: $AWK, awk, tar or gunzip is a cygwin symlink!
Native windows programs cannot use cygwin symlinks. Remove the symbolic
link, and copy the program to the name of the link." >&2;}
   { (exit 1); exit 1; }; }
      fi
                  CC=`echo $CC | $SED "s/^guw.exe //"`
   CXX=`echo $CXX | $SED "s/^guw.exe //"`

   fi
elif test $_os = "OS2"; then
   if test "$with_use_shell" != "tcsh"; then
      as_fn_error "only \"tcsh\" is supported options" "$LINENO" 5
echo "$as_me: error: only \"tcsh\" is supported options" >&2;}
   { (exit 1); exit 1; }; }
   fi
else
            if test "$with_use_shell" != "tcsh" -a "$with_use_shell" != "bash"; then
      as_fn_error "only \"tcsh\" or \"bash\" are supported options" "$LINENO" 5
echo "$as_me: error: only \"tcsh\" or \"bash\" are supported options" >&2;}
   { (exit 1); exit 1; }; }
   fi
fi
USE_SHELL="$with_use_shell"
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $USE_SHELL" >&5
$as_echo "$USE_SHELL" >&6; }



if test "$_os" = "WINNT" ; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for cygwin gcc/g++" >&5
$as_echo_n "checking for cygwin gcc/g++... " >&6; }
   if which gcc > /dev/null && which g++ > /dev/null ; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
$as_echo "found" >&6; }
   else
      as_fn_error "cygwin gcc and g++ are needed, please install them." "$LINENO" 5
echo "$as_me: error: cygwin gcc and g++ are needed, please install them." >&2;}
   { (exit 1); exit 1; }; }
   fi
fi


if test "$with_use_shell" = "tcsh"; then
   # Extract the first word of "tcsh", so it can be a program name with args.
set dummy tcsh; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_SHELLPATH+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $SHELLPATH in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_SHELLPATH="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
SHELLPATH=$ac_cv_path_SHELLPATH

if test -n "$SHELLPATH"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SHELLPATH" >&5
$as_echo "$SHELLPATH" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


   if test -z "$SHELLPATH"; then
      as_fn_error "tcsh not found in \$PATH" "$LINENO" 5
echo "$as_me: error: tcsh not found in \$PATH" >&2;}
   { (exit 1); exit 1; }; }
   else
      SHELLPATH=`echo $SHELLPATH | $SED -n "s/\/tcsh$//p"`
   fi
elif test "$with_use_shell" = "bash"; then
   # Extract the first word of "bash", so it can be a program name with args.
set dummy bash; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_SHELLPATH+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $SHELLPATH in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_SHELLPATH="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
SHELLPATH=$ac_cv_path_SHELLPATH

if test -n "$SHELLPATH"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SHELLPATH" >&5
$as_echo "$SHELLPATH" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


   if test -z "$SHELLPATH"; then
      as_fn_error "bash not found in \$PATH" "$LINENO" 5
echo "$as_me: error: bash not found in \$PATH" >&2;}
   { (exit 1); exit 1; }; }
   else
      SHELLPATH=`echo $SHELLPATH | $SED -n "s/\/bash$//p"`
   fi
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Windows/OS/2 4NT builds don't test for the shell" >&5
$as_echo "$as_me: WARNING: Windows/OS/2 4NT builds don't test for the shell" >&2;}
   SHELLPATH="NO_SHELLPATH_NEEDED"
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking gcc home" >&5
$as_echo_n "checking gcc home... " >&6; }
if test -z "$with_gcc_home"; then
	GCC_HOME=`which gcc | $SED -e s,/bin/gcc,,`
else
	GCC_HOME="$with_gcc_home"
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $GCC_HOME" >&5
$as_echo "$GCC_HOME" >&6; }


if test -n "$with_gcc_home"; then

if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
set dummy ${ac_tool_prefix}gcc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_CC+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_CC"; then
  ac_ct_CC=$CC
  # Extract the first word of "gcc", so it can be a program name with args.
set dummy gcc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_CC"; then
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_prog_ac_ct_CC="gcc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
$as_echo "$ac_ct_CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_CC" = x; then
    CC=""
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    CC=$ac_ct_CC
  fi
else
  CC="$ac_cv_prog_CC"
fi

if test -z "$CC"; then
          if test -n "$ac_tool_prefix"; then
    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
set dummy ${ac_tool_prefix}cc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_CC+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_prog_CC="${ac_tool_prefix}cc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi
  ac_ct_CC=$CC
  # Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
echo "$as_me:$LINENO: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  if test -n "$ac_ct_CC"; then
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  for ac_exec_ext in '' $ac_executable_extensions; do
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_CC="cc"
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
done

fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
echo "${ECHO_T}$ac_ct_CC" >&6
else
  echo "$as_me:$LINENO: result: no" >&5
echo "${ECHO_T}no" >&6
fi

  CC=$ac_ct_CC
else
  CC="$ac_cv_prog_CC"
fi

fi
if test -z "$CC"; then
  # Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_CC+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
       ac_prog_rejected=yes
       continue
     fi
    ac_cv_prog_CC="cc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

if test $ac_prog_rejected = yes; then
  # We found a bogon in the path, so make sure we never use it.

fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$CC"; then
  if test -n "$ac_tool_prefix"; then
  for ac_prog in cl.exe
  do
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_CC+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    test -n "$CC" && break
  done
fi
if test -z "$CC"; then
  ac_ct_CC=$CC
  for ac_prog in cl.exe
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_CC"; then
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_prog_ac_ct_CC="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
$as_echo "$ac_ct_CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ac_ct_CC" && break
done

  if test "x$ac_ct_CC" = x; then
    CC=""
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    CC=$ac_ct_CC
  fi
fi

fi


test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error "no acceptable C compiler found in \$PATH
See \`config.log' for more details." "$LINENO" 5; }

# Provide some information about the compiler.
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
set X $ac_compile
ac_compiler=$2
for ac_option in --version -v -V -qversion; do
  { { ac_try="$ac_compiler $ac_option >&5"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    sed '10a\
... rest of stderr output deleted ...
         10q' conftest.err >conftest.er1
    cat conftest.er1 >&5
  fi
  rm -f conftest.er1 conftest.err
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
done

cat confdefs.h - <<_ACEOF >conftest.$ac_ext

cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

int

}
_ACEOF
ac_clean_files_save=$ac_clean_files
ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
# Try to create an executable without -o first, disregard a.out.
# It will help us diagnose broken compilers, and finding out an intuition
# of exeext.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
$as_echo_n "checking whether the C compiler works... " >&6; }
ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`

# The possible output files:
ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"

ac_rmfiles=
for ac_file in $ac_files
do
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
  esac
done
rm -f $ac_rmfiles

if { { ac_try="$ac_link_default"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link_default") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then :
  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
# in a Makefile.  We should not override ac_cv_exeext if it was cached,
# so that the user can short-circuit this test for compilers unknown to
# Autoconf.
for ac_file in $ac_files ''
ac_cv_exeext=
# b.out is created by i960 compilers.
for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
do
  test -f "$ac_file" || continue
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
	;;
    conftest.$ac_ext )
	# This is the source file.
	;;
    [ab].out )
	# We found the default executable, but exeext='' is most
	# certainly right.
	break;;
    *.* )
	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
	then :; else
	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
	fi
	# We set ac_cv_exeext here because the later test for it is not
	# safe: cross compilers may not add the suffix if given an `-o'
	# argument, so we may need to know it at that point already.
	# Even if this section looks crufty: it has the advantage of
	# actually working.
	break;;
    * )
	break;;
  esac
done
test "$ac_cv_exeext" = no && ac_cv_exeext=

else
  ac_file=''
fi
if test -z "$ac_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
{ as_fn_set_status 77
as_fn_error "C compiler cannot create executables
See \`config.log' for more details." "$LINENO" 5; }; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
$as_echo_n "checking for C compiler default output file name... " >&6; }
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
$as_echo "$ac_file" >&6; }
ac_exeext=$ac_cv_exeext

rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
ac_clean_files=$ac_clean_files_save
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
$as_echo_n "checking for suffix of executables... " >&6; }
if { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then :
    cross_compiling=no
  else
    if test "$cross_compiling" = maybe; then
	cross_compiling=yes
    else
	{ { echo "$as_me:$LINENO: error: cannot run C compiled programs.
If you meant to cross compile, use \`--host'.
See \`config.log' for more details." >&5
echo "$as_me: error: cannot run C compiled programs.
If you meant to cross compile, use \`--host'.
See \`config.log' for more details." >&2;}
   { (exit 1); exit 1; }; }
    fi
  fi
fi
echo "$as_me:$LINENO: result: yes" >&5
echo "${ECHO_T}yes" >&6

rm -f a.out a.exe conftest$ac_cv_exeext b.out
ac_clean_files=$ac_clean_files_save
# Check the compiler produces executables we can run.  If not, either
# the compiler is broken, or we cross compile.
echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
echo "$as_me:$LINENO: result: $cross_compiling" >&5
echo "${ECHO_T}$cross_compiling" >&6

echo "$as_me:$LINENO: checking for suffix of executables" >&5
echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; then
  # If both `conftest.exe' and `conftest' are `present' (well, observable)
# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
# work properly (i.e., refer to `conftest.exe'), while it won't with

for ac_file in conftest.exe conftest conftest.*; do
  test -f "$ac_file" || continue
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
	  export ac_cv_exeext
	  break;;
    * ) break;;
  esac
done
else
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error "cannot compute suffix of executables: cannot compile and link
See \`config.log' for more details." "$LINENO" 5; }
fi
rm -f conftest conftest$ac_cv_exeext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
$as_echo "$ac_cv_exeext" >&6; }
echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
echo "${ECHO_T}$ac_cv_exeext" >&6

rm -f conftest.$ac_ext
EXEEXT=$ac_cv_exeext
ac_exeext=$EXEEXT
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <stdio.h>
int
main ()
{
FILE *f = fopen ("conftest.out", "w");
 return ferror (f) || fclose (f) != 0;

  ;
  return 0;
}
_ACEOF
ac_clean_files="$ac_clean_files conftest.out"
# Check that the compiler produces executables we can run.  If not, either
# the compiler is broken, or we cross compile.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
$as_echo_n "checking whether we are cross compiling... " >&6; }
if test "$cross_compiling" != yes; then
  { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
  if { ac_try='./conftest$ac_cv_exeext'
  { { case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_try") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; }; then
    cross_compiling=no
  else
    if test "$cross_compiling" = maybe; then
	cross_compiling=yes
    else
	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error "cannot run C compiled programs.
If you meant to cross compile, use \`--host'.
See \`config.log' for more details." "$LINENO" 5; }
    fi
  fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
$as_echo "$cross_compiling" >&6; }

rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
ac_clean_files=$ac_clean_files_save
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
$as_echo_n "checking for suffix of object files... " >&6; }
if test "${ac_cv_objext+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int

}
_ACEOF
rm -f conftest.o conftest.obj
if { { ac_try="$ac_compile"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compile") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then :
  for ac_file in conftest.o conftest.obj conftest.*; do
  test -f "$ac_file" || continue;
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
       break;;
  esac
done
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error "cannot compute suffix of object files: cannot compile
See \`config.log' for more details." "$LINENO" 5; }
fi
fi

rm -f conftest.$ac_cv_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
$as_echo "$ac_cv_objext" >&6; }
OBJEXT=$ac_cv_objext
ac_objext=$OBJEXT
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
if test "${ac_cv_c_compiler_gnu+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

int

  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_compiler_gnu=yes
else
  ac_compiler_gnu=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_compiler_gnu=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
ac_cv_c_compiler_gnu=$ac_compiler_gnu

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
$as_echo "$ac_cv_c_compiler_gnu" >&6; }
if test $ac_compiler_gnu = yes; then
  GCC=yes
else
  GCC=
fi
ac_test_CFLAGS=${CFLAGS+set}
ac_save_CFLAGS=$CFLAGS
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
$as_echo_n "checking whether $CC accepts -g... " >&6; }
if test "${ac_cv_prog_cc_g+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_save_c_werror_flag=$ac_c_werror_flag
   ac_c_werror_flag=yes
   ac_cv_prog_cc_g=no
   CFLAGS="-g"
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_prog_cc_g=yes
else
  CFLAGS=""
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :

else
  ac_c_werror_flag=$ac_save_c_werror_flag
	 CFLAGS="-g"
	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_prog_cc_g=yes
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
   ac_c_werror_flag=$ac_save_c_werror_flag
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
$as_echo "$ac_cv_prog_cc_g" >&6; }
if test "$ac_test_CFLAGS" = set; then
  CFLAGS=$ac_save_CFLAGS
elif test $ac_cv_prog_cc_g = yes; then

    CFLAGS=
  fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
if test "${ac_cv_prog_cc_c89+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_cv_prog_cc_c89=no
ac_save_CC=$CC
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <stdarg.h>
#include <stdio.h>

/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
   function prototypes and stuff, but not '\xHH' hex character constants.
   These don't provoke an error unfortunately, instead are silently treated
   as 'x'.  The following induces an error, until -std is added to get
   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
   array size at least.  It's necessary to write '\x00'==0 to get something
   that's true only with -std.  */
int osf4_cc_array ['\x00' == 0 ? 1 : -1];

/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
   inside strings and character constants.  */
#define FOO(x) 'x'
int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];

int test (int i, double x);
struct s1 {int (*f) (int a);};
struct s2 {int (*f) (double a);};

  return 0;
}
_ACEOF
for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
# AIX			-qlanglvl=ansi
# Ultrix and OSF/1	-std1
# HP-UX 10.20 and later	-Ae
# HP-UX older versions	-Aa -D_HPUX_SOURCE
# SVR4			-Xc -D__EXTENSIONS__
for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
do
  CC="$ac_save_CC $ac_arg"
  if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_prog_cc_c89=$ac_arg
fi
rm -f core conftest.err conftest.$ac_objext
  test "x$ac_cv_prog_cc_c89" != "xno" && break
done
rm -f conftest.$ac_ext
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_prog_cc_stdc=$ac_arg
break
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

fi
rm -f conftest.err conftest.$ac_objext
done
rm -f conftest.$ac_ext conftest.$ac_objext
CC=$ac_save_CC

fi
# AC_CACHE_VAL
case "x$ac_cv_prog_cc_c89" in
  x)
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
$as_echo "none needed" >&6; } ;;
  xno)
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
$as_echo "unsupported" >&6; } ;;
  *)
    CC="$CC $ac_cv_prog_cc_c89"
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
esac
if test "x$ac_cv_prog_cc_c89" != xno; then :

fi

  choke me
#endif
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  for ac_declaration in \
   '' \
   'extern "C" void std::exit (int) throw (); using std::exit;' \
   'extern "C" void std::exit (int); using std::exit;' \
   'extern "C" void exit (int) throw ();' \
   'extern "C" void exit (int);' \
   'void exit (int);'
do
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_declaration
#include <stdlib.h>
int
main ()
{
exit (42);
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  :
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

continue
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_declaration
int
main ()
{
exit (42);
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  break
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
done
rm -f conftest*
if test -n "$ac_declaration"; then
  echo '#ifdef __cplusplus' >>confdefs.h
  echo $ac_declaration      >>confdefs.h
  echo '#endif'             >>confdefs.h
fi

else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_COMPATH+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $COMPATH in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_COMPATH="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
COMPATH=$ac_cv_path_COMPATH

if test -n "$COMPATH"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPATH" >&5
$as_echo "$COMPATH" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$COMPATH" && break
done

echo $COMPATH
GCCVER=20995
if test \( "$_os" != "WINNT" -o "$WITH_MINGWIN" = "yes" \) -a "$GCC" = "yes"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking the GNU gcc compiler version" >&5
$as_echo_n "checking the GNU gcc compiler version... " >&6; }
   _gcc_version=`$CC -dumpversion`
   _gcc_major=`echo $_gcc_version | $AWK -F. '{ print \$1 }'`
   _gcc_longver=`echo $_gcc_version | $AWK -F. '{ print \$1*10000+\$2*100+\$3 }'`
   GCCVER=`echo $_gcc_version | $AWK -F. '{ print \$1*10000+\$2*100+\$3 }'`

   if test "$_gcc_major" -lt "3"; then
      as_fn_error "found version \"$_gcc_version\", use version 3+ of the gcc compiler" "$LINENO" 5
echo "$as_me: error: found version \"$_gcc_version\", use version 3+ of the gcc compiler" >&2;}
   { (exit 1); exit 1; }; }
   else
      if test "$GCCVER" -eq "030203"; then
	    if test "$ENABLE_SYMBOLS" = "SMALL"; then
           as_fn_error "version \"$_gcc_version\" gives internal error with small." "$LINENO" 5
echo "$as_me: error: version \"$_gcc_version\" gives internal error with small." >&2;}
   { (exit 1); exit 1; }; }
	    fi
      fi
   fi
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked (gcc $_gcc_version)" >&5
$as_echo "checked (gcc $_gcc_version)" >&6; }
   if test "$_os" = "SunOS"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking gcc linker" >&5
$as_echo_n "checking gcc linker... " >&6; }
      if $CC -Wl,--version 2>&1 |head -n 1| grep -v GNU > /dev/null;then
          as_fn_error "failed (not GNU ld). Use GNU ld instead of Sun ld on Solaris" "$LINENO" 5
      fi
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok (GNU ld)" >&5
$as_echo "ok (GNU ld)" >&6; }
      echo "$as_me:$LINENO: result: ok (GNU ld)" >&5
echo "${ECHO_T}ok (GNU ld)" >&6
   fi
fi


HAVE_LD_BSYMBOLIC_FUNCTIONS=
if test "$GCC" = "yes"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -Bsymbolic-functions linker support " >&5
$as_echo_n "checking for -Bsymbolic-functions linker support ... " >&6; }
   bsymbolic_functions_ldflags_save=$LDFLAGS
   LDFLAGS="$LDFLAGS -Wl,-Bsymbolic-functions -Wl,--dynamic-list-cpp-new -Wl,--dynamic-list-cpp-typeinfo"

cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

   #include <stdio.h>

  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  HAVE_LD_BSYMBOLIC_FUNCTIONS=TRUE
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext

fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
   if test "z$HAVE_LD_BSYMBOLIC_FUNCTIONS" = "zTRUE"; then
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: found " >&5
$as_echo "found " >&6; }
   else
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found " >&5
$as_echo "not found " >&6; }
   fi
   LDFLAGS=$bsymbolic_functions_ldflags_save
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable pch feature" >&5
$as_echo_n "checking whether to enable pch feature... " >&6; }
if test -n "$enable_pch" && test "$enable_pch" != "no"; then
   if test "$_os" = "WINNT" -a "$WITH_MINGWIN" != "yes"; then
	   ENABLE_PCH="TRUE"
	   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   elif test "$GCC" = "yes" -a "$GCCVER" -gt "030400"; then
	   ENABLE_PCH="TRUE"
	   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   else
	   ENABLE_PCH=""
	   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Precompiled header not yet supported for your platform/compiler" >&5
$as_echo "$as_me: WARNING: Precompiled header not yet supported for your platform/compiler" >&2;}
   fi
else
   ENABLE_PCH=""
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable hid list feature" >&5
$as_echo_n "checking whether to enable hid list feature... " >&6; }
if test -n "$enable_hids" && test "$enable_hids" != "no"; then
   NO_HIDS=""
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
   NO_HIDS="TRUE"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU make" >&5
$as_echo_n "checking for GNU make... " >&6; }
for a in "$MAKE" $GNUMAKE make gmake gnumake; do
      $a --version 2> /dev/null | grep GNU  2>&1 > /dev/null
      if test $? -eq 0;  then

           break
      fi
done
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNUMAKE" >&5
$as_echo "$GNUMAKE" >&6; }
if test -z "$GNUMAKE"; then
    as_fn_error "not found. install GNU make." "$LINENO" 5
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the GNU make version" >&5
$as_echo_n "checking the GNU make version... " >&6; }
echo "$as_me:$LINENO: checking the GNU make version" >&5
echo $ECHO_N "checking the GNU make version... $ECHO_C" >&6
_make_version=`$GNUMAKE --version | grep GNU | $SED -e 's@^[^0-9]*@@' -e 's@ .*@@' -e 's@,.*@@'`;
_make_longver=`echo $_make_version | $AWK -F. '{ print \$1*10000+\$2*100+\$3 }'`
if test "$_make_longver" -ge "037901" ; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNUMAKE $_make_version" >&5
$as_echo "$GNUMAKE $_make_version" >&6; }
else
   if test "$_os" = "Darwin"; then
       if test "$_make_longver" -ge "037900" ; then
		   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNUMAKE $_make_version" >&5
$as_echo "$GNUMAKE $_make_version" >&6; }
       else
           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: failed ($GNUMAKE $_make_version need 3.79.0+)" >&5
$as_echo "$as_me: WARNING: failed ($GNUMAKE $_make_version need 3.79.0+)" >&2;}
       fi
   else
       as_fn_error "failed ($GNUMAKE $_make_version need 3.79.1+)" "$LINENO" 5
   fi
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU tar" >&5
$as_echo_n "checking for GNU tar... " >&6; }
echo "$as_me:$LINENO: checking for GNU tar" >&5
echo $ECHO_N "checking for GNU tar... $ECHO_C" >&6
for a in $GNUTAR gtar gnutar tar; do
      $a --version 2> /dev/null | grep GNU  2>&1 > /dev/null
      if test $? -eq 0;  then

           break
      fi
done
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNUTAR" >&5
$as_echo "$GNUTAR" >&6; }
if test -z "$GNUTAR"; then
    as_fn_error "not found. install GNU tar." "$LINENO" 5
echo "$as_me: error: not found. install GNU tar." >&2;}
   { (exit 1); exit 1; }; }
fi



do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path__cc+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $_cc in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path__cc="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
_cc=$ac_cv_path__cc

if test -n "$_cc"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_cc" >&5
$as_echo "$_cc" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$_cc" && break
done

      COMPATH=`echo $_cc | $SED -n "s/\/bin\/cc//p"`
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking the SunStudio C/C++ compiler version" >&5
$as_echo_n "checking the SunStudio C/C++ compiler version... " >&6; }
            _sunstudio_string=`$CC -V 2>&1 | grep '^cc' | sed -e 's/.* C //'`
      _sunstudio_version=`echo $_sunstudio_string | $AWK '{ print $1 }'`
      _sunstudio_major=`echo $_sunstudio_version | $AWK -F. '{ print $1 }'`
      if test "$_sunstudio_major" != "5"; then
         as_fn_error "found version \"$_sunstudio_version\", use version 5.5, 5.7, 5.8 or 5.9 of the SunStudio C/C++ compiler" "$LINENO" 5
echo "$as_me: error: found version \"$_sunstudio_version\", use version 5.5, 5.7, 5.8 or 5.9 of the SunStudio C/C++ compiler" >&2;}
   { (exit 1); exit 1; }; }
      else
         _sunstudio_minor=`echo $_sunstudio_version | $AWK -F. '{ if ($2 == 5) print "true"; else if ($2 == 7) print "true"; else if ($2 == 8) print "true"; else if ($2 == 9) print "true"; else print "false" }'`
         if test "$_sunstudio_minor" = "false"; then
            as_fn_error "found version \"$_sunstudio_version\", use version 5.5, 5.7, 5.8 or 5.9 of the SunStudio C/C++ compiler" "$LINENO" 5
echo "$as_me: error: found version \"$_sunstudio_version\", use version 5.5, 5.7, 5.8 or 5.9 of the SunStudio C/C++ compiler" >&2;}
   { (exit 1); exit 1; }; }
         else
                        { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked" >&5
$as_echo "checked" >&6; }
         fi
      fi
   fi
fi

if test "$GCC" = "yes"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for --hash-style=both linker support " >&5
$as_echo_n "checking for --hash-style=both linker support ... " >&6; }
   hash_style_ldflags_save=$LDFLAGS
   LDFLAGS="$LDFLAGS -Wl,--hash-style=both"
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

   #include <stdio.h>

  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  HAVE_LD_HASH_STYLE=TRUE
else
  HAVE_LD_HASH_STYLE=FALSE
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
   if test "z$HAVE_LD_HASH_STYLE" = "zTRUE"; then
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: found " >&5
$as_echo "found " >&6; }
   else
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found " >&5
$as_echo "not found " >&6; }
   fi
   LDFLAGS=$hash_style_ldflags_save
fi

do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path__cc+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $_cc in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path__cc="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
_cc=$ac_cv_path__cc

if test -n "$_cc"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_cc" >&5
$as_echo "$_cc" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$_cc" && break
done

      COMPATH=`echo $_cc | $SED -n "s/\/bin\/cc//p"`
      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: ******* $_cc , $COMPATH" >&5
$as_echo "$as_me: WARNING: ******* $_cc , $COMPATH" >&2;}
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking the Compaq C compiler version" >&5
$as_echo_n "checking the Compaq C compiler version... " >&6; }
            _compaqc_version=`$CC -V 2>&1 | $AWK '{ print $3 }'`
      _compaqc_major=`echo $_compaqc_version | $AWK -F. '{ print $1 }'`
      if test "$_compaqc_major" != "T6"; then
         as_fn_error "found version \"$_compaqc_version\", use version 6 of the Compaq C compiler" "$LINENO" 5
      else
                  { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked" >&5
$as_echo "checked" >&6; }
                  echo "$as_me:$LINENO: result: checked" >&5
echo "${ECHO_T}checked" >&6
      fi
   fi
fi

if test -z "$with_perl_home"; then
   # Extract the first word of "perl", so it can be a program name with args.
set dummy perl; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PERL+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PERL in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PERL="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
PERL=$ac_cv_path_PERL

if test -n "$PERL"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PERL" >&5
$as_echo "$PERL" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


else
   if test "$_os" = "WINNT"; then

   if test -x "$_perl_path"; then
      PERL=$_perl_path
   else
      as_fn_error "$_perl_path not found" "$LINENO" 5
echo "$as_me: error: $_perl_path not found" >&2;}
   { (exit 1); exit 1; }; }
   fi
fi

if test "$PERL"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking the Perl version" >&5
$as_echo_n "checking the Perl version... " >&6; }
   ${PERL} -e "exit($]);"
   _perl_version=$?
   if test "$_perl_version" -lt 5; then
      as_fn_error "found Perl version \"$_perl_version\", use version 5 of Perl" "$LINENO" 5
   fi
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked (perl $_perl_version)" >&5
$as_echo "checked (perl $_perl_version)" >&6; }
else
   as_fn_error "Perl not found, install version 5 of Perl" "$LINENO" 5
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for required Perl modules" >&5
$as_echo_n "checking for required Perl modules... " >&6; }


echo "$as_me:$LINENO: checking for required Perl modules" >&5
echo $ECHO_N "checking for required Perl modules... $ECHO_C" >&6
if `$PERL -e 'use Archive::Zip;'`; then
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: all modules found" >&5
$as_echo "all modules found" >&6; }
else
	as_fn_error "Failed to find some modules" "$LINENO" 5
echo "$as_me: error: Failed to find some modules" >&2;}
   { (exit 1); exit 1; }; }
fi

if test "$_os" = "WINNT"; then
	if test "$WITH_MINGWIN" != "yes"; then
		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for friendly registry keys" >&5
$as_echo_n "checking for friendly registry keys... " >&6; }
		# VS.Net 2003, VS.Net 2005
		if test -z "$with_cl_home"; then
			vctest=`./oowintool --msvc-productdir`;

		else
			with_cl_home=`cygpath -u "$with_cl_home"`
		fi
		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5
$as_echo "done" >&6; }

										if test -n "$with_mspdb_path";then
			with_mspdb_path=`cygpath -u "$with_mspdb_path"`

		if test -z "$MSPDB_PATH";then
						# Extract the first word of "mspdb80.dll", so it can be a program name with args.
set dummy mspdb80.dll; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_MSPDB_PATH+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $MSPDB_PATH in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_MSPDB_PATH="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
MSPDB_PATH=$ac_cv_path_MSPDB_PATH

if test -n "$MSPDB_PATH"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSPDB_PATH" >&5
$as_echo "$MSPDB_PATH" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


			# Extract the first word of "mspdb71.dll", so it can be a program name with args.
set dummy mspdb71.dll; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_MSPDB_PATH+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $MSPDB_PATH in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_MSPDB_PATH="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
MSPDB_PATH=$ac_cv_path_MSPDB_PATH

if test -n "$MSPDB_PATH"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSPDB_PATH" >&5
$as_echo "$MSPDB_PATH" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


			MSPDB_PATH=`dirname "$MSPDB_PATH"`
		fi

		if test -z "$MSPDB_PATH"; then
			as_fn_error "You need a mspdb71.dll/mspdb80.dll, make sure it's in the path or use --with-mspdb-path" "$LINENO" 5
echo "$as_me: error: You need a mspdb71.dll/mspdb80.dll, make sure it's in the path or use --with-mspdb-path" >&2;}
   { (exit 1); exit 1; }; }
		fi
		MSPDB_PATH=`cygpath -d "$MSPDB_PATH"`
		MSPDB_PATH=`cygpath -u "$MSPDB_PATH"`
				PATH="$MSPDB_PATH:$PATH"

		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the Microsoft C/C++ Compiler" >&5
$as_echo_n "checking the Microsoft C/C++ Compiler... " >&6; }
   		if test -x "$with_cl_home/bin/cl.exe"; then
   			CC="$with_cl_home/bin/cl.exe"
   		else
   			# Extract the first word of "cl.exe", so it can be a program name with args.
set dummy cl.exe; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_CC+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $CC in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_CC="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
CC=$ac_cv_path_CC

if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


   		fi
  		if test -e "$CC"; then

			CC=`cygpath -d "$CC"`
			CC=`cygpath -u "$CC"`
			# Remove /cl.exe from CC case insensitive
			{ $as_echo "$as_me:${as_lineno-$LINENO}: result: found ($CC)" >&5
$as_echo "found ($CC)" >&6; }
			COMPATH=`echo $CC | $SED 's@\/[Bb][Ii][Nn]\/[cC][lL]\.[eE][xX][eE]@@'`
			export INCLUDE=`cygpath -d "$COMPATH/Include"`
						{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the Version of Microsoft C/C++ Compiler" >&5
$as_echo_n "checking the Version of Microsoft C/C++ Compiler... " >&6; }
			CCNUMVER=`$CC 2>&1 | $AWK "/Microsoft/ && /..\\...\\...../ {
							x = match( \\\$0, /..\\...\\...../ )
							CCversion = substr( \\\$0, RSTART, RLENGTH)

								printf (\"%04d\",vertoken[i] )
							}
							}"`
			{ $as_echo "$as_me:${as_lineno-$LINENO}: result: found Compiler version $CCNUMVER." >&5
$as_echo "found Compiler version $CCNUMVER." >&6; }
			if test "$CCNUMVER" -ge "001500000000"; then
				COMEX=12
				MSVSVER=2008
				{ $as_echo "$as_me:${as_lineno-$LINENO}: result: found .NET 2008 / VS 9.0." >&5
$as_echo "found .NET 2008 / VS 9.0." >&6; }
			elif test "$CCNUMVER" -ge "001400000000"; then
				COMEX=11
				MSVSVER=2005
				{ $as_echo "$as_me:${as_lineno-$LINENO}: result: found .NET 2005." >&5
$as_echo "found .NET 2005." >&6; }
			elif test "$CCNUMVER" -ge "001300102240"; then
				COMEX=10
				MSVSVER=2003
				{ $as_echo "$as_me:${as_lineno-$LINENO}: result: found .NET 2003." >&5
$as_echo "found .NET 2003." >&6; }
			else
				as_fn_error "Compiler too old. Use Microsoft C/C++ .NET 2003/2005 compiler." "$LINENO" 5
echo "$as_me: error: Compiler too old. Use Microsoft C/C++ .NET 2003/2005 compiler." >&2;}
   { (exit 1); exit 1; }; }
			fi
		else
			as_fn_error "Microsoft C/C++ Compiler not found. Use --with-cl-home or set path to cl.exe." "$LINENO" 5
echo "$as_me: error: Microsoft C/C++ Compiler not found. Use --with-cl-home or set path to cl.exe." >&2;}
   { (exit 1); exit 1; }; }
		fi
	else
		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the Mingwin32 C++ Compiler" >&5
$as_echo_n "checking the Mingwin32 C++ Compiler... " >&6; }
		if test `$CC -dumpmachine | $SED -e 's/^.*-//'` = "mingw32"; then
			{ $as_echo "$as_me:${as_lineno-$LINENO}: result: found." >&5
$as_echo "found." >&6; }
			if $CC -dumpspecs | grep -q "mno-cygwin"; then
				USE_MINGW="cygwin"
			else
				USE_MINGW="pure-mingw"
			fi
		else
			as_fn_error "Mingwin32 C++ Compiler not found." "$LINENO" 5
echo "$as_me: error: Mingwin32 C++ Compiler not found." >&2;}
   { (exit 1); exit 1; }; }
		fi
	fi
fi

if test "$WITH_MINGWIN" = "yes" || test "$COMEX" -ge "10"; then
		# Extract the first word of "midl.exe", so it can be a program name with args.
set dummy midl.exe; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_MIDL_PATH+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $MIDL_PATH in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_MIDL_PATH="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
MIDL_PATH=$ac_cv_path_MIDL_PATH

if test -n "$MIDL_PATH"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MIDL_PATH" >&5
$as_echo "$MIDL_PATH" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


	if test -n "$MIDL_PATH";then
		MIDL_PATH=`dirname "$MIDL_PATH"`

		fi
	fi
	if test ! -x "$MIDL_PATH/midl.exe"; then
		as_fn_error "midl.exe not found. Make sure it's in the path or use --with-midl-path" "$LINENO" 5
echo "$as_me: error: midl.exe not found. Make sure it's in the path or use --with-midl-path" >&2;}
   { (exit 1); exit 1; }; }
	fi
	# Convert to posix path with 8.3 filename restrictions ( No spaces )
	MIDL_PATH=`cygpath -d "$MIDL_PATH"`


		# Extract the first word of "csc.exe", so it can be a program name with args.
set dummy csc.exe; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_CSC_PATH+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $CSC_PATH in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_CSC_PATH="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
CSC_PATH=$ac_cv_path_CSC_PATH

if test -n "$CSC_PATH"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CSC_PATH" >&5
$as_echo "$CSC_PATH" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


	if test -n "$CSC_PATH";then
		CSC_PATH=`dirname "$CSC_PATH"`

	   fi
	fi
	if test ! -x "$CSC_PATH/csc.exe"; then
		as_fn_error "csc.exe not found. Make sure it's in the path or use --with-csc-path" "$LINENO" 5
echo "$as_me: error: csc.exe not found. Make sure it's in the path or use --with-csc-path" >&2;}
   { (exit 1); exit 1; }; }
	fi
	# Convert to posix path with 8.3 filename restrictions ( No spaces )
	CSC_PATH=`cygpath -d "$CSC_PATH"`
	CSC_PATH=`cygpath -u "$CSC_PATH"`

               { $as_echo "$as_me:${as_lineno-$LINENO}: checking .NET Framework" >&5
$as_echo_n "checking .NET Framework... " >&6; }
	    if test -n "$with_frame_home"; then
		with_frame_home=`cygpath -u "$with_frame_home"`
	    fi

          fi
	    fi
	    if test ! -f "$FRAME_HOME/lib/mscoree.lib"; then
		as_fn_error "mscoree.lib (.NET Framework) not found. Make sure you use --with-frame-home" "$LINENO" 5
echo "$as_me: error: mscoree.lib (.NET Framework) not found. Make sure you use --with-frame-home" >&2;}
   { (exit 1); exit 1; }; }
	    fi
	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
$as_echo "found" >&6; }
	# Convert to posix path with 8.3 filename restrictions ( No spaces )
	FRAME_HOME=`cygpath -d "$FRAME_HOME"`
	FRAME_HOME=`cygpath -u "$FRAME_HOME"`

ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
$as_echo_n "checking how to run the C preprocessor... " >&6; }
# On Suns, sometimes $CPP names a directory.
if test -n "$CPP" && test -d "$CPP"; then
  CPP=
fi
if test -z "$CPP"; then
  if test "${ac_cv_prog_CPP+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
      # Double quotes because CPP needs to be expanded
    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"

  # <limits.h> exists even on freestanding compilers.
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp. "Syntax error" is here to catch this case.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#ifdef __STDC__
# include <limits.h>

#endif
		     Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :

else
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  :
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  # Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.$ac_ext

  # OK, works on sane cases.  Now check whether nonexistent headers
  # can be detected and how.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <ac_nonexistent.h>
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  # Broken: success on invalid input.
continue
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  # Passes both tests.
ac_preproc_ok=:
break

done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :
  break
fi


else
  ac_cv_prog_CPP=$CPP
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
$as_echo "$CPP" >&6; }
ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
do

  # <limits.h> exists even on freestanding compilers.
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp. "Syntax error" is here to catch this case.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#ifdef __STDC__
# include <limits.h>

#endif
		     Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :

else
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  :
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  # Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.$ac_ext

  # OK, works on sane cases.  Now check whether nonexistent headers
  # can be detected and how.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <ac_nonexistent.h>
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  # Broken: success on invalid input.
continue
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  # Passes both tests.
ac_preproc_ok=:
break

done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :

else
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error "C preprocessor \"$CPP\" fails sanity check
See \`config.log' for more details." "$LINENO" 5; }
   { (exit 1); exit 1; }; }
fi

ac_ext=c

ac_compiler_gnu=$ac_cv_c_compiler_gnu


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
$as_echo_n "checking for ANSI C header files... " >&6; }
if test "${ac_cv_header_stdc+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <stdlib.h>
#include <stdarg.h>

  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_header_stdc=yes
else
  ac_cv_header_stdc=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_cv_header_stdc=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

if test $ac_cv_header_stdc = yes; then
  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <string.h>

_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  $EGREP "memchr" >/dev/null 2>&1; then :

else
  ac_cv_header_stdc=no
fi


if test $ac_cv_header_stdc = yes; then
  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <stdlib.h>

_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  $EGREP "free" >/dev/null 2>&1; then :

else
  ac_cv_header_stdc=no
fi


if test $ac_cv_header_stdc = yes; then
  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
  if test "$cross_compiling" = yes; then :
  :
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <ctype.h>
#include <stdlib.h>
#if ((' ' & 0x0FF) == 0x020)
# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))

  for (i = 0; i < 256; i++)
    if (XOR (islower (i), ISLOWER (i))
	|| toupper (i) != TOUPPER (i))
      return 2;
  return 0;
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :

else
  ac_cv_header_stdc=no
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
$as_echo "$ac_cv_header_stdc" >&6; }
  echo "$as_me: program exited with status $ac_status" >&5
echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

( exit $ac_status )
ac_cv_header_stdc=no
fi
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
fi
fi
fi
echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
echo "${ECHO_T}$ac_cv_header_stdc" >&6
if test $ac_cv_header_stdc = yes; then

$as_echo "#define STDC_HEADERS 1" >>confdefs.h
#define STDC_HEADERS 1
_ACEOF

fi

fi

if test "$_os" != "WINNT" -o "$WITH_MINGWIN" = "yes"; then
   ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
if test -z "$CXX"; then
  if test -n "$CCC"; then
    CXX=$CCC
  else
    if test -n "$ac_tool_prefix"; then
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
  do
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_CXX+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CXX"; then
  ac_cv_prog_CXX="$CXX" # Let the user override the test.

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CXX=$ac_cv_prog_CXX
if test -n "$CXX"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
$as_echo "$CXX" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    test -n "$CXX" && break
  done
fi
if test -z "$CXX"; then
  ac_ct_CXX=$CXX
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_CXX"; then
  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_prog_ac_ct_CXX="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
if test -n "$ac_ct_CXX"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
$as_echo "$ac_ct_CXX" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ac_ct_CXX" && break
done

  if test "x$ac_ct_CXX" = x; then
    CXX="g++"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    CXX=$ac_ct_CXX
  fi
fi

  fi
fi
# Provide some information about the compiler.
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
set X $ac_compile
ac_compiler=$2
for ac_option in --version -v -V -qversion; do
  { { ac_try="$ac_compiler $ac_option >&5"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    sed '10a\
... rest of stderr output deleted ...
         10q' conftest.err >conftest.er1
    cat conftest.er1 >&5
  fi
  rm -f conftest.er1 conftest.err
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
done

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

int

  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_compiler_gnu=yes
else
  ac_compiler_gnu=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_compiler_gnu=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
if test $ac_compiler_gnu = yes; then
  GXX=yes
else
  GXX=
fi
ac_test_CXXFLAGS=${CXXFLAGS+set}
ac_save_CXXFLAGS=$CXXFLAGS
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
$as_echo_n "checking whether $CXX accepts -g... " >&6; }
if test "${ac_cv_prog_cxx_g+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
   ac_cxx_werror_flag=yes
   ac_cv_prog_cxx_g=no
   CXXFLAGS="-g"
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_prog_cxx_g=yes
else
  CXXFLAGS=""
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :

else
  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
	 CXXFLAGS="-g"
	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  ac_cv_prog_cxx_g=yes
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
$as_echo "$ac_cv_prog_cxx_g" >&6; }
if test "$ac_test_CXXFLAGS" = set; then
  CXXFLAGS=$ac_save_CXXFLAGS
elif test $ac_cv_prog_cxx_g = yes; then

    CXXFLAGS=
  fi
fi
for ac_declaration in \
   '' \
   'extern "C" void std::exit (int) throw (); using std::exit;' \
   'extern "C" void std::exit (int); using std::exit;' \
   'extern "C" void exit (int) throw ();' \
   'extern "C" void exit (int);' \
   'void exit (int);'
do
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_declaration
#include <stdlib.h>
int
main ()
{
exit (42);
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  :
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

continue
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_declaration
int
main ()
{
exit (42);
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  break
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
done
rm -f conftest*
if test -n "$ac_declaration"; then
  echo '#ifdef __cplusplus' >>confdefs.h
  echo $ac_declaration      >>confdefs.h
  echo '#endif'             >>confdefs.h
fi

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu

ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
if test -z "$CXXCPP"; then
  if test "${ac_cv_prog_CXXCPP+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
      # Double quotes because CXXCPP needs to be expanded
    for CXXCPP in "$CXX -E" "/lib/cpp"

  # <limits.h> exists even on freestanding compilers.
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp. "Syntax error" is here to catch this case.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#ifdef __STDC__
# include <limits.h>

#endif
		     Syntax error
_ACEOF
if ac_fn_cxx_try_cpp "$LINENO"; then :

else
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_cxx_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  :
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  # Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.$ac_ext

  # OK, works on sane cases.  Now check whether nonexistent headers
  # can be detected and how.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <ac_nonexistent.h>
_ACEOF
if ac_fn_cxx_try_cpp "$LINENO"; then :
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_cxx_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  # Broken: success on invalid input.
continue
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  # Passes both tests.
ac_preproc_ok=:
break

done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :
  break
fi


else
  ac_cv_prog_CXXCPP=$CXXCPP
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
$as_echo "$CXXCPP" >&6; }
ac_preproc_ok=false
for ac_cxx_preproc_warn_flag in '' yes
do

  # <limits.h> exists even on freestanding compilers.
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp. "Syntax error" is here to catch this case.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#ifdef __STDC__
# include <limits.h>

#endif
		     Syntax error
_ACEOF
if ac_fn_cxx_try_cpp "$LINENO"; then :

else
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_cxx_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  :
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  # Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.$ac_ext

  # OK, works on sane cases.  Now check whether nonexistent headers
  # can be detected and how.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <ac_nonexistent.h>
_ACEOF
if ac_fn_cxx_try_cpp "$LINENO"; then :
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_cxx_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  # Broken: success on invalid input.
continue
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  # Passes both tests.
ac_preproc_ok=:
break

done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :

else
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error "C++ preprocessor \"$CXXCPP\" fails sanity check
See \`config.log' for more details." "$LINENO" 5; }
   { (exit 1); exit 1; }; }
fi

ac_ext=c

ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
$as_echo_n "checking how to run the C preprocessor... " >&6; }
# On Suns, sometimes $CPP names a directory.
if test -n "$CPP" && test -d "$CPP"; then
  CPP=
fi
if test -z "$CPP"; then
  if test "${ac_cv_prog_CPP+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
      # Double quotes because CPP needs to be expanded
    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"

  # <limits.h> exists even on freestanding compilers.
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp. "Syntax error" is here to catch this case.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#ifdef __STDC__
# include <limits.h>

#endif
		     Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :

else
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  :
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  # Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.$ac_ext

  # OK, works on sane cases.  Now check whether nonexistent headers
  # can be detected and how.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <ac_nonexistent.h>
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  # Broken: success on invalid input.
continue
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  # Passes both tests.
ac_preproc_ok=:
break

done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :
  break
fi


else
  ac_cv_prog_CPP=$CPP
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
$as_echo "$CPP" >&6; }
ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
do

  # <limits.h> exists even on freestanding compilers.
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp. "Syntax error" is here to catch this case.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#ifdef __STDC__
# include <limits.h>

#endif
		     Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :

else
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  :
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  # Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.$ac_ext

  # OK, works on sane cases.  Now check whether nonexistent headers
  # can be detected and how.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <ac_nonexistent.h>
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  # Broken: success on invalid input.
continue
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  # Passes both tests.
ac_preproc_ok=:
break

done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :

else
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error "C preprocessor \"$CPP\" fails sanity check
See \`config.log' for more details." "$LINENO" 5; }
   { (exit 1); exit 1; }; }
fi

ac_ext=c

fi

# On IRIX 5.3, sys/types and inttypes.h are conflicting.









for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
		  inttypes.h stdint.h unistd.h
do :
  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
"
eval as_val=\$$as_ac_Header
   if test "x$as_val" = x""yes; then :
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default

#include <$ac_header>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  eval "$as_ac_Header=yes"
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

eval "$as_ac_Header=no"
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
fi
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
if test `eval echo '${'$as_ac_Header'}'` = yes; then
  cat >>confdefs.h <<_ACEOF
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
_ACEOF

fi

done


# The cast to long int works around a bug in the HP C Compiler
# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
# This bug is HP SR number 8606223364.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of long" >&5
$as_echo_n "checking size of long... " >&6; }
if test "${ac_cv_sizeof_long+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (long))" "ac_cv_sizeof_long"        "$ac_includes_default"; then :

$ac_includes_default
int
main ()
{
if ((long *) 0)
  return 0;
if (sizeof (long))
  return 0;
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_type_long=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_cv_type_long=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
fi
echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5
echo "${ECHO_T}$ac_cv_type_long" >&6

echo "$as_me:$LINENO: checking size of long" >&5
echo $ECHO_N "checking size of long... $ECHO_C" >&6
if test "${ac_cv_sizeof_long+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  if test "$ac_cv_type_long" = yes; then
     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
{ as_fn_set_status 77
as_fn_error "cannot compute sizeof (long)
See \`config.log' for more details." "$LINENO" 5; }; }
   else
     ac_cv_sizeof_long=0
   fi
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long" >&5
$as_echo "$ac_cv_sizeof_long" >&6; }



static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)];
test_array [0] = 0

  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_lo=0 ac_mid=0
  while :; do
    cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
int
main ()
{
static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
test_array [0] = 0

  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_hi=$ac_mid; break
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_lo=`expr $ac_mid + 1`
		    if test $ac_lo -le $ac_mid; then
		      ac_lo= ac_hi=
		      break
		    fi
		    ac_mid=`expr 2 '*' $ac_mid + 1`
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
  done
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
int
main ()
{
static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)];
test_array [0] = 0

  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_hi=-1 ac_mid=-1
  while :; do
    cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
int
main ()
{
static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)];
test_array [0] = 0

  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_lo=$ac_mid; break
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_hi=`expr '(' $ac_mid ')' - 1`
		       if test $ac_mid -le $ac_hi; then
			 ac_lo= ac_hi=
			 break
		       fi
		       ac_mid=`expr 2 '*' $ac_mid`
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
  done
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_lo= ac_hi=
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
# Binary search between lo and hi bounds.
while test "x$ac_lo" != "x$ac_hi"; do
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
int
main ()
{
static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
test_array [0] = 0

  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_hi=$ac_mid
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_lo=`expr '(' $ac_mid ')' + 1`
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
done
case $ac_lo in
?*) ac_cv_sizeof_long=$ac_lo;;
'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
See \`config.log' for more details." >&5
echo "$as_me: error: cannot compute sizeof (long), 77
See \`config.log' for more details." >&2;}
   { (exit 1); exit 1; }; } ;;
esac
else
  if test "$cross_compiling" = yes; then
  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
See \`config.log' for more details." >&5
echo "$as_me: error: cannot run test program while cross compiling
See \`config.log' for more details." >&2;}
   { (exit 1); exit 1; }; }
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
long longval () { return (long) (sizeof (long)); }
unsigned long ulongval () { return (long) (sizeof (long)); }
#include <stdio.h>
#include <stdlib.h>
int
main ()
{

  FILE *f = fopen ("conftest.val", "w");
  if (! f)
    exit (1);
  if (((long) (sizeof (long))) < 0)
    {
      long i = longval ();
      if (i != ((long) (sizeof (long))))
	exit (1);
      fprintf (f, "%ld\n", i);
    }
  else
    {
      unsigned long i = ulongval ();
      if (i != ((long) (sizeof (long))))
	exit (1);
      fprintf (f, "%lu\n", i);
    }
  exit (ferror (f) || fclose (f) != 0);

  ;
  return 0;
}
_ACEOF
rm -f conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_sizeof_long=`cat conftest.val`
else
  echo "$as_me: program exited with status $ac_status" >&5
echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

( exit $ac_status )
{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
See \`config.log' for more details." >&5
echo "$as_me: error: cannot compute sizeof (long), 77
See \`config.log' for more details." >&2;}
   { (exit 1); exit 1; }; }
fi
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
fi
fi
rm -f conftest.val
else
  ac_cv_sizeof_long=0
fi
fi
echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5
echo "${ECHO_T}$ac_cv_sizeof_long" >&6
cat >>confdefs.h <<_ACEOF
#define SIZEOF_LONG $ac_cv_sizeof_long
_ACEOF


SIZEOF_LONG=$ac_cv_sizeof_long

 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
$as_echo_n "checking whether byte ordering is bigendian... " >&6; }
if test "${ac_cv_c_bigendian+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_cv_c_bigendian=unknown
    # See if we're dealing with a universal compiler.
    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#ifndef __APPLE_CC__
	       not a universal capable compiler
	     #endif
	     typedef int dummy;

_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :

	# Check for potential -arch flags.  It is not universal unless
	# there are at least two -arch flags with different values.
	ac_arch=
	ac_prev=
	for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do
	 if test -n "$ac_prev"; then
	   case $ac_word in
	     i?86 | x86_64 | ppc | ppc64)
	       if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then
		 ac_arch=$ac_word
	       else
		 ac_cv_c_bigendian=universal
		 break
	       fi
	       ;;
	   esac
	   ac_prev=
	 elif test "x$ac_word" = "x-arch"; then
	   ac_prev=arch
	 fi
       done
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    if test $ac_cv_c_bigendian = unknown; then
      # See if sys/param.h defines the BYTE_ORDER macro.
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <sys/types.h>
	     #include <sys/param.h>

int
main ()
{
#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
		     && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
		     && LITTLE_ENDIAN)
	      bogus endian macros
	     #endif

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  # It does; now see whether it defined to BIG_ENDIAN or not.
	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <sys/types.h>
		#include <sys/param.h>

int
main ()
{
#if BYTE_ORDER != BIG_ENDIAN
		 not big endian
		#endif

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_c_bigendian=yes
else
  ac_cv_c_bigendian=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    fi
    if test $ac_cv_c_bigendian = unknown; then
      # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <limits.h>

int
main ()
{
#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
	      bogus endian macros
	     #endif

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  # It does; now see whether it defined to _BIG_ENDIAN or not.
	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <limits.h>

int
main ()
{
#ifndef _BIG_ENDIAN
		 not big endian
		#endif

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  if grep BIGenDianSyS conftest.$ac_objext >/dev/null ; then
  ac_cv_c_bigendian=yes
else
if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
  if test "$ac_cv_c_bigendian" = unknown; then
    ac_cv_c_bigendian=no
  else
    # finding both strings is unlikely to happen, but who knows?
    ac_cv_c_bigendian=unknown
  fi
fi
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
int
main ()
{
  /* Are we little or big endian?  From Harbison&Steele.  */
  union
  {
    long l;
    char c[sizeof (long)];
  } u;
  u.l = 1;
  exit (u.c[sizeof (long) - 1] == 1);
}
_ACEOF
rm -f conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_c_bigendian=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    fi
    if test $ac_cv_c_bigendian = unknown; then
      # Compile a test program.
      if test "$cross_compiling" = yes; then :
  # Try to guess by grepping values from an object file.
	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
short int ascii_mm[] =
		  { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
		short int ascii_ii[] =
		  { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
		int use_ascii (int i) {
		  return ascii_mm[i] + ascii_ii[i];
		}
		short int ebcdic_ii[] =
		  { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
		short int ebcdic_mm[] =
		  { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
		int use_ebcdic (int i) {
		  return ebcdic_mm[i] + ebcdic_ii[i];
		}
		extern int foo;

int
main ()
{
return use_ascii (foo) == use_ebcdic (foo);
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
	      ac_cv_c_bigendian=yes
	    fi
	    if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
	      if test "$ac_cv_c_bigendian" = unknown; then
		ac_cv_c_bigendian=no
	      else
		# finding both strings is unlikely to happen, but who knows?
		ac_cv_c_bigendian=unknown
	      fi
	    fi
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$ac_includes_default
int
main ()
{

	     /* Are we little or big endian?  From Harbison&Steele.  */
	     union
	     {
	       long int l;
	       char c[sizeof (long int)];
	     } u;
	     u.l = 1;
	     return u.c[sizeof (long int) - 1] == 1;

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
  ac_cv_c_bigendian=no
else
  ac_cv_c_bigendian=yes
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

    fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
$as_echo "$ac_cv_c_bigendian" >&6; }
 case $ac_cv_c_bigendian in #(
   yes)
     $as_echo "#define WORDS_BIGENDIAN 1" >>confdefs.h
;; #(
   no)
      ;; #(
   universal)

$as_echo "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h

     ;; #(
   *)
     as_fn_error "unknown endianness
 presetting ac_cv_c_bigendian=no (or yes) will help" "$LINENO" 5 ;;
 esac

WORDS_BIGENDIAN=$ac_cv_c_bigendian


# Check whether --enable-largefile was given.
if test "${enable_largefile+set}" = set; then :
  enableval=$enable_largefile;
fi

if test "$enable_largefile" != no; then

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for special C compiler options needed for large files" >&5
$as_echo_n "checking for special C compiler options needed for large files... " >&6; }
if test "${ac_cv_sys_largefile_CC+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_cv_sys_largefile_CC=no
     if test "$GCC" != yes; then
       ac_save_CC=$CC
       while :; do
	 # IRIX 6.2 and later do not support large files by default,
	 # so use the C compiler's -n32 option if that helps.
	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <sys/types.h>
 /* Check that off_t can represent 2**63 - 1 correctly.

  return 0;
}
_ACEOF
	 if ac_fn_c_try_compile "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  break
fi
rm -f core conftest.err conftest.$ac_objext
	 CC="$CC -n32"
	 if ac_fn_c_try_compile "$LINENO"; then :
fi
rm -f conftest.err conftest.$ac_objext
     	 CC="$CC -n32"
     	 rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_sys_largefile_CC=' -n32'; break
fi
rm -f core conftest.err conftest.$ac_objext
sed 's/^/| /' conftest.$ac_ext >&5

fi
rm -f conftest.err conftest.$ac_objext
	 break
       done
       CC=$ac_save_CC
       rm -f conftest.$ac_ext
    fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_largefile_CC" >&5
$as_echo "$ac_cv_sys_largefile_CC" >&6; }
  if test "$ac_cv_sys_largefile_CC" != no; then
    CC=$CC$ac_cv_sys_largefile_CC
  fi

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _FILE_OFFSET_BITS value needed for large files" >&5
$as_echo_n "checking for _FILE_OFFSET_BITS value needed for large files... " >&6; }
if test "${ac_cv_sys_file_offset_bits+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  while :; do
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <sys/types.h>
 /* Check that off_t can represent 2**63 - 1 correctly.

  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_sys_file_offset_bits=no; break
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  break
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#define _FILE_OFFSET_BITS 64
#include <sys/types.h>

  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_sys_file_offset_bits=64; break
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  ac_cv_sys_file_offset_bits=unknown

fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
  break
done
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_file_offset_bits" >&5
$as_echo "$ac_cv_sys_file_offset_bits" >&6; }
case $ac_cv_sys_file_offset_bits in #(
  no | unknown) ;;
  *)
cat >>confdefs.h <<_ACEOF
#define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits
_ACEOF
;;
esac
rm -rf conftest*
  if test $ac_cv_sys_file_offset_bits = unknown; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _LARGE_FILES value needed for large files" >&5
$as_echo_n "checking for _LARGE_FILES value needed for large files... " >&6; }
if test "${ac_cv_sys_large_files+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  while :; do
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <sys/types.h>
 /* Check that off_t can represent 2**63 - 1 correctly.

  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_sys_large_files=no; break
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  break
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#define _LARGE_FILES 1
#include <sys/types.h>

  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_sys_large_files=1; break
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  ac_cv_sys_large_files=unknown

fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
  break
done
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_large_files" >&5
$as_echo "$ac_cv_sys_large_files" >&6; }
case $ac_cv_sys_large_files in #(
  no | unknown) ;;
  *)
cat >>confdefs.h <<_ACEOF
#define _LARGE_FILES $ac_cv_sys_large_files
_ACEOF
;;
esac
rm -rf conftest*
  fi
fi

if test -n "$ac_cv_sys_file_offset_bits"; then

fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to disable vba feature" >&5
$as_echo_n "checking whether to disable vba feature... " >&6; }
if test -n "$enable_vba" && test "$enable_vba" = "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   ENABLE_VBA=NO
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   ENABLE_VBA=YES
fi


if test "$ENABLE_VBA" = "YES"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to package the vba compatibility api" >&5
$as_echo_n "checking how to package the vba compatibility api... " >&6; }
   if test -n "$with_vba_package_format"; then
      if test "$with_vba_package_format" = "extn"; then
         VBA_EXTENSION=YES
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: uno extension" >&5
$as_echo "uno extension" >&6; }
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-vba-package-format=extn can cause problems" >&5
$as_echo "$as_me: WARNING: --with-vba-package-format=extn can cause problems" >&2;}
      else if test "$with_vba_package_format" = "builtin"; then
            VBA_EXTENSION=NO
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: build into installset" >&5
$as_echo "build into installset" >&6; }
         else
            as_fn_error "unknown packaging method" "$LINENO" 5
echo "$as_me: error: unknown packaging method" >&2;}
   { (exit 1); exit 1; }; }
         fi
      fi

   else
      VBA_EXTENSION=NO
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: defaulting to build into installset" >&5
$as_echo "defaulting to build into installset" >&6; }
   fi
else
      VBA_EXTENSION=NO



if test "$test_cups" = "yes" -a "$ENABLE_CUPS" = "TRUE" ; then
    ac_fn_c_check_header_mongrel "$LINENO" "cups/cups.h" "ac_cv_header_cups_cups_h" "$ac_includes_default"
if test "x$ac_cv_header_cups_cups_h" = x""yes; then :

else
  as_fn_error "cups/cups.h could not be found. libcupsys2-dev or cups???-devel missing?" "$LINENO" 5
fi
echo "$as_me:$LINENO: result: $ac_cv_header_cups_cups_h" >&5
echo "${ECHO_T}$ac_cv_header_cups_cups_h" >&6
else
  # Is the header compilable?
echo "$as_me:$LINENO: checking cups/cups.h usability" >&5
echo $ECHO_N "checking cups/cups.h usability... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <cups/cups.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking cups/cups.h presence" >&5
echo $ECHO_N "checking cups/cups.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <cups/cups.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: cups/cups.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: cups/cups.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: cups/cups.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: cups/cups.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: cups/cups.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: cups/cups.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: cups/cups.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: cups/cups.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: cups/cups.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: cups/cups.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: cups/cups.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: cups/cups.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: cups/cups.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: cups/cups.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: cups/cups.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: cups/cups.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for cups/cups.h" >&5
echo $ECHO_N "checking for cups/cups.h... $ECHO_C" >&6
if test "${ac_cv_header_cups_cups_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_cups_cups_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_cups_cups_h" >&5
echo "${ECHO_T}$ac_cv_header_cups_cups_h" >&6

fi
if test $ac_cv_header_cups_cups_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: cups/cups.h could not be found. libcupsys2-dev or cups???-devel missing?" >&5
echo "$as_me: error: cups/cups.h could not be found. libcupsys2-dev or cups???-devel missing?" >&2;}
   { (exit 1); exit 1; }; }
fi


fi

if test "$_os" = "Linux" -o "$_os" = "FreeBSD" -o "$_os" = "GNU"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable pam support" >&5
$as_echo_n "checking whether to enable pam support... " >&6; }
  if test -z "$enable_pam" || test "$enable_pam" != "no"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
    PAM=YES
    ac_fn_c_check_header_mongrel "$LINENO" "security/pam_appl.h" "ac_cv_header_security_pam_appl_h" "$ac_includes_default"
if test "x$ac_cv_header_security_pam_appl_h" = x""yes; then :

else
  as_fn_error "pam_appl.h could not be found. libpam-dev or pam-devel missing?" "$LINENO" 5
fi


    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to link to libpam" >&5
$as_echo_n "checking whether to link to libpam... " >&6; }
echo "$as_me:$LINENO: checking security/pam_appl.h usability" >&5
echo $ECHO_N "checking security/pam_appl.h usability... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <security/pam_appl.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking security/pam_appl.h presence" >&5
echo $ECHO_N "checking security/pam_appl.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <security/pam_appl.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: security/pam_appl.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: security/pam_appl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: security/pam_appl.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: security/pam_appl.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: security/pam_appl.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: security/pam_appl.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: security/pam_appl.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: security/pam_appl.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: security/pam_appl.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: security/pam_appl.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: security/pam_appl.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: security/pam_appl.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: security/pam_appl.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: security/pam_appl.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: security/pam_appl.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: security/pam_appl.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for security/pam_appl.h" >&5
echo $ECHO_N "checking for security/pam_appl.h... $ECHO_C" >&6
if test "${ac_cv_header_security_pam_appl_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_security_pam_appl_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_security_pam_appl_h" >&5
echo "${ECHO_T}$ac_cv_header_security_pam_appl_h" >&6

fi
if test $ac_cv_header_security_pam_appl_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: pam_appl.h could not be found. libpam-dev or pam-devel missing?" >&5
echo "$as_me: error: pam_appl.h could not be found. libpam-dev or pam-devel missing?" >&2;}
   { (exit 1); exit 1; }; }
fi


    echo "$as_me:$LINENO: checking whether to link to libpam" >&5
echo $ECHO_N "checking whether to link to libpam... $ECHO_C" >&6
    if test -n "$enable_pam_link" -a "$enable_pam_link" != "no"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
      PAM_LINK=YES
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pam_start in -lpam" >&5
$as_echo_n "checking for pam_start in -lpam... " >&6; }
if test "${ac_cv_lib_pam_pam_start+set}" = set; then :
  $as_echo_n "(cached) " >&6
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lpam  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char pam_start ();
int
main ()
{
return pam_start ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_pam_pam_start=yes
else
  ac_cv_lib_pam_pam_start=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pam_pam_start" >&5
$as_echo "$ac_cv_lib_pam_pam_start" >&6; }
if test "x$ac_cv_lib_pam_pam_start" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBPAM 1
_ACEOF

  LIBS="-lpam $LIBS"

else
  as_fn_error "libpam not found or functional" "$LINENO" 5
echo "$as_me: error: libpam not found or functional" >&2;}
   { (exit 1); exit 1; }; }
fi

    else
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, dynamically open it" >&5
$as_echo "no, dynamically open it" >&6; }
      PAM_LINK=NO
    fi
  else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    PAM=NO
    PAM_LINK=NO


ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu

    { $as_echo "$as_me:${as_lineno-$LINENO}: checking how many arguments getspnam_r() takes" >&5
$as_echo_n "checking how many arguments getspnam_r() takes... " >&6; }

    if test "${ac_cv_func_which_getspnam_r+set}" = set; then :
  $as_echo_n "(cached) " >&6
else



# netdb.h is not declaring the function, and the compiler is thereby
# assuming an implicit prototype. In which case, we're out of luck.
#
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

	    #include <sys/types.h>

  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_func_which_getspnam_r=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
sed 's/^/| /' conftest.$ac_ext >&5

fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

#
# FIVE ARGUMENTS


if test "$ac_cv_func_which_getspnam_r" = "unknown"; then

cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

	    #include <sys/types.h>

  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_func_which_getspnam_r=five
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
sed 's/^/| /' conftest.$ac_ext >&5

fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

fi



if test "$ac_cv_func_which_getspnam_r" = "unknown"; then

cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

	    #include <sys/types.h>

  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_func_which_getspnam_r=four
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
sed 's/^/| /' conftest.$ac_ext >&5

fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

fi



case "$ac_cv_func_which_getspnam_r" in
    five)
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: five" >&5
$as_echo "five" >&6; }
    NEW_SHADOW_API=YES
    ;;

    four)
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: four" >&5
$as_echo "four" >&6; }
    ;;

    no)
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: cannot find function declaration in shadow.h" >&5
$as_echo "cannot find function declaration in shadow.h" >&6; }
    ;;

    unknown)
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: can't tell" >&5
$as_echo "can't tell" >&6; }
    ;;

    *)
    as_fn_error "internal error" "$LINENO" 5
echo "$as_me: error: internal error" >&2;}
   { (exit 1); exit 1; }; }
    ;;
esac




if test "$_os" = "Linux"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to link to libcrypt" >&5
$as_echo_n "checking whether to link to libcrypt... " >&6; }
    if test -n "$enable_crypt_link" -a "$enable_crypt_link" != "no"; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
        CRYPT_LINK=YES
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for crypt in -lcrypt" >&5
$as_echo_n "checking for crypt in -lcrypt... " >&6; }
if test "${ac_cv_lib_crypt_crypt+set}" = set; then :
  $as_echo_n "(cached) " >&6
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lcrypt  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char crypt ();
int
main ()
{
return crypt ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_crypt_crypt=yes
else
  ac_cv_lib_crypt_crypt=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_crypt_crypt" >&5
$as_echo "$ac_cv_lib_crypt_crypt" >&6; }
if test "x$ac_cv_lib_crypt_crypt" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBCRYPT 1
_ACEOF

  LIBS="-lcrypt $LIBS"

else
  as_fn_error "libcrypt not found or functional" "$LINENO" 5
echo "$as_me: error: libcrypt not found or functional" >&2;}
   { (exit 1); exit 1; }; }
fi

    else
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, dynamically open it" >&5
$as_echo "no, dynamically open it" >&6; }
        CRYPT_LINK=NO
    fi
fi

fi

if test "$_os" != "WINNT" -o "$WITH_MINGWIN" = "yes"; then
   ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
if test -z "$CXX"; then
  if test -n "$CCC"; then
    CXX=$CCC
  else
    if test -n "$ac_tool_prefix"; then
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
  do
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_CXX+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CXX"; then
  ac_cv_prog_CXX="$CXX" # Let the user override the test.

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CXX=$ac_cv_prog_CXX
if test -n "$CXX"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
$as_echo "$CXX" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    test -n "$CXX" && break
  done
fi
if test -z "$CXX"; then
  ac_ct_CXX=$CXX
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_CXX"; then
  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_prog_ac_ct_CXX="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
if test -n "$ac_ct_CXX"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
$as_echo "$ac_ct_CXX" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ac_ct_CXX" && break
done

  if test "x$ac_ct_CXX" = x; then
    CXX="g++"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    CXX=$ac_ct_CXX
  fi
fi

  fi
fi
# Provide some information about the compiler.
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
set X $ac_compile
ac_compiler=$2
for ac_option in --version -v -V -qversion; do
  { { ac_try="$ac_compiler $ac_option >&5"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    sed '10a\
... rest of stderr output deleted ...
         10q' conftest.err >conftest.er1
    cat conftest.er1 >&5
  fi
  rm -f conftest.er1 conftest.err
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
done

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

int

  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_compiler_gnu=yes
else
  ac_compiler_gnu=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_compiler_gnu=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
if test $ac_compiler_gnu = yes; then
  GXX=yes
else
  GXX=
fi
ac_test_CXXFLAGS=${CXXFLAGS+set}
ac_save_CXXFLAGS=$CXXFLAGS
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
$as_echo_n "checking whether $CXX accepts -g... " >&6; }
if test "${ac_cv_prog_cxx_g+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
   ac_cxx_werror_flag=yes
   ac_cv_prog_cxx_g=no
   CXXFLAGS="-g"
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_prog_cxx_g=yes
else
  CXXFLAGS=""
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :

else
  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
	 CXXFLAGS="-g"
	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  ac_cv_prog_cxx_g=yes
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
$as_echo "$ac_cv_prog_cxx_g" >&6; }
if test "$ac_test_CXXFLAGS" = set; then
  CXXFLAGS=$ac_save_CXXFLAGS
elif test $ac_cv_prog_cxx_g = yes; then

    CXXFLAGS=
  fi
fi
for ac_declaration in \
   '' \
   'extern "C" void std::exit (int) throw (); using std::exit;' \
   'extern "C" void std::exit (int); using std::exit;' \
   'extern "C" void exit (int) throw ();' \
   'extern "C" void exit (int);' \
   'void exit (int);'
do
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_declaration
#include <stdlib.h>
int
main ()
{
exit (42);
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  :
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

continue
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_declaration
int
main ()
{
exit (42);
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  break
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
done
rm -f conftest*
if test -n "$ac_declaration"; then
  echo '#ifdef __cplusplus' >>confdefs.h
  echo $ac_declaration      >>confdefs.h
  echo '#endif'             >>confdefs.h
fi

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

fi

if test "$GXX" = "yes"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking the GNU C++ compiler version" >&5
$as_echo_n "checking the GNU C++ compiler version... " >&6; }

   _gpp_version=`$CXX -dumpversion`
   _gpp_major=`echo $_gpp_version | $AWK -F. '{ print \$1 }'`
   _gpp_minor=`echo $_gpp_version | $AWK -F. '{ print \$2 }'`

   { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked (g++ $_gpp_version)" >&5
$as_echo "checked (g++ $_gpp_version)" >&6; }

   if test "$_gpp_major" = "3"; then
      if test "$_gpp_minor" = "4"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX has the enum bug" >&5
$as_echo_n "checking whether $CXX has the enum bug... " >&6; }
if test "$cross_compiling" = yes; then :
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error "cannot run test program while cross compiling
See \`config.log' for more details." "$LINENO" 5; }
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

extern "C" void abort (void);

}

_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
  as_fn_error "your version of the GNU C++ compile has a bug which prevents OpenOffice.org from being compiled correctly - please check http://gcc.gnu.org/ml/gcc-patches/2004-07/msg00968.html for details." "$LINENO" 5
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

  (exit $ac_status); }; }; then
  { { echo "$as_me:$LINENO: error: your version of the GNU C++ compile has a bug which prevents OpenOffice.org from being compiled correctly - please check http://gcc.gnu.org/ml/gcc-patches/2004-07/msg00968.html for details." >&5
echo "$as_me: error: your version of the GNU C++ compile has a bug which prevents OpenOffice.org from being compiled correctly - please check http://gcc.gnu.org/ml/gcc-patches/2004-07/msg00968.html for details." >&2;}
   { (exit 1); exit 1; }; }
else
  echo "$as_me: program exited with status $ac_status" >&5
echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

( exit $ac_status )
echo "$as_me:$LINENO: result: no" >&5
echo "${ECHO_T}no" >&6
fi
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
fi
      fi
   fi
fi

# Removed the special FreeBSD treatment. The problem was that with_gxx_include_path
# often contains an i386 which is expanded as a macro. Solved in stlport.
if test "$GXX" = "yes"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for g++ include path" >&5
$as_echo_n "checking for g++ include path... " >&6; }
   if test -z "$with_gxx_include_path"; then
      with_gxx_include_path=`echo "#include <cstring>" | $CXX -E -xc++ - | $SED -n '/.*1*"\(.*\)\/cstring".*/s//\1/p' | head -n 1`
      if test "$with_gxx_include_path" = "/usr/libexec/(null)/include"; then

fi
if test -z "$with_gxx_include_path"; then
   with_gxx_include_path="NO_GXX_INCLUDE"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no g++ includes" >&5
$as_echo "no g++ includes" >&6; }
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_gxx_include_path" >&5
$as_echo "$with_gxx_include_path" >&6; }
fi
GXX_INCLUDE_PATH="$with_gxx_include_path"


if test "$WITH_MINGWIN" = "yes"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mingwin runtime include path" >&5
$as_echo_n "checking for mingwin runtime include path... " >&6; }
   cat >conftest.$ac_ext <<_ACEOF
#include <stddef.h>
#include <bits/c++config.h>

   fi
   if test -z "$_mingw_lib_include_path"; then
      _mingw_lib_include_path="NO_LIB_INCLUDE"
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no mingwin runtime includes" >&5
$as_echo "no mingwin runtime includes" >&6; }
   else
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_mingw_lib_include_path" >&5
$as_echo "$_mingw_lib_include_path" >&6; }
   fi
  MINGW_LIB_INCLUDE_PATH="$_mingw_lib_include_path"

   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mingwin c++ backward include path" >&5
$as_echo_n "checking for mingwin c++ backward include path... " >&6; }
   cat >conftest.$ac_ext <<_ACEOF
#include <hash_set>
_ACEOF

   if test -n "$_mingw_backward_include_path"; then
      _mingw_backward_include_path=`cygpath -d $_mingw_backward_include_path`
      _mingw_backward_include_path=`cygpath -u $_mingw_backward_include_path`
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_mingw_backward_include_path" >&5
$as_echo "$_mingw_backward_include_path" >&6; }
   else
      _mingw_backward_include_path="NO_BACKWARD_INCLUDE"
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no mingwin c++ backward includes" >&5
$as_echo "no mingwin c++ backward includes" >&6; }
   fi
  MINGW_BACKWARD_INCLUDE_PATH="$_mingw_backward_include_path"

  mingw_crtbegin=`$CC -print-file-name=crtbegin.o`
  MINGW_CLIB_DIR=`dirname $mingw_crtbegin`
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use dynamic libgcc" >&5
$as_echo_n "checking whether to use dynamic libgcc... " >&6; }
  if test -e "$MINGW_CLIB_DIR/libgcc_s.a"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic libgcc name" >&5
$as_echo_n "checking dynamic libgcc name... " >&6; }
    MINGW_GCCDLL_pattern=`nm $MINGW_CLIB_DIR/libgcc_s.a | sed -ne 's@.* _libgcc\(.*\)_dll_iname@libgcc\1.dll@p' | uniq | sed -e 's@_@?@g'`
    MINGW_GCCDLL=`cd $COMPATH/bin && ls $MINGW_GCCDLL_pattern 2>/dev/null`
    if test -n "$MINGW_GCCDLL"; then
        MINGW_SHARED_GCCLIB=YES
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: use $MINGW_GCCDLL" >&5
$as_echo "use $MINGW_GCCDLL" >&6; }
    else
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    fi
  else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
  fi
  if test -e "$MINGW_CLIB_DIR/libgcc_eh.a"; then
      MINGW_GCCLIB_EH=YES
  fi
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use dynamic libstdc++" >&5
$as_echo_n "checking whether to use dynamic libstdc++... " >&6; }
  if test -e "$MINGW_CLIB_DIR/libstdc++_s.a" ; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic libstdc++ name" >&5
$as_echo_n "checking dynamic libstdc++ name... " >&6; }
    MINGW_GXXDLL_pattern=`nm $MINGW_CLIB_DIR/libstdc++_s.a | sed -ne 's@.* _libstdc__\(.*\)_dll_iname@libstdc++\1.dll@p' | uniq | sed -e 's@_@?@g'`
    MINGW_GXXDLL=`cd $COMPATH/bin && ls $MINGW_GXXDLL_pattern 2>/dev/null`
    if test -n "$MINGW_GXXDLL"; then
        MINGW_SHARED_GXXLIB=YES
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: use $MINGW_GXXDLL" >&5
$as_echo "use $MINGW_GXXDLL" >&6; }
    else
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    fi
  else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
  fi
  MINGW_CLIB_DIR=`cygpath $MINGW_CLIB_DIR`



if test "$_os" = "SunOS"; then
      if test "$CC" = "cc"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking SunStudio C++ Compiler" >&5
$as_echo_n "checking SunStudio C++ Compiler... " >&6; }
      if test "$CXX" != "CC"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: SunStudio C++ was not found" >&5
$as_echo "$as_me: WARNING: SunStudio C++ was not found" >&2;}
         echo "SunStudio C++ was not found" >> warn
      else
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked" >&5
$as_echo "checked" >&6; }
      fi
   fi
fi
if test "$_os" = "Darwin"; then
      if test "$CC" = "cc"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking Macosx c++ Compiler" >&5
$as_echo_n "checking Macosx c++ Compiler... " >&6; }
      if test "$CXX" != "c++"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Macosx C++ was not found" >&5
$as_echo "$as_me: WARNING: Macosx C++ was not found" >&2;}
         echo "Macosx C++ was not found" >> warn
      else
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked" >&5
$as_echo "checked" >&6; }
      fi
   fi
fi
if test "$_os" = "OSF1"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking Compaq C++ compiler version" >&5
$as_echo_n "checking Compaq C++ compiler version... " >&6; }
      _compaqcxx_version=`$CXX -V 2>&1 | $AWK '{ print $3 }'`
   _compaqcxx_major=`echo $_compaqcxx_version | $AWK -F. '{ print $1 }'`
   if test "$_compaqcxx_major" != "V6"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found version \"$_compaqc_version\", use version 6 of the Compaq C++ compiler" >&5
$as_echo "$as_me: WARNING: found version \"$_compaqc_version\", use version 6 of the Compaq C++ compiler" >&2;}
      echo "found version $_compaqc_version, use version 6 of the Compaq C++ compiler" >> warn
   else
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked" >&5
$as_echo "checked" >&6; }
   fi
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking exception type" >&5
$as_echo_n "checking exception type... " >&6; }
ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'


if test "$WITH_MINGWIN" = "yes"; then

cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <iostream>


  return 0;
}
_ACEOF
if ac_fn_cxx_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  exceptions_type="sjlj"
else
  exceptions_type="dwarf2"

fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $exceptions_type" >&5
$as_echo "$exceptions_type" >&6; }

echo "$as_me:$LINENO: result: $exceptions_type" >&5
echo "${ECHO_T}$exceptions_type" >&6
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

if test "$_os" = "SunOS"; then
   _temp=`showrev -p | $AWK -F" " '{ print $2 }'`
   if test "$_os_release" = "7"; then
                        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for patch 106327-06 or greater" >&5
$as_echo_n "checking for patch 106327-06 or greater... " >&6; }
      _patch=`echo $_temp | $AWK '/106327-06/ { print "found" }'`
      _patch="false"
      for i in $_temp

        fi
      done
      if test "$_patch" = "found"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
$as_echo "found" >&6; }
      else
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: patch 106327-06 not found, please install compiler patch 106327-06 or greater" >&5
$as_echo "$as_me: WARNING: patch 106327-06 not found, please install compiler patch 106327-06 or greater" >&2;}
         echo "patch 106327-06 not found, please install compiler patch 106327-06 or greater" >> warn
      fi
                        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for patch 106950-11 or greater" >&5
$as_echo_n "checking for patch 106950-11 or greater... " >&6; }
      _patch=`echo $_temp | $AWK '/106950-11/ { print "found" }'`
      _patch="false"
      for i in $_temp

         fi
      done
      if test "$_patch" = "found"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
$as_echo "found" >&6; }
      else
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: patch 106950-11 not found, please install linker patch 106950-11 or greater" >&5
$as_echo "$as_me: WARNING: patch 106950-11 not found, please install linker patch 106950-11 or greater" >&2;}
         echo "patch 106950-11 not found, please install linker patch 106950-11 or greater" >> warn
      fi
   else
      if test "$_os_release" = "6"; then
                                    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for patch 105591-09 or greater" >&5
$as_echo_n "checking for patch 105591-09 or greater... " >&6; }
         _patch=`echo $_temp | $AWK '/105591-09/ { print "found" }'`
         _patch="false"
         for i in $_temp

           fi
         done
         if test "$_patch" = "found"; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
$as_echo "found" >&6; }
         else
            { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: patch 105591-09 not found, please install compiler patch 105591-09 or greater" >&5
$as_echo "$as_me: WARNING: patch 105591-09 not found, please install compiler patch 105591-09 or greater" >&2;}
            echo "patch 105591-09 not found, please install compiler patch 105591-09 or greater" >> warn
         fi
                                    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for patch 107733-08 or greater" >&5
$as_echo_n "checking for patch 107733-08 or greater... " >&6; }
         _patch=`echo $_temp | $AWK '/107733-08/ { print "found" }'`
         _patch="false"
         for i in $_temp

           fi
         done
         if test "$_patch" = "found"; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
$as_echo "found" >&6; }
         else
            { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: patch 107733-06 not found, please install linker patch 107733-08 or greater" >&5
$as_echo "$as_me: WARNING: patch 107733-06 not found, please install linker patch 107733-08 or greater" >&2;}
            echo "patch 107733-06 not found, please install linker patch 107733-08 or greater" >> warn
         fi
      fi
   fi
fi

   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what the default STL should be" >&5
$as_echo_n "checking what the default STL should be... " >&6; }
   DEFAULT_TO_STLPORT="no"
   if test "$_os" = "Linux"; then
     case "$build_cpu" in

      DEFAULT_TO_STLPORT="yes"
   fi
   if test "$DEFAULT_TO_STLPORT" = "yes"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: stlport" >&5
$as_echo "stlport" >&6; }
   else
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: system" >&5
$as_echo "system" >&6; }
   fi
   if test "$WITH_STLPORT" = "auto"; then
      WITH_STLPORT=$DEFAULT_TO_STLPORT
   fi

   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STL providing headers" >&5
$as_echo_n "checking for STL providing headers... " >&6; }
   STLPORT4=""
   USE_SYSTEM_STL=""
   if test "$WITH_STLPORT" = "yes"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: using internal stlport." >&5
$as_echo "using internal stlport." >&6; }
      if test "$DEFAULT_TO_STLPORT" != "yes"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using stlport. Warning, breaks your ABI compatability!" >&5
$as_echo "$as_me: WARNING: using stlport. Warning, breaks your ABI compatability!" >&2;}
         echo "using stlport. Warning, breaks your ABI compatability!" >>warn
      fi
   elif test "$WITH_STLPORT" = "no"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: using system STL" >&5
$as_echo "using system STL" >&6; }
      USE_SYSTEM_STL="YES"
      if test "$DEFAULT_TO_STLPORT" != "no"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using system STL. Warning, breaks your ABI compatability!" >&5
$as_echo "$as_me: WARNING: using system STL. Warning, breaks your ABI compatability!" >&2;}
         echo "using system STL. Warning, breaks your ABI compatability!" >>warn
      fi
   else
      STLPORT4=$WITH_STLPORT
      if test "$_os" != "WINNT" -o "$WITH_MINGWIN" = "yes"; then
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$STLPORT4/stlport/hash_map
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked." >&5
$as_echo "checked." >&6; }
else
  as_fn_error "STLport headers not found." "$LINENO" 5
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  echo "$as_me:$LINENO: result: checked." >&5
echo "${ECHO_T}checked." >&6
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  { { echo "$as_me:$LINENO: error: STLport headers not found." >&5
echo "$as_me: error: STLport headers not found." >&2;}
   { (exit 1); exit 1; }; }
fi
rm -f conftest.err conftest.$ac_ext
      else
                  if test -f "$STLPORT4/stlport/hash_map"; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked." >&5
$as_echo "checked." >&6; }
         else
            as_fn_error "STLport headers not found." "$LINENO" 5
echo "$as_me: error: STLport headers not found." >&2;}
   { (exit 1); exit 1; }; }
         fi
      fi
      if test "$_os" != "WINNT" -o "$WITH_MINGWIN" = "yes"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STLport libraries" >&5
$as_echo_n "checking for STLport libraries... " >&6; }
         if test "$_os" = "SunOS"; then
		      if test -f "$STLPORT4/lib/libstlport_sunpro.so"; then
			      { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked" >&5
$as_echo "checked" >&6; }
		      elif test -f "$STLPORT4/lib/libstlport.so"; then
			      { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked" >&5
$as_echo "checked" >&6; }
			      STLPORT_VER=500
		      else
			      as_fn_error "STLport libraries not found" "$LINENO" 5
echo "$as_me: error: STLport libraries not found" >&2;}
   { (exit 1); exit 1; }; }
		      fi
	      elif test "$_os" = "Darwin"; then
		      if test -f "$STLPORT4/lib/libstlport_gcc.dylib"; then
			      { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked" >&5
$as_echo "checked" >&6; }
		      elif test -f "$STLPORT4/lib/libstlport.dylib"; then
			      { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked" >&5
$as_echo "checked" >&6; }
			      STLPORT_VER=500
		      else
			      as_fn_error "STLport libraries not found" "$LINENO" 5
echo "$as_me: error: STLport libraries not found" >&2;}
   { (exit 1); exit 1; }; }
		      fi
		   else
			   if test -f "$STLPORT4/lib/libstlport_gcc.so"; then
				   { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked" >&5
$as_echo "checked" >&6; }
			   elif test -f "$STLPORT4/lib/libstlport.so"; then
				   { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked" >&5
$as_echo "checked" >&6; }
				   STLPORT_VER=500
			   else
				   as_fn_error "STLport libraries not found" "$LINENO" 5
echo "$as_me: error: STLport libraries not found" >&2;}
   { (exit 1); exit 1; }; }
			   fi
		   fi
	   fi
      if test "$DEFAULT_TO_STLPORT" != "yes"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using stlport. Warning, breaks your ABI compatability!" >&5
$as_echo "$as_me: WARNING: using stlport. Warning, breaks your ABI compatability!" >&2;}
         echo "using stlport. Warning, breaks your ABI compatability!" >>warn
      fi
   fi



if test "$GCC" = "yes"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC supports -fvisibility=hidden" >&5
$as_echo_n "checking whether $CC supports -fvisibility=hidden... " >&6; }
   save_CFLAGS=$CFLAGS
   CFLAGS="$CFLAGS -fvisibility=hidden"
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

int

  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
   HAVE_GCC_VISIBILITY_FEATURE=TRUE
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext

fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
   CFLAGS=$save_CFLAGS
   if test "$HAVE_GCC_VISIBILITY_FEATURE" = "TRUE"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   else
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   fi
fi

# ===================================================================
# use --ccache-skip?
# ===================================================================
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are allowed and able to use --ccache-skip" >&5
$as_echo_n "checking whether we are allowed and able to use --ccache-skip... " >&6; }
if test "$_os" != "Darwin" ; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: only used on Mac currently, skipping" >&5
$as_echo "only used on Mac currently, skipping" >&6; }
elif test "$enable_ccache_skip" = "no" ; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no - diabled explicitly" >&5
$as_echo "no - diabled explicitly" >&6; }
elif test "$enable_ccache_skip" = "yes" ; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes - enabled explicitly, skipping checks" >&5
$as_echo "yes - enabled explicitly, skipping checks" >&6; }
   USE_CCACHE=YES

elif test "$enable_ccache_skip" = "auto" ; then
   # checking for ccache presence/version
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: probing..." >&5
$as_echo "probing..." >&6; }
   # Extract the first word of "ccache", so it can be a program name with args.
set dummy ccache; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_CCACHE+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $CCACHE in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_CCACHE" && ac_cv_path_CCACHE="not_found"
  ;;
esac
fi
CCACHE=$ac_cv_path_CCACHE

if test -n "$CCACHE"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
$as_echo "$CCACHE" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


   if test "$CCACHE" = "not_found" ; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: not enabling --ccache-skip (ccache not found)" >&5
$as_echo "$as_me: not enabling --ccache-skip (ccache not found)" >&6;}
   else
      # check ccache version
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether version of ccache is suitable" >&5
$as_echo_n "checking whether version of ccache is suitable... " >&6; }
      CCACHE_VERSION=`"$CCACHE" -V | "$AWK" '/^ccache version/{print $3}'`
      if test "$CCACHE_VERSION" = "2.4_OOo"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
         { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ccache is actually used for the build" >&5
$as_echo_n "checking whether ccache is actually used for the build... " >&6; }
         ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'


         save_CXXFLAGS=$CXXFLAGS
         CXXFLAGS="$CXXFLAGS --ccache-skip -O2"
                  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  use_ccache=yes
else
  use_ccache=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
use_ccache=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
         if test $use_ccache = yes ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, will enable --ccache-skip" >&5
$as_echo "yes, will enable --ccache-skip" >&6; }
            USE_CCACHE=YES

         else
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, will not enable --ccache-skip" >&5
$as_echo "no, will not enable --ccache-skip" >&6; }
         fi
         CXXFLAGS=$save_CXXFLAGS
         ac_ext=c

ac_compiler_gnu=$ac_cv_c_compiler_gnu

      else
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
         { $as_echo "$as_me:${as_lineno-$LINENO}: ccache version $CCACHE_VERSION not accepted. See description for --enable-ccache-skip" >&5
$as_echo "$as_me: ccache version $CCACHE_VERSION not accepted. See description for --enable-ccache-skip" >&6;}
      fi
   fi
else
   as_fn_error "invalid option to --enable-ccache-skip. Valid values are \"auto\", \"yes\" and \"no\"" "$LINENO" 5
echo "$as_me: error: invalid option to --enable-ccache-skip. Valid values are \"auto\", \"yes\" and \"no\"" >&2;}
   { (exit 1); exit 1; }; }
fi

if test "$USE_SYSTEM_STL" = "YES"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if hash_map will be in __gnu_cxx namespace" >&5
$as_echo_n "checking if hash_map will be in __gnu_cxx namespace... " >&6; }
   ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu


   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <ext/hash_map>
using namespace __gnu_cxx;

  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_cxx_have_ext_hash_map=yes
else
  ac_cv_cxx_have_ext_hash_map=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_cv_cxx_have_ext_hash_map=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

   if test "$ac_cv_cxx_have_ext_hash_map" = "no"; then
      as_fn_error "Can't find hash_map. Try with --with-stlport" "$LINENO" 5
   else
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_have_ext_hash_map" >&5
$as_echo "$ac_cv_cxx_have_ext_hash_map" >&6; }
      echo "$as_me:$LINENO: result: $ac_cv_cxx_have_ext_hash_map" >&5
echo "${ECHO_T}$ac_cv_cxx_have_ext_hash_map" >&6
   fi

   if test "$HAVE_GCC_VISIBILITY_FEATURE" = "TRUE"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking if STL headers are visibility safe" >&5
$as_echo_n "checking if STL headers are visibility safe... " >&6; }

cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <string>

_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  $EGREP "visibility push" >/dev/null 2>&1; then :
  stlvisok=yes
else
  stlvisok=no
fi
rm -f conftest*

      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $stlvisok" >&5
$as_echo "$stlvisok" >&6; }
      if test "$stlvisok" = "no"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Your gcc STL headers are not visibility safe. Disabling visibility" >&5
$as_echo "$as_me: WARNING: Your gcc STL headers are not visibility safe. Disabling visibility" >&2;}
         echo "Your gcc STL headers are not visibility safe. Disabling visibility" >> warn
         unset HAVE_GCC_VISIBILITY_FEATURE
      fi

      sharedlink_ldflags_save=$LDFLAGS
      LDFLAGS="$LDFLAGS -fvisibility-inlines-hidden -fpic -shared"

      { $as_echo "$as_me:${as_lineno-$LINENO}: checking if gcc is -fvisibility-inlines-hidden safe with STL headers" >&5
$as_echo_n "checking if gcc is -fvisibility-inlines-hidden safe with STL headers... " >&6; }
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <sstream>
using namespace std;

  return 0;
}
_ACEOF
if ac_fn_cxx_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  $EGREP -q  unresolvable conftest.err;
      if test $? -eq 0; then gccvisok=no; else gccvisok=yes; fi
else
  gccvisok=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gccvisok" >&5
$as_echo "$gccvisok" >&6; }
      conftest$ac_exeext conftest.$ac_ext
      echo "$as_me:$LINENO: result: $gccvisok" >&5
echo "${ECHO_T}$gccvisok" >&6
      if test "$gccvisok" = "no"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Your gcc is not -fvisibility-inlines-hidden safe. Disabling visibility" >&5
$as_echo "$as_me: WARNING: Your gcc is not -fvisibility-inlines-hidden safe. Disabling visibility" >&2;}
         echo "Your gcc is not -fvisibility-inlines-hidden safe. Disabling visibility" >> warn
         unset HAVE_GCC_VISIBILITY_FEATURE
      fi

   fi

   if test "$HAVE_GCC_VISIBILITY_FEATURE" = "TRUE"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking if gcc has a visibility bug with class-level attributes (GCC bug 26905)" >&5
$as_echo_n "checking if gcc has a visibility bug with class-level attributes (GCC bug 26905)... " >&6; }
      cat >visibility.cxx <<_ACEOF
#pragma GCC visibility push(hidden)
struct __attribute__ ((visibility ("default"))) TestStruct {

      fi
      rm -f visibility.s

      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gccvisbroken" >&5
$as_echo "$gccvisbroken" >&6; }
      if test "$gccvisbroken" = "yes"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Your gcc is not -fvisibility=hidden safe. Disabling visibility" >&5
$as_echo "$as_me: WARNING: Your gcc is not -fvisibility=hidden safe. Disabling visibility" >&2;}
         echo "Your gcc is not -fvisibility=hidden safe. Disabling visibility" >> warn
         unset HAVE_GCC_VISIBILITY_FEATURE
      fi




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which memory allocator to use" >&5
$as_echo_n "checking which memory allocator to use... " >&6; }
if test "$with_alloc" = "system"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: system" >&5
$as_echo "system" >&6; }
    ALLOC="SYS_ALLOC";
    for ac_func in malloc realloc calloc free
do :
  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
eval as_val=\$$as_ac_var
   if test "x$as_val" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
_ACEOF

fi
done

fi
if test "$with_alloc" = "tcmalloc"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: tcmalloc" >&5
$as_echo "tcmalloc" >&6; }
    if ! echo $build_cpu | grep -E 'i[3456]86' 2>/dev/null >/dev/null; then
        as_fn_error "tcmalloc only available/usable on ix86" "$LINENO" 5
    fi
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for malloc in -ltcmalloc" >&5
$as_echo_n "checking for malloc in -ltcmalloc... " >&6; }
if test "${ac_cv_lib_tcmalloc_malloc+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-ltcmalloc  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#undef $ac_func

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char $ac_func ();
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
choke me
#else
char (*f) () = $ac_func;
#endif
#ifdef __cplusplus
}
#endif

int
main ()
{
return f != $ac_func;
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  eval "$as_ac_var=yes"
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

eval "$as_ac_var=no"
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
fi
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
if test `eval echo '${'$as_ac_var'}'` = yes; then
  cat >>confdefs.h <<_ACEOF
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
_ACEOF

fi
done

fi
if test "$with_alloc" = "tcmalloc"; then
    echo "$as_me:$LINENO: result: tcmalloc" >&5
echo "${ECHO_T}tcmalloc" >&6
    if ! echo $build_cpu | grep -E 'i[3456]86' 2>/dev/null >/dev/null; then
        { { echo "$as_me:$LINENO: error: tcmalloc only available/usable on ix86" >&5
echo "$as_me: error: tcmalloc only available/usable on ix86" >&2;}
   { (exit 1); exit 1; }; }
    fi

echo "$as_me:$LINENO: checking for malloc in -ltcmalloc" >&5
echo $ECHO_N "checking for malloc in -ltcmalloc... $ECHO_C" >&6
if test "${ac_cv_lib_tcmalloc_malloc+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-ltcmalloc  $LIBS"
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char malloc ();
int
main ()
{
return malloc ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_tcmalloc_malloc=yes
else
  ac_cv_lib_tcmalloc_malloc=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_tcmalloc_malloc" >&5
$as_echo "$ac_cv_lib_tcmalloc_malloc" >&6; }
if test "x$ac_cv_lib_tcmalloc_malloc" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBTCMALLOC 1
_ACEOF

  LIBS="-ltcmalloc $LIBS"

else
  as_fn_error "tcmalloc not found or functional. Install the Google Profiling Tools" "$LINENO" 5
echo "$as_me: error: tcmalloc not found or functional. Install the Google Profiling Tools" >&2;}
   { (exit 1); exit 1; }; }
fi

    ALLOC="TCMALLOC";
fi
if test "$with_alloc" = "internal" -o -z "$with_alloc"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
fi



{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to add custom build version" >&5
$as_echo_n "checking whether to add custom build version... " >&6; }
if test "z$with_build_version" != "z"; then
   BUILD_VER_STRING=$with_build_version
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, $BUILD_VER_STRING" >&5
$as_echo "yes, $BUILD_VER_STRING" >&6; }
else
   BUILD_VER_STRING=
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build with Java support" >&5
$as_echo_n "checking whether to build with Java support... " >&6; }
if test "$WITH_JAVA" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   SOLAR_JAVA="TRUE"
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   SOLAR_JAVA=""

   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: building without java will mean some features will not be available" >&5
$as_echo "$as_me: WARNING: building without java will mean some features will not be available" >&2;}
   echo "building without java will mean some features will not be available" >>warn
fi


   if test -z "$with_jdk_home"; then
      # Extract the first word of "$WITH_JAVA", so it can be a program name with args.
set dummy $WITH_JAVA; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_JAVAINTERPRETER+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $JAVAINTERPRETER in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_JAVAINTERPRETER="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
JAVAINTERPRETER=$ac_cv_path_JAVAINTERPRETER

if test -n "$JAVAINTERPRETER"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAINTERPRETER" >&5
$as_echo "$JAVAINTERPRETER" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


   else
      _java_path="$with_jdk_home/bin/$WITH_JAVA"
            if test -x "$_java_path"; then
         JAVAINTERPRETER=$_java_path
      else
         as_fn_error "$_java_path not found set with_jdk_home" "$LINENO" 5
echo "$as_me: error: $_java_path not found set with_jdk_home" >&2;}
   { (exit 1); exit 1; }; }
      fi
   fi
   if test "$_os" = "WINNT"; then


if test "$SOLAR_JAVA" != ""; then
   _gij_longver=0
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking the installed JDK" >&5
$as_echo_n "checking the installed JDK... " >&6; }
   if test -n "$JAVAINTERPRETER"; then
            if test `$JAVAINTERPRETER -version 2>&1 | grep -c "Kaffe"` -gt 0; then
         as_fn_error "No valid check available. Please check the block for your desired java in configure.in" "$LINENO" 5
echo "$as_me: error: No valid check available. Please check the block for your desired java in configure.in" >&2;}
   { (exit 1); exit 1; }; }
#        dnl Kaffe specific tests
#        KAFFE_VER=`$JAVAINTERPRETER -version 2>&1 | $EGREP "  Version:" | $SED -r "s/.*  Version: ([[0-9\.]]*).*/\1/"`
#        if test -z "$KAFFE_VER"; then

#        JAVA_HOME=`echo $JAVAINTERPRETER | $SED -n "s,//*bin//*java,,p"`
      elif test `$JAVAINTERPRETER --version 2>&1 | grep -c "GNU libgcj"` -gt 0; then
        JDK=gcj
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked (gcj)" >&5
$as_echo "checked (gcj)" >&6; }
        _gij_version=`$JAVAINTERPRETER --version | grep GNU | $SED -e 's@^[^0-9]*@@' -e 's@ .*@@' -e 's@,.*@@'`;
        _gij_longver=`echo $_gij_version | $AWK -F. '{ print \$1*10000+\$2*100+\$3 }'`

      elif test `$JAVAINTERPRETER -version 2>&1 | awk '{ print }' | grep -c "BEA"` -gt 0; then
         as_fn_error "No valid check available. Please check the block for your desired java in configure.in" "$LINENO" 5
echo "$as_me: error: No valid check available. Please check the block for your desired java in configure.in" >&2;}
   { (exit 1); exit 1; }; }
#        JDK=bea
#
#        dnl BEA JDK specific tests

        _jdk_ver=`echo "$_jdk" | $AWK -F. '{ print (($1 * 100) + $2) * 100 + $3;}'`

        if test "$_jdk_ver" -lt 10500; then
             as_fn_error "IBM JDK is too old, you need at least 1.5" "$LINENO" 5
        fi

        { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked (IBM JDK $_jdk)" >&5
$as_echo "checked (IBM JDK $_jdk)" >&6; }
        echo "$as_me:$LINENO: result: checked (IBM JDK $_jdk)" >&5
echo "${ECHO_T}checked (IBM JDK $_jdk)" >&6

        if test "$with_jdk_home" = ""; then
             as_fn_error "In order to successfully build OpenOffice.org using the IBM JDK,
you must use the \"--with-jdk-home\" configure option explicitly" "$LINENO" 5
echo "$as_me: error: In order to successfully build OpenOffice.org using the IBM JDK,
you must use the \"--with-jdk-home\" configure option explicitly" >&2;}
   { (exit 1); exit 1; }; }
        fi

        JAVA_HOME=$with_jdk_home

        _jdk_ver=`echo "$_jdk" | $AWK -F. '{ print (($1 * 100) + $2) * 100 + $3;}'`

        if test "$_jdk_ver" -lt 10500; then
             as_fn_error "JDK is too old, you need at least 1.5" "$LINENO" 5
        fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked (JDK $_jdk)" >&5
$as_echo "checked (JDK $_jdk)" >&6; }
        echo "$as_me:$LINENO: result: checked (JDK $_jdk)" >&5
echo "${ECHO_T}checked (JDK $_jdk)" >&6
        JAVA_HOME=`echo $JAVAINTERPRETER | $SED -n "s,//*bin//*java,,p"`
        if test "$_os" = "WINNT"; then
          JAVA_HOME=`echo $JAVA_HOME | $SED "s,\.[eE][xX][eE]$,,"`

        fi
      fi
   else
      as_fn_error "JAVA not found. You need at least jdk-1.5, or gcj-4" "$LINENO" 5
echo "$as_me: error: JAVA not found. You need at least jdk-1.5, or gcj-4" >&2;}
   { (exit 1); exit 1; }; }
   fi
else
      JAVA_HOME=NO_JAVA_HOME ; export JAVA_HOME

    if test -z "$with_jdk_home"; then
        # Extract the first word of "$javacompiler", so it can be a program name with args.
set dummy $javacompiler; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_JAVACOMPILER+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $JAVACOMPILER in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_JAVACOMPILER="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
JAVACOMPILER=$ac_cv_path_JAVACOMPILER

if test -n "$JAVACOMPILER"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVACOMPILER" >&5
$as_echo "$JAVACOMPILER" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    else
        _javac_path="$with_jdk_home/bin/$javacompiler"

        fi
    fi
    if test -z "$JAVACOMPILER"; then
      as_fn_error "$javacompiler not found set with_jdk_home" "$LINENO" 5
echo "$as_me: error: $javacompiler not found set with_jdk_home" >&2;}
   { (exit 1); exit 1; }; }
    fi
    if test "$_os" = "WINNT"; then
       if test x`echo "$JAVACOMPILER" | grep -i '\.exe$'` = x; then

    fi

    if test `$JAVACOMPILER -version 2>&1 | grep -c "Eclipse Java Compiler"` -gt 0; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking re-checking JDK" >&5
$as_echo_n "checking re-checking JDK... " >&6; }
        JDK=gcj
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked (ecj)" >&5
$as_echo "checked (ecj)" >&6; }
        #TODO: what's to do here? some switch to do 1.5 compiling?
        JAVAFLAGS="-source 1.5 -target 1.5"
        _gij_longver="40200"

    if test -z "$with_jdk_home"; then
        # Extract the first word of "javadoc", so it can be a program name with args.
set dummy javadoc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_JAVADOC+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $JAVADOC in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_JAVADOC="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
JAVADOC=$ac_cv_path_JAVADOC

if test -n "$JAVADOC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVADOC" >&5
$as_echo "$JAVADOC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    else
        _javadoc_path="$with_jdk_home/bin/javadoc"

        else
            # Extract the first word of "javadoc", so it can be a program name with args.
set dummy javadoc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_JAVADOC+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $JAVADOC in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_JAVADOC="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
JAVADOC=$ac_cv_path_JAVADOC

if test -n "$JAVADOC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVADOC" >&5
$as_echo "$JAVADOC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


        fi
    fi
    if test -z "$JAVADOC"; then
      as_fn_error "$_javadoc_path not found set with_jdk_home" "$LINENO" 5
echo "$as_me: error: $_javadoc_path not found set with_jdk_home" >&2;}
   { (exit 1); exit 1; }; }
    fi
    if test "$_os" = "WINNT"; then
        if test x`echo "$JAVADOC" | grep -i '\.exe$'` = x; then

    }
}
_ACEOF
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking if javac works" >&5
$as_echo_n "checking if javac works... " >&6; }
        javac_cmd="$JAVACOMPILER findhome.java 1>&2"
        { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$javac_cmd\""; } >&5
  (eval $javac_cmd) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
        if test $? = 0 && test -f ./findhome.class ; then
          { $as_echo "$as_me:${as_lineno-$LINENO}: result: javac works" >&5
$as_echo "javac works" >&6; }
        else
          echo "configure: javac test failed" >&5
          cat findhome.java >&5
          as_fn_error "javac does not work - java projects will not build!" "$LINENO" 5
        fi

        { $as_echo "$as_me:${as_lineno-$LINENO}: checking if gij knows its java.home" >&5
$as_echo_n "checking if gij knows its java.home... " >&6; }
        echo "$as_me:$LINENO: checking if gij knows its java.home" >&5
echo $ECHO_N "checking if gij knows its java.home... $ECHO_C" >&6
        JAVA_HOME=`$JAVAINTERPRETER findhome`
        if test $? = 0 && test "$JAVA_HOME" != "" ; then
          { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_HOME" >&5
$as_echo "$JAVA_HOME" >&6; }
        else
          echo "configure: java test failed" >&5
          cat findhome.java >&5
          as_fn_error "gij does not know its java.home - use --with-jdk-home" "$LINENO" 5
echo "$as_me: error: gij does not know its java.home - use --with-jdk-home" >&2;}
   { (exit 1); exit 1; }; }
        fi
      else
        JAVA_HOME=`echo $JAVAINTERPRETER | $SED -n "s,//*bin//*$WITH_JAVA,,p"`

            JAVA_HOME=$(readlink $JAVACOMPILER)
         else
          # else warn
          { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: JAVA_HOME is set to /usr - this is very likely to be incorrect" >&5
$as_echo "$as_me: WARNING: JAVA_HOME is set to /usr - this is very likely to be incorrect" >&2;}
          { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: if this is the case, please inform the correct JAVA_HOME with --with-jdk-home" >&5
$as_echo "$as_me: WARNING: if this is the case, please inform the correct JAVA_HOME with --with-jdk-home" >&2;}
          echo "JAVA_HOME is set to /usr - this is very likely to be incorrect" >> warn
          echo "if this is the case, please inform the correct JAVA_HOME with --with-jdk-home" >> warn
          fi

         JAVA_HOME_OK="NO"
      fi
      if test "$JAVA_HOME_OK" = "NO"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: JAVA_HOME was not explicitly informed with --with-jdk-home. the configure script" >&5
$as_echo "$as_me: WARNING: JAVA_HOME was not explicitly informed with --with-jdk-home. the configure script" >&2;}
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: attempted to find JAVA_HOME automatically, but apparently it failed" >&5
$as_echo "$as_me: WARNING: attempted to find JAVA_HOME automatically, but apparently it failed" >&2;}
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: in case JAVA_HOME is incorrectly set, some projects with not be built correctly" >&5
$as_echo "$as_me: WARNING: in case JAVA_HOME is incorrectly set, some projects with not be built correctly" >&2;}
         echo "JAVA_HOME was not explicitly informed with --with-jdk-home. the configure script" >> warn
         echo "attempted to find JAVA_HOME automatically, but apparently it failed" >> warn
         echo "in case JAVA_HOME is incorrectly set, some projects with not be built correctly" >> warn


AWTLIB=
if test "$SOLAR_JAVA" != ""; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jawt lib name" >&5
$as_echo_n "checking for jawt lib name... " >&6; }
   if test "$JDK" = "gcj"; then
      save_CFLAGS=$CFLAGS
      save_LDFLAGS=$LDFLAGS
      CFLAGS="$CFLAGS -I$JAVA_HOME/include"
      LDFLAGS="$LDFLAGS -L$JAVA_HOME/lib -lgcj"
      exec 6>/dev/null # no output
      ac_fn_c_check_header_mongrel "$LINENO" "jni.h" "ac_cv_header_jni_h" "$ac_includes_default"
if test "x$ac_cv_header_jni_h" = x""yes; then :

else
  as_fn_error "jni.h could not be found. Mismatch between gcc and libgcj or libgcj-devel missing?" "$LINENO" 5
fi


      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAWT_GetAWT in -lgcjawt" >&5
$as_echo_n "checking for JAWT_GetAWT in -lgcjawt... " >&6; }
if test "${ac_cv_lib_gcjawt_JAWT_GetAWT+set}" = set; then :
  $as_echo_n "(cached) " >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <jni.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking jni.h presence" >&5
echo $ECHO_N "checking jni.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <jni.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: jni.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: jni.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: jni.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: jni.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: jni.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: jni.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: jni.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: jni.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: jni.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: jni.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: jni.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: jni.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: jni.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: jni.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: jni.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: jni.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for jni.h" >&5
echo $ECHO_N "checking for jni.h... $ECHO_C" >&6
if test "${ac_cv_header_jni_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_jni_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_jni_h" >&5
echo "${ECHO_T}$ac_cv_header_jni_h" >&6

fi
if test $ac_cv_header_jni_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: jni.h could not be found. Mismatch between gcc and libgcj or libgcj-devel missing?" >&5
echo "$as_me: error: jni.h could not be found. Mismatch between gcc and libgcj or libgcj-devel missing?" >&2;}
   { (exit 1); exit 1; }; }
fi


      echo "$as_me:$LINENO: checking for JAWT_GetAWT in -lgcjawt" >&5
echo $ECHO_N "checking for JAWT_GetAWT in -lgcjawt... $ECHO_C" >&6
if test "${ac_cv_lib_gcjawt_JAWT_GetAWT+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lgcjawt  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char JAWT_GetAWT ();
int
main ()
{
return JAWT_GetAWT ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_gcjawt_JAWT_GetAWT=yes
else
  ac_cv_lib_gcjawt_JAWT_GetAWT=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gcjawt_JAWT_GetAWT" >&5
$as_echo "$ac_cv_lib_gcjawt_JAWT_GetAWT" >&6; }
if test "x$ac_cv_lib_gcjawt_JAWT_GetAWT" = x""yes; then :
   AWTLIB="-lgcjawt -lgcj"
fi


      LD_LIBRARY_PATH=$JAVA_HOME/jre/bin:$JAVA_HOME/jre/bin/classic:$JAVA_HOME/jre/bin/xawt:$LD_LIBRARY_PATH
      export LD_LIBRARY_PATH
      exec 6>/dev/null # no output
      ac_fn_c_check_header_mongrel "$LINENO" "jni.h" "ac_cv_header_jni_h" "$ac_includes_default"
if test "x$ac_cv_header_jni_h" = x""yes; then :

else
  as_fn_error "jni.h could not be found." "$LINENO" 5
fi


      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAWT_GetAWT in -ljawt" >&5
$as_echo_n "checking for JAWT_GetAWT in -ljawt... " >&6; }
if test "${ac_cv_lib_jawt_JAWT_GetAWT+set}" = set; then :
  $as_echo_n "(cached) " >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <jni.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking jni.h presence" >&5
echo $ECHO_N "checking jni.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <jni.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: jni.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: jni.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: jni.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: jni.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: jni.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: jni.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: jni.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: jni.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: jni.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: jni.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: jni.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: jni.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: jni.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: jni.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: jni.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: jni.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for jni.h" >&5
echo $ECHO_N "checking for jni.h... $ECHO_C" >&6
if test "${ac_cv_header_jni_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_jni_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_jni_h" >&5
echo "${ECHO_T}$ac_cv_header_jni_h" >&6

fi
if test $ac_cv_header_jni_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: jni.h could not be found." >&5
echo "$as_me: error: jni.h could not be found." >&2;}
   { (exit 1); exit 1; }; }
fi


      echo "$as_me:$LINENO: checking for JAWT_GetAWT in -ljawt" >&5
echo $ECHO_N "checking for JAWT_GetAWT in -ljawt... $ECHO_C" >&6
if test "${ac_cv_lib_jawt_JAWT_GetAWT+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-ljawt  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char JAWT_GetAWT ();
int
main ()
{
return JAWT_GetAWT ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_jawt_JAWT_GetAWT=yes
else
  ac_cv_lib_jawt_JAWT_GetAWT=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_jawt_JAWT_GetAWT" >&5
$as_echo "$ac_cv_lib_jawt_JAWT_GetAWT" >&6; }
if test "x$ac_cv_lib_jawt_JAWT_GetAWT" = x""yes; then :
   AWTLIB="-ljawt"
fi

      if test -z "$AWTLIB"; then
         LDFLAGS="$LDFLAGS -L$JAVA_HOME/jre/bin/xawt -ljawt"
         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAWT_GetAWT in -lmawt" >&5
$as_echo_n "checking for JAWT_GetAWT in -lmawt... " >&6; }
if test "${ac_cv_lib_mawt_JAWT_GetAWT+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lmawt  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char JAWT_GetAWT ();
int
main ()
{
return JAWT_GetAWT ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_mawt_JAWT_GetAWT=yes
else
  ac_cv_lib_mawt_JAWT_GetAWT=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mawt_JAWT_GetAWT" >&5
$as_echo "$ac_cv_lib_mawt_JAWT_GetAWT" >&6; }
if test "x$ac_cv_lib_mawt_JAWT_GetAWT" = x""yes; then :
   AWTLIB="-L$JAVA_HOME/jre/bin/xawt -ljawt -lmawt"
fi


   if test -z "$AWTLIB"; then
      AWTLIB=-ljawt
   fi
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWTLIB" >&5
$as_echo "$AWTLIB" >&6; }

fi

if test "$SOLAR_JAVA" != ""; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable gcj aot compilation" >&5
$as_echo_n "checking whether to enable gcj aot compilation... " >&6; }
  if test -n "$enable_gcjaot" && test "$enable_gcjaot" != "no"; then
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
     if test `echo $WITH_JAVA | grep -c "gij"` -eq 0; then
        gcjaot="gcj"
     else
        gcjaot=`echo $WITH_JAVA | $SED -e "s/gij/gcj/g"`
     fi
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gcjaot" >&5
$as_echo "$gcjaot" >&6; }
     if test -n "$with_jdk_home"; then
        _javac_path="$with_jdk_home/bin/$gcjaot"
                if test -x "$_javac_path"; then

     if test -z "$JAVAAOTCOMPILER"; then
        # Extract the first word of "$gcjaot", so it can be a program name with args.
set dummy $gcjaot; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_JAVAAOTCOMPILER+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $JAVAAOTCOMPILER in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_JAVAAOTCOMPILER="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
JAVAAOTCOMPILER=$ac_cv_path_JAVAAOTCOMPILER

if test -n "$JAVAAOTCOMPILER"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAAOTCOMPILER" >&5
$as_echo "$JAVAAOTCOMPILER" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


     fi
     if test -z "$JAVAAOTCOMPILER"; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $gcjaot not found, set with_jdk_home" >&5
$as_echo "$as_me: WARNING: $gcjaot not found, set with_jdk_home" >&2;}
     fi
  else
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
  fi
fi



# Extract the first word of "dmake", so it can be a program name with args.
set dummy dmake; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_DMAKE+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $DMAKE in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_DMAKE="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_DMAKE" && ac_cv_path_DMAKE="no"
  ;;
esac
fi
DMAKE=$ac_cv_path_DMAKE

if test -n "$DMAKE"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DMAKE" >&5
$as_echo "$DMAKE" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


if test "$DMAKE" = "no"; then
    BUILD_DMAKE=YES
    echo "dmake will be built on ./bootstrap"
else
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the found dmake is the right dmake" >&5
$as_echo_n "checking whether the found dmake is the right dmake... " >&6; }
    # we need to find out whether that dmake we found is "our" dmake
    # or the dmake from Sun's SunStudio Compiler which is something
    # different

    $DMAKE -V 2>/dev/null | grep 'dmake .* Version .*' >/dev/null
    if test $? -eq 0; then
       BUILD_DMAKE=NO
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
       { $as_echo "$as_me:${as_lineno-$LINENO}: checking the dmake version" >&5
$as_echo_n "checking the dmake version... " >&6; }
       DMAKE_VERSION=`$DMAKE -V | $AWK '$3 == "Version" {print $4}'`
       if test "`echo $DMAKE_VERSION | cut -d'.' -f1`" -gt "4"; then
	 { $as_echo "$as_me:${as_lineno-$LINENO}: result: OK, >= 4.11" >&5
$as_echo "OK, >= 4.11" >&6; }
       elif test "`echo $DMAKE_VERSION | cut -d'.' -f1`" = "4" && \
	    test "`echo $DMAKE_VERSION | cut -d'.' -f2`" -ge "11"; then
	 { $as_echo "$as_me:${as_lineno-$LINENO}: result: OK, >= 4.11" >&5
$as_echo "OK, >= 4.11" >&6; }
       else
	 { $as_echo "$as_me:${as_lineno-$LINENO}: result: too old. >= 4.11 is needed" >&5
$as_echo "too old. >= 4.11 is needed" >&6; }
	 echo "A newer dmake will be built on ./bootstrap"
	 BUILD_DMAKE=YES
       fi
    else
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
       echo "dmake will be built on ./bootstrap"
       BUILD_DMAKE=YES
    fi
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable EPM for packing" >&5
$as_echo_n "checking whether to enable EPM for packing... " >&6; }
if test "$_os" != "WINNT" -a \( "z$enable_epm" = "z" -o "$enable_epm" != "no" \) ; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            if test "$_os" != "WINNT"; then
      if test -n "$with_epm"; then
	      EPM=$with_epm
      else
         # Extract the first word of "epm", so it can be a program name with args.
set dummy epm; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_EPM+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $EPM in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_EPM="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_EPM" && ac_cv_path_EPM="no"
  ;;
esac
fi
EPM=$ac_cv_path_EPM

if test -n "$EPM"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EPM" >&5
$as_echo "$EPM" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


      fi
      if test "$EPM" = "no" || test "$EPM" = "internal"; then

         BUILD_TYPE="$BUILD_TYPE EPM"
      else
         # Gentoo has some epm which is something different...
         { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the found epm is the right epm" >&5
$as_echo_n "checking whether the found epm is the right epm... " >&6; }
         if $EPM | grep "ESP Package Manager" >/dev/null 2>/dev/null; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
         else
            as_fn_error "no. Install ESP Package Manager (www.easysw.com/epm) and/or specify the path to the right epm" "$LINENO" 5
echo "$as_me: error: no. Install ESP Package Manager (www.easysw.com/epm) and/or specify the path to the right epm" >&2;}
   { (exit 1); exit 1; }; }
         fi
         { $as_echo "$as_me:${as_lineno-$LINENO}: checking epm version" >&5
$as_echo_n "checking epm version... " >&6; }
         EPM_VERSION=`$EPM | grep 'ESP Package Manager' | cut -d' ' -f4 | $SED -e s/v//`
	 if test "`echo $EPM_VERSION | cut -d'.' -f1`" -gt "3" || \
	       test "`echo $EPM_VERSION | cut -d'.' -f1`" -eq "3" -a "`echo $EPM_VERSION | cut -d'.' -f2`" -ge "7"; then
           { $as_echo "$as_me:${as_lineno-$LINENO}: result: OK, >= 3.7" >&5
$as_echo "OK, >= 3.7" >&6; }
           BUILD_EPM=NO
	        if test "$_os" = "Darwin"; then
               { $as_echo "$as_me:${as_lineno-$LINENO}: checking which PackageMaker EPM thinks to use" >&5
$as_echo_n "checking which PackageMaker EPM thinks to use... " >&6; }
        	      _pm=`strings $EPM | grep PackageMaker | cut -d" " -f1`
        	      if test "$_pm" = "/Developer/Applications/PackageMaker.app/Contents/MacOS/PackageMaker"; then
          		      as_fn_error "$_pm; PackageMaker expected in wrong path. Either patch your epm with the right path (/Developer/Applications/Utilities/PackageMaker.app/Contents/MacOS/PackageMaker) or use internal patched epm (--with-epm=internal)" "$LINENO" 5
echo "$as_me: error: $_pm; PackageMaker expected in wrong path. Either patch your epm with the right path (/Developer/Applications/Utilities/PackageMaker.app/Contents/MacOS/PackageMaker) or use internal patched epm (--with-epm=internal)" >&2;}
   { (exit 1); exit 1; }; }
        	      elif test "$_pm" = "/Developer/Applications/Utilities/PackageMaker.app/Contents/MacOS/PackageMaker"; then
          		    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_pm, ok" >&5
$as_echo "$_pm, ok" >&6; }
        	      else # we never should get here, but go safe
			          as_fn_error "$_pm; PackageMaker expected in unknown path. Either patch your epm with the right path (/Developer/Applications/Utilities/PackageMaker.app/Contents/MacOS/PackageMaker) or use internal patched epm (--with-epm=internal)" "$LINENO" 5
echo "$as_me: error: $_pm; PackageMaker expected in unknown path. Either patch your epm with the right path (/Developer/Applications/Utilities/PackageMaker.app/Contents/MacOS/PackageMaker) or use internal patched epm (--with-epm=internal)" >&2;}
   { (exit 1); exit 1; }; }
		          fi
	       fi
	 else
           { $as_echo "$as_me:${as_lineno-$LINENO}: result: too old. epm >= 3.7 is required." >&5
$as_echo "too old. epm >= 3.7 is required." >&6; }
           echo "EPM will be built."
           BUILD_EPM=YES
           BUILD_TYPE="$BUILD_TYPE EPM"

   fi

   # test which package format to use
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which package format to use" >&5
$as_echo_n "checking which package format to use... " >&6; }
   # epm supports the following formats:
   # aix - AIX software distribution
   # bsd - FreeBSD, NetBSD, or OpenBSD software distribution

	# we never should get here since we check the arciecture/os at the beginning,
	# but go sure...
	*)
		as_fn_error "unknown system" "$LINENO" 5
echo "$as_me: error: unknown system" >&2;}
   { (exit 1); exit 1; }; }
   esac
   if test -n "$with_package_format"; then
	for i in $with_package_format; do

			aix | bsd | deb | inst | tardist | osx | pkg | rpm | setld | native | portable)
			;;
		*)
			as_fn_error "unsupported format $i. Supported by EPM are:
aix - AIX software distribution
bsd - FreeBSD, NetBSD, or OpenBSD software distribution
depot or swinstall - HP-UX software distribution

setld - Tru64 (setld) software distribution
native - \"Native\" software distribution for the platform
portable - Portable software distribution
			" "$LINENO" 5
echo "$as_me: error: unsupported format $i. Supported by EPM are:
aix - AIX software distribution
bsd - FreeBSD, NetBSD, or OpenBSD software distribution
depot or swinstall - HP-UX software distribution
deb - Debian software distribution
inst or tardist - IRIX software distribution
osx - MacOS X software distribution
pkg - Solaris software distribution
rpm - RedHat software distribution
setld - Tru64 (setld) software distribution
native - \"Native\" software distribution for the platform
portable - Portable software distribution
			" >&2;}
   { (exit 1); exit 1; }; }
			;;
		esac
	done
	PKGFORMAT="$with_package_format"
   fi
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGFORMAT" >&5
$as_echo "$PKGFORMAT" >&6; }
   if echo "$PKGFORMAT" | $EGREP rpm 2>&1 >/dev/null; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for rpm" >&5
$as_echo_n "checking for rpm... " >&6; }
      for a in "$RPM" rpmbuild rpm; do
         $a --usage >/dev/null 2> /dev/null
         if test $? -eq 0; then

         fi
       done
       if test -z "$RPM" ; then
          as_fn_error "not found" "$LINENO" 5
echo "$as_me: error: not found" >&2;}
   { (exit 1); exit 1; }; }
       else
	  RPM_PATH=`which $RPM`
          { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RPM_PATH" >&5
$as_echo "$RPM_PATH" >&6; }
       fi
   fi
   if echo "$PKGFORMAT" | $EGREP deb 2>&1 >/dev/null; then
      # Extract the first word of "dpkg", so it can be a program name with args.
set dummy dpkg; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_DPKG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $DPKG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_DPKG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_DPKG" && ac_cv_path_DPKG="no"
  ;;
esac
fi
DPKG=$ac_cv_path_DPKG

if test -n "$DPKG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DPKG" >&5
$as_echo "$DPKG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


      if test "$DPKG" = "no"; then
         as_fn_error "dpkg needed for deb creation. Install dpkg." "$LINENO" 5
echo "$as_me: error: dpkg needed for deb creation. Install dpkg." >&2;}
   { (exit 1); exit 1; }; }
      fi
   fi
   if echo "PKGFORMAT" | $EGREP osx 2>&1 >/dev/null; then
      if test "$_os" = "Darwin"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PackageMaker availability" >&5
$as_echo_n "checking for PackageMaker availability... " >&6; }
         if ! test -x /Developer/Applications/Utilities/PackageMaker.app/Contents/MacOS/PackageMaker; then
            as_fn_error "not installed. Please install Apples Dev Tools" "$LINENO" 5
echo "$as_me: error: not installed. Please install Apples Dev Tools" >&2;}
   { (exit 1); exit 1; }; }
         else
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
$as_echo "ok" >&6; }
         fi
      else
         as_fn_error "PackageMaker needed to build OSX packages and you are not on OSX..." "$LINENO" 5
echo "$as_me: error: PackageMaker needed to build OSX packages and you are not on OSX..." >&2;}
   { (exit 1); exit 1; }; }
       fi
   fi
   if echo "$PKGFORMAT" | $EGREP rpm 2>&1 >/dev/null || \
      echo "$PKGFORMAT" | $EGREP pkg 2>&1 >/dev/null; then
      	if test "$EPM" != "no" && test "$EPM" != "internal"; then
           if test "`echo $EPM_VERSION | cut -d'.' -f1`" -lt "4"; then
               { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether epm is patched for OOos needs" >&5
$as_echo_n "checking whether epm is patched for OOos needs... " >&6; }
               if grep "Patched for OpenOffice.org" $EPM >/dev/null 2>/dev/null; then
                  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
               else
                  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
                  if echo "$PKGFORMAT" | grep -q rpm; then
                      _pt="rpm"
                      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: the rpms will need to be installed with --nodeps" >&5
$as_echo "$as_me: WARNING: the rpms will need to be installed with --nodeps" >&2;}
                      echo "the rpms will need to be installed with --nodeps" >> warn
                  else
                      _pt="pkg"
                  fi
                  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: the ${_pt}s will not be relocateable" >&5
$as_echo "$as_me: WARNING: the ${_pt}s will not be relocateable" >&2;}
                  echo "the ${_pt}s will not be relocateable" >> warn
                  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: if you want to make sure installation without --nodeps and
                  relocation will work, you need to patch your epm with the
                  patch in epm/epm-3.7.patch or build with
                  --with-epm=internal which will build a suitable epm" >&5
$as_echo "$as_me: WARNING: if you want to make sure installation without --nodeps and
                  relocation will work, you need to patch your epm with the
                  patch in epm/epm-3.7.patch or build with
                  --with-epm=internal which will build a suitable epm" >&2;}

   if echo "$PKGFORMAT" | $EGREP pkg 2>&1 >/dev/null; then
      # Extract the first word of "pkgmk", so it can be a program name with args.
set dummy pkgmk; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKGMK+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKGMK in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKGMK="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKGMK" && ac_cv_path_PKGMK="no"
  ;;
esac
fi
PKGMK=$ac_cv_path_PKGMK

if test -n "$PKGMK"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGMK" >&5
$as_echo "$PKGMK" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


      if test "$PKGMK" = "no"; then
         as_fn_error "pkgmk needed for Solaris pkg creation. Install it." "$LINENO" 5
      fi
   fi





else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   echo "$as_me:$LINENO: result: no" >&5
echo "${ECHO_T}no" >&6
   EPM=NO
fi


# Extract the first word of "gperf", so it can be a program name with args.
set dummy gperf; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_GPERF+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $GPERF in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_GPERF="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
GPERF=$ac_cv_path_GPERF

if test -n "$GPERF"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GPERF" >&5
$as_echo "$GPERF" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


if test -z "$GPERF"; then
	as_fn_error "gperf not found but needed. Install it." "$LINENO" 5
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking gperf version" >&5
$as_echo_n "checking gperf version... " >&6; }
echo "$as_me:$LINENO: checking gperf version" >&5
echo $ECHO_N "checking gperf version... $ECHO_C" >&6
if test "`$GPERF --version | $EGREP ^GNU\ gperf | $AWK '{ print $3 }' | cut -d. -f1`" -ge "3"; then
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: OK" >&5
$as_echo "OK" >&6; }
else
	as_fn_error "too old, you need at least 3.0.0" "$LINENO" 5
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build the ODK" >&5
$as_echo_n "checking whether to build the ODK... " >&6; }
echo "$as_me:$LINENO: checking whether to build the ODK" >&5
echo $ECHO_N "checking whether to build the ODK... $ECHO_C" >&6
if test "z$enable_odk" = "z" -o "$enable_odk" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   if test "$WITH_JAVA" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for external/unowinreg/unowinreg.dll" >&5
$as_echo_n "checking for external/unowinreg/unowinreg.dll... " >&6; }
   if ! test -f "./external/unowinreg/unowinreg.dll"; then
      HAVE_UNOWINREG_DLL=no
   else
      HAVE_UNOWINREG_DLL=yes
   fi
   if test "$HAVE_UNOWINREG_DLL" = "yes"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
$as_echo "found" >&6; }
      BUILD_UNOWINREG=NO
   else
      if test "$_os" = "WINNT"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found, will be built" >&5
$as_echo "not found, will be built" >&6; }
      else
         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: not found, will be cross-built using mingw32" >&5
$as_echo "$as_me: WARNING: not found, will be cross-built using mingw32" >&2;}
      fi
      BUILD_UNOWINREG=YES
   fi
   if test "$_os" != "WINNT" && test "$BUILD_UNOWINREG" = "YES"; then
      if test -z "$WITH_MINGWIN" || test "$WITH_MINGWIN" = "0"; then
         as_fn_error "for rebuilding unowinreg.dll you need the mingw32 C++ compiler.
         Specify mingw32 g++ executable name with --with-mingwin.
         Or use prebuilt one from http://tools.openoffice.org/unowinreg_prebuild/680/ and
         put it into external/unowinreg" "$LINENO" 5
echo "$as_me: error: for rebuilding unowinreg.dll you need the mingw32 C++ compiler.
         Specify mingw32 g++ executable name with --with-mingwin.
         Or use prebuilt one from http://tools.openoffice.org/unowinreg_prebuild/680/ and
         put it into external/unowinreg" >&2;}
   { (exit 1); exit 1; }; }
      fi
      if echo "$WITH_MINGWIN" | $EGREP -q "/"; then
         if ! test -x "$WITH_MINGWIN"; then MINGWCXX=false; else MINGWCXX=`basename $WITH_MINGWIN`; fi

         if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}$WITH_MINGWIN", so it can be a program name with args.
set dummy ${ac_tool_prefix}$WITH_MINGWIN; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_MINGWCXX+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$MINGWCXX"; then
  ac_cv_prog_MINGWCXX="$MINGWCXX" # Let the user override the test.

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_prog_MINGWCXX="${ac_tool_prefix}$WITH_MINGWIN"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
MINGWCXX=$ac_cv_prog_MINGWCXX
if test -n "$MINGWCXX"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MINGWCXX" >&5
$as_echo "$MINGWCXX" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_MINGWCXX"; then
  ac_ct_MINGWCXX=$MINGWCXX
  # Extract the first word of "$WITH_MINGWIN", so it can be a program name with args.
set dummy $WITH_MINGWIN; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_MINGWCXX+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_MINGWCXX"; then
  ac_cv_prog_ac_ct_MINGWCXX="$ac_ct_MINGWCXX" # Let the user override the test.

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_prog_ac_ct_MINGWCXX="$WITH_MINGWIN"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_MINGWCXX=$ac_cv_prog_ac_ct_MINGWCXX
if test -n "$ac_ct_MINGWCXX"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MINGWCXX" >&5
$as_echo "$ac_ct_MINGWCXX" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_MINGWCXX" = x; then
    MINGWCXX="false"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    MINGWCXX=$ac_ct_MINGWCXX
  fi
else
  MINGWCXX="$ac_cv_prog_MINGWCXX"
fi

      fi
      if test "$MINGWCXX" = "false"; then
         as_fn_error "specified MinGW32 C++ cross-compiler not found. Install it or correct name." "$LINENO" 5
      fi
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the MinGW32 cross C++ compiler" >&5
$as_echo_n "checking whether we are using the MinGW32 cross C++ compiler... " >&6; }
      echo "$as_me:$LINENO: checking whether we are using the MinGW32 cross C++ compiler" >&5
echo $ECHO_N "checking whether we are using the MinGW32 cross C++ compiler... $ECHO_C" >&6
      if ! echo "`$MINGWCXX -dumpmachine`" | grep -q mingw32; then
         as_fn_error "no" "$LINENO" 5
      else
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
         echo "$as_me:$LINENO: result: yes" >&5
echo "${ECHO_T}yes" >&6
      fi
      if echo "$WITH_MINGWIN" | $EGREP -q "/"; then
         if ! test -x "`echo $WITH_MINGWIN | $SED -e s/g++/strip/`"; then MINGSTRIP=false; else MINGWSTRIP=$(basename $(echo $WITH_MINGWIN | $SED -e s/g++/strip/)); fi

         if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}`echo $WITH_MINGWIN | $SED -e s/g++/strip/`", so it can be a program name with args.
set dummy ${ac_tool_prefix}`echo $WITH_MINGWIN | $SED -e s/g++/strip/`; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_MINGWSTRIP+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$MINGWSTRIP"; then
  ac_cv_prog_MINGWSTRIP="$MINGWSTRIP" # Let the user override the test.

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_prog_MINGWSTRIP="${ac_tool_prefix}`echo $WITH_MINGWIN | $SED -e s/g++/strip/`"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
MINGWSTRIP=$ac_cv_prog_MINGWSTRIP
if test -n "$MINGWSTRIP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MINGWSTRIP" >&5
$as_echo "$MINGWSTRIP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_MINGWSTRIP"; then
  ac_ct_MINGWSTRIP=$MINGWSTRIP
  # Extract the first word of "`echo $WITH_MINGWIN | $SED -e s/g++/strip/`", so it can be a program name with args.
set dummy `echo $WITH_MINGWIN | $SED -e s/g++/strip/`; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_MINGWSTRIP+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_MINGWSTRIP"; then
  ac_cv_prog_ac_ct_MINGWSTRIP="$ac_ct_MINGWSTRIP" # Let the user override the test.

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_prog_ac_ct_MINGWSTRIP="`echo $WITH_MINGWIN | $SED -e s/g++/strip/`"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_MINGWSTRIP=$ac_cv_prog_ac_ct_MINGWSTRIP
if test -n "$ac_ct_MINGWSTRIP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MINGWSTRIP" >&5
$as_echo "$ac_ct_MINGWSTRIP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_MINGWSTRIP" = x; then
    MINGWSTRIP="false"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    MINGWSTRIP=$ac_ct_MINGWSTRIP
  fi
else
  MINGWSTRIP="$ac_cv_prog_MINGWSTRIP"
fi

      fi
      if test "$MINGWSTRIP" = "false"; then
         as_fn_error "MinGW32 binutils needed. Install them." "$LINENO" 5
      fi
      ac_ext=cpp
      fi
      ac_ext=cc
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

      # do not make sense here (and 'd make the check fail)
      save_LIBS=$LIBS
      LIBS=""
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lkernel32" >&5
$as_echo_n "checking for main in -lkernel32... " >&6; }
if test "${ac_cv_lib_kernel32_main+set}" = set; then :
  $as_echo_n "(cached) " >&6
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lkernel32  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */


int
main ()
{
return main ();
  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_link "$LINENO"; then :
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_kernel32_main=yes
else
  ac_cv_lib_kernel32_main=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_kernel32_main" >&5
$as_echo "$ac_cv_lib_kernel32_main" >&6; }
if test "x$ac_cv_lib_kernel32_main" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBKERNEL32 1
_ACEOF

fi
ac_cv_lib_kernel32=ac_cv_lib_kernel32_main

      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -ladvapi32" >&5
$as_echo_n "checking for main in -ladvapi32... " >&6; }
if test "${ac_cv_lib_advapi32_main+set}" = set; then :
  $as_echo_n "(cached) " >&6
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-ladvapi32  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */


int
main ()
{
return main ();
  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_link "$LINENO"; then :
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_advapi32_main=yes
else
  ac_cv_lib_advapi32_main=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_advapi32_main" >&5
$as_echo "$ac_cv_lib_advapi32_main" >&6; }
if test "x$ac_cv_lib_advapi32_main" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBADVAPI32 1
_ACEOF

fi
ac_cv_lib_advapi32=ac_cv_lib_advapi32_main

      ac_fn_cxx_check_header_mongrel "$LINENO" "windows.h" "ac_cv_header_windows_h" "$ac_includes_default"
if test "x$ac_cv_header_windows_h" = x""yes; then :

else
  as_fn_error "windows.h missing" "$LINENO" 5
fi
echo "$as_me:$LINENO: result: $ac_cv_header_windows_h" >&5
echo "${ECHO_T}$ac_cv_header_windows_h" >&6
else
  # Is the header compilable?
echo "$as_me:$LINENO: checking windows.h usability" >&5
echo $ECHO_N "checking windows.h usability... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <windows.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking windows.h presence" >&5
echo $ECHO_N "checking windows.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <windows.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_cxx_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: windows.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: windows.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: windows.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: windows.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: windows.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: windows.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: windows.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: windows.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: windows.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: windows.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: windows.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: windows.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: windows.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: windows.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: windows.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: windows.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for windows.h" >&5
echo $ECHO_N "checking for windows.h... $ECHO_C" >&6
if test "${ac_cv_header_windows_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_windows_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_windows_h" >&5
echo "${ECHO_T}$ac_cv_header_windows_h" >&6

fi
if test $ac_cv_header_windows_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: windows.h missing" >&5
echo "$as_me: error: windows.h missing" >&2;}
   { (exit 1); exit 1; }; }
fi



   fi
   BUILD_TYPE="$BUILD_TYPE ODK"
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   BUILD_UNOWINREG=NO
fi




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build qadevOOo" >&5
$as_echo_n "checking whether to build qadevOOo... " >&6; }
if test "z$enable_qadevooo" = "z" -o "$enable_qadevooo" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   BUILD_QADEVOOO="YES"
   BUILD_TYPE="$BUILD_TYPE QADEVOOO"
else
   BUILD_QADEVOOO="NO"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi



  if test -n "$checkforstdlibproblems"; then
    if test -f /etc/rpm/macros.prelink; then
      with_system_stdlibs=yes
      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: prelinked libgcc_s.so.1, enabling --with-system-stdlibs, use --without-system-stdlibs to override" >&5
$as_echo "$as_me: WARNING: prelinked libgcc_s.so.1, enabling --with-system-stdlibs, use --without-system-stdlibs to override" >&2;}
      echo "prelinked libgcc_s.so.1, enabling --with-system-stdlibs, use --without-system-stdlibs to override" >> warn
    elif test "$GCC" = "yes" -a ! -e `$CC -print-file-name=libgcc_s.so.1`; then
      with_system_stdlibs=yes
      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: platform doesn't have a libgcc_s.so.1, enabling --with-system-stdlibs, use --without-system-stdlibs to override" >&5
$as_echo "$as_me: WARNING: platform doesn't have a libgcc_s.so.1, enabling --with-system-stdlibs, use --without-system-stdlibs to override" >&2;}
      echo "platform doesn't have a libgcc_s.so.1, enabling --with-system-stdlibs, use --without-system-stdlibs to override" >> warn
    fi
  fi
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to provide libstdc++/libgcc_s in the installset" >&5
$as_echo_n "checking whether to provide libstdc++/libgcc_s in the installset... " >&6; }
if test -n "$with_system_stdlibs" -o -n "$with_system_libs" && \
   test "$with_system_stdlibs" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   SYSTEM_STDLIBS=YES
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   SYSTEM_STDLIBS=NO
fi


if test "$_os" = "Darwin" && test "$with_system_zlib" != "no"; then
   with_system_zlib=yes
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which zlib to use" >&5
$as_echo_n "checking which zlib to use... " >&6; }
if test -n "$with_system_zlib" -o -n "$with_system_libs" && \
	test "$with_system_zlib" != "no"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
    SYSTEM_ZLIB=YES
    ac_fn_c_check_header_mongrel "$LINENO" "zlib.h" "ac_cv_header_zlib_h" "$ac_includes_default"
if test "x$ac_cv_header_zlib_h" = x""yes; then :

else
  as_fn_error "zlib.h not found. install zlib" "$LINENO" 5
fi


    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for deflate in -lz" >&5
$as_echo_n "checking for deflate in -lz... " >&6; }
if test "${ac_cv_lib_z_deflate+set}" = set; then :
  $as_echo_n "(cached) " >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <zlib.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking zlib.h presence" >&5
echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <zlib.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for zlib.h" >&5
echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
if test "${ac_cv_header_zlib_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_zlib_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
echo "${ECHO_T}$ac_cv_header_zlib_h" >&6

fi
if test $ac_cv_header_zlib_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: zlib.h not found. install zlib" >&5
echo "$as_me: error: zlib.h not found. install zlib" >&2;}
   { (exit 1); exit 1; }; }
fi


    echo "$as_me:$LINENO: checking for deflate in -lz" >&5
echo $ECHO_N "checking for deflate in -lz... $ECHO_C" >&6
if test "${ac_cv_lib_z_deflate+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lz  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char deflate ();
int
main ()
{
return deflate ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_z_deflate=yes
else
  ac_cv_lib_z_deflate=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_deflate" >&5
$as_echo "$ac_cv_lib_z_deflate" >&6; }
if test "x$ac_cv_lib_z_deflate" = x""yes; then :
   ZLIB=-lz
else
  as_fn_error "zlib not found or functional" "$LINENO" 5
fi

else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    echo "$as_me:$LINENO: result: internal" >&5
echo "${ECHO_T}internal" >&6
    SYSTEM_ZLIB=NO
    BUILD_TYPE="$BUILD_TYPE ZLIB"
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which jpeg to use" >&5
$as_echo_n "checking which jpeg to use... " >&6; }
if test -n "$with_system_jpeg" -o -n "$with_system_libs" && \
	test "$with_system_jpeg" != "no"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
    SYSTEM_JPEG=YES
    ac_fn_c_check_header_mongrel "$LINENO" "jpeglib.h" "ac_cv_header_jpeglib_h" "$ac_includes_default"
if test "x$ac_cv_header_jpeglib_h" = x""yes; then :

else
  as_fn_error "jpeg.h not found. install libjpeg" "$LINENO" 5
fi


    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jpeg_resync_to_restart in -ljpeg" >&5
$as_echo_n "checking for jpeg_resync_to_restart in -ljpeg... " >&6; }
if test "${ac_cv_lib_jpeg_jpeg_resync_to_restart+set}" = set; then :
  $as_echo_n "(cached) " >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <jpeglib.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking jpeglib.h presence" >&5
echo $ECHO_N "checking jpeglib.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <jpeglib.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: jpeglib.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: jpeglib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: jpeglib.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: jpeglib.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: jpeglib.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: jpeglib.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: jpeglib.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: jpeglib.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: jpeglib.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: jpeglib.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: jpeglib.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: jpeglib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: jpeglib.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: jpeglib.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: jpeglib.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: jpeglib.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for jpeglib.h" >&5
echo $ECHO_N "checking for jpeglib.h... $ECHO_C" >&6
if test "${ac_cv_header_jpeglib_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_jpeglib_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_jpeglib_h" >&5
echo "${ECHO_T}$ac_cv_header_jpeglib_h" >&6

fi
if test $ac_cv_header_jpeglib_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: jpeg.h not found. install libjpeg" >&5
echo "$as_me: error: jpeg.h not found. install libjpeg" >&2;}
   { (exit 1); exit 1; }; }
fi


    echo "$as_me:$LINENO: checking for jpeg_resync_to_restart in -ljpeg" >&5
echo $ECHO_N "checking for jpeg_resync_to_restart in -ljpeg... $ECHO_C" >&6
if test "${ac_cv_lib_jpeg_jpeg_resync_to_restart+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-ljpeg  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char jpeg_resync_to_restart ();
int
main ()
{
return jpeg_resync_to_restart ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_jpeg_jpeg_resync_to_restart=yes
else
  ac_cv_lib_jpeg_jpeg_resync_to_restart=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_jpeg_jpeg_resync_to_restart" >&5
$as_echo "$ac_cv_lib_jpeg_jpeg_resync_to_restart" >&6; }
if test "x$ac_cv_lib_jpeg_jpeg_resync_to_restart" = x""yes; then :
   JPEG3RDLIB=-ljpeg
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking jpeg library not found or fuctional" >&5
$as_echo_n "checking jpeg library not found or fuctional... " >&6; }
fi

else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    SYSTEM_JPEG=NO
    BUILD_TYPE="$BUILD_TYPE JPEG"
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which expat to use" >&5
$as_echo_n "checking which expat to use... " >&6; }
if test -n "$with_system_expat" -o -n "$with_system_libs" && \
	test "$with_system_expat" != "no"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
    SYSTEM_EXPAT=YES
    ac_fn_c_check_header_mongrel "$LINENO" "expat.h" "ac_cv_header_expat_h" "$ac_includes_default"
if test "x$ac_cv_header_expat_h" = x""yes; then :

else
  as_fn_error "expat.h not found. install expat" "$LINENO" 5
fi


    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XML_ParserCreate in -lexpat" >&5
$as_echo_n "checking for XML_ParserCreate in -lexpat... " >&6; }
if test "${ac_cv_lib_expat_XML_ParserCreate+set}" = set; then :
  $as_echo_n "(cached) " >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <expat.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking expat.h presence" >&5
echo $ECHO_N "checking expat.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <expat.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: expat.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: expat.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: expat.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: expat.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: expat.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: expat.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: expat.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: expat.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: expat.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: expat.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: expat.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: expat.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: expat.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: expat.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: expat.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: expat.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for expat.h" >&5
echo $ECHO_N "checking for expat.h... $ECHO_C" >&6
if test "${ac_cv_header_expat_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_expat_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_expat_h" >&5
echo "${ECHO_T}$ac_cv_header_expat_h" >&6

fi
if test $ac_cv_header_expat_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: expat.h not found. install expat" >&5
echo "$as_me: error: expat.h not found. install expat" >&2;}
   { (exit 1); exit 1; }; }
fi



echo "$as_me:$LINENO: checking for XML_ParserCreate in -lexpat" >&5
echo $ECHO_N "checking for XML_ParserCreate in -lexpat... $ECHO_C" >&6
if test "${ac_cv_lib_expat_XML_ParserCreate+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lexpat  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char XML_ParserCreate ();
int
main ()
{
return XML_ParserCreate ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_expat_XML_ParserCreate=yes
else
  ac_cv_lib_expat_XML_ParserCreate=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_expat_XML_ParserCreate" >&5
$as_echo "$ac_cv_lib_expat_XML_ParserCreate" >&6; }
if test "x$ac_cv_lib_expat_XML_ParserCreate" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBEXPAT 1
_ACEOF

  LIBS="-lexpat $LIBS"

else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: expat library not found or functional." >&5
$as_echo "expat library not found or functional." >&6; }
fi

else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    SYSTEM_EXPAT=NO
    BUILD_TYPE="$BUILD_TYPE EXPAT"
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which libwpd to use" >&5
$as_echo_n "checking which libwpd to use... " >&6; }
if test -n "$with_system_libwpd" -o -n "$with_system_libs" && \
        test "$with_system_libwpd" != "no"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
    SYSTEM_LIBWPD=YES

  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for libwpd-0.8 " >&5
$as_echo_n "checking for libwpd-0.8 ... " >&6; }

        if $PKG_CONFIG --exists "libwpd-0.8 " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking LIBWPD_CFLAGS" >&5
$as_echo_n "checking LIBWPD_CFLAGS... " >&6; }
            LIBWPD_CFLAGS=`$PKG_CONFIG --cflags "libwpd-0.8 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIBWPD_CFLAGS" >&5
$as_echo "$LIBWPD_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking LIBWPD_LIBS" >&5
$as_echo_n "checking LIBWPD_LIBS... " >&6; }
            LIBWPD_LIBS=`$PKG_CONFIG --libs "libwpd-0.8 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIBWPD_LIBS" >&5
$as_echo "$LIBWPD_LIBS" >&6; }
        else
            LIBWPD_CFLAGS=""
            LIBWPD_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (libwpd-0.8 ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
  fi

else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    echo "$as_me:$LINENO: result: internal" >&5
echo "${ECHO_T}internal" >&6
    SYSTEM_LIBWPD=NO
    BUILD_TYPE="$BUILD_TYPE LIBWPD"
fi



if test  "$test_freetype" = "yes"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether freetype is available" >&5
$as_echo_n "checking whether freetype is available... " >&6; }

  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype2 >= 2.0 " >&5
$as_echo_n "checking for freetype2 >= 2.0 ... " >&6; }

        if $PKG_CONFIG --exists "freetype2 >= 2.0 " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking FREETYPE_CFLAGS" >&5
$as_echo_n "checking FREETYPE_CFLAGS... " >&6; }
            FREETYPE_CFLAGS=`$PKG_CONFIG --cflags "freetype2 >= 2.0 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_CFLAGS" >&5
$as_echo "$FREETYPE_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking FREETYPE_LIBS" >&5
$as_echo_n "checking FREETYPE_LIBS... " >&6; }
            FREETYPE_LIBS=`$PKG_CONFIG --libs "freetype2 >= 2.0 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIBS" >&5
$as_echo "$FREETYPE_LIBS" >&6; }
        else
            FREETYPE_CFLAGS=""
            FREETYPE_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (freetype2 >= 2.0 ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
echo "$as_me: error: Library requirements (freetype2 >= 2.0 ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." >&2;}
   { (exit 1); exit 1; }; }
  fi

fi

    save_LIBS="$LIBS"
    CPPFLAGS="$CPPFLAGS $FREETYPE_CFLAGS"
    LDFLAGS="$LDFLAGS $FREETYPE_LIBS"
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FT_GlyphSlot_Embolden in -lfreetype" >&5
$as_echo_n "checking for FT_GlyphSlot_Embolden in -lfreetype... " >&6; }
if test "${ac_cv_lib_freetype_FT_GlyphSlot_Embolden+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lfreetype  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char FT_GlyphSlot_Embolden ();
int
main ()
{
return FT_GlyphSlot_Embolden ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_freetype_FT_GlyphSlot_Embolden=yes
else
  ac_cv_lib_freetype_FT_GlyphSlot_Embolden=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_freetype_FT_GlyphSlot_Embolden" >&5
$as_echo "$ac_cv_lib_freetype_FT_GlyphSlot_Embolden" >&6; }
if test "x$ac_cv_lib_freetype_FT_GlyphSlot_Embolden" = x""yes; then :
  USE_FT_EMBOLDEN="YES"
else
  USE_FT_EMBOLDEN="NO"

    fi
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which libxslt to use" >&5
$as_echo_n "checking which libxslt to use... " >&6; }
if test -n "$with_system_libxslt" -o -n "$with_system_libs" -o \
       "$_os" = "Darwin" && \
   test "$with_system_libxslt" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
   SYSTEM_LIBXSLT=YES

   if test "$_os" = "Darwin"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking LIBXSLT_CFLAGS" >&5
$as_echo_n "checking LIBXSLT_CFLAGS... " >&6; }
   LIBXSLT_CFLAGS=`xslt-config --cflags`
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIBXSLT_CFLAGS" >&5
$as_echo "$LIBXSLT_CFLAGS" >&6; }
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking LIBXSLT_LIBS" >&5
$as_echo_n "checking LIBXSLT_LIBS... " >&6; }
   LIBXSLT_LIBS=`xslt-config --libs`
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIBXSLT_LIBS" >&5
$as_echo "$LIBXSLT_LIBS" >&6; }


 else

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for libxslt" >&5
$as_echo_n "checking for libxslt... " >&6; }

        if $PKG_CONFIG --exists "libxslt" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking LIBXSLT_CFLAGS" >&5
$as_echo_n "checking LIBXSLT_CFLAGS... " >&6; }
            LIBXSLT_CFLAGS=`$PKG_CONFIG --cflags "libxslt"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIBXSLT_CFLAGS" >&5
$as_echo "$LIBXSLT_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking LIBXSLT_LIBS" >&5
$as_echo_n "checking LIBXSLT_LIBS... " >&6; }
            LIBXSLT_LIBS=`$PKG_CONFIG --libs "libxslt"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIBXSLT_LIBS" >&5
$as_echo "$LIBXSLT_LIBS" >&6; }
        else
            LIBXSLT_CFLAGS=""
            LIBXSLT_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (libxslt) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
echo "$as_me: error: Library requirements (libxslt) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." >&2;}
   { (exit 1); exit 1; }; }
  fi

 fi


      # Extract the first word of "xsltproc", so it can be a program name with args.
set dummy xsltproc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_XSLTPROC+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $XSLTPROC in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_XSLTPROC="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_XSLTPROC" && ac_cv_path_XSLTPROC="no"
  ;;
esac
fi
XSLTPROC=$ac_cv_path_XSLTPROC

if test -n "$XSLTPROC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XSLTPROC" >&5
$as_echo "$XSLTPROC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


   if test "$XSLTPROC" = "no"; then
      as_fn_error "xsltproc is required" "$LINENO" 5
   fi
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
   echo "$as_me:$LINENO: result: internal" >&5
echo "${ECHO_T}internal" >&6
   SYSTEM_LIBXSLT=NO
   BUILD_TYPE="$BUILD_TYPE LIBXSLT"
fi




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which libxml to use" >&5
$as_echo_n "checking which libxml to use... " >&6; }
if test -n "$with_system_libxml" -o -n "$with_system_libs" -o \
            "$_os" = "Darwin" && \
	test "$with_system_libxml" != "no"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
    SYSTEM_LIBXML=YES
    if test "$_os" = "Darwin"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking LIBXML_CFLAGS" >&5
$as_echo_n "checking LIBXML_CFLAGS... " >&6; }
   LIBXML_CFLAGS=`xml2-config --cflags`
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIBXML_CFLAGS" >&5
$as_echo "$LIBXML_CFLAGS" >&6; }
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking LIBXML_LIBS" >&5
$as_echo_n "checking LIBXML_LIBS... " >&6; }
   LIBXML_LIBS=`xml2-config --libs`
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIBXML_LIBS" >&5
$as_echo "$LIBXML_LIBS" >&6; }


 else

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for libxml-2.0 >= 2.0" >&5
$as_echo_n "checking for libxml-2.0 >= 2.0... " >&6; }

        if $PKG_CONFIG --exists "libxml-2.0 >= 2.0" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking LIBXML_CFLAGS" >&5
$as_echo_n "checking LIBXML_CFLAGS... " >&6; }
            LIBXML_CFLAGS=`$PKG_CONFIG --cflags "libxml-2.0 >= 2.0"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIBXML_CFLAGS" >&5
$as_echo "$LIBXML_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking LIBXML_LIBS" >&5
$as_echo_n "checking LIBXML_LIBS... " >&6; }
            LIBXML_LIBS=`$PKG_CONFIG --libs "libxml-2.0 >= 2.0"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIBXML_LIBS" >&5
$as_echo "$LIBXML_LIBS" >&6; }
        else
            LIBXML_CFLAGS=""
            LIBXML_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (libxml-2.0 >= 2.0) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
echo "$as_me: error: Library requirements (libxml-2.0 >= 2.0) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." >&2;}
   { (exit 1); exit 1; }; }
  fi

 fi

    BUILD_TYPE="$BUILD_TYPE LIBXMLSEC"
else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    SYSTEM_LIBXML=NO
    BUILD_TYPE="$BUILD_TYPE LIBXML2 LIBXMLSEC"
fi

if test "$_os" = "Darwin" && test "$with_system_python" != "no"; then
   with_system_python=yes
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which python to use" >&5
$as_echo_n "checking which python to use... " >&6; }
if test -n "$with_system_python" -o -n "$with_system_libs" && \
	test "$with_system_python" != "no"; then
   SYSTEM_PYTHON=YES
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }




        if test -n "$PYTHON"; then
      # If the user set $PYTHON, use it and don't search something else.
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $PYTHON version >= 2.2" >&5
$as_echo_n "checking whether $PYTHON version >= 2.2... " >&6; }
      prog="import sys, string
# split strings by '.' and convert to numeric.  Append some zeros
# because we need at least 4 digits for the hex conversion.

   ($PYTHON -c "$prog") >&5 2>&5
   ac_status=$?
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
  as_fn_error "too old" "$LINENO" 5
fi
   { (exit 1); exit 1; }; }
fi

      am_display_PYTHON=$PYTHON
    else
      # Otherwise, try each interpreter until we find one that satisfies
      # VERSION.
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a Python interpreter with version >= 2.2" >&5
$as_echo_n "checking for a Python interpreter with version >= 2.2... " >&6; }
if test "${am_cv_pathless_PYTHON+set}" = set; then :
  $as_echo_n "(cached) " >&6
else

	for am_cv_pathless_PYTHON in python python2 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0 python1.6 python1.5 none; do

   ($am_cv_pathless_PYTHON -c "$prog") >&5 2>&5
   ac_status=$?
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; then :
  break
fi

	done
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_pathless_PYTHON" >&5
$as_echo "$am_cv_pathless_PYTHON" >&6; }
      # Set $PYTHON to the absolute path of $am_cv_pathless_PYTHON.
      if test "$am_cv_pathless_PYTHON" = none; then
	PYTHON=:
      else
        # Extract the first word of "$am_cv_pathless_PYTHON", so it can be a program name with args.
set dummy $am_cv_pathless_PYTHON; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PYTHON+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PYTHON in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PYTHON="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
PYTHON=$ac_cv_path_PYTHON

if test -n "$PYTHON"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON" >&5
$as_echo "$PYTHON" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


      fi
      am_display_PYTHON=$am_cv_pathless_PYTHON



  if test "$PYTHON" = :; then
      as_fn_error "no suitable Python interpreter found" "$LINENO" 5
  else


  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON version" >&5
$as_echo_n "checking for $am_display_PYTHON version... " >&6; }
if test "${am_cv_python_version+set}" = set; then :
  $as_echo_n "(cached) " >&6
if test "${am_cv_python_version+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  am_cv_python_version=`$PYTHON -c "import sys; print sys.version[:3]"`
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_version" >&5
$as_echo "$am_cv_python_version" >&6; }
  PYTHON_VERSION=$am_cv_python_version






  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON platform" >&5
$as_echo_n "checking for $am_display_PYTHON platform... " >&6; }
if test "${am_cv_python_platform+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  am_cv_python_platform=`$PYTHON -c "import sys; print sys.platform"`
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_platform" >&5
$as_echo "$am_cv_python_platform" >&6; }
  PYTHON_PLATFORM=$am_cv_python_platform




                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON script directory" >&5
$as_echo_n "checking for $am_display_PYTHON script directory... " >&6; }
if test "${am_cv_python_pythondir+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  am_cv_python_pythondir=`$PYTHON -c "from distutils import sysconfig; print sysconfig.get_python_lib(0,0,prefix='$PYTHON_PREFIX')" 2>/dev/null ||
     echo "$PYTHON_PREFIX/lib/python$PYTHON_VERSION/site-packages"`
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pythondir" >&5
$as_echo "$am_cv_python_pythondir" >&6; }
  pythondir=$am_cv_python_pythondir



  pkgpythondir=\${pythondir}/$PACKAGE


            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON extension module directory" >&5
$as_echo_n "checking for $am_display_PYTHON extension module directory... " >&6; }
if test "${am_cv_python_pyexecdir+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  am_cv_python_pyexecdir=`$PYTHON -c "from distutils import sysconfig; print sysconfig.get_python_lib(1,0,prefix='$PYTHON_EXEC_PREFIX')" 2>/dev/null ||
     echo "${PYTHON_EXEC_PREFIX}/lib/python${PYTHON_VERSION}/site-packages"`
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pyexecdir" >&5
$as_echo "$am_cv_python_pyexecdir" >&6; }
  pyexecdir=$am_cv_python_pyexecdir




      save_CPPFLAGS="$CPPFLAGS"
   CPPFLAGS="$CPPFLAGS $PYTHON_CFLAGS"
   ac_fn_c_check_header_mongrel "$LINENO" "Python.h" "ac_cv_header_Python_h" "$ac_includes_default"
if test "x$ac_cv_header_Python_h" = x""yes; then :

else
  as_fn_error "Python headers not found" "$LINENO" 5
fi
echo "$as_me:$LINENO: result: $ac_cv_header_Python_h" >&5
echo "${ECHO_T}$ac_cv_header_Python_h" >&6
else
  # Is the header compilable?
echo "$as_me:$LINENO: checking Python.h usability" >&5
echo $ECHO_N "checking Python.h usability... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <Python.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking Python.h presence" >&5
echo $ECHO_N "checking Python.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <Python.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: Python.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: Python.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: Python.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: Python.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: Python.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: Python.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: Python.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: Python.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: Python.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: Python.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: Python.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: Python.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: Python.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: Python.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: Python.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: Python.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for Python.h" >&5
echo $ECHO_N "checking for Python.h... $ECHO_C" >&6
if test "${ac_cv_header_Python_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_Python_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_Python_h" >&5
echo "${ECHO_T}$ac_cv_header_Python_h" >&6

fi
if test $ac_cv_header_Python_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: Python headers not found" >&5
echo "$as_me: error: Python headers not found" >&2;}
   { (exit 1); exit 1; }; }
fi



else
   SYSTEM_PYTHON=NO
   BUILD_TYPE="$BUILD_TYPE PYTHON"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
   # Embedded python dies without Home set
   if test "z$HOME" = "z"; then
      export HOME="";

   if test -z "$BZIP2"; then
	# Extract the first word of "bzip2", so it can be a program name with args.
set dummy bzip2; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_BZIP2+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $BZIP2 in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_BZIP2="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
BZIP2=$ac_cv_path_BZIP2

if test -n "$BZIP2"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BZIP2" >&5
$as_echo "$BZIP2" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


	if test -z "$BZIP2"; then
   		as_fn_error "the internal Python module has a .tar.bz2. You need bzip2" "$LINENO" 5
echo "$as_me: error: the internal Python module has a .tar.bz2. You need bzip2" >&2;}
   { (exit 1); exit 1; }; }
   	fi
   fi
fi

HOME=`echo $HOME | sed 's:\\\\:/:g'`


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which db to use" >&5
$as_echo_n "checking which db to use... " >&6; }
if test -n "$with_system_db" -o -n "$with_system_libs" && \
	test "$with_system_db" != "no"; then
    SYSTEM_DB=YES
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
    ac_fn_c_check_header_compile "$LINENO" "db.h" "ac_cv_header_db_h" "

"
if test "x$ac_cv_header_db_h" = x""yes; then :
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */



#include <db.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_header_db_h=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_cv_header_db_h=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
fi
echo "$as_me:$LINENO: result: $ac_cv_header_db_h" >&5
echo "${ECHO_T}$ac_cv_header_db_h" >&6
if test $ac_cv_header_db_h = yes; then
   DB_INCLUDES=/usr/include
else

             CFLAGS=-I/usr/include/db4
             ac_fn_c_check_header_compile "$LINENO" "db4/db.h" "ac_cv_header_db4_db_h" "+
"
if test "x$ac_cv_header_db4_db_h" = x""yes; then :
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
+

#include <db4/db.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_header_db4_db_h=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_cv_header_db4_db_h=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
fi
echo "$as_me:$LINENO: result: $ac_cv_header_db4_db_h" >&5
echo "${ECHO_T}$ac_cv_header_db4_db_h" >&6
if test $ac_cv_header_db4_db_h = yes; then
   DB_INCLUDES=/usr/include/db4
else
   as_fn_error "no. install the db4 libraries" "$LINENO" 5
fi



fi


    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether db is at least 4.1" >&5
$as_echo_n "checking whether db is at least 4.1... " >&6; }
    if test "$cross_compiling" = yes; then :
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error "cannot run test program while cross compiling
See \`config.log' for more details." "$LINENO" 5; }
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
   { (exit 1); exit 1; }; }
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

#include <db.h>

}

_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
  as_fn_error "no. you need at least db 4.1" "$LINENO" 5
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -ldb" >&5
$as_echo_n "checking for main in -ldb... " >&6; }
if test "${ac_cv_lib_db_main+set}" = set; then :
  $as_echo_n "(cached) " >&6
  echo "$as_me: program exited with status $ac_status" >&5
echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

( exit $ac_status )
{ { echo "$as_me:$LINENO: error: no. you need at least db 4.1" >&5
echo "$as_me: error: no. you need at least db 4.1" >&2;}
   { (exit 1); exit 1; }; }
fi
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
fi

echo "$as_me:$LINENO: checking for main in -ldb" >&5
echo $ECHO_N "checking for main in -ldb... $ECHO_C" >&6
if test "${ac_cv_lib_db_main+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-ldb  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */


int
main ()
{
return main ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_db_main=yes
else
  ac_cv_lib_db_main=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_db_main" >&5
$as_echo "$ac_cv_lib_db_main" >&6; }
if test "x$ac_cv_lib_db_main" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBDB 1
_ACEOF

  LIBS="-ldb $LIBS"

else
  as_fn_error "db not installed or functional" "$LINENO" 5
echo "$as_me: error: db not installed or functional" >&2;}
   { (exit 1); exit 1; }; }
fi
ac_cv_lib_db=ac_cv_lib_db_main

    SCPDEFS="$SCPDEFS -DSYSTEM_DB"
else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    SYSTEM_DB=NO
    BUILD_TYPE="$BUILD_TYPE BERKELEYDB"
fi




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which lucene to use" >&5
$as_echo_n "checking which lucene to use... " >&6; }
if test -n "$with_system_lucene" -o -n "$with_system_libs" && \
       test "$with_system_lucene" != "no" && test "$with_system_jars" != "no"; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
        SYSTEM_LUCENE=YES
        if test -z $LUCENE_CORE_JAR; then
          { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/lucene-core-2.3.jar" >&5
$as_echo_n "checking for /usr/share/java/lucene-core-2.3.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_lucene_core_2_3_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/lucene-core-2.3.jar"; then
  ac_cv_file__usr_share_java_lucene_core_2_3_jar=yes
else
  ac_cv_file__usr_share_java_lucene_core_2_3_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_lucene_core_2_3_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_lucene_core_2_3_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_lucene_core_2_3_jar" = x""yes; then :
   LUCENE_CORE_JAR=/usr/share/java/lucene-core-2.3.jar
else

              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/lucene.jar" >&5
$as_echo_n "checking for /usr/share/java/lucene.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_lucene_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/lucene.jar"; then
  ac_cv_file__usr_share_java_lucene_jar=yes
else
  ac_cv_file__usr_share_java_lucene_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_lucene_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_lucene_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_lucene_jar" = x""yes; then :
   LUCENE_CORE_JAR=/usr/share/java/lucene.jar
else
   as_fn_error "lucene-core.jar replacement not found" "$LINENO" 5

fi



fi

        else
          as_ac_File=`$as_echo "ac_cv_file_$LUCENE_CORE_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LUCENE_CORE_JAR" >&5
$as_echo_n "checking for $LUCENE_CORE_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$LUCENE_CORE_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "lucene-core.jar not found." "$LINENO" 5
fi

        fi

        if test -z $LUCENE_ANALYZERS_JAR; then
          { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/lucene-analyzers-2.3.jar" >&5
$as_echo_n "checking for /usr/share/java/lucene-analyzers-2.3.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_lucene_analyzers_2_3_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/lucene-analyzers-2.3.jar"; then
  ac_cv_file__usr_share_java_lucene_analyzers_2_3_jar=yes
else
  ac_cv_file__usr_share_java_lucene_analyzers_2_3_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_lucene_analyzers_2_3_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_lucene_analyzers_2_3_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_lucene_analyzers_2_3_jar" = x""yes; then :
   LUCENE_ANALYZERS_JAR=/usr/share/java/lucene-analyzers-2.3.jar
else

              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/lucene-contrib/lucene-analyzers.jar" >&5
$as_echo_n "checking for /usr/share/java/lucene-contrib/lucene-analyzers.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_lucene_contrib_lucene_analyzers_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/lucene-contrib/lucene-analyzers.jar"; then
  ac_cv_file__usr_share_java_lucene_contrib_lucene_analyzers_jar=yes
else
  ac_cv_file__usr_share_java_lucene_contrib_lucene_analyzers_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_lucene_contrib_lucene_analyzers_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_lucene_contrib_lucene_analyzers_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_lucene_contrib_lucene_analyzers_jar" = x""yes; then :
   LUCENE_ANALYZERS_JAR=/usr/share/java/lucene-contrib/lucene-analyzers.jar
else
   as_fn_error "lucene-analyzers.jar replacement not found." "$LINENO" 5

fi



fi

        else
          as_ac_File=`$as_echo "ac_cv_file_$LUCENE_CORE_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LUCENE_CORE_JAR" >&5
$as_echo_n "checking for $LUCENE_CORE_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$LUCENE_CORE_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
   as_fn_error "lucene-analyzers.jar not found." "$LINENO" 5
fi

        fi
else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    SYSTEM_LUCENE=NO
    BUILD_TYPE="$BUILD_TYPE LUCENE"
fi




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build the MySQL Connector extension" >&5
$as_echo_n "checking whether to build the MySQL Connector extension... " >&6; }
if test -n "$enable_mysql_connector" -a "$enable_mysql_connector" != "no"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
  ENABLE_MYSQLC=YES
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mysqlc module" >&5
$as_echo_n "checking for mysqlc module... " >&6; }
  if test -d mysqlc; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: OK" >&5
$as_echo "OK" >&6; }
  else
   as_fn_error "not existing. get it (did you get the -extensions tarball?)" "$LINENO" 5
echo "$as_me: error: not existing. get it (did you get the -extensions tarball?)" >&2;}
   { (exit 1); exit 1; }; }
  fi
  BUILD_TYPE="$BUILD_TYPE MYSQLC"
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
  ENABLE_MYSQLC=NO
fi


if test "$ENABLE_MYSQLC" = "YES"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mysql pre-requisites" >&5
$as_echo_n "checking for mysql pre-requisites... " >&6; }
if test -n "$with_system_mysql" -o -n "$with_system_libs" && \
       test "$with_system_mysql" != "no" && test "$with_system_libs" != "no"; then
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: external MySQL" >&5
$as_echo "external MySQL" >&6; }
	SYSTEM_MYSQL=YES
	# Extract the first word of "mysql_config", so it can be a program name with args.
set dummy mysql_config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_MYSQLCONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $MYSQLCONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_MYSQLCONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
MYSQLCONFIG=$ac_cv_path_MYSQLCONFIG

if test -n "$MYSQLCONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MYSQLCONFIG" >&5
$as_echo "$MYSQLCONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking MySQL version" >&5
$as_echo_n "checking MySQL version... " >&6; }
	MYSQL_VERSION=`$MYSQLCONFIG --version`
	MYSQL_MAJOR=`$MYSQLCONFIG --version | cut -d"." -f1`
	if test "$MYSQL_MAJOR" -ge "2"; then
		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: OK" >&5
$as_echo "OK" >&6; }
	else
		as_fn_error "too old, use 5.0.x or 5.1.x" "$LINENO" 5
echo "$as_me: error: too old, use 5.0.x or 5.1.x" >&2;}
   { (exit 1); exit 1; }; }
	fi
	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MySQL Client library" >&5
$as_echo_n "checking for MySQL Client library... " >&6; }
	MYSQL_INC=`$MYSQLCONFIG --include`
	MYSQL_LIB=`$MYSQLCONFIG --libs`
	MYSQL_DEFINES=`$MYSQLCONFIG --cflags | sed -e s,$MYSQL_INC,,`
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: includes $MYSQL_INC, libraries $MYSQL_LIB" >&5
$as_echo "includes $MYSQL_INC, libraries $MYSQL_LIB" >&6; }
else
    SYSTEM_MYSQL=NO
    if test -n "$with_libmysql_path"; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: external Connector/C (libmysql)" >&5
$as_echo "external Connector/C (libmysql)" >&6; }
        LIBMYSQL=libmysql.so
        if test "$_os" = "Darwin"; then
            LIBMYSQL=libmysql.dylib
        elif test "$_os" = "WINNT"; then
            LIBMYSQL=libmysql.dll
        fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LIBMYSQL" >&5
$as_echo_n "checking for $LIBMYSQL... " >&6; }
        if test -e "$with_libmysql_path/lib/$LIBMYSQL"; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: found." >&5
$as_echo "found." >&6; }
            LIBMYSQL_PATH=$with_libmysql_path
        else
            as_fn_error "not found. Please specify proper path in --with-libmysql-path." "$LINENO" 5
echo "$as_me: error: not found. Please specify proper path in --with-libmysql-path." >&2;}
   { (exit 1); exit 1; }; }
        fi
    else
        as_fn_error "not given. Please specify either --with-system-mysql or --with-libmysql-path" "$LINENO" 5
    fi
fi






ac_ext=cpp

ac_ext=cc
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'


# FIXME!
# who thought this too-generic cppconn dir was a good idea?
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking MySQL Connector/C++" >&5
$as_echo_n "checking MySQL Connector/C++... " >&6; }
if test -n "$with_system_mysql_cppconn" -o -n "$with_system_libs" && \
		test "$with_system_mysql_cppconn" != "no" && test "$with_system_libs" != "no"; then
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
	SYSTEM_MYSQL_CPPCONN=YES
        ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu

	ac_fn_cxx_check_header_mongrel "$LINENO" "mysql_driver.h" "ac_cv_header_mysql_driver_h" "$ac_includes_default"
if test "x$ac_cv_header_mysql_driver_h" = x""yes; then :

else
  as_fn_error "mysql_driver.h not found. install MySQL C++ Connectivity" "$LINENO" 5
fi


	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lmysqlcppconn" >&5
$as_echo_n "checking for main in -lmysqlcppconn... " >&6; }
if test "${ac_cv_lib_mysqlcppconn_main+set}" = set; then :
  $as_echo_n "(cached) " >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <mysql_driver.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking mysql_driver.h presence" >&5
echo $ECHO_N "checking mysql_driver.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <mysql_driver.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_cxx_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: mysql_driver.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: mysql_driver.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: mysql_driver.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: mysql_driver.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: mysql_driver.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: mysql_driver.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: mysql_driver.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: mysql_driver.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: mysql_driver.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: mysql_driver.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: mysql_driver.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: mysql_driver.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: mysql_driver.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: mysql_driver.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: mysql_driver.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: mysql_driver.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for mysql_driver.h" >&5
echo $ECHO_N "checking for mysql_driver.h... $ECHO_C" >&6
if test "${ac_cv_header_mysql_driver_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_mysql_driver_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_mysql_driver_h" >&5
echo "${ECHO_T}$ac_cv_header_mysql_driver_h" >&6

fi
if test $ac_cv_header_mysql_driver_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: mysql_driver.h not found. install MySQL C++ Connectivity" >&5
echo "$as_me: error: mysql_driver.h not found. install MySQL C++ Connectivity" >&2;}
   { (exit 1); exit 1; }; }
fi



echo "$as_me:$LINENO: checking for main in -lmysqlcppconn" >&5
echo $ECHO_N "checking for main in -lmysqlcppconn... $ECHO_C" >&6
if test "${ac_cv_lib_mysqlcppconn_main+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lmysqlcppconn  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */


int
main ()
{
return main ();
  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_link "$LINENO"; then :
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_mysqlcppconn_main=yes
else
  ac_cv_lib_mysqlcppconn_main=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mysqlcppconn_main" >&5
$as_echo "$ac_cv_lib_mysqlcppconn_main" >&6; }
if test "x$ac_cv_lib_mysqlcppconn_main" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBMYSQLCPPCONN 1
_ACEOF

  LIBS="-lmysqlcppconn $LIBS"

else
  as_fn_error "MySQL C++ Connectivity lib not found or functional" "$LINENO" 5
fi

   { $as_echo "$as_me:${as_lineno-$LINENO}: checking version" >&5
$as_echo_n "checking version... " >&6; }
      if test "$cross_compiling" = yes; then :
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error "cannot run test program while cross compiling
See \`config.log' for more details." "$LINENO" 5; }
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
   { (exit 1); exit 1; }; }
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

#include <mysql_driver.h>

}

_ACEOF
if ac_fn_cxx_try_run "$LINENO"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: OK" >&5
$as_echo "OK" >&6; }
else
  as_fn_error "not suitable, we need >= 1.0.6" "$LINENO" 5
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

        ac_ext=cpp
  echo "$as_me:$LINENO: result: OK" >&5
echo "${ECHO_T}OK" >&6
else
  echo "$as_me: program exited with status $ac_status" >&5
echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

( exit $ac_status )
{ { echo "$as_me:$LINENO: error: not suitable, we need >= 1.0.6" >&5
echo "$as_me: error: not suitable, we need >= 1.0.6" >&2;}
   { (exit 1); exit 1; }; }
fi
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
fi
        ac_ext=cc
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'



else
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mysqlcppconn module" >&5
$as_echo_n "checking for mysqlcppconn module... " >&6; }
        if test -d mysqlcppconn; then
          { $as_echo "$as_me:${as_lineno-$LINENO}: result: OK" >&5
$as_echo "OK" >&6; }
        else
          as_fn_error "not existing. get it (did you get the -extensions tarball?)" "$LINENO" 5
echo "$as_me: error: not existing. get it (did you get the -extensions tarball?)" >&2;}
   { (exit 1); exit 1; }; }
        fi
	BUILD_TYPE="$BUILD_TYPE MYSQLCPPCONN"
	SYSTEM_MYSQL_CPPCONN=NO


fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which hsqldb to use" >&5
$as_echo_n "checking which hsqldb to use... " >&6; }
if test -n "$with_system_hsqldb" -o -n "$with_system_libs" && \
       test "$with_system_hsqldb" != "no" && test "$with_system_jars" != "no"; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
        SYSTEM_HSQLDB=YES
        if test -z $HSQLDB_JAR; then
               HSQLDB_JAR=/usr/share/java/hsqldb.jar
        fi
        as_ac_File=`$as_echo "ac_cv_file_$HSQLDB_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $HSQLDB_JAR" >&5
$as_echo_n "checking for $HSQLDB_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$HSQLDB_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "hsqldb.jar not found." "$LINENO" 5
fi

        { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether hsqldb is >= 1.8.0.9" >&5
$as_echo_n "checking whether hsqldb is >= 1.8.0.9... " >&6; }
        export HSQLDB_JAR
        if $PERL -e 'use Archive::Zip;
            my $file = "$ENV{'HSQLDB_JAR'}";

	    } else {
	        exit 1;
            }'; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
         else
            as_fn_error "no, hsqldb >= 1.8.0.9 is needed" "$LINENO" 5
echo "$as_me: error: no, hsqldb >= 1.8.0.9 is needed" >&2;}
   { (exit 1); exit 1; }; }
         fi
else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    SYSTEM_HSQLDB=NO
    BUILD_TYPE="$BUILD_TYPE HSQLDB"
fi



{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which beanshell to use" >&5
$as_echo_n "checking which beanshell to use... " >&6; }
if test -n "$with_system_beanshell" -o -n "$with_system_libs" && \
       test "$with_system_beanshell" != "no" && test "$with_system_jars" != "no"; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
        SYSTEM_BSH=YES
        if test -z $BSH_JAR; then
               BSH_JAR=/usr/share/java/bsh.jar
        fi
        as_ac_File=`$as_echo "ac_cv_file_$BSH_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $BSH_JAR" >&5
$as_echo_n "checking for $BSH_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$BSH_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "bsh.jar not found." "$LINENO" 5
fi

else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    SYSTEM_BSH=NO
    BUILD_TYPE="$BUILD_TYPE BSH"
fi




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which saxon to use" >&5
$as_echo_n "checking which saxon to use... " >&6; }
if test -n "$with_system_saxon" -o -n "$with_system_libs" && \
       test "$with_system_saxon" != "no" && test "$with_system_jars" != "no"; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
        SYSTEM_SAXON=YES
        if test -z $SAXON_JAR; then
          { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/saxon9.jar" >&5
$as_echo_n "checking for /usr/share/java/saxon9.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_saxon9_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/saxon9.jar"; then
  ac_cv_file__usr_share_java_saxon9_jar=yes
else
  ac_cv_file__usr_share_java_saxon9_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_saxon9_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_saxon9_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_saxon9_jar" = x""yes; then :
   SAXON_JAR=/usr/share/java/saxon9.jar
else

              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/saxon.jar" >&5
$as_echo_n "checking for /usr/share/java/saxon.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_saxon_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/saxon.jar"; then
  ac_cv_file__usr_share_java_saxon_jar=yes
else
  ac_cv_file__usr_share_java_saxon_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_saxon_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_saxon_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_saxon_jar" = x""yes; then :
   SAXON_JAR=/usr/share/java/saxon.jar
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/saxon9.jar" >&5
$as_echo_n "checking for /usr/share/java/saxon9.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_saxon9_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/saxon9.jar"; then
  ac_cv_file__usr_share_java_saxon9_jar=yes
else
  ac_cv_file__usr_share_java_saxon9_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_saxon9_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_saxon9_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_saxon9_jar" = x""yes; then :
   SAXON_JAR=/usr/share/java/saxon9.jar
else
   as_fn_error "saxon.jar replacement not found" "$LINENO" 5

fi



fi



fi

        else
          as_ac_File=`$as_echo "ac_cv_file_$SAXON_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $SAXON_JAR" >&5
$as_echo_n "checking for $SAXON_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$SAXON_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "saxon.jar replacement not found." "$LINENO" 5
fi

        fi
        if test -n "$SERIALIZER_JAR"; then
          as_ac_File=`$as_echo "ac_cv_file_$SERIALIZER_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $SERIALIZER_JAR" >&5
$as_echo_n "checking for $SERIALIZER_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$SERIALIZER_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "serializer.jar not found." "$LINENO" 5
fi


        fi


        { $as_echo "$as_me:${as_lineno-$LINENO}: checking if saxon works" >&5
$as_echo_n "checking if saxon works... " >&6; }
        cat > saxontest.java <<_ACEOF
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.Transformer;


_ACEOF
        javac_cmd="$JAVACOMPILER -cp $SAXON_JAR saxontest.java 1>&2"
        { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$javac_cmd\""; } >&5
  (eval $javac_cmd) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
        if test $? = 0 && test -f ./saxontest.class ; then
            java_cmd="$JAVAINTERPRETER -cp $SAXON_JAR:. saxontest saxontest.xsl 1>&2"
            { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$java_cmd\""; } >&5
  (eval $java_cmd) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
            if test $? = 0; then
              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            else
              cat saxontest.java >&5
              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
              as_fn_error "Non-functional saxon jar, e.g. crippled saxon-he instead of saxonb" "$LINENO" 5
echo "$as_me: error: Non-functional saxon jar, e.g. crippled saxon-he instead of saxonb" >&2;}
   { (exit 1); exit 1; }; }
            fi
        else
          { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
          cat saxontest.java >&5
          as_fn_error "saxontest could not be compiled, non-functional saxon jar" "$LINENO" 5
        fi
else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    echo "$as_me:$LINENO: result: internal" >&5
echo "${ECHO_T}internal" >&6
    SYSTEM_SAXON=NO
    NEED_SAXON=TRUE
fi

if test "$_os" = "Darwin" && test "$with_system_curl" != "no"; then
   with_system_curl=yes
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which curl to use" >&5
$as_echo_n "checking which curl to use... " >&6; }
if test -n "$with_system_curl" -o -n "$with_system_libs" && \
	test "$with_system_curl" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
   SYSTEM_CURL=YES

   # Extract the first word of "curl-config", so it can be a program name with args.
set dummy curl-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_CURLCONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $CURLCONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_CURLCONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
CURLCONFIG=$ac_cv_path_CURLCONFIG

if test -n "$CURLCONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CURLCONFIG" >&5
$as_echo "$CURLCONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


   if test -z "$CURLCONFIG"; then
      as_fn_error "install curl to run this script" "$LINENO" 5
echo "$as_me: error: install curl to run this script" >&2;}
   { (exit 1); exit 1; }; }
   fi

   # check curl version
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether curl is >= 7.13.1" >&5
$as_echo_n "checking whether curl is >= 7.13.1... " >&6; }
   if test "`$CURLCONFIG --version | $AWK -F' ' '{print $2}' | $AWK -F. '{ print $1 }'`" -gt "7" -a \
	"`$CURLCONFIG --version | $AWK -F' ' '{print $2}' | $AWK -F. '{ print $2 }'`" -gt "13" -a \
	"`$CURLCONFIG --version | $AWK -F' ' '{print $2}' | $AWK -F. '{ print $3 }'`" -gt "1"; then
      as_fn_error "no, you need at least curl 7.13,1" "$LINENO" 5
   else
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
      echo "$as_me:$LINENO: result: yes" >&5
echo "${ECHO_T}yes" >&6
   fi
   CURL_LIBS=`$CURLCONFIG --libs`
   CURL_CFLAGS=`$CURLCONFIG --cflags`
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
   SYSTEM_CURL=NO
   BUILD_TYPE="$BUILD_TYPE CURL"
fi




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which boost to use" >&5
$as_echo_n "checking which boost to use... " >&6; }
if test -n "$with_system_boost" -o -n "$with_system_headers" && \
	test "$with_system_boost" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
   SYSTEM_BOOST=YES
   ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu

   ac_fn_cxx_check_header_mongrel "$LINENO" "boost/shared_ptr.hpp" "ac_cv_header_boost_shared_ptr_hpp" "$ac_includes_default"
if test "x$ac_cv_header_boost_shared_ptr_hpp" = x""yes; then :

else
  as_fn_error "boost/shared_ptr.hpp not found. install boost" "$LINENO" 5
fi


   ac_fn_cxx_check_header_mongrel "$LINENO" "boost/spirit/include/classic_core.hpp" "ac_cv_header_boost_spirit_include_classic_core_hpp" "$ac_includes_default"
if test "x$ac_cv_header_boost_spirit_include_classic_core_hpp" = x""yes; then :

else
  as_fn_error "boost/spirit/include/classic_core.hpp not found. install boost >= 1.38" "$LINENO" 5
fi


   ac_fn_cxx_check_header_mongrel "$LINENO" "boost/function.hpp" "ac_cv_header_boost_function_hpp" "$ac_includes_default"
if test "x$ac_cv_header_boost_function_hpp" = x""yes; then :

else
  as_fn_error "boost/function.hpp not found. install boost" "$LINENO" 5
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking boost/shared_ptr.hpp presence" >&5
echo $ECHO_N "checking boost/shared_ptr.hpp presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <boost/shared_ptr.hpp>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_cxx_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: boost/shared_ptr.hpp: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: boost/shared_ptr.hpp: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/shared_ptr.hpp: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: boost/shared_ptr.hpp: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: boost/shared_ptr.hpp: present but cannot be compiled" >&5
echo "$as_me: WARNING: boost/shared_ptr.hpp: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/shared_ptr.hpp:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: boost/shared_ptr.hpp:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/shared_ptr.hpp: see the Autoconf documentation" >&5
echo "$as_me: WARNING: boost/shared_ptr.hpp: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/shared_ptr.hpp:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: boost/shared_ptr.hpp:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/shared_ptr.hpp: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: boost/shared_ptr.hpp: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/shared_ptr.hpp: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: boost/shared_ptr.hpp: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for boost/shared_ptr.hpp" >&5
echo $ECHO_N "checking for boost/shared_ptr.hpp... $ECHO_C" >&6
if test "${ac_cv_header_boost_shared_ptr_hpp+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_boost_shared_ptr_hpp=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_boost_shared_ptr_hpp" >&5
echo "${ECHO_T}$ac_cv_header_boost_shared_ptr_hpp" >&6

fi
if test $ac_cv_header_boost_shared_ptr_hpp = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: boost/shared_ptr.hpp not found. install boost" >&5
echo "$as_me: error: boost/shared_ptr.hpp not found. install boost" >&2;}
   { (exit 1); exit 1; }; }
fi


   if test "${ac_cv_header_boost_spirit_include_classic_core_hpp+set}" = set; then
  echo "$as_me:$LINENO: checking for boost/spirit/include/classic_core.hpp" >&5
echo $ECHO_N "checking for boost/spirit/include/classic_core.hpp... $ECHO_C" >&6
if test "${ac_cv_header_boost_spirit_include_classic_core_hpp+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
fi
echo "$as_me:$LINENO: result: $ac_cv_header_boost_spirit_include_classic_core_hpp" >&5
echo "${ECHO_T}$ac_cv_header_boost_spirit_include_classic_core_hpp" >&6
else
  # Is the header compilable?
echo "$as_me:$LINENO: checking boost/spirit/include/classic_core.hpp usability" >&5
echo $ECHO_N "checking boost/spirit/include/classic_core.hpp usability... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <boost/spirit/include/classic_core.hpp>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking boost/spirit/include/classic_core.hpp presence" >&5
echo $ECHO_N "checking boost/spirit/include/classic_core.hpp presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <boost/spirit/include/classic_core.hpp>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_cxx_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: boost/spirit/include/classic_core.hpp: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: boost/spirit/include/classic_core.hpp: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/spirit/include/classic_core.hpp: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: boost/spirit/include/classic_core.hpp: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: boost/spirit/include/classic_core.hpp: present but cannot be compiled" >&5
echo "$as_me: WARNING: boost/spirit/include/classic_core.hpp: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/spirit/include/classic_core.hpp:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: boost/spirit/include/classic_core.hpp:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/spirit/include/classic_core.hpp: see the Autoconf documentation" >&5
echo "$as_me: WARNING: boost/spirit/include/classic_core.hpp: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/spirit/include/classic_core.hpp:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: boost/spirit/include/classic_core.hpp:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/spirit/include/classic_core.hpp: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: boost/spirit/include/classic_core.hpp: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/spirit/include/classic_core.hpp: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: boost/spirit/include/classic_core.hpp: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for boost/spirit/include/classic_core.hpp" >&5
echo $ECHO_N "checking for boost/spirit/include/classic_core.hpp... $ECHO_C" >&6
if test "${ac_cv_header_boost_spirit_include_classic_core_hpp+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_boost_spirit_include_classic_core_hpp=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_boost_spirit_include_classic_core_hpp" >&5
echo "${ECHO_T}$ac_cv_header_boost_spirit_include_classic_core_hpp" >&6

fi
if test $ac_cv_header_boost_spirit_include_classic_core_hpp = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: boost/spirit/include/classic_core.hpp not found. install boost >= 1.38" >&5
echo "$as_me: error: boost/spirit/include/classic_core.hpp not found. install boost >= 1.38" >&2;}
   { (exit 1); exit 1; }; }
fi


   if test "${ac_cv_header_boost_function_hpp+set}" = set; then
  echo "$as_me:$LINENO: checking for boost/function.hpp" >&5
echo $ECHO_N "checking for boost/function.hpp... $ECHO_C" >&6
if test "${ac_cv_header_boost_function_hpp+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
fi
echo "$as_me:$LINENO: result: $ac_cv_header_boost_function_hpp" >&5
echo "${ECHO_T}$ac_cv_header_boost_function_hpp" >&6
else
  # Is the header compilable?
echo "$as_me:$LINENO: checking boost/function.hpp usability" >&5
echo $ECHO_N "checking boost/function.hpp usability... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <boost/function.hpp>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking boost/function.hpp presence" >&5
echo $ECHO_N "checking boost/function.hpp presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <boost/function.hpp>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_cxx_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: boost/function.hpp: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: boost/function.hpp: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/function.hpp: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: boost/function.hpp: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: boost/function.hpp: present but cannot be compiled" >&5
echo "$as_me: WARNING: boost/function.hpp: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/function.hpp:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: boost/function.hpp:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/function.hpp: see the Autoconf documentation" >&5
echo "$as_me: WARNING: boost/function.hpp: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/function.hpp:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: boost/function.hpp:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/function.hpp: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: boost/function.hpp: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: boost/function.hpp: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: boost/function.hpp: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for boost/function.hpp" >&5
echo $ECHO_N "checking for boost/function.hpp... $ECHO_C" >&6
if test "${ac_cv_header_boost_function_hpp+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_boost_function_hpp=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_boost_function_hpp" >&5
echo "${ECHO_T}$ac_cv_header_boost_function_hpp" >&6

fi
if test $ac_cv_header_boost_function_hpp = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: boost/function.hpp not found. install boost" >&5
echo "$as_me: error: boost/function.hpp not found. install boost" >&2;}
   { (exit 1); exit 1; }; }
fi



   save_CXXFLAGS=$CXXFLAGS
   CXXFLAGS="$CXXFLAGS -fno-exceptions"
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether boost/function.hpp compiles with -fno-exceptions" >&5
$as_echo_n "checking whether boost/function.hpp compiles with -fno-exceptions... " >&6; }
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <boost/function.hpp>


  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_cxx_boost_no_exceptons_broken=no
else
  ac_cv_cxx_boost_no_exceptons_broken=yes
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_cv_cxx_boost_no_exceptons_broken=yes
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

   if test "$ac_cv_cxx_boost_no_exceptons_broken" = "yes"; then
	as_fn_error "no, see https://bugzilla.redhat.com/show_bug.cgi?id=477131" "$LINENO" 5
   else
  	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
  	echo "$as_me:$LINENO: result: yes" >&5
echo "${ECHO_T}yes" >&6
   fi
   CXXFLAGS=$save_CXXFLAGS
   ac_ext=c

ac_compiler_gnu=$ac_cv_c_compiler_gnu

else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
   BUILD_TYPE="$BUILD_TYPE BOOST"
   SYSTEM_BOOST=NO
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which vigra to use" >&5
$as_echo_n "checking which vigra to use... " >&6; }
if test -n "$with_system_vigra" -o -n "$with_system_headers" && \
	test "$with_system_vigra" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
   SYSTEM_VIGRA=YES
   ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu

   ac_fn_cxx_check_header_mongrel "$LINENO" "vigra/copyimage.hxx" "ac_cv_header_vigra_copyimage_hxx" "$ac_includes_default"
if test "x$ac_cv_header_vigra_copyimage_hxx" = x""yes; then :

else
  as_fn_error "vigra/copyimage.hxx not found. install vigra" "$LINENO" 5
fi
echo "$as_me:$LINENO: result: $ac_cv_header_vigra_copyimage_hxx" >&5
echo "${ECHO_T}$ac_cv_header_vigra_copyimage_hxx" >&6
else
  # Is the header compilable?
echo "$as_me:$LINENO: checking vigra/copyimage.hxx usability" >&5
echo $ECHO_N "checking vigra/copyimage.hxx usability... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <vigra/copyimage.hxx>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking vigra/copyimage.hxx presence" >&5
echo $ECHO_N "checking vigra/copyimage.hxx presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <vigra/copyimage.hxx>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_cxx_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: vigra/copyimage.hxx: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: vigra/copyimage.hxx: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: vigra/copyimage.hxx: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: vigra/copyimage.hxx: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: vigra/copyimage.hxx: present but cannot be compiled" >&5
echo "$as_me: WARNING: vigra/copyimage.hxx: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: vigra/copyimage.hxx:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: vigra/copyimage.hxx:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: vigra/copyimage.hxx: see the Autoconf documentation" >&5
echo "$as_me: WARNING: vigra/copyimage.hxx: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: vigra/copyimage.hxx:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: vigra/copyimage.hxx:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: vigra/copyimage.hxx: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: vigra/copyimage.hxx: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: vigra/copyimage.hxx: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: vigra/copyimage.hxx: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for vigra/copyimage.hxx" >&5
echo $ECHO_N "checking for vigra/copyimage.hxx... $ECHO_C" >&6
if test "${ac_cv_header_vigra_copyimage_hxx+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_vigra_copyimage_hxx=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_vigra_copyimage_hxx" >&5
echo "${ECHO_T}$ac_cv_header_vigra_copyimage_hxx" >&6

fi
if test $ac_cv_header_vigra_copyimage_hxx = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: vigra/copyimage.hxx not found. install vigra" >&5
echo "$as_me: error: vigra/copyimage.hxx not found. install vigra" >&2;}
   { (exit 1); exit 1; }; }
fi



ac_compiler_gnu=$ac_cv_c_compiler_gnu

else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
   BUILD_TYPE="$BUILD_TYPE VIGRA"
   SYSTEM_VIGRA=NO
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which odbc headers to use" >&5
$as_echo_n "checking which odbc headers to use... " >&6; }
if test -n "$with_system_odbc_headers" -o -n "$with_system_headers" && \
	test "$with_system_odbc_headers" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
   SYSTEM_ODBC_HEADERS=YES

   ac_fn_c_check_header_mongrel "$LINENO" "sqlext.h" "ac_cv_header_sqlext_h" "$ac_includes_default"
if test "x$ac_cv_header_sqlext_h" = x""yes; then :

else
  as_fn_error "odbc not found. install odbc" "$LINENO" 5
fi


else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
echo $ECHO_N "checking sqlext.h usability... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <sqlext.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking sqlext.h presence" >&5
echo $ECHO_N "checking sqlext.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <sqlext.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: sqlext.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: sqlext.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: sqlext.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: sqlext.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: sqlext.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: sqlext.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: sqlext.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: sqlext.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: sqlext.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: sqlext.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: sqlext.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: sqlext.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: sqlext.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: sqlext.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: sqlext.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: sqlext.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for sqlext.h" >&5
echo $ECHO_N "checking for sqlext.h... $ECHO_C" >&6
if test "${ac_cv_header_sqlext_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_sqlext_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_sqlext_h" >&5
echo "${ECHO_T}$ac_cv_header_sqlext_h" >&6

fi
if test $ac_cv_header_sqlext_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: odbc not found. install odbc" >&5
echo "$as_me: error: odbc not found. install odbc" >&2;}
   { (exit 1); exit 1; }; }
fi


else
   echo "$as_me:$LINENO: result: internal" >&5
echo "${ECHO_T}internal" >&6
   SYSTEM_ODBC_HEADERS=NO
   BUILD_TYPE="$BUILD_TYPE UNIXODBC"
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable build of Mozilla/Mozilla NSS-using components" >&5
$as_echo_n "checking whether to enable build of Mozilla/Mozilla NSS-using components... " >&6; }
if test "$enable_mozilla" = "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   WITH_MOZILLA=NO
   ENABLE_NSS_MODULE=NO
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   WITH_MOZILLA=YES
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build Mozilla addressbook connectivity" >&5
$as_echo_n "checking whether to build Mozilla addressbook connectivity... " >&6; }
if test "$enable_mozilla" = "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
elif test "$with_system_mozilla" = "yes"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, not possible with system-mozilla" >&5
$as_echo "no, not possible with system-mozilla" >&6; }
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build XML Security support" >&5
$as_echo_n "checking whether to build XML Security support... " >&6; }
if test "$enable_mozilla" = "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, since Mozilla (NSS) disabled but needed" >&5
$as_echo "no, since Mozilla (NSS) disabled but needed" >&6; }
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build LDAP configuration backend" >&5
$as_echo_n "checking whether to build LDAP configuration backend... " >&6; }
if test -z "$enable_ldap" || test "$enable_ldap" = "yes"; then
   if test "$enable_mozilla" = "yes" || test "$with_openldap" = "yes"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
      WITH_LDAP=YES
   else
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no. Either Mozilla or OpenLDAP needed" >&5
$as_echo "no. Either Mozilla or OpenLDAP needed" >&6; }
      WITH_LDAP=NO
   fi
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   WITH_LDAP=NO
fi

if test "$WITH_LDAP" = "YES"; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: checking which LDAP SDK to use" >&5
$as_echo_n "checking which LDAP SDK to use... " >&6; }
   if test -n "$with_openldap" && test "$with_openldap" != "no"; then
  	   { $as_echo "$as_me:${as_lineno-$LINENO}: result: OpenLDAP" >&5
$as_echo "OpenLDAP" >&6; }
	   WITH_OPENLDAP=YES
	   for ac_header in ldap.h
do :
  ac_fn_c_check_header_mongrel "$LINENO" "ldap.h" "ac_cv_header_ldap_h" "$ac_includes_default"
if test "x$ac_cv_header_ldap_h" = x""yes; then :
if eval "test \"\${$as_ac_Header+set}\" = set"; then
  echo "$as_me:$LINENO: checking for $ac_header" >&5
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
if eval "test \"\${$as_ac_Header+set}\" = set"; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
fi
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
else
  # Is the header compilable?
echo "$as_me:$LINENO: checking $ac_header usability" >&5
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <$ac_header>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking $ac_header presence" >&5
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <$ac_header>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for $ac_header" >&5
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
if eval "test \"\${$as_ac_Header+set}\" = set"; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  eval "$as_ac_Header=\$ac_header_preproc"
fi
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

fi
if test `eval echo '${'$as_ac_Header'}'` = yes; then
  cat >>confdefs.h <<_ACEOF
#define HAVE_LDAP_H 1
_ACEOF

else
  as_fn_error "ldap.h not found. install openldap libs" "$LINENO" 5
fi

done

	   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ldap_simple_bind_s in -lldap" >&5
$as_echo_n "checking for ldap_simple_bind_s in -lldap... " >&6; }
if test "${ac_cv_lib_ldap_ldap_simple_bind_s+set}" = set; then :
  $as_echo_n "(cached) " >&6
echo $ECHO_N "checking for ldap_simple_bind_s in -lldap... $ECHO_C" >&6
if test "${ac_cv_lib_ldap_ldap_simple_bind_s+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lldap  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char ldap_simple_bind_s ();
int
main ()
{
return ldap_simple_bind_s ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_ldap_ldap_simple_bind_s=yes
else
  ac_cv_lib_ldap_ldap_simple_bind_s=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ldap_ldap_simple_bind_s" >&5
$as_echo "$ac_cv_lib_ldap_ldap_simple_bind_s" >&6; }
if test "x$ac_cv_lib_ldap_ldap_simple_bind_s" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBLDAP 1
_ACEOF

  LIBS="-lldap $LIBS"

else
  as_fn_error "openldap lib not found or functional" "$LINENO" 5
echo "$as_me: error: openldap lib not found or functional" >&2;}
   { (exit 1); exit 1; }; }
fi

	   # rumours say that OpenLDAP doesn't have that function. I looked and
	   # it has it. Test for it to be sure
         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ldap_set_option in -lldap" >&5
$as_echo_n "checking for ldap_set_option in -lldap... " >&6; }
if test "${ac_cv_lib_ldap_ldap_set_option+set}" = set; then :
  $as_echo_n "(cached) " >&6
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lldap  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char ldap_set_option ();
int
main ()
{
return ldap_set_option ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_ldap_ldap_set_option=yes
else
  ac_cv_lib_ldap_ldap_set_option=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ldap_ldap_set_option" >&5
$as_echo "$ac_cv_lib_ldap_ldap_set_option" >&6; }
if test "x$ac_cv_lib_ldap_ldap_set_option" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBLDAP 1
_ACEOF

  LIBS="-lldap $LIBS"

else
  as_fn_error "openldap lib not found or functional" "$LINENO" 5
fi

   else
	   { $as_echo "$as_me:${as_lineno-$LINENO}: result: Netscape/Mozilla" >&5
$as_echo "Netscape/Mozilla" >&6; }
	   echo "$as_me:$LINENO: result: Netscape/Mozilla" >&5
echo "${ECHO_T}Netscape/Mozilla" >&6
	   # TODO. Actually do a sanity check and check for
	   # LDAP_OPT_SIZELIMIT and LDAP_X_OPT_CONNECT_TIMEOUT
	   WITH_OPENLDAP=NO




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which mozilla to use" >&5
$as_echo_n "checking which mozilla to use... " >&6; }
if test -n "$with_system_mozilla" && test "$with_system_mozilla" != "no"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
    SYSTEM_MOZILLA=YES
    ENABLE_NSS_MODULE=NO
    enable_nss_module=no
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking which Mozilla flavour to use" >&5
$as_echo_n "checking which Mozilla flavour to use... " >&6; }
    if test -n "$with_system_mozilla" && test "$with_system_mozilla" = "libxul"; then
      MOZ_FLAVOUR=libxul
    elif test -n "$with_system_mozilla" && test "$with_system_mozilla" = "xulrunner"; then

      MOZ_FLAVOUR=libxul
    fi
    tmp=`echo $MOZ_FLAVOUR | $PERL -e 'print ucfirst(<STDIN>);'`
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tmp" >&5
$as_echo "$tmp" >&6; }


  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for nss" >&5
$as_echo_n "checking for nss... " >&6; }

        if $PKG_CONFIG --exists "nss" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZ_NSS_CFLAGS" >&5
$as_echo_n "checking MOZ_NSS_CFLAGS... " >&6; }
            MOZ_NSS_CFLAGS=`$PKG_CONFIG --cflags "nss"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZ_NSS_CFLAGS" >&5
$as_echo "$MOZ_NSS_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZ_NSS_LIBS" >&5
$as_echo_n "checking MOZ_NSS_LIBS... " >&6; }
            MOZ_NSS_LIBS=`$PKG_CONFIG --libs "nss"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZ_NSS_LIBS" >&5
$as_echo "$MOZ_NSS_LIBS" >&6; }
        else
            MOZ_NSS_CFLAGS=""
            MOZ_NSS_LIBS=""

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $MOZ_FLAVOUR-nss " >&5
$as_echo_n "checking for $MOZ_FLAVOUR-nss ... " >&6; }

        if $PKG_CONFIG --exists "$MOZ_FLAVOUR-nss " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZ_NSS_CFLAGS" >&5
$as_echo_n "checking MOZ_NSS_CFLAGS... " >&6; }
            MOZ_NSS_CFLAGS=`$PKG_CONFIG --cflags "$MOZ_FLAVOUR-nss "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZ_NSS_CFLAGS" >&5
$as_echo "$MOZ_NSS_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZ_NSS_LIBS" >&5
$as_echo_n "checking MOZ_NSS_LIBS... " >&6; }
            MOZ_NSS_LIBS=`$PKG_CONFIG --libs "$MOZ_FLAVOUR-nss "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZ_NSS_LIBS" >&5
$as_echo "$MOZ_NSS_LIBS" >&6; }
        else
            MOZ_NSS_CFLAGS=""
            MOZ_NSS_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements ($MOZ_FLAVOUR-nss ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
echo "$as_me: error: Library requirements ($MOZ_FLAVOUR-nss ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." >&2;}
   { (exit 1); exit 1; }; }
  fi

    else

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for nspr " >&5
$as_echo_n "checking for nspr ... " >&6; }

        if $PKG_CONFIG --exists "nspr " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZ_NSPR_CFLAGS" >&5
$as_echo_n "checking MOZ_NSPR_CFLAGS... " >&6; }
            MOZ_NSPR_CFLAGS=`$PKG_CONFIG --cflags "nspr "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZ_NSPR_CFLAGS" >&5
$as_echo "$MOZ_NSPR_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZ_NSPR_LIBS" >&5
$as_echo_n "checking MOZ_NSPR_LIBS... " >&6; }
            MOZ_NSPR_LIBS=`$PKG_CONFIG --libs "nspr "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZ_NSPR_LIBS" >&5
$as_echo "$MOZ_NSPR_LIBS" >&6; }
        else
            MOZ_NSPR_CFLAGS=""
            MOZ_NSPR_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (nspr ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
echo "$as_me: error: Library requirements (nspr ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." >&2;}
   { (exit 1); exit 1; }; }
  fi

      NSPR_LIB="-L`$PKG_CONFIG --variable=libdir nspr`"

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $MOZ_FLAVOUR-nspr " >&5
$as_echo_n "checking for $MOZ_FLAVOUR-nspr ... " >&6; }

        if $PKG_CONFIG --exists "$MOZ_FLAVOUR-nspr " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZ_NSPR_CFLAGS" >&5
$as_echo_n "checking MOZ_NSPR_CFLAGS... " >&6; }
            MOZ_NSPR_CFLAGS=`$PKG_CONFIG --cflags "$MOZ_FLAVOUR-nspr "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZ_NSPR_CFLAGS" >&5
$as_echo "$MOZ_NSPR_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZ_NSPR_LIBS" >&5
$as_echo_n "checking MOZ_NSPR_LIBS... " >&6; }
            MOZ_NSPR_LIBS=`$PKG_CONFIG --libs "$MOZ_FLAVOUR-nspr "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZ_NSPR_LIBS" >&5
$as_echo "$MOZ_NSPR_LIBS" >&6; }
        else
            MOZ_NSPR_CFLAGS=""
            MOZ_NSPR_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements ($MOZ_FLAVOUR-nspr ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
echo "$as_me: error: Library requirements ($MOZ_FLAVOUR-nspr ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." >&2;}
   { (exit 1); exit 1; }; }
  fi

    fi

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $MOZ_FLAVOUR-xpcom" >&5
$as_echo_n "checking for $MOZ_FLAVOUR-xpcom... " >&6; }

        if $PKG_CONFIG --exists "$MOZ_FLAVOUR-xpcom" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZILLAXPCOM_CFLAGS" >&5
$as_echo_n "checking MOZILLAXPCOM_CFLAGS... " >&6; }
            MOZILLAXPCOM_CFLAGS=`$PKG_CONFIG --cflags "$MOZ_FLAVOUR-xpcom"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZILLAXPCOM_CFLAGS" >&5
$as_echo "$MOZILLAXPCOM_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZILLAXPCOM_LIBS" >&5
$as_echo_n "checking MOZILLAXPCOM_LIBS... " >&6; }
            MOZILLAXPCOM_LIBS=`$PKG_CONFIG --libs "$MOZ_FLAVOUR-xpcom"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZILLAXPCOM_LIBS" >&5
$as_echo "$MOZILLAXPCOM_LIBS" >&6; }
        else
            MOZILLAXPCOM_CFLAGS=""
            MOZILLAXPCOM_LIBS=""

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for libxul " >&5
$as_echo_n "checking for libxul ... " >&6; }

        if $PKG_CONFIG --exists "libxul " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZILLAXPCOM_CFLAGS" >&5
$as_echo_n "checking MOZILLAXPCOM_CFLAGS... " >&6; }
            MOZILLAXPCOM_CFLAGS=`$PKG_CONFIG --cflags "libxul "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZILLAXPCOM_CFLAGS" >&5
$as_echo "$MOZILLAXPCOM_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZILLAXPCOM_LIBS" >&5
$as_echo_n "checking MOZILLAXPCOM_LIBS... " >&6; }
            MOZILLAXPCOM_LIBS=`$PKG_CONFIG --libs "libxul "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZILLAXPCOM_LIBS" >&5
$as_echo "$MOZILLAXPCOM_LIBS" >&6; }
        else
            MOZILLAXPCOM_CFLAGS=""
            MOZILLAXPCOM_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (libxul ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
echo "$as_me: error: Library requirements (libxul ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." >&2;}
   { (exit 1); exit 1; }; }
  fi

      MOZ_INC=`$PKG_CONFIG --variable=includedir libxul`

    save_LIBS="$LIBS"
    CPPFLAGS="$CPPFLAGS $MOZ_NSS_CFLAGS"
    LDFLAGS="$LDFLAGS $MOZ_NSS_LIBS"
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PK11_GetCertFromPrivateKey in -lnss3" >&5
$as_echo_n "checking for PK11_GetCertFromPrivateKey in -lnss3... " >&6; }
if test "${ac_cv_lib_nss3_PK11_GetCertFromPrivateKey+set}" = set; then :
  $as_echo_n "(cached) " >&6
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lnss3  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char PK11_GetCertFromPrivateKey ();
int
main ()
{
return PK11_GetCertFromPrivateKey ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_nss3_PK11_GetCertFromPrivateKey=yes
else
  ac_cv_lib_nss3_PK11_GetCertFromPrivateKey=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nss3_PK11_GetCertFromPrivateKey" >&5
$as_echo "$ac_cv_lib_nss3_PK11_GetCertFromPrivateKey" >&6; }
if test "x$ac_cv_lib_nss3_PK11_GetCertFromPrivateKey" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBNSS3 1
_ACEOF

  LIBS="-lnss3 $LIBS"

else
  as_fn_error "PK11_GetCertFromPrivateKey missing but needed.
See https://bugzilla.mozilla.org/show_bug.cgi?id=262274.
Fixed since nss 3.9.3 (contained by e.g. mozilla >= 1.7.5)" "$LINENO" 5
echo "$as_me: error: PK11_GetCertFromPrivateKey missing but needed.
See https://bugzilla.mozilla.org/show_bug.cgi?id=262274.
Fixed since nss 3.9.3 (contained by e.g. mozilla >= 1.7.5)" >&2;}
   { (exit 1); exit 1; }; }
fi

    LDFLAGS="$save_LDFLAGS"


    MOZ_LIB_XPCOM=$MOZILLAXPCOM_LIBS
    if test "$WITH_LDAP" != "NO" && test "$WITH_OPENLDAP" != "YES"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $tmp was compiled with --enable-ldap" >&5
$as_echo_n "checking whether $tmp was compiled with --enable-ldap... " >&6; }
      if test -d "$MOZ_INC/ldap"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
         MOZ_LDAP_CFLAGS="-I$MOZ_INC"
      else
        as_fn_error "no.
Could not find LDAP header include files in $MOZ_INC/ldap.
Please recompile $tmp with --enable-ldap or use --with-openldap." "$LINENO" 5
echo "$as_me: error: no.
Could not find LDAP header include files in $MOZ_INC/ldap.
Please recompile $tmp with --enable-ldap or use --with-openldap." >&2;}
   { (exit 1); exit 1; }; }
      fi
    fi


    fi

elif test "$enable_mozilla" = "no"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
$as_echo "none" >&6; }
    WITH_MOZILLA=NO
    ENABLE_NSS_MODULE=NO
    enable_nss_module=no
else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    SYSTEM_MOZILLA=NO
    BUILD_TYPE="$BUILD_TYPE MOZ"
if test -z "$with_mozilla_version"; then
   MOZILLA_VERSION=
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which mozilla version to build" >&5
$as_echo_n "checking which mozilla version to build... " >&6; }
   MOZILLA_VERSION=$with_mozilla_version
   enable_build_mozilla=1
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZILLA_VERSION" >&5
$as_echo "$MOZILLA_VERSION" >&6; }
fi



{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolkit mozilla should use" >&5
$as_echo_n "checking for toolkit mozilla should use... " >&6; }
if test -z "$with_mozilla_toolkit"; then
   if test "$_os" != "WINNT" ; then
      if test "$_os" = "Darwin" ; then
         MOZILLA_TOOLKIT=mac
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: mac" >&5
$as_echo "mac" >&6; }
      else
         MOZILLA_TOOLKIT=gtk2
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: gtk2" >&5
$as_echo "gtk2" >&6; }
      fi
   fi
else
   MOZILLA_TOOLKIT=$with_mozilla_toolkit
   enable_build_mozilla=1
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZILLA_TOOLKIT" >&5
$as_echo "$MOZILLA_TOOLKIT" >&6; }
fi
#if test "$_os" = "Darwin" && test "$MOZILLA_TOOLKIT" != "gtk2"; then
#   #only gtk2 toolkit supported - xlib or cocoa nees glib1 and libIDL1 - the latter is not

      enable_build_mozilla=
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build Mozilla/SeaMonkey" >&5
$as_echo_n "checking whether to build Mozilla/SeaMonkey... " >&6; }
if test -n "$enable_build_mozilla"; then
   BUILD_MOZAB="TRUE"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
   BUILD_MOZAB=""
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build provided NSS module" >&5
$as_echo_n "checking whether to build provided NSS module... " >&6; }
if test "$enable_nss_module" != "no"; then
   ENABLE_NSS_MODULE="YES"
   BUILD_TYPE="$BUILD_TYPE NSS"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   if test "$_os" = "WINNT"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Mozilla build tooling" >&5
$as_echo_n "checking for Mozilla build tooling... " >&6; }
      if test -z "$MOZILLABUILD" ; then
as_fn_error "Mozilla build tooling not found.
Use the --with-mozilla-build option after installling the tools obtained
from http://ftp.mozilla.org/pub/mozilla.org/mozilla/libraries/win32" "$LINENO" 5
echo "$as_me: error: Mozilla build tooling not found.
Use the --with-mozilla-build option after installling the tools obtained
from http://ftp.mozilla.org/pub/mozilla.org/mozilla/libraries/win32" >&2;}
   { (exit 1); exit 1; }; }
      else
         if test \( "$WITH_MINGWIN" = "yes" \) ; then
            if test ! -d "$MOZILLABUILD" ; then
as_fn_error "Mozilla build tooling incomplete!" "$LINENO" 5
echo "$as_me: error: Mozilla build tooling incomplete!" >&2;}
   { (exit 1); exit 1; }; }
            else
               { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
$as_echo "ok" >&6; }
            fi
         else
            if test ! -d "$MOZILLABUILD/moztools" \
               -o ! -d "$MOZILLABUILD/msys" ; then
as_fn_error "Mozilla build tooling incomplete!" "$LINENO" 5
echo "$as_me: error: Mozilla build tooling incomplete!" >&2;}
   { (exit 1); exit 1; }; }
            else
               { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
$as_echo "ok" >&6; }
            fi
         fi
      fi
   fi
else
   ENABLE_NSS_MODULE="NO"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

if test "$BUILD_MOZAB" = "TRUE"; then

    if test "$WITH_MINGWIN" != "yes"; then
      # compiling with MSVC. Only supported platform here is MSVS2005 at the moment.
      if test "$MSVSVER" != "2005"; then
        as_fn_error "Building SeaMonkey is supported with Microsoft Visual Studio .NET 2005 only." "$LINENO" 5
echo "$as_me: error: Building SeaMonkey is supported with Microsoft Visual Studio .NET 2005 only." >&2;}
   { (exit 1); exit 1; }; }
      fi
    else
      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Building SeaMonkey with mingwin is not tested, and likely to break." >&5
$as_echo "$as_me: WARNING: Building SeaMonkey with mingwin is not tested, and likely to break." >&2;}
      echo "Building SeaMonkey with mingwin is not tested, and likely to break." >> warn
    fi
  fi

   fi
   MOZILLA_SOURCE_VERSION="seamonkey-${MOZILLA_VERSION}.source"
   for e in gz bz2; do
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $MOZILLA_SOURCE_VERSION.tar.$e" >&5
$as_echo_n "checking for $MOZILLA_SOURCE_VERSION.tar.$e... " >&6; }
      if test ! -e "moz/download/$MOZILLA_SOURCE_VERSION.tar.$e" && test "$HAVE_MOZILLA_TARBALL" != "y"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
$as_echo "not found" >&6; }
         HAVE_MOZILLA_TARBALL=n
      else
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
$as_echo "found" >&6; }
         HAVE_MOZILLA_TARBALL=y
      fi
   done
   if test "$HAVE_MOZILLA_TARBALL" != "y"; then
         as_fn_error "Mozilla/SeaMonkey source archive not found.
Please copy $MOZILLA_SOURCE_VERSION.tar.bz2 or $MOZILLA_SOURCE_VERSION.tar.gz to moz/download/.
The archives can be found here:
ftp://ftp.mozilla.org/pub/mozilla.org/seamonkey/releases/$MOZILLA_VERSION/" "$LINENO" 5
echo "$as_me: error: Mozilla/SeaMonkey source archive not found.
Please copy $MOZILLA_SOURCE_VERSION.tar.bz2 or $MOZILLA_SOURCE_VERSION.tar.gz to moz/download/.
The archives can be found here:
ftp://ftp.mozilla.org/pub/mozilla.org/seamonkey/releases/$MOZILLA_VERSION/" >&2;}
   { (exit 1); exit 1; }; }
   fi
   if test "$_os" = "WINNT"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for moztools binaries" >&5
$as_echo_n "checking for moztools binaries... " >&6; }
      if test ! -e "moz/download/vc8-moztools.zip" ; then
        as_fn_error "The following file is missing in moz/download: vc8-moztools.zip
(from ftp://ftp.mozilla.org/pub/mozilla.org/mozilla/libraries/win32/historic/vc8/)" "$LINENO" 5
      else
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
$as_echo "ok" >&6; }
      else
         echo "$as_me:$LINENO: result: ok" >&5
echo "${ECHO_T}ok" >&6
      fi
   elif test "$_os" = "Darwin"; then
      if test "$MOZILLA_TOOLKIT" = "gtk2"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether mozilla can be built..." >&5
$as_echo "$as_me: checking whether mozilla can be built..." >&6;}

  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gtk+-2.0 >= 2.4 libIDL-2.0 >= 0.8" >&5
$as_echo_n "checking for gtk+-2.0 >= 2.4 libIDL-2.0 >= 0.8... " >&6; }

        if $PKG_CONFIG --exists "gtk+-2.0 >= 2.4 libIDL-2.0 >= 0.8" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZGTK2_CFLAGS" >&5
$as_echo_n "checking MOZGTK2_CFLAGS... " >&6; }
            MOZGTK2_CFLAGS=`$PKG_CONFIG --cflags "gtk+-2.0 >= 2.4 libIDL-2.0 >= 0.8"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZGTK2_CFLAGS" >&5
$as_echo "$MOZGTK2_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZGTK2_LIBS" >&5
$as_echo_n "checking MOZGTK2_LIBS... " >&6; }
            MOZGTK2_LIBS=`$PKG_CONFIG --libs "gtk+-2.0 >= 2.4 libIDL-2.0 >= 0.8"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZGTK2_LIBS" >&5
$as_echo "$MOZGTK2_LIBS" >&6; }
        else
            MOZGTK2_CFLAGS=""
            MOZGTK2_LIBS=""

  fi

  if test $succeeded = yes; then
     { $as_echo "$as_me:${as_lineno-$LINENO}: OK - can build mozilla" >&5
$as_echo "$as_me: OK - can build mozilla" >&6;}
  else
     as_fn_error "Prerequisites to build mozilla not met. Either use the precompiled mozilla binaries or install the missing packages" "$LINENO" 5
echo "$as_me: error: Prerequisites to build mozilla not met. Either use the precompiled mozilla binaries or install the missing packages" >&2;}
   { (exit 1); exit 1; }; }
  fi

      else

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for libIDL-2.0 >= 0.6.3" >&5
$as_echo_n "checking for libIDL-2.0 >= 0.6.3... " >&6; }

        if $PKG_CONFIG --exists "libIDL-2.0 >= 0.6.3" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZLIBREQ_CFLAGS" >&5
$as_echo_n "checking MOZLIBREQ_CFLAGS... " >&6; }
            MOZLIBREQ_CFLAGS=`$PKG_CONFIG --cflags "libIDL-2.0 >= 0.6.3"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZLIBREQ_CFLAGS" >&5
$as_echo "$MOZLIBREQ_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZLIBREQ_LIBS" >&5
$as_echo_n "checking MOZLIBREQ_LIBS... " >&6; }
            MOZLIBREQ_LIBS=`$PKG_CONFIG --libs "libIDL-2.0 >= 0.6.3"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZLIBREQ_LIBS" >&5
$as_echo "$MOZLIBREQ_LIBS" >&6; }
        else
            MOZLIBREQ_CFLAGS=""
            MOZLIBREQ_LIBS=""

  fi

         if test -z "$MOZIDL"; then
            as_fn_error "libIDL 0.6.3 or newer is needed to build mozilla with mac toolkit." "$LINENO" 5
echo "$as_me: error: libIDL 0.6.3 or newer is needed to build mozilla with mac toolkit." >&2;}
   { (exit 1); exit 1; }; }
         fi
      fi
   else

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gtk+-2.0" >&5
$as_echo_n "checking for gtk+-2.0... " >&6; }

        if $PKG_CONFIG --exists "gtk+-2.0" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZLIBREQ_CFLAGS" >&5
$as_echo_n "checking MOZLIBREQ_CFLAGS... " >&6; }
            MOZLIBREQ_CFLAGS=`$PKG_CONFIG --cflags "gtk+-2.0"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZLIBREQ_CFLAGS" >&5
$as_echo "$MOZLIBREQ_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZLIBREQ_LIBS" >&5
$as_echo_n "checking MOZLIBREQ_LIBS... " >&6; }
            MOZLIBREQ_LIBS=`$PKG_CONFIG --libs "gtk+-2.0"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZLIBREQ_LIBS" >&5
$as_echo "$MOZLIBREQ_LIBS" >&6; }
        else
            MOZLIBREQ_CFLAGS=""
            MOZLIBREQ_LIBS=""

  fi

         if test -z "$MOZGTK"; then
            as_fn_error "GTK2 is needed to build mozilla." "$LINENO" 5
echo "$as_me: error: GTK2 is needed to build mozilla." >&2;}
   { (exit 1); exit 1; }; }
         fi

  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for libIDL-2.0 >= 0.8.0" >&5
$as_echo_n "checking for libIDL-2.0 >= 0.8.0... " >&6; }

        if $PKG_CONFIG --exists "libIDL-2.0 >= 0.8.0" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZLIBREQ_CFLAGS" >&5
$as_echo_n "checking MOZLIBREQ_CFLAGS... " >&6; }
            MOZLIBREQ_CFLAGS=`$PKG_CONFIG --cflags "libIDL-2.0 >= 0.8.0"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZLIBREQ_CFLAGS" >&5
$as_echo "$MOZLIBREQ_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZLIBREQ_LIBS" >&5
$as_echo_n "checking MOZLIBREQ_LIBS... " >&6; }
            MOZLIBREQ_LIBS=`$PKG_CONFIG --libs "libIDL-2.0 >= 0.8.0"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZLIBREQ_LIBS" >&5
$as_echo "$MOZLIBREQ_LIBS" >&6; }
        else
            MOZLIBREQ_CFLAGS=""
            MOZLIBREQ_LIBS=""

  fi

         if test -z "$MOZIDL"; then
            as_fn_error "libIDL >= 0.8.0 is needed when using GTK2 to build mozilla." "$LINENO" 5
echo "$as_me: error: libIDL >= 0.8.0 is needed when using GTK2 to build mozilla." >&2;}
   { (exit 1); exit 1; }; }
         fi
      else


  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gtk+ >= 1.2.3" >&5
$as_echo_n "checking for gtk+ >= 1.2.3... " >&6; }

        if $PKG_CONFIG --exists "gtk+ >= 1.2.3" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZLIBREQ_CFLAGS" >&5
$as_echo_n "checking MOZLIBREQ_CFLAGS... " >&6; }
            MOZLIBREQ_CFLAGS=`$PKG_CONFIG --cflags "gtk+ >= 1.2.3"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZLIBREQ_CFLAGS" >&5
$as_echo "$MOZLIBREQ_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZLIBREQ_LIBS" >&5
$as_echo_n "checking MOZLIBREQ_LIBS... " >&6; }
            MOZLIBREQ_LIBS=`$PKG_CONFIG --libs "gtk+ >= 1.2.3"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZLIBREQ_LIBS" >&5
$as_echo "$MOZLIBREQ_LIBS" >&6; }
        else
            MOZLIBREQ_CFLAGS=""
            MOZLIBREQ_LIBS=""

  fi

         if test -z "$MOZGTK"; then
            as_fn_error "gtk 1.2 is needed when not using GTK2 to build mozilla." "$LINENO" 5
echo "$as_me: error: gtk 1.2 is needed when not using GTK2 to build mozilla." >&2;}
   { (exit 1); exit 1; }; }
         fi

  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for libidl >= 0.6.3 libidl <= 0.6.8" >&5
$as_echo_n "checking for libidl >= 0.6.3 libidl <= 0.6.8... " >&6; }

        if $PKG_CONFIG --exists "libidl >= 0.6.3 libidl <= 0.6.8" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZLIBREQ_CFLAGS" >&5
$as_echo_n "checking MOZLIBREQ_CFLAGS... " >&6; }
            MOZLIBREQ_CFLAGS=`$PKG_CONFIG --cflags "libidl >= 0.6.3 libidl <= 0.6.8"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZLIBREQ_CFLAGS" >&5
$as_echo "$MOZLIBREQ_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking MOZLIBREQ_LIBS" >&5
$as_echo_n "checking MOZLIBREQ_LIBS... " >&6; }
            MOZLIBREQ_LIBS=`$PKG_CONFIG --libs "libidl >= 0.6.3 libidl <= 0.6.8"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOZLIBREQ_LIBS" >&5
$as_echo "$MOZLIBREQ_LIBS" >&6; }
        else
            MOZLIBREQ_CFLAGS=""
            MOZLIBREQ_LIBS=""

  fi

         if test -z "$MOZIDL"; then
            as_fn_error "libIDL 0.6.3 - 0.6.8 is needed when not using GTK2 to build mozilla." "$LINENO" 5
echo "$as_me: error: libIDL 0.6.3 - 0.6.8 is needed when not using GTK2 to build mozilla." >&2;}
   { (exit 1); exit 1; }; }
         fi
      fi
   fi




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which sane header to use" >&5
$as_echo_n "checking which sane header to use... " >&6; }
if test -n "$with_system_sane_header" -o -n "$with_system_headers" && \
	test "$with_system_sane_header" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
   SYSTEM_SANE_HEADER=YES
   ac_fn_c_check_header_mongrel "$LINENO" "sane/sane.h" "ac_cv_header_sane_sane_h" "$ac_includes_default"
if test "x$ac_cv_header_sane_sane_h" = x""yes; then :

else
  as_fn_error "sane not found. install sane" "$LINENO" 5
fi


else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
echo $ECHO_N "checking sane/sane.h usability... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <sane/sane.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking sane/sane.h presence" >&5
echo $ECHO_N "checking sane/sane.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <sane/sane.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: sane/sane.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: sane/sane.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: sane/sane.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: sane/sane.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: sane/sane.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: sane/sane.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: sane/sane.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: sane/sane.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: sane/sane.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: sane/sane.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: sane/sane.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: sane/sane.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: sane/sane.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: sane/sane.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: sane/sane.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: sane/sane.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for sane/sane.h" >&5
echo $ECHO_N "checking for sane/sane.h... $ECHO_C" >&6
if test "${ac_cv_header_sane_sane_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_sane_sane_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_sane_sane_h" >&5
echo "${ECHO_T}$ac_cv_header_sane_sane_h" >&6

fi
if test $ac_cv_header_sane_sane_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: sane not found. install sane" >&5
echo "$as_me: error: sane not found. install sane" >&2;}
   { (exit 1); exit 1; }; }
fi


else
   echo "$as_me:$LINENO: result: internal" >&5
echo "${ECHO_T}internal" >&6
   SYSTEM_SANE_HEADER=NO
   BUILD_TYPE="$BUILD_TYPE SANE"
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which icu to use" >&5
$as_echo_n "checking which icu to use... " >&6; }
if test -n "$with_system_icu" -o -n "$with_system_libs" && \
	test "$with_system_icu" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
   SYSTEM_ICU=YES
   ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu

   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for unicode/rbbi.h" >&5
$as_echo_n "checking for unicode/rbbi.h... " >&6; }
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
unicode/rbbi.h
_ACEOF
if ac_fn_cxx_try_cpp "$LINENO"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked." >&5
$as_echo "checked." >&6; }
else
  as_fn_error "icu headers not found." "$LINENO" 5
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_cxx_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  echo "$as_me:$LINENO: result: checked." >&5
echo "${ECHO_T}checked." >&6
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  { { echo "$as_me:$LINENO: error: icu headers not found." >&5
echo "$as_me: error: icu headers not found." >&2;}
   { (exit 1); exit 1; }; }
fi
rm -f conftest.err conftest.$ac_ext
   # Extract the first word of "genbrk", so it can be a program name with args.
set dummy genbrk; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_SYSTEM_GENBRK+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $SYSTEM_GENBRK in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_SYSTEM_GENBRK="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
SYSTEM_GENBRK=$ac_cv_path_SYSTEM_GENBRK

if test -n "$SYSTEM_GENBRK"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSTEM_GENBRK" >&5
$as_echo "$SYSTEM_GENBRK" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


   if test -z "$SYSTEM_GENBRK"; then
      as_fn_error "\\"genbrk\\" not found in \$PATH, install the icu development tool \\"genbrk\"\" "$LINENO" 5
echo "$as_me: error: \\"genbrk\\" not found in \$PATH, install the icu development tool \\"genbrk\"\" >&2;}
   { (exit 1); exit 1; }; }
   fi
   # Extract the first word of "genccode", so it can be a program name with args.
set dummy genccode; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_SYSTEM_GENCCODE+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $SYSTEM_GENCCODE in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_SYSTEM_GENCCODE="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
SYSTEM_GENCCODE=$ac_cv_path_SYSTEM_GENCCODE

if test -n "$SYSTEM_GENCCODE"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSTEM_GENCCODE" >&5
$as_echo "$SYSTEM_GENCCODE" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


   if test -z "$SYSTEM_GENCCODE"; then
      as_fn_error "\\"genccode\\" not found in \$PATH, install the icu development tool \\"genccode\"\" "$LINENO" 5
echo "$as_me: error: \\"genccode\\" not found in \$PATH, install the icu development tool \\"genccode\"\" >&2;}
   { (exit 1); exit 1; }; }
   fi
   # Extract the first word of "gencmn", so it can be a program name with args.
set dummy gencmn; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_SYSTEM_GENCMN+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $SYSTEM_GENCMN in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_SYSTEM_GENCMN="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
SYSTEM_GENCMN=$ac_cv_path_SYSTEM_GENCMN

if test -n "$SYSTEM_GENCMN"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSTEM_GENCMN" >&5
$as_echo "$SYSTEM_GENCMN" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


   if test -z "$SYSTEM_GENCMN"; then
      as_fn_error "\\"gencmn\\" not found in \$PATH, install the icu development tool \\"gencmn\"\" "$LINENO" 5
   fi
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking ICU version" >&5
$as_echo_n "checking ICU version... " >&6; }
      if test "$cross_compiling" = yes; then :
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error "cannot run test program while cross compiling
See \`config.log' for more details." "$LINENO" 5; }
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
   { (exit 1); exit 1; }; }
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

#include <unicode/uversion.h>

}

_ACEOF
if ac_fn_cxx_try_run "$LINENO"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: OK" >&5
$as_echo "OK" >&6; }
else
  as_fn_error "not suitable, only >= 4.0 supported currently" "$LINENO" 5
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

  (exit $ac_status); }; }; then
  echo "$as_me:$LINENO: result: OK" >&5
echo "${ECHO_T}OK" >&6
else
  echo "$as_me: program exited with status $ac_status" >&5
echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

( exit $ac_status )
{ { echo "$as_me:$LINENO: error: not suitable, only >= 4.0 supported currently" >&5
echo "$as_me: error: not suitable, only >= 4.0 supported currently" >&2;}
   { (exit 1); exit 1; }; }
fi
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
fi
      ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

ac_compiler_gnu=$ac_cv_c_compiler_gnu

else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    SYSTEM_ICU=NO
    BUILD_TYPE="$BUILD_TYPE ICU"
fi




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable graphite support" >&5
$as_echo_n "checking whether to enable graphite support... " >&6; }
if test "$_os" = "WINNT" -o "$_os" = "Linux" && test "z$enable_graphite" == "z" -o "$enable_graphite" != "no" ; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
    ENABLE_GRAPHITE="TRUE"
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking which graphite to use" >&5
$as_echo_n "checking which graphite to use... " >&6; }
    if test -n "$with_system_graphite" -o -n "$with_system_libs" && \
        test "$with_system_graphite" != "no"; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
        SYSTEM_GRAPHITE=YES

  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for silgraphite " >&5
$as_echo_n "checking for silgraphite ... " >&6; }

        if $PKG_CONFIG --exists "silgraphite " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking GRAPHITE_CFLAGS" >&5
$as_echo_n "checking GRAPHITE_CFLAGS... " >&6; }
            GRAPHITE_CFLAGS=`$PKG_CONFIG --cflags "silgraphite "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GRAPHITE_CFLAGS" >&5
$as_echo "$GRAPHITE_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking GRAPHITE_LIBS" >&5
$as_echo_n "checking GRAPHITE_LIBS... " >&6; }
            GRAPHITE_LIBS=`$PKG_CONFIG --libs "silgraphite "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GRAPHITE_LIBS" >&5
$as_echo "$GRAPHITE_LIBS" >&6; }
        else
            GRAPHITE_CFLAGS=""
            GRAPHITE_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (silgraphite ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
echo "$as_me: error: Library requirements (silgraphite ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." >&2;}
   { (exit 1); exit 1; }; }
  fi

    else
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
        SYSTEM_GRAPHITE=NO
        BUILD_TYPE="$BUILD_TYPE GRAPHITE"
    fi
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi




if test  "$_os" = "Darwin"; then
   if test "x$with_x" = "xyes"; then
      as_fn_error "X11 build is no longer supported on MacOSX, please use the native aqua build" "$LINENO" 5
   else
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /System/Library/Frameworks/AppKit.framework" >&5
$as_echo_n "checking for /System/Library/Frameworks/AppKit.framework... " >&6; }
      echo "$as_me:$LINENO: checking for /System/Library/Frameworks/AppKit.framework" >&5
echo $ECHO_N "checking for /System/Library/Frameworks/AppKit.framework... $ECHO_C" >&6
      if test -d "/System/Library/Frameworks/AppKit.framework/"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
         x_includes="no_x_includes"
         x_libraries="no_x_libraries"
                  enable_gtk=no

         ENABLE_CUPS=""

      else
         as_fn_error "No AppKit.framewrok found" "$LINENO" 5
echo "$as_me: error: No AppKit.framewrok found" >&2;}
   { (exit 1); exit 1; }; }
      fi
   fi
fi

   echo "Do Nothing for _os = OS2. Don't check for X11."
      :
elif test "$_os" != "WINNT" ; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for X" >&5
$as_echo_n "checking for X... " >&6; }


# Check whether --with-x was given.
if test "${with_x+set}" = set; then :
  withval=$with_x;
fi

# $have_x is `yes', `no', `disabled', or empty when we do not yet know.
if test "x$with_x" = xno; then
  # The user explicitly disabled X.
  have_x=disabled
else
  case $x_includes,$x_libraries in #(
    *\'*) as_fn_error "cannot use X directory names containing '" "$LINENO" 5;; #(
    *,NONE | NONE,*) if test "${ac_cv_have_x+set}" = set; then :
  $as_echo_n "(cached) " >&6
    if test "${ac_cv_have_x+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  # One or both of the vars are not set, and there is no cached value.
ac_x_includes=no ac_x_libraries=no
rm -f -r conftest.dir
if mkdir conftest.dir; then
  cd conftest.dir
  # Make sure to not put "make" in the Imakefile rules, since we grep it out.
  cat >Imakefile <<'_ACEOF'
incroot:
	@echo incroot='${INCROOT}'
usrlibdir:
	@echo usrlibdir='${USRLIBDIR}'
libdir:
	@echo libdir='${LIBDIR}'
_ACEOF
  if (export CC; ${XMKMF-xmkmf}) >/dev/null 2>/dev/null && test -f Makefile; then
    # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
    for ac_var in incroot usrlibdir libdir; do
      eval "ac_im_$ac_var=\`\${MAKE-make} $ac_var 2>/dev/null | sed -n 's/^$ac_var=//p'\`"
    done
    # Open Windows xmkmf reportedly sets LIBDIR instead of USRLIBDIR.
    for ac_extension in a so sl dylib la dll; do
      if test ! -f "$ac_im_usrlibdir/libX11.$ac_extension" &&
	 test -f "$ac_im_libdir/libX11.$ac_extension"; then
	ac_im_usrlibdir=$ac_im_libdir; break
      fi
    done

    # bogus both because they are the default anyway, and because
    # using them would break gcc on systems where it needs fixed includes.
    case $ac_im_incroot in
	/usr/include) ac_x_includes= ;;
	*) test -f "$ac_im_incroot/X11/Xos.h" && ac_x_includes=$ac_im_incroot;;
    esac
    case $ac_im_usrlibdir in
	/usr/lib | /usr/lib64 | /lib | /lib64) ;;
	*) test -d "$ac_im_usrlibdir" && ac_x_libraries=$ac_im_usrlibdir ;;
    esac
  fi
  cd ..
  rm -f -r conftest.dir
fi

# Standard set of common directories for X headers.
# Check X11 before X11Rn because it is often a symlink to the current release.
ac_x_header_dirs='
/usr/X11/include
/usr/X11R7/include
/usr/X11R6/include
/usr/X11R5/include
/usr/X11R4/include

/usr/include/X11
/usr/include/X11R7
/usr/include/X11R6
/usr/include/X11R5
/usr/include/X11R4

/usr/local/X11/include
/usr/local/X11R7/include
/usr/local/X11R6/include
/usr/local/X11R5/include
/usr/local/X11R4/include

/usr/local/include/X11
/usr/local/include/X11R7
/usr/local/include/X11R6
/usr/local/include/X11R5
/usr/local/include/X11R4

/usr/openwin/share/include'

if test "$ac_x_includes" = no; then
  # Guess where to find include files, by looking for Xlib.h.
  # First, try using that file with no special directory specified.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <X11/Xlib.h>
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
/* end confdefs.h.  */
#include <X11/Intrinsic.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  # We can compile using X headers with no special include directory.
ac_x_includes=
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  for ac_dir in $ac_x_header_dirs; do
  if test -r "$ac_dir/X11/Xlib.h"; then
    ac_x_includes=$ac_dir
    break
  fi

  # See if we find them without any special options.
  # Don't add to $LIBS permanently.
  ac_save_LIBS=$LIBS
  LIBS="-lX11 $LIBS"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <X11/Xlib.h>
int
main ()
{
XrmInitialize ()
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  LIBS=$ac_save_LIBS
# We can link X programs with no special library path.
ac_x_libraries=
else
  LIBS=$ac_save_LIBS
for ac_dir in `$as_echo "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g`

LIBS=$ac_save_LIBS
for ac_dir in `echo "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g`
do
  # Don't even attempt the hair of trying to link an X program!
  for ac_extension in a so sl dylib la dll; do
    if test -r "$ac_dir/libX11.$ac_extension"; then
      ac_x_libraries=$ac_dir
      break 2
    fi
  done
done
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi # $ac_x_libraries = no

case $ac_x_includes,$ac_x_libraries in #(
  no,* | *,no | *\'*)
    # Didn't find X, or a directory has "'" in its name.
    ac_cv_have_x="have_x=no";; #(
  *)
    # Record where we found X for the cache.
    ac_cv_have_x="have_x=yes\
	ac_x_includes='$ac_x_includes'\
	ac_x_libraries='$ac_x_libraries'"
esac
fi
;; #(
    *) have_x=yes;;
  esac
  eval "$ac_cv_have_x"
fi # $with_x != no

if test "$have_x" != yes; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5
$as_echo "$have_x" >&6; }
  no_x=yes
else
  # If each of the values was on the command line, it overrides each guess.
  test "x$x_includes" = xNONE && x_includes=$ac_x_includes
  test "x$x_libraries" = xNONE && x_libraries=$ac_x_libraries
  # Update the cache value to reflect the command line values.
  ac_cv_have_x="have_x=yes\
	ac_x_includes='$x_includes'\
	ac_x_libraries='$x_libraries'"
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5
$as_echo "libraries $x_libraries, headers $x_includes" >&6; }
fi

   if test "$no_x" = yes; then
  # Not all programs may use this symbol, but it does not hurt to define it.

$as_echo "#define X_DISPLAY_MISSING 1" >>confdefs.h
#define X_DISPLAY_MISSING 1
_ACEOF

  X_CFLAGS= X_PRE_LIBS= X_LIBS= X_EXTRA_LIBS=
else

    X_LIBS="$X_LIBS -L$x_libraries"
    # For Solaris; some versions of Sun CC require a space after -R and
    # others require no space.  Words are not sufficient . . . .
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -R must be followed by a space" >&5
$as_echo_n "checking whether -R must be followed by a space... " >&6; }
    ac_xsave_LIBS=$LIBS; LIBS="$LIBS -R$x_libraries"
    ac_xsave_c_werror_flag=$ac_c_werror_flag
    ac_c_werror_flag=yes
    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
       X_LIBS="$X_LIBS -R$x_libraries"
else
  LIBS="$ac_xsave_LIBS -R $x_libraries"
       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_R_nospace=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_R_nospace=no
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
      if test $ac_R_nospace = yes; then
	echo "$as_me:$LINENO: result: no" >&5
echo "${ECHO_T}no" >&6
	X_LIBS="$X_LIBS -R$x_libraries"
      else
	LIBS="$ac_xsave_LIBS -R $x_libraries"
	cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_R_space=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_R_space=no
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
	if test $ac_R_space = yes; then
	  echo "$as_me:$LINENO: result: yes" >&5
echo "${ECHO_T}yes" >&6
	  X_LIBS="$X_LIBS -R $x_libraries"
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: neither works" >&5
$as_echo "neither works" >&6; }
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
    ac_c_werror_flag=$ac_xsave_c_werror_flag
    LIBS=$ac_xsave_LIBS
  fi

  # Check for system-dependent libraries X programs must link with.

    # libraries were built with DECnet support.  And Karl Berry says
    # the Alpha needs dnet_stub (dnet does not exist).
    ac_xsave_LIBS="$LIBS"; LIBS="$LIBS $X_LIBS -lX11"
    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char XOpenDisplay ();
int
main ()
{
return XOpenDisplay ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :

else
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet" >&5
$as_echo_n "checking for dnet_ntoa in -ldnet... " >&6; }
if test "${ac_cv_lib_dnet_dnet_ntoa+set}" = set; then :
  $as_echo_n "(cached) " >&6
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  :
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

echo "$as_me:$LINENO: checking for dnet_ntoa in -ldnet" >&5
echo $ECHO_N "checking for dnet_ntoa in -ldnet... $ECHO_C" >&6
if test "${ac_cv_lib_dnet_dnet_ntoa+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-ldnet  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char dnet_ntoa ();
int
main ()
{
return dnet_ntoa ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_dnet_dnet_ntoa=yes
else
  ac_cv_lib_dnet_dnet_ntoa=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_dnet_ntoa" >&5
$as_echo "$ac_cv_lib_dnet_dnet_ntoa" >&6; }
if test "x$ac_cv_lib_dnet_dnet_ntoa" = x""yes; then :
  X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet"
fi

    if test $ac_cv_lib_dnet_dnet_ntoa = no; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet_stub" >&5
$as_echo_n "checking for dnet_ntoa in -ldnet_stub... " >&6; }
if test "${ac_cv_lib_dnet_stub_dnet_ntoa+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-ldnet_stub  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char dnet_ntoa ();
int
main ()
{
return dnet_ntoa ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_dnet_stub_dnet_ntoa=yes
else
  ac_cv_lib_dnet_stub_dnet_ntoa=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_stub_dnet_ntoa" >&5
$as_echo "$ac_cv_lib_dnet_stub_dnet_ntoa" >&6; }
if test "x$ac_cv_lib_dnet_stub_dnet_ntoa" = x""yes; then :
  X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet_stub"
fi

    fi
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
    LIBS="$ac_xsave_LIBS"

    # msh@cis.ufl.edu says -lnsl (and -lsocket) are needed for his 386/AT,

    # on Irix 5.2, according to T.E. Dickey.
    # The functions gethostbyname, getservbyname, and inet_addr are
    # in -lbsd on LynxOS 3.0.1/i386, according to Lars Hecking.
    ac_fn_c_check_func "$LINENO" "gethostbyname" "ac_cv_func_gethostbyname"
if test "x$ac_cv_func_gethostbyname" = x""yes; then :

fi

    if test $ac_cv_func_gethostbyname = no; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5
$as_echo_n "checking for gethostbyname in -lnsl... " >&6; }
if test "${ac_cv_lib_nsl_gethostbyname+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lnsl  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

#ifdef __STDC__
# include <limits.h>
#else
# include <assert.h>
#endif

#undef gethostbyname

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
char gethostbyname ();
int
main ()
{
return gethostbyname ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_nsl_gethostbyname=yes
else
  ac_cv_lib_nsl_gethostbyname=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5
$as_echo "$ac_cv_lib_nsl_gethostbyname" >&6; }
if test "x$ac_cv_lib_nsl_gethostbyname" = x""yes; then :
  X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl"
fi

      if test $ac_cv_lib_nsl_gethostbyname = no; then
	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lbsd" >&5
$as_echo_n "checking for gethostbyname in -lbsd... " >&6; }
if test "${ac_cv_lib_bsd_gethostbyname+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lbsd  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
char gethostbyname ();
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_gethostbyname) || defined (__stub___gethostbyname)
choke me
#else
char (*f) () = gethostbyname;
#endif
#ifdef __cplusplus
}
#endif

int
main ()
{
return f != gethostbyname;
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_func_gethostbyname=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_cv_func_gethostbyname=no
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
fi
echo "$as_me:$LINENO: result: $ac_cv_func_gethostbyname" >&5
echo "${ECHO_T}$ac_cv_func_gethostbyname" >&6

    if test $ac_cv_func_gethostbyname = no; then
      echo "$as_me:$LINENO: checking for gethostbyname in -lnsl" >&5
echo $ECHO_N "checking for gethostbyname in -lnsl... $ECHO_C" >&6
if test "${ac_cv_lib_nsl_gethostbyname+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lnsl  $LIBS"
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char gethostbyname ();
int
main ()
{
return gethostbyname ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_bsd_gethostbyname=yes
else
  ac_cv_lib_bsd_gethostbyname=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_nsl_gethostbyname=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_cv_lib_nsl_gethostbyname=no
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_bsd_gethostbyname" >&5
$as_echo "$ac_cv_lib_bsd_gethostbyname" >&6; }
if test "x$ac_cv_lib_bsd_gethostbyname" = x""yes; then :
  X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl"
fi

      if test $ac_cv_lib_nsl_gethostbyname = no; then
	echo "$as_me:$LINENO: checking for gethostbyname in -lbsd" >&5
echo $ECHO_N "checking for gethostbyname in -lbsd... $ECHO_C" >&6
if test "${ac_cv_lib_bsd_gethostbyname+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lbsd  $LIBS"
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char gethostbyname ();
int
main ()
{
gethostbyname ();
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_bsd_gethostbyname=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_cv_lib_bsd_gethostbyname=no
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
echo "$as_me:$LINENO: result: $ac_cv_lib_bsd_gethostbyname" >&5
echo "${ECHO_T}$ac_cv_lib_bsd_gethostbyname" >&6
if test $ac_cv_lib_bsd_gethostbyname = yes; then
  X_EXTRA_LIBS="$X_EXTRA_LIBS -lbsd"
fi


    # variants that don't use the name server (or something).  -lsocket
    # must be given before -lnsl if both are needed.  We assume that
    # if connect needs -lnsl, so does gethostbyname.
    ac_fn_c_check_func "$LINENO" "connect" "ac_cv_func_connect"
if test "x$ac_cv_func_connect" = x""yes; then :

fi

    if test $ac_cv_func_connect = no; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for connect in -lsocket" >&5
$as_echo_n "checking for connect in -lsocket... " >&6; }
if test "${ac_cv_lib_socket_connect+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lsocket $X_EXTRA_LIBS $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

#ifdef __STDC__
# include <limits.h>
#else
# include <assert.h>
#endif

#undef connect

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
char connect ();
int
main ()
{
return connect ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_socket_connect=yes
else
  ac_cv_lib_socket_connect=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_connect" >&5
$as_echo "$ac_cv_lib_socket_connect" >&6; }
if test "x$ac_cv_lib_socket_connect" = x""yes; then :
  X_EXTRA_LIBS="-lsocket $X_EXTRA_LIBS"
fi

    fi

    # Guillermo Gomez says -lposix is necessary on A/UX.
    ac_fn_c_check_func "$LINENO" "remove" "ac_cv_func_remove"
if test "x$ac_cv_func_remove" = x""yes; then :

fi

    if test $ac_cv_func_remove = no; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for remove in -lposix" >&5
$as_echo_n "checking for remove in -lposix... " >&6; }
if test "${ac_cv_lib_posix_remove+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lposix  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
char connect ();
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_connect) || defined (__stub___connect)
choke me
#else
char (*f) () = connect;
#endif
#ifdef __cplusplus
}
#endif

int
main ()
{
return f != connect;
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_func_connect=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_cv_func_connect=no
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
fi
echo "$as_me:$LINENO: result: $ac_cv_func_connect" >&5
echo "${ECHO_T}$ac_cv_func_connect" >&6

    if test $ac_cv_func_connect = no; then
      echo "$as_me:$LINENO: checking for connect in -lsocket" >&5
echo $ECHO_N "checking for connect in -lsocket... $ECHO_C" >&6
if test "${ac_cv_lib_socket_connect+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lsocket $X_EXTRA_LIBS $LIBS"
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
char remove ();
int
main ()
{
return remove ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_posix_remove=yes
else
  ac_cv_lib_posix_remove=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix_remove" >&5
$as_echo "$ac_cv_lib_posix_remove" >&6; }
if test "x$ac_cv_lib_posix_remove" = x""yes; then :
  X_EXTRA_LIBS="$X_EXTRA_LIBS -lposix"
fi

    fi

    # BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay.
    ac_fn_c_check_func "$LINENO" "shmat" "ac_cv_func_shmat"
if test "x$ac_cv_func_shmat" = x""yes; then :

fi

    if test $ac_cv_func_shmat = no; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shmat in -lipc" >&5
$as_echo_n "checking for shmat in -lipc... " >&6; }
if test "${ac_cv_lib_ipc_shmat+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lipc  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
char connect ();
int
main ()
{
connect ();
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_socket_connect=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_cv_lib_socket_connect=no
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
echo "$as_me:$LINENO: result: $ac_cv_lib_socket_connect" >&5
echo "${ECHO_T}$ac_cv_lib_socket_connect" >&6
if test $ac_cv_lib_socket_connect = yes; then
  X_EXTRA_LIBS="-lsocket $X_EXTRA_LIBS"
fi

    fi

    # Guillermo Gomez says -lposix is necessary on A/UX.
    echo "$as_me:$LINENO: checking for remove" >&5
echo $ECHO_N "checking for remove... $ECHO_C" >&6
if test "${ac_cv_func_remove+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
/* Define remove to an innocuous variant, in case <limits.h> declares remove.
   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
#define remove innocuous_remove

/* System header to define __stub macros and hopefully few prototypes,
    which can conflict with char remove (); below.
    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
    <limits.h> exists even on freestanding compilers.  */

#ifdef __STDC__
# include <limits.h>
#else
# include <assert.h>
#endif

#undef remove

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
char shmat ();
int
main ()
{
return shmat ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_ipc_shmat=yes
else
  ac_cv_lib_ipc_shmat=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
int
main ()
{
return f != remove;
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_func_remove=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_cv_func_remove=no
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
fi
echo "$as_me:$LINENO: result: $ac_cv_func_remove" >&5
echo "${ECHO_T}$ac_cv_func_remove" >&6

    if test $ac_cv_func_remove = no; then
      echo "$as_me:$LINENO: checking for remove in -lposix" >&5
echo $ECHO_N "checking for remove in -lposix... $ECHO_C" >&6
if test "${ac_cv_lib_posix_remove+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lposix  $LIBS"
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char remove ();
int
main ()
{
remove ();
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_posix_remove=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_cv_lib_posix_remove=no
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ipc_shmat" >&5
$as_echo "$ac_cv_lib_ipc_shmat" >&6; }
if test "x$ac_cv_lib_ipc_shmat" = x""yes; then :
  X_EXTRA_LIBS="$X_EXTRA_LIBS -lposix"
fi

    fi

    # BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay.
    echo "$as_me:$LINENO: checking for shmat" >&5
echo $ECHO_N "checking for shmat... $ECHO_C" >&6
if test "${ac_cv_func_shmat+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
/* Define shmat to an innocuous variant, in case <limits.h> declares shmat.
   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
#define shmat innocuous_shmat

/* System header to define __stub macros and hopefully few prototypes,
    which can conflict with char shmat (); below.
    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
    <limits.h> exists even on freestanding compilers.  */

#ifdef __STDC__
# include <limits.h>
#else
# include <assert.h>
#endif

#undef shmat

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
{
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char shmat ();
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_shmat) || defined (__stub___shmat)
choke me
#else
char (*f) () = shmat;
#endif
#ifdef __cplusplus
}
#endif

int
main ()
{
return f != shmat;
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_func_shmat=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_cv_func_shmat=no
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
fi
echo "$as_me:$LINENO: result: $ac_cv_func_shmat" >&5
echo "${ECHO_T}$ac_cv_func_shmat" >&6

    if test $ac_cv_func_shmat = no; then
      echo "$as_me:$LINENO: checking for shmat in -lipc" >&5
echo $ECHO_N "checking for shmat in -lipc... $ECHO_C" >&6
if test "${ac_cv_lib_ipc_shmat+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lipc  $LIBS"
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char shmat ();
int
main ()
{
shmat ();
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_ipc_shmat=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_cv_lib_ipc_shmat=no
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
echo "$as_me:$LINENO: result: $ac_cv_lib_ipc_shmat" >&5
echo "${ECHO_T}$ac_cv_lib_ipc_shmat" >&6
if test $ac_cv_lib_ipc_shmat = yes; then
  X_EXTRA_LIBS="$X_EXTRA_LIBS -lipc"
fi


  # These have to be linked with before -lX11, unlike the other
  # libraries we check for below, so use a different variable.
  # John Interrante, Karl Berry
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for IceConnectionNumber in -lICE" >&5
$as_echo_n "checking for IceConnectionNumber in -lICE... " >&6; }
if test "${ac_cv_lib_ICE_IceConnectionNumber+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lICE $X_EXTRA_LIBS $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char IceConnectionNumber ();
int
main ()
{
return IceConnectionNumber ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_ICE_IceConnectionNumber=yes
else
  ac_cv_lib_ICE_IceConnectionNumber=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ICE_IceConnectionNumber" >&5
$as_echo "$ac_cv_lib_ICE_IceConnectionNumber" >&6; }
if test "x$ac_cv_lib_ICE_IceConnectionNumber" = x""yes; then :
  X_PRE_LIBS="$X_PRE_LIBS -lSM -lICE"
fi


     x_libraries="default_x_libraries"
   fi
      if test -z "$x_libraries"; then
      as_fn_error "No X libraries found" "$LINENO" 5 # Exit
echo "$as_me: error: No X libraries found" >&2;}
   { (exit 1); exit 1; }; } # Exit
   fi
   if test -z "$x_includes"; then
      as_fn_error "No X includes found" "$LINENO" 5 # Exit
echo "$as_me: error: No X includes found" >&2;}
   { (exit 1); exit 1; }; } # Exit
   fi
   CFLAGS=$X_CFLAGS
   LDFLAGS="$X_LDFLAGS $X_LIBS"
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XOpenDisplay in -lX11" >&5
$as_echo_n "checking for XOpenDisplay in -lX11... " >&6; }
if test "${ac_cv_lib_X11_XOpenDisplay+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lX11  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char XOpenDisplay ();
int
main ()
{
return XOpenDisplay ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_X11_XOpenDisplay=yes
else
  ac_cv_lib_X11_XOpenDisplay=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_X11_XOpenDisplay" >&5
$as_echo "$ac_cv_lib_X11_XOpenDisplay" >&6; }
if test "x$ac_cv_lib_X11_XOpenDisplay" = x""yes; then :
  x_libs="-lX11 $X_EXTRA_LIBS"
else
  as_fn_error "X Development libraries not found" "$LINENO" 5
fi

      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XauDisposeAuth in -lXau" >&5
$as_echo_n "checking for XauDisposeAuth in -lXau... " >&6; }
if test "${ac_cv_lib_Xau_XauDisposeAuth+set}" = set; then :
  $as_echo_n "(cached) " >&6
if test "${ac_cv_lib_Xau_XauDisposeAuth+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lXau  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char XauDisposeAuth ();
int
main ()
{
return XauDisposeAuth ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_Xau_XauDisposeAuth=yes
else
  ac_cv_lib_Xau_XauDisposeAuth=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xau_XauDisposeAuth" >&5
$as_echo "$ac_cv_lib_Xau_XauDisposeAuth" >&6; }
if test "x$ac_cv_lib_Xau_XauDisposeAuth" = x""yes; then :
  XAU_LIBS="-lXau"
fi




if test "$_os" != "WINNT" -a "$_os" != "OS2" -a "$_os" != "Darwin"; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use Xaw" >&5
$as_echo_n "checking whether to use Xaw... " >&6; }
   if test "$enable_Xaw" = "no"; then
       DISABLE_XAW=TRUE
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
       for ac_header in X11/Composite.h
do :
  ac_fn_c_check_header_compile "$LINENO" "X11/Composite.h" "ac_cv_header_X11_Composite_h" "#include <X11/Intrinsic.h>
"
if test "x$ac_cv_header_X11_Composite_h" = x""yes; then :
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
if eval "test \"\${$as_ac_Header+set}\" = set"; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <X11/Intrinsic.h>

#include <$ac_header>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  eval "$as_ac_Header=yes"
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

eval "$as_ac_Header=no"
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
fi
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
if test `eval echo '${'$as_ac_Header'}'` = yes; then
  cat >>confdefs.h <<_ACEOF
#define HAVE_X11_COMPOSITE_H 1
_ACEOF

else
  as_fn_error "Xt include headers not found" "$LINENO" 5
fi

done

   else
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
       for ac_header in X11/Xaw/Label.h
do :
  ac_fn_c_check_header_compile "$LINENO" "X11/Xaw/Label.h" "ac_cv_header_X11_Xaw_Label_h" "#include <X11/Intrinsic.h>
"
if test "x$ac_cv_header_X11_Xaw_Label_h" = x""yes; then :
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
echo "$as_me:$LINENO: checking for $ac_header" >&5
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
if eval "test \"\${$as_ac_Header+set}\" = set"; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <X11/Intrinsic.h>

#include <$ac_header>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  eval "$as_ac_Header=yes"
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

eval "$as_ac_Header=no"
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
fi
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
if test `eval echo '${'$as_ac_Header'}'` = yes; then
  cat >>confdefs.h <<_ACEOF
#define HAVE_X11_XAW_LABEL_H 1
_ACEOF

else
  as_fn_error "Xaw include headers not found" "$LINENO" 5
fi

done

       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lXaw" >&5
$as_echo_n "checking for main in -lXaw... " >&6; }
if test "${ac_cv_lib_Xaw_main+set}" = set; then :
  $as_echo_n "(cached) " >&6
echo $ECHO_N "checking for main in -lXaw... $ECHO_C" >&6
if test "${ac_cv_lib_Xaw_main+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lXaw  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */


int
main ()
{
return main ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_Xaw_main=yes
else
  ac_cv_lib_Xaw_main=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xaw_main" >&5
$as_echo "$ac_cv_lib_Xaw_main" >&6; }
if test "x$ac_cv_lib_Xaw_main" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBXAW 1
_ACEOF

  LIBS="-lXaw $LIBS"

else
  as_fn_error "Xaw library not found or functional" "$LINENO" 5
echo "$as_me: error: Xaw library not found or functional" >&2;}
   { (exit 1); exit 1; }; }
fi

   fi



if test "$ENABLE_FONTCONFIG" = "TRUE" ; then
    ac_fn_c_check_header_mongrel "$LINENO" "fontconfig/fontconfig.h" "ac_cv_header_fontconfig_fontconfig_h" "$ac_includes_default"
if test "x$ac_cv_header_fontconfig_fontconfig_h" = x""yes; then :

else
  as_fn_error "fontconfig/fontconfig.h could not be found. libfontconfig1-dev or fontconfig???-devel missing?" "$LINENO" 5
fi


    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether fontconfig is >= 2.2.0" >&5
$as_echo_n "checking whether fontconfig is >= 2.2.0... " >&6; }
    if test "$cross_compiling" = yes; then :
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error "cannot run test program while cross compiling
See \`config.log' for more details." "$LINENO" 5; }
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$ac_includes_default
#include <fontconfig/fontconfig.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking fontconfig/fontconfig.h presence" >&5
echo $ECHO_N "checking fontconfig/fontconfig.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <fontconfig/fontconfig.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: fontconfig/fontconfig.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: fontconfig/fontconfig.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: fontconfig/fontconfig.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: fontconfig/fontconfig.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: fontconfig/fontconfig.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: fontconfig/fontconfig.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: fontconfig/fontconfig.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: fontconfig/fontconfig.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: fontconfig/fontconfig.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: fontconfig/fontconfig.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: fontconfig/fontconfig.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: fontconfig/fontconfig.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: fontconfig/fontconfig.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: fontconfig/fontconfig.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: fontconfig/fontconfig.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: fontconfig/fontconfig.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for fontconfig/fontconfig.h" >&5
echo $ECHO_N "checking for fontconfig/fontconfig.h... $ECHO_C" >&6
if test "${ac_cv_header_fontconfig_fontconfig_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_fontconfig_fontconfig_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_fontconfig_fontconfig_h" >&5
echo "${ECHO_T}$ac_cv_header_fontconfig_fontconfig_h" >&6

fi
if test $ac_cv_header_fontconfig_fontconfig_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: fontconfig/fontconfig.h could not be found. libfontconfig1-dev or fontconfig???-devel missing?" >&5
echo "$as_me: error: fontconfig/fontconfig.h could not be found. libfontconfig1-dev or fontconfig???-devel missing?" >&2;}
   { (exit 1); exit 1; }; }
fi


    echo "$as_me:$LINENO: checking whether fontconfig is >= 2.2.0" >&5
echo $ECHO_N "checking whether fontconfig is >= 2.2.0... $ECHO_C" >&6
    if test "$cross_compiling" = yes; then
  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
See \`config.log' for more details." >&5
echo "$as_me: error: cannot run test program while cross compiling
See \`config.log' for more details." >&2;}
   { (exit 1); exit 1; }; }
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

#include <fontconfig/fontconfig.h>

}

_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
  as_fn_error "no, fontconfig >= 2.2.0 needed" "$LINENO" 5
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to link to Xrender" >&5
$as_echo_n "checking whether to link to Xrender... " >&6; }
  echo "$as_me: program exited with status $ac_status" >&5
echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

( exit $ac_status )
{ { echo "$as_me:$LINENO: error: no, fontconfig >= 2.2.0 needed" >&5
echo "$as_me: error: no, fontconfig >= 2.2.0 needed" >&2;}
   { (exit 1); exit 1; }; }
fi
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
fi
fi

echo "$as_me:$LINENO: checking whether to link to Xrender" >&5
echo $ECHO_N "checking whether to link to Xrender... $ECHO_C" >&6
if test -n "$enable_xrender_link" -a "$enable_xrender_link" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   XRENDER_LINK=YES
   with_system_xrender_headers=yes
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, dynamically open it" >&5
$as_echo "no, dynamically open it" >&6; }
   XRENDER_LINK=NO
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which Xrender headers to use" >&5
$as_echo_n "checking which Xrender headers to use... " >&6; }
if test -n "$with_system_xrender_headers" -o -n "$with_system_headers" && \
	test "$with_system_xrender_headers" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
   SYSTEM_XRENDER_HEADERS=YES
   ac_fn_c_check_header_mongrel "$LINENO" "X11/extensions/Xrender.h" "ac_cv_header_X11_extensions_Xrender_h" "$ac_includes_default"
if test "x$ac_cv_header_X11_extensions_Xrender_h" = x""yes; then :

else
  as_fn_error "Xrender not found. install X" "$LINENO" 5
fi


else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
echo $ECHO_N "checking X11/extensions/Xrender.h usability... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <X11/extensions/Xrender.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking X11/extensions/Xrender.h presence" >&5
echo $ECHO_N "checking X11/extensions/Xrender.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <X11/extensions/Xrender.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrender.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: X11/extensions/Xrender.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrender.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: X11/extensions/Xrender.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrender.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: X11/extensions/Xrender.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrender.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: X11/extensions/Xrender.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrender.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: X11/extensions/Xrender.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrender.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: X11/extensions/Xrender.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrender.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: X11/extensions/Xrender.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrender.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: X11/extensions/Xrender.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for X11/extensions/Xrender.h" >&5
echo $ECHO_N "checking for X11/extensions/Xrender.h... $ECHO_C" >&6
if test "${ac_cv_header_X11_extensions_Xrender_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_X11_extensions_Xrender_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_X11_extensions_Xrender_h" >&5
echo "${ECHO_T}$ac_cv_header_X11_extensions_Xrender_h" >&6

fi
if test $ac_cv_header_X11_extensions_Xrender_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: Xrender not found. install X" >&5
echo "$as_me: error: Xrender not found. install X" >&2;}
   { (exit 1); exit 1; }; }
fi


else
   echo "$as_me:$LINENO: result: internal" >&5
echo "${ECHO_T}internal" >&6
   SYSTEM_XRENDER_HEADERS=NO
   BUILD_TYPE="$BUILD_TYPE X11_EXTENSIONS"
fi
if test "$XRENDER_LINK" = "YES"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XRenderQueryVersion in -lXrender" >&5
$as_echo_n "checking for XRenderQueryVersion in -lXrender... " >&6; }
if test "${ac_cv_lib_Xrender_XRenderQueryVersion+set}" = set; then :
  $as_echo_n "(cached) " >&6
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lXrender  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char XRenderQueryVersion ();
int
main ()
{
return XRenderQueryVersion ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_Xrender_XRenderQueryVersion=yes
else
  ac_cv_lib_Xrender_XRenderQueryVersion=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xrender_XRenderQueryVersion" >&5
$as_echo "$ac_cv_lib_Xrender_XRenderQueryVersion" >&6; }
if test "x$ac_cv_lib_Xrender_XRenderQueryVersion" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBXRENDER 1
_ACEOF

  LIBS="-lXrender $LIBS"

else
  as_fn_error "libXrender not found or functional" "$LINENO" 5
fi

fi



{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable RandR support" >&5
$as_echo_n "checking whether to enable RandR support... " >&6; }
echo "$as_me:$LINENO: checking whether to enable RandR support" >&5
echo $ECHO_N "checking whether to enable RandR support... $ECHO_C" >&6
if test "$test_randr" = "yes" -a \( "$enable_randr" = "yes" -o "$enable_randr" = "TRUE" \) ; then
   if test -z "$enable_randr_link" -o "$enable_randr_link" = "no"; then
	  XRANDR_DLOPEN="TRUE"
	  { $as_echo "$as_me:${as_lineno-$LINENO}: result: resorting to dlopen libXrandr at runtime" >&5
$as_echo "resorting to dlopen libXrandr at runtime" >&6; }
   else
	  XRANDR_DLOPEN="FALSE"


  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for xrandr >= 1.2" >&5
$as_echo_n "checking for xrandr >= 1.2... " >&6; }

        if $PKG_CONFIG --exists "xrandr >= 1.2" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking XRANDR_CFLAGS" >&5
$as_echo_n "checking XRANDR_CFLAGS... " >&6; }
            XRANDR_CFLAGS=`$PKG_CONFIG --cflags "xrandr >= 1.2"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XRANDR_CFLAGS" >&5
$as_echo "$XRANDR_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking XRANDR_LIBS" >&5
$as_echo_n "checking XRANDR_LIBS... " >&6; }
            XRANDR_LIBS=`$PKG_CONFIG --libs "xrandr >= 1.2"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XRANDR_LIBS" >&5
$as_echo "$XRANDR_LIBS" >&6; }
        else
            XRANDR_CFLAGS=""
            XRANDR_LIBS=""

  fi

      if test "$ENABLE_RANDR" != "TRUE"; then
         ac_fn_c_check_header_mongrel "$LINENO" "X11/extensions/Xrandr.h" "ac_cv_header_X11_extensions_Xrandr_h" "$ac_includes_default"
if test "x$ac_cv_header_X11_extensions_Xrandr_h" = x""yes; then :

else
  as_fn_error "X11/extensions/Xrandr.h could not be found. X11 dev missing?" "$LINENO" 5
fi
echo "$as_me:$LINENO: result: $ac_cv_header_X11_extensions_Xrandr_h" >&5
echo "${ECHO_T}$ac_cv_header_X11_extensions_Xrandr_h" >&6
else
  # Is the header compilable?
echo "$as_me:$LINENO: checking X11/extensions/Xrandr.h usability" >&5
echo $ECHO_N "checking X11/extensions/Xrandr.h usability... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <X11/extensions/Xrandr.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking X11/extensions/Xrandr.h presence" >&5
echo $ECHO_N "checking X11/extensions/Xrandr.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <X11/extensions/Xrandr.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrandr.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: X11/extensions/Xrandr.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrandr.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: X11/extensions/Xrandr.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrandr.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: X11/extensions/Xrandr.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrandr.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: X11/extensions/Xrandr.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrandr.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: X11/extensions/Xrandr.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrandr.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: X11/extensions/Xrandr.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrandr.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: X11/extensions/Xrandr.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xrandr.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: X11/extensions/Xrandr.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for X11/extensions/Xrandr.h" >&5
echo $ECHO_N "checking for X11/extensions/Xrandr.h... $ECHO_C" >&6
if test "${ac_cv_header_X11_extensions_Xrandr_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_X11_extensions_Xrandr_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_X11_extensions_Xrandr_h" >&5
echo "${ECHO_T}$ac_cv_header_X11_extensions_Xrandr_h" >&6

fi
if test $ac_cv_header_X11_extensions_Xrandr_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: X11/extensions/Xrandr.h could not be found. X11 dev missing?" >&5
echo "$as_me: error: X11/extensions/Xrandr.h could not be found. X11 dev missing?" >&2;}
   { (exit 1); exit 1; }; }
fi


         XRANDR_CFLAGS=" "
         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XRRQueryExtension in -lXrandr" >&5
$as_echo_n "checking for XRRQueryExtension in -lXrandr... " >&6; }
if test "${ac_cv_lib_Xrandr_XRRQueryExtension+set}" = set; then :
  $as_echo_n "(cached) " >&6
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lXrandr  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char XRRQueryExtension ();
int
main ()
{
return XRRQueryExtension ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_Xrandr_XRRQueryExtension=yes
else
  ac_cv_lib_Xrandr_XRRQueryExtension=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xrandr_XRRQueryExtension" >&5
$as_echo "$ac_cv_lib_Xrandr_XRRQueryExtension" >&6; }
if test "x$ac_cv_lib_Xrandr_XRRQueryExtension" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBXRANDR 1
_ACEOF

  LIBS="-lXrandr $LIBS"

else
   as_fn_error "libXrandr not found or functional" "$LINENO" 5
echo "$as_me: error: libXrandr not found or functional" >&2;}
   { (exit 1); exit 1; }; }
fi

         XRANDR_LIBS="-lXrandr "
         ENABLE_RANDR="TRUE"
	     { $as_echo "$as_me:${as_lineno-$LINENO}: result: enabling RandR support" >&5
$as_echo "enabling RandR support" >&6; }
      fi
   fi
else
   ENABLE_RANDR=""
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi





{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use neon" >&5
$as_echo_n "checking whether to use neon... " >&6; }
if test "$enable_neon" = "no"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    DISABLE_NEON=TRUE

else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which neon to use" >&5
$as_echo_n "checking which neon to use... " >&6; }
if test -n "$with_system_neon" -o -n "$with_system_libs" && \
	test "$with_system_neon" != "no"; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }

  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for neon >= 0.24.0" >&5
$as_echo_n "checking for neon >= 0.24.0... " >&6; }

        if $PKG_CONFIG --exists "neon >= 0.24.0" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking NEON_CFLAGS" >&5
$as_echo_n "checking NEON_CFLAGS... " >&6; }
            NEON_CFLAGS=`$PKG_CONFIG --cflags "neon >= 0.24.0"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NEON_CFLAGS" >&5
$as_echo "$NEON_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking NEON_LIBS" >&5
$as_echo_n "checking NEON_LIBS... " >&6; }
            NEON_LIBS=`$PKG_CONFIG --libs "neon >= 0.24.0"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NEON_LIBS" >&5
$as_echo "$NEON_LIBS" >&6; }
        else
            NEON_CFLAGS=""
            NEON_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "you need neon >= 0.24.x for system-neon" "$LINENO" 5
echo "$as_me: error: you need neon >= 0.24.x for system-neon" >&2;}
   { (exit 1); exit 1; }; }
  fi

        NEON_VERSION="`$PKG_CONFIG --modversion neon | $SED 's/\.//g'`"
        NEON_CFLAGS="$NEON_CFLAGS -DSYSTEM_NEON -DUSE_DAV_LOCKS=1"
        SYSTEM_NEON=YES
else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    SYSTEM_NEON=NO
    NEON_LIBS=-lneon
    NEON_CFLAGS=

if test "$_os" = "Darwin" && test "$with_system_openssl" != "no"; then
   with_system_openssl=yes
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which libssl to use" >&5
$as_echo_n "checking which libssl to use... " >&6; }
if test -n "$with_system_openssl" -o -n "$with_system_libs" && \
        test "$with_system_openssl" != "no"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
    # Mac OS builds should get out without extra stuff is the Mac porters'
    # wish. And pkg-config is although Xcode ships a .pc for openssl
    if test "$_os" = "Darwin"; then

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for openssl " >&5
$as_echo_n "checking for openssl ... " >&6; }

        if $PKG_CONFIG --exists "openssl " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking OPENSSL_CFLAGS" >&5
$as_echo_n "checking OPENSSL_CFLAGS... " >&6; }
            OPENSSL_CFLAGS=`$PKG_CONFIG --cflags "openssl "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENSSL_CFLAGS" >&5
$as_echo "$OPENSSL_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking OPENSSL_LIBS" >&5
$as_echo_n "checking OPENSSL_LIBS... " >&6; }
            OPENSSL_LIBS=`$PKG_CONFIG --libs "openssl "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENSSL_LIBS" >&5
$as_echo "$OPENSSL_LIBS" >&6; }
        else
            OPENSSL_CFLAGS=""
            OPENSSL_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (openssl ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
echo "$as_me: error: Library requirements (openssl ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." >&2;}
   { (exit 1); exit 1; }; }
  fi

    fi
    SYSTEM_OPENSSL=YES
else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    SYSTEM_OPENSSL=NO
    BUILD_TYPE="$BUILD_TYPE OPENSSL"
fi




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable agg" >&5
$as_echo_n "checking whether to enable agg... " >&6; }
if test "$with_agg" = "no"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
  ENABLE_AGG=YES


        { $as_echo "$as_me:${as_lineno-$LINENO}: checking which AGG to use" >&5
$as_echo_n "checking which AGG to use... " >&6; }
  if test -n "$with_system_agg" -o -n "$with_system_libs" && \
     test "$with_system_agg" != "no"; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }

  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for libagg >= 2.3" >&5
$as_echo_n "checking for libagg >= 2.3... " >&6; }

        if $PKG_CONFIG --exists "libagg >= 2.3" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking AGG_CFLAGS" >&5
$as_echo_n "checking AGG_CFLAGS... " >&6; }
            AGG_CFLAGS=`$PKG_CONFIG --cflags "libagg >= 2.3"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AGG_CFLAGS" >&5
$as_echo "$AGG_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking AGG_LIBS" >&5
$as_echo_n "checking AGG_LIBS... " >&6; }
            AGG_LIBS=`$PKG_CONFIG --libs "libagg >= 2.3"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AGG_LIBS" >&5
$as_echo "$AGG_LIBS" >&6; }
        else
            AGG_CFLAGS=""
            AGG_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (libagg >= 2.3) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
  fi

         { $as_echo "$as_me:${as_lineno-$LINENO}: checking agg version" >&5
$as_echo_n "checking agg version... " >&6; }
         echo "$as_me:$LINENO: checking agg version" >&5
echo $ECHO_N "checking agg version... $ECHO_C" >&6
         # workaround; if AGG_CFLAGS is empty (broken libagg.pc in 2.3), add /usr/include/agg2 anyway
         # (/usr/include gets stripped from pkg-config output)
         if test -z "$AGG_CFLAGS" || test "$AGG_CFLAGS" = " "; then

	 	$PKG_CONFIG --modversion libagg | grep -q 2.4; then
            # 2.4's libagg.pc.in still contains 2.3 :/
            if $EGREP -q "Version 2.4" `echo $AGG_INCDIR`/agg_basics.h; then
               { $as_echo "$as_me:${as_lineno-$LINENO}: result: 2.4" >&5
$as_echo "2.4" >&6; }
               AGG_VERSION=2400
            else
               { $as_echo "$as_me:${as_lineno-$LINENO}: result: 2.3" >&5
$as_echo "2.3" >&6; }
               AGG_VERSION=2300
            fi
            SYSTEM_AGG=YES
	 else
	    as_fn_error "only agg 2.3 and 2.4 are supported" "$LINENO" 5
echo "$as_me: error: only agg 2.3 and 2.4 are supported" >&2;}
   { (exit 1); exit 1; }; }
	 fi
  else
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
         SYSTEM_AGG=NO
         AGG_VERSION=2300
         BUILD_TYPE="$BUILD_TYPE AGG"


fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which redland library to use" >&5
$as_echo_n "checking which redland library to use... " >&6; }
if test -n "$with_system_redland" && \
	test "$with_system_redland" != "no"; then
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
	SYSTEM_REDLAND=YES

  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for redland" >&5
$as_echo_n "checking for redland... " >&6; }

        if $PKG_CONFIG --exists "redland" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking REDLAND_CFLAGS" >&5
$as_echo_n "checking REDLAND_CFLAGS... " >&6; }
            REDLAND_CFLAGS=`$PKG_CONFIG --cflags "redland"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $REDLAND_CFLAGS" >&5
$as_echo "$REDLAND_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking REDLAND_LIBS" >&5
$as_echo_n "checking REDLAND_LIBS... " >&6; }
            REDLAND_LIBS=`$PKG_CONFIG --libs "redland"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $REDLAND_LIBS" >&5
$as_echo "$REDLAND_LIBS" >&6; }
        else
            REDLAND_CFLAGS=""
            REDLAND_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (redland) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
  fi

else
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
	echo "$as_me:$LINENO: result: internal" >&5
echo "${ECHO_T}internal" >&6
	BUILD_TYPE="$BUILD_TYPE REDLAND"
	SYSTEM_REDLAND=NO
fi



{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which libhunspell to use" >&5
$as_echo_n "checking which libhunspell to use... " >&6; }
if test -n "$with_system_hunspell" -o -n "$with_system_libs" && \
	test "$with_system_hunspell" != "no"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
    SYSTEM_HUNSPELL=YES
    ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for hunspell" >&5
$as_echo_n "checking for hunspell... " >&6; }

        if $PKG_CONFIG --exists "hunspell" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking HUNSPELL_CFLAGS" >&5
$as_echo_n "checking HUNSPELL_CFLAGS... " >&6; }
            HUNSPELL_CFLAGS=`$PKG_CONFIG --cflags "hunspell"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HUNSPELL_CFLAGS" >&5
$as_echo "$HUNSPELL_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking HUNSPELL_LIBS" >&5
$as_echo_n "checking HUNSPELL_LIBS... " >&6; }
            HUNSPELL_LIBS=`$PKG_CONFIG --libs "hunspell"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HUNSPELL_LIBS" >&5
$as_echo "$HUNSPELL_LIBS" >&6; }
        else
            HUNSPELL_CFLAGS=""
            HUNSPELL_LIBS=""

  fi

    if test "$HUNSPELL_PC" != "TRUE"; then
      ac_fn_cxx_check_header_mongrel "$LINENO" "hunspell.hxx" "ac_cv_header_hunspell_hxx" "$ac_includes_default"
if test "x$ac_cv_header_hunspell_hxx" = x""yes; then :

else

      ac_fn_cxx_check_header_mongrel "$LINENO" "hunspell/hunspell.hxx" "ac_cv_header_hunspell_hunspell_hxx" "$ac_includes_default"
if test "x$ac_cv_header_hunspell_hunspell_hxx" = x""yes; then :
echo "${ECHO_T}$ac_cv_header_hunspell_hxx" >&6
else
  # Is the header compilable?
echo "$as_me:$LINENO: checking hunspell.hxx usability" >&5
echo $ECHO_N "checking hunspell.hxx usability... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <hunspell.hxx>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking hunspell.hxx presence" >&5
echo $ECHO_N "checking hunspell.hxx presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <hunspell.hxx>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_cxx_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: hunspell.hxx: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: hunspell.hxx: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: hunspell.hxx: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: hunspell.hxx: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: hunspell.hxx: present but cannot be compiled" >&5
echo "$as_me: WARNING: hunspell.hxx: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: hunspell.hxx:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: hunspell.hxx:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: hunspell.hxx: see the Autoconf documentation" >&5
echo "$as_me: WARNING: hunspell.hxx: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: hunspell.hxx:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: hunspell.hxx:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: hunspell.hxx: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: hunspell.hxx: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: hunspell.hxx: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: hunspell.hxx: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for hunspell.hxx" >&5
echo $ECHO_N "checking for hunspell.hxx... $ECHO_C" >&6
if test "${ac_cv_header_hunspell_hxx+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_hunspell_hxx=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_hunspell_hxx" >&5
echo "${ECHO_T}$ac_cv_header_hunspell_hxx" >&6

fi
if test $ac_cv_header_hunspell_hxx = yes; then
  :
else

      if test "${ac_cv_header_hunspell_hunspell_hxx+set}" = set; then
  echo "$as_me:$LINENO: checking for hunspell/hunspell.hxx" >&5
echo $ECHO_N "checking for hunspell/hunspell.hxx... $ECHO_C" >&6
if test "${ac_cv_header_hunspell_hunspell_hxx+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
fi
echo "$as_me:$LINENO: result: $ac_cv_header_hunspell_hunspell_hxx" >&5
echo "${ECHO_T}$ac_cv_header_hunspell_hunspell_hxx" >&6
else
  # Is the header compilable?
echo "$as_me:$LINENO: checking hunspell/hunspell.hxx usability" >&5
echo $ECHO_N "checking hunspell/hunspell.hxx usability... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <hunspell/hunspell.hxx>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking hunspell/hunspell.hxx presence" >&5
echo $ECHO_N "checking hunspell/hunspell.hxx presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <hunspell/hunspell.hxx>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_cxx_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: hunspell/hunspell.hxx: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: hunspell/hunspell.hxx: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: hunspell/hunspell.hxx: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: hunspell/hunspell.hxx: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: hunspell/hunspell.hxx: present but cannot be compiled" >&5
echo "$as_me: WARNING: hunspell/hunspell.hxx: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: hunspell/hunspell.hxx:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: hunspell/hunspell.hxx:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: hunspell/hunspell.hxx: see the Autoconf documentation" >&5
echo "$as_me: WARNING: hunspell/hunspell.hxx: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: hunspell/hunspell.hxx:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: hunspell/hunspell.hxx:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: hunspell/hunspell.hxx: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: hunspell/hunspell.hxx: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: hunspell/hunspell.hxx: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: hunspell/hunspell.hxx: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for hunspell/hunspell.hxx" >&5
echo $ECHO_N "checking for hunspell/hunspell.hxx... $ECHO_C" >&6
if test "${ac_cv_header_hunspell_hunspell_hxx+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_hunspell_hunspell_hxx=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_hunspell_hunspell_hxx" >&5
echo "${ECHO_T}$ac_cv_header_hunspell_hunspell_hxx" >&6

fi
if test $ac_cv_header_hunspell_hunspell_hxx = yes; then
   HUNSPELL_CFLAGS=-I/usr/include/hunspell
else
  as_fn_error "hunspell headers not found." "$LINENO" 5
fi



fi


      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lhunspell" >&5
$as_echo_n "checking for main in -lhunspell... " >&6; }
if test "${ac_cv_lib_hunspell_main+set}" = set; then :
  $as_echo_n "(cached) " >&6
echo $ECHO_N "checking for main in -lhunspell... $ECHO_C" >&6
if test "${ac_cv_lib_hunspell_main+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lhunspell  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */


int
main ()
{
return main ();
  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_link "$LINENO"; then :
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_cxx_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_hunspell_main=yes
else
  ac_cv_lib_hunspell_main=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_hunspell_main" >&5
$as_echo "$ac_cv_lib_hunspell_main" >&6; }
if test "x$ac_cv_lib_hunspell_main" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBHUNSPELL 1
_ACEOF

  LIBS="-lhunspell $LIBS"

else
   as_fn_error "hunspell library not found." "$LINENO" 5
echo "$as_me: error: hunspell library not found." >&2;}
   { (exit 1); exit 1; }; }
fi

      HUNSPELL_LIBS=-lhunspell

ac_compiler_gnu=$ac_cv_c_compiler_gnu

else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    SYSTEM_HUNSPELL=NO
    BUILD_TYPE="$BUILD_TYPE HUNSPELL"
fi




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which altlinuxhyph to use" >&5
$as_echo_n "checking which altlinuxhyph to use... " >&6; }
if test -n "$with_system_altlinuxhyph" -o -n "$with_system_libs" && \
	test "$with_system_altlinuxhyph" != "no"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
    SYSTEM_HYPH=YES
    ac_fn_c_check_header_mongrel "$LINENO" "hyphen.h" "ac_cv_header_hyphen_h" "$ac_includes_default"
if test "x$ac_cv_header_hyphen_h" = x""yes; then :

else
   as_fn_error "altlinuxhyph headers not found." "$LINENO" 5
fi


    ac_fn_c_check_member "$LINENO" "struct _HyphenDict" "cset" "ac_cv_member_struct__HyphenDict_cset" "#include <hyphen.h>
"
if test "x$ac_cv_member_struct__HyphenDict_cset" = x""yes; then :

else
   as_fn_error "no. You are sure you have altlinuyhyph headers?" "$LINENO" 5
fi

    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for hnj_hyphen_hyphenate2 in -lhyphen" >&5
$as_echo_n "checking for hnj_hyphen_hyphenate2 in -lhyphen... " >&6; }
if test "${ac_cv_lib_hyphen_hnj_hyphen_hyphenate2+set}" = set; then :
  $as_echo_n "(cached) " >&6
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking hyphen.h presence" >&5
echo $ECHO_N "checking hyphen.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <hyphen.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: hyphen.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: hyphen.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: hyphen.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: hyphen.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: hyphen.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: hyphen.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: hyphen.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: hyphen.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: hyphen.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: hyphen.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: hyphen.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: hyphen.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: hyphen.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: hyphen.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: hyphen.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: hyphen.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for hyphen.h" >&5
echo $ECHO_N "checking for hyphen.h... $ECHO_C" >&6
if test "${ac_cv_header_hyphen_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_hyphen_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_hyphen_h" >&5
echo "${ECHO_T}$ac_cv_header_hyphen_h" >&6

fi
if test $ac_cv_header_hyphen_h = yes; then
  :
else
   { { echo "$as_me:$LINENO: error: altlinuxhyph headers not found." >&5
echo "$as_me: error: altlinuxhyph headers not found." >&2;}
   { (exit 1); exit 1; }; }
fi


    echo "$as_me:$LINENO: checking for struct _HyphenDict.cset" >&5
echo $ECHO_N "checking for struct _HyphenDict.cset... $ECHO_C" >&6
if test "${ac_cv_member_struct__HyphenDict_cset+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <hyphen.h>

int
main ()
{
static struct _HyphenDict ac_aggr;
if (ac_aggr.cset)
return 0;
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_member_struct__HyphenDict_cset=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <hyphen.h>

int
main ()
{
static struct _HyphenDict ac_aggr;
if (sizeof ac_aggr.cset)
return 0;
  ;
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_member_struct__HyphenDict_cset=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_cv_member_struct__HyphenDict_cset=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
fi
echo "$as_me:$LINENO: result: $ac_cv_member_struct__HyphenDict_cset" >&5
echo "${ECHO_T}$ac_cv_member_struct__HyphenDict_cset" >&6
if test $ac_cv_member_struct__HyphenDict_cset = yes; then
  :
else
   { { echo "$as_me:$LINENO: error: no. You are sure you have altlinuyhyph headers?" >&5
echo "$as_me: error: no. You are sure you have altlinuyhyph headers?" >&2;}
   { (exit 1); exit 1; }; }
fi

    echo "$as_me:$LINENO: checking for hnj_hyphen_hyphenate2 in -lhyphen" >&5
echo $ECHO_N "checking for hnj_hyphen_hyphenate2 in -lhyphen... $ECHO_C" >&6
if test "${ac_cv_lib_hyphen_hnj_hyphen_hyphenate2+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lhyphen  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char hnj_hyphen_hyphenate2 ();
int
main ()
{
return hnj_hyphen_hyphenate2 ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_hyphen_hnj_hyphen_hyphenate2=yes
else
  ac_cv_lib_hyphen_hnj_hyphen_hyphenate2=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_hyphen_hnj_hyphen_hyphenate2" >&5
$as_echo "$ac_cv_lib_hyphen_hnj_hyphen_hyphenate2" >&6; }
if test "x$ac_cv_lib_hyphen_hnj_hyphen_hyphenate2" = x""yes; then :
  HYPHEN_LIB=-lhyphen
else
   as_fn_error "altlinuxhyph library not found or too old." "$LINENO" 5
echo "$as_me: error: altlinuxhyph library not found or too old." >&2;}
   { (exit 1); exit 1; }; }
fi

    if test -z "$HYPHEN_LIB"; then
       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for hnj_hyphen_hyphenate2 in -lhyph" >&5
$as_echo_n "checking for hnj_hyphen_hyphenate2 in -lhyph... " >&6; }
if test "${ac_cv_lib_hyph_hnj_hyphen_hyphenate2+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lhyph  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char hnj_hyphen_hyphenate2 ();
int
main ()
{
return hnj_hyphen_hyphenate2 ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_hyph_hnj_hyphen_hyphenate2=yes
else
  ac_cv_lib_hyph_hnj_hyphen_hyphenate2=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_hyph_hnj_hyphen_hyphenate2" >&5
$as_echo "$ac_cv_lib_hyph_hnj_hyphen_hyphenate2" >&6; }
if test "x$ac_cv_lib_hyph_hnj_hyphen_hyphenate2" = x""yes; then :
  HYPHEN_LIB=-lhyph
else
   as_fn_error "altlinuxhyph library not found or too old." "$LINENO" 5
echo "$as_me: error: altlinuxhyph library not found or too old." >&2;}
   { (exit 1); exit 1; }; }
fi

    fi
    if test -z "$HYPHEN_LIB"; then
       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for hnj_hyphen_hyphenate2 in -lhnj" >&5
$as_echo_n "checking for hnj_hyphen_hyphenate2 in -lhnj... " >&6; }
if test "${ac_cv_lib_hnj_hnj_hyphen_hyphenate2+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lhnj  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char hnj_hyphen_hyphenate2 ();
int
main ()
{
return hnj_hyphen_hyphenate2 ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_hnj_hnj_hyphen_hyphenate2=yes
else
  ac_cv_lib_hnj_hnj_hyphen_hyphenate2=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_hnj_hnj_hyphen_hyphenate2" >&5
$as_echo "$ac_cv_lib_hnj_hnj_hyphen_hyphenate2" >&6; }
if test "x$ac_cv_lib_hnj_hnj_hyphen_hyphenate2" = x""yes; then :
  HYPHEN_LIB=-lhnj
else
   as_fn_error "altlinuxhyph library not found or too old." "$LINENO" 5
fi

    fi
else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    echo "$as_me:$LINENO: result: internal" >&5
echo "${ECHO_T}internal" >&6
    SYSTEM_HYPH=NO
    BUILD_TYPE="$BUILD_TYPE HYPHEN"
fi



{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which mythes to use" >&5
$as_echo_n "checking which mythes to use... " >&6; }
if test -n "$with_system_mythes" && test "$with_system_mythes" != "no"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
    SYSTEM_MYTHES=YES
    ac_fn_c_check_header_mongrel "$LINENO" "mythes.hxx" "ac_cv_header_mythes_hxx" "$ac_includes_default"
if test "x$ac_cv_header_mythes_hxx" = x""yes; then :

else
   as_fn_error "mythes.hxx headers not found." "$LINENO" 5
fi


    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lmythes" >&5
$as_echo_n "checking for main in -lmythes... " >&6; }
if test "${ac_cv_lib_mythes_main+set}" = set; then :
  $as_echo_n "(cached) " >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <mythes.hxx>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking mythes.hxx presence" >&5
echo $ECHO_N "checking mythes.hxx presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <mythes.hxx>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: mythes.hxx: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: mythes.hxx: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: mythes.hxx: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: mythes.hxx: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: mythes.hxx: present but cannot be compiled" >&5
echo "$as_me: WARNING: mythes.hxx: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: mythes.hxx:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: mythes.hxx:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: mythes.hxx: see the Autoconf documentation" >&5
echo "$as_me: WARNING: mythes.hxx: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: mythes.hxx:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: mythes.hxx:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: mythes.hxx: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: mythes.hxx: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: mythes.hxx: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: mythes.hxx: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for mythes.hxx" >&5
echo $ECHO_N "checking for mythes.hxx... $ECHO_C" >&6
if test "${ac_cv_header_mythes_hxx+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_mythes_hxx=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_mythes_hxx" >&5
echo "${ECHO_T}$ac_cv_header_mythes_hxx" >&6

fi
if test $ac_cv_header_mythes_hxx = yes; then
  :
else
   { { echo "$as_me:$LINENO: error: mythes.hxx headers not found." >&5
echo "$as_me: error: mythes.hxx headers not found." >&2;}
   { (exit 1); exit 1; }; }
fi



echo "$as_me:$LINENO: checking for main in -lmythes" >&5
echo $ECHO_N "checking for main in -lmythes... $ECHO_C" >&6
if test "${ac_cv_lib_mythes_main+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lmythes  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */


int
main ()
{
return main ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_mythes_main=yes
else
  ac_cv_lib_mythes_main=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mythes_main" >&5
$as_echo "$ac_cv_lib_mythes_main" >&6; }
if test "x$ac_cv_lib_mythes_main" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBMYTHES 1
_ACEOF

  LIBS="-lmythes $LIBS"

else
   as_fn_error "mythes library not found." "$LINENO" 5
fi

else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    echo "$as_me:$LINENO: result: internal" >&5
echo "${ECHO_T}internal" >&6
    SYSTEM_MYTHES=NO
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which lpsolve to use" >&5
$as_echo_n "checking which lpsolve to use... " >&6; }
if test -n "$with_system_lpsolve" -o -n "$with_system_libs" && \
	test "$with_system_lpsolve" != "no"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
    SYSTEM_LPSOLVE=YES
    ac_fn_c_check_header_mongrel "$LINENO" "lpsolve/lp_lib.h" "ac_cv_header_lpsolve_lp_lib_h" "$ac_includes_default"
if test "x$ac_cv_header_lpsolve_lp_lib_h" = x""yes; then :

else
   as_fn_error "lpsolve headers not found." "$LINENO" 5
fi


    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for make_lp in -llpsolve55" >&5
$as_echo_n "checking for make_lp in -llpsolve55... " >&6; }
if test "${ac_cv_lib_lpsolve55_make_lp+set}" = set; then :
  $as_echo_n "(cached) " >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <lpsolve/lp_lib.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking lpsolve/lp_lib.h presence" >&5
echo $ECHO_N "checking lpsolve/lp_lib.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <lpsolve/lp_lib.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: lpsolve/lp_lib.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: lpsolve/lp_lib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: lpsolve/lp_lib.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: lpsolve/lp_lib.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: lpsolve/lp_lib.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: lpsolve/lp_lib.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: lpsolve/lp_lib.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: lpsolve/lp_lib.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: lpsolve/lp_lib.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: lpsolve/lp_lib.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: lpsolve/lp_lib.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: lpsolve/lp_lib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: lpsolve/lp_lib.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: lpsolve/lp_lib.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: lpsolve/lp_lib.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: lpsolve/lp_lib.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for lpsolve/lp_lib.h" >&5
echo $ECHO_N "checking for lpsolve/lp_lib.h... $ECHO_C" >&6
if test "${ac_cv_header_lpsolve_lp_lib_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_lpsolve_lp_lib_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_lpsolve_lp_lib_h" >&5
echo "${ECHO_T}$ac_cv_header_lpsolve_lp_lib_h" >&6

fi
if test $ac_cv_header_lpsolve_lp_lib_h = yes; then
  :
else
   { { echo "$as_me:$LINENO: error: lpsolve headers not found." >&5
echo "$as_me: error: lpsolve headers not found." >&2;}
   { (exit 1); exit 1; }; }
fi



echo "$as_me:$LINENO: checking for make_lp in -llpsolve55" >&5
echo $ECHO_N "checking for make_lp in -llpsolve55... $ECHO_C" >&6
if test "${ac_cv_lib_lpsolve55_make_lp+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-llpsolve55  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char make_lp ();
int
main ()
{
return make_lp ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_lpsolve55_make_lp=yes
else
  ac_cv_lib_lpsolve55_make_lp=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_lpsolve55_make_lp" >&5
$as_echo "$ac_cv_lib_lpsolve55_make_lp" >&6; }
if test "x$ac_cv_lib_lpsolve55_make_lp" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBLPSOLVE55 1
_ACEOF

  LIBS="-llpsolve55 $LIBS"

else
   as_fn_error "lpsolve library not found or too old." "$LINENO" 5
fi

else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    echo "$as_me:$LINENO: result: internal" >&5
echo "${ECHO_T}internal" >&6
    SYSTEM_LPSOLVE=NO
    BUILD_TYPE="$BUILD_TYPE LPSOLVE"
fi


if test "$_os" = "Linux"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether libc is >= 2.1.1" >&5
$as_echo_n "checking whether libc is >= 2.1.1... " >&6; }
   exec 6>/dev/null # no output
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gnu_get_libc_version in -lc" >&5
$as_echo_n "checking for gnu_get_libc_version in -lc... " >&6; }
if test "${ac_cv_lib_c_gnu_get_libc_version+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lc  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char gnu_get_libc_version ();
int
main ()
{
return gnu_get_libc_version ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_c_gnu_get_libc_version=yes
else
  ac_cv_lib_c_gnu_get_libc_version=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_gnu_get_libc_version" >&5
$as_echo "$ac_cv_lib_c_gnu_get_libc_version" >&6; }
if test "x$ac_cv_lib_c_gnu_get_libc_version" = x""yes; then :
  HAVE_LIBC=yes; export HAVE_LIBC
fi

   exec 6>&1 # output on again
   if test "$HAVE_LIBC"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   else
      as_fn_error "no, upgrade libc" "$LINENO" 5
echo "$as_me: error: no, upgrade libc" >&2;}
   { (exit 1); exit 1; }; }
   fi
fi

if test \( "$_os" = "WINNT" \) ; then
	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for PSDK files" >&5
$as_echo_n "checking for PSDK files... " >&6; }
	if test -z "$with_psdk_home"; then
		# This first line will detect a February 2003 Microsoft Platform SDK
		PSDK_HOME=`./oowintool --psdk-home`

        PSDK_HOME=`echo $PSDK_HOME | $SED 's/\/$//'`
    # Problem with current PSDK (iz 49865)
    if test -f "$PSDK_HOME/Lib/libcp.lib"; then
        as_fn_error "

Some modules do not build correctly with MS Platform SDK - April 2005
Edition if the library ($PSDK_HOME/Lib/libcp.lib) is found.
Remove/rename/backup that file and restart configure. Details about this
problem can be found in issue 49856." "$LINENO" 5
echo "$as_me: error:

Some modules do not build correctly with MS Platform SDK - April 2005
Edition if the library ($PSDK_HOME/Lib/libcp.lib) is found.
Remove/rename/backup that file and restart configure. Details about this
problem can be found in issue 49856." >&2;}
   { (exit 1); exit 1; }; }
    fi
# WIndows SDK has different headers
	if test \( -f "$PSDK_HOME/Include/adoint.h" \) \

		HAVE_PSDK_LIB="no"
	fi
    if test "$HAVE_PSDK_H" = "no" -o "$HAVE_PSDK_LIB" = "no"; then
        as_fn_error "Some (all?) PSDK files not found, please check if all needed Platform SDKs
are installed or use --with-psdk-home ." "$LINENO" 5
echo "$as_me: error: Some (all?) PSDK files not found, please check if all needed Platform SDKs
are installed or use --with-psdk-home ." >&2;}
   { (exit 1); exit 1; }; }
    fi
    if test ! -x "$PSDK_HOME/bin/msiinfo.exe" \
         -o ! -x "$PSDK_HOME/bin/msidb.exe" \
         -o ! -x "$PSDK_HOME/bin/uuidgen.exe" \
         -o ! -x "$PSDK_HOME/bin/msitran.exe" ; then
        as_fn_error "Some (all) files of the Windows Installer SDK are missing, please install." "$LINENO" 5
    fi
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: SDK files found ...)" >&5
$as_echo "SDK files found ...)" >&6; }
    echo "$as_me:$LINENO: result: SDK files found ...)" >&5
echo "${ECHO_T}SDK files found ...)" >&6
    if echo $PSDK_HOME | grep "v6.1" >/dev/null 2>/dev/null; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: Found Windows SDK 6.1 ($PSDK_HOME)" >&5
$as_echo "Found Windows SDK 6.1 ($PSDK_HOME)" >&6; }
        WINDOWS_VISTA_PSDK=TRUE
    elif echo $PSDK_HOME | grep "v6.0" >/dev/null 2>/dev/null; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: Found Windows SDK 6.0 ($PSDK_HOME)" >&5
$as_echo "Found Windows SDK 6.0 ($PSDK_HOME)" >&6; }
        WINDOWS_VISTA_PSDK=TRUE
    else
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: Found Legacy Windows Platform SDK ($PSDK_HOME)" >&5
$as_echo "Found Legacy Windows Platform SDK ($PSDK_HOME)" >&6; }
    fi
fi



if test \( "$_os" = "WINNT" \) ; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DirectX SDK files" >&5
$as_echo_n "checking for DirectX SDK files... " >&6; }
    if test -z "$with_directx_home"; then
                if test -n "$DXSDK_DIR"; then
            DIRECTXSDK_HOME=`cygpath -d "$DXSDK_DIR"`

    fi
    if test -n "$ENABLE_DIRECTX"; then
	    if test "$HAVE_DIRECTXSDK_H" = "yes" -a "$HAVE_DIRECTXSDK_LIB" = "yes"; then
		    { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
$as_echo "found" >&6; }
	    else
		    as_fn_error "DirectX SDK files not found, please use --with-directx-home or -disable-directx." "$LINENO" 5
echo "$as_me: error: DirectX SDK files not found, please use --with-directx-home or -disable-directx." >&2;}
   { (exit 1); exit 1; }; }
	    fi
    else
		DIRECTXSDK_HOME=""
		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
$as_echo "disabled" >&6; }
    fi
fi



NSIS_PATH=""
if test "$_os" = "WINNT" ; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NSIS" >&5
$as_echo_n "checking for NSIS... " >&6; }
    # Extract the first word of "nsis.exe", so it can be a program name with args.
set dummy nsis.exe; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_NSIS_PATH+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $NSIS_PATH in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_NSIS_PATH="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
NSIS_PATH=$ac_cv_path_NSIS_PATH

if test -n "$NSIS_PATH"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NSIS_PATH" >&5
$as_echo "$NSIS_PATH" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    if test -n "$NSIS_PATH"; then
        NSIS_PATH=`dirname "$NSIS_PATH"`

        NSIS_PATH="$nsistest"
    fi
    if test -z "$NSIS_PATH"; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: NSIS not found, no self contained installer will be build." >&5
$as_echo "$as_me: WARNING: NSIS not found, no self contained installer will be build." >&2;}
        echo "NSIS not found, no self contained installer will be build." >> warn
    else
        NSIS_PATH=`cygpath -d "$NSIS_PATH"`
        NSIS_PATH=`cygpath -u "$NSIS_PATH"`
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: found ($NSIS_PATH)" >&5
$as_echo "found ($NSIS_PATH)" >&6; }
    fi
fi


# Extract the first word of "bison", so it can be a program name with args.
set dummy bison; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_BISON+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $BISON in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_BISON="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
BISON=$ac_cv_path_BISON

if test -n "$BISON"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BISON" >&5
$as_echo "$BISON" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


if test -z "$BISON"; then
   as_fn_error "no bison found in \$PATH, install bison" "$LINENO" 5
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking the bison version" >&5
$as_echo_n "checking the bison version... " >&6; }
   echo "$as_me:$LINENO: checking the bison version" >&5
echo $ECHO_N "checking the bison version... $ECHO_C" >&6
   _bison_version=`$BISON --version | grep GNU | $SED -e 's@^[^0-9]*@@' -e 's@ .*@@' -e 's@,.*@@'`;
    _bison_longver=`echo $_bison_version | $AWK -F. '{ print \$1*1000+\$2}'`
    # Accept newer than 1.875 or older(equal) than 1.75
    if test "$_bison_longver" -ge 1875 -o "$_bison_longver" -le 1075; then
       if test "$_bison_version" = "1.875" ; then
          { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: suspect ($BISON $_bison_version)" >&5
$as_echo "$as_me: WARNING: suspect ($BISON $_bison_version)" >&2;}
          echo "Suspect ($BISON $_bison_version) suggest upgrade" >> warn
       else
          { $as_echo "$as_me:${as_lineno-$LINENO}: result: checked ($BISON $_bison_version)" >&5
$as_echo "checked ($BISON $_bison_version)" >&6; }
       fi
    else
       as_fn_error "failed ($BISON $_bison_version need 1.875+ (or 1.75 and older))" "$LINENO" 5
echo "$as_me: error: failed ($BISON $_bison_version need 1.875+ (or 1.75 and older))" >&2;}
   { (exit 1); exit 1; }; }
    fi
fi
# Extract the first word of "flex", so it can be a program name with args.
set dummy flex; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_FLEX+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $FLEX in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_FLEX="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
FLEX=$ac_cv_path_FLEX

if test -n "$FLEX"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FLEX" >&5
$as_echo "$FLEX" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


if test -z "$FLEX"; then
   as_fn_error "no flex found in \$PATH, install flex" "$LINENO" 5
echo "$as_me: error: no flex found in \$PATH, install flex" >&2;}
   { (exit 1); exit 1; }; }
fi
# Extract the first word of "patch", so it can be a program name with args.
set dummy patch; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PATCH+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PATCH in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
PATCH=$ac_cv_path_PATCH

if test -n "$PATCH"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
$as_echo "$PATCH" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


if test -z "$PATCH"; then
   as_fn_error "\\"patch\\" not found in \$PATH, install the development tool named\\"patch\"\" "$LINENO" 5
echo "$as_me: error: \\"patch\\" not found in \$PATH, install the development tool named\\"patch\"\" >&2;}
   { (exit 1); exit 1; }; }
fi

if test "$_os" = "SunOS" -o "$_os" = "FreeBSD" -o "$_os" = "Darwin"; then

      if test -x "$with_gnu_patch"; then
	GNUPATCH=$with_gnu_patch
      else
        as_fn_error "--with-gnu-patch did not point to an executable" "$LINENO" 5
      fi
   fi

   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $GNUPATCH is GNU patch" >&5
$as_echo_n "checking whether $GNUPATCH is GNU patch... " >&6; }
   echo "$as_me:$LINENO: checking whether $GNUPATCH is GNU patch" >&5
echo $ECHO_N "checking whether $GNUPATCH is GNU patch... $ECHO_C" >&6
   if $GNUPATCH --version | grep "Free Software Foundation" >/dev/null 2>/dev/null; then
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   else
  	as_fn_error "no, GNU patch needed. install or specify with --with-gnu-patch=/path/to/it" "$LINENO" 5
echo "$as_me: error: no, GNU patch needed. install or specify with --with-gnu-patch=/path/to/it" >&2;}
   { (exit 1); exit 1; }; }
   fi



do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_GNUCP+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $GNUCP in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_GNUCP="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
GNUCP=$ac_cv_path_GNUCP

if test -n "$GNUCP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNUCP" >&5
$as_echo "$GNUCP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$GNUCP" && break
done

    if test -z $GNUCP; then
      as_fn_error "Neither gnucp nor cp found. Install GNU cp and/or specify --with-gnu-cp=/path/to/it" "$LINENO" 5
echo "$as_me: error: Neither gnucp nor cp found. Install GNU cp and/or specify --with-gnu-cp=/path/to/it" >&2;}
   { (exit 1); exit 1; }; }
    fi
  else
    if test -x "$with_gnu_cp"; then
      GNUCP=$with_gnu_cp
    else
      as_fn_error "--with-gnu-cp did not point to an executable" "$LINENO" 5
    fi
  fi

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $GNUCP is GNU cp" >&5
$as_echo_n "checking whether $GNUCP is GNU cp... " >&6; }
  echo "$as_me:$LINENO: checking whether $GNUCP is GNU cp" >&5
echo $ECHO_N "checking whether $GNUCP is GNU cp... $ECHO_C" >&6
  if $GNUCP --version 2>/dev/null | grep "Free Software Foundation" >/dev/null 2>/dev/null; then
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
  else
   if $GNUCP --version 2>/dev/null | grep "GNU fileutils" >/dev/null 2>/dev/null; then
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   else
      if test "$_os" = "Darwin"; then
         GNUCP=''
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no gnucp found - using the system's cp command" >&5
$as_echo "no gnucp found - using the system's cp command" >&6; }
      else
         as_fn_error "no, GNU cp needed. install or specify with --with-gnu-cp=/path/to/it" "$LINENO" 5
echo "$as_me: error: no, GNU cp needed. install or specify with --with-gnu-cp=/path/to/it" >&2;}
   { (exit 1); exit 1; }; }
      fi
   fi
  fi

    CYGWIN_PATH=""
    # Extract the first word of "bash", so it can be a program name with args.
set dummy bash; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_CYGWIN_PATH+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $CYGWIN_PATH in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_CYGWIN_PATH="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
CYGWIN_PATH=$ac_cv_path_CYGWIN_PATH

if test -n "$CYGWIN_PATH"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_PATH" >&5
$as_echo "$CYGWIN_PATH" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    CYGWIN_PATH=`dirname "$CYGWIN_PATH"`
fi



if test "$_os" = "WINNT" -a "$WITH_MINGWIN" != "yes"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking ml.exe assembler path" >&5
$as_echo_n "checking ml.exe assembler path... " >&6; }
  if test -n "$with_asm_home"; then
    with_asm_home=`cygpath -u "$with_asm_home"`
  fi
  if test ! -x "$with_asm_home/ml.exe"; then
    # Extract the first word of "ml.exe", so it can be a program name with args.
set dummy ml.exe; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_ML_EXE+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $ML_EXE in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_ML_EXE="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
ML_EXE=$ac_cv_path_ML_EXE

if test -n "$ML_EXE"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ML_EXE" >&5
$as_echo "$ML_EXE" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    if test -z "$ML_EXE"; then
      if test -x "$with_cl_home/bin/ml.exe"; then
        with_asm_home=$with_cl_home/bin
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: found ($with_asm_home)" >&5
$as_echo "found ($with_asm_home)" >&6; }
      else
        as_fn_error "Configure did not find ml.exe assembler." "$LINENO" 5
echo "$as_me: error: Configure did not find ml.exe assembler." >&2;}
   { (exit 1); exit 1; }; }
      fi
    else
       with_asm_home="ASM_IN_PATH"

fi
ASM_HOME="$with_asm_home"
if test -n "$ASM_HOME"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ASM_HOME" >&5
$as_echo "$ASM_HOME" >&6; }
fi



else
    # Extract the first word of "zip", so it can be a program name with args.
set dummy zip; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_ZIP+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $ZIP in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
ZIP=$ac_cv_path_ZIP

if test -n "$ZIP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
$as_echo "$ZIP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    # Extract the first word of "unzip", so it can be a program name with args.
set dummy unzip; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_UNZIP+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $UNZIP in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
UNZIP=$ac_cv_path_UNZIP

if test -n "$UNZIP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
$as_echo "$UNZIP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    ZIP_HOME=`dirname "$ZIP"`
fi
if test -z "$ZIP" -o -z "$UNZIP"; then
    as_fn_error "Zip/Unzip are required to build, please install or use --with-zip-home" "$LINENO" 5
echo "$as_me: error: Zip/Unzip are required to build, please install or use --with-zip-home" >&2;}
   { (exit 1); exit 1; }; }
fi

if test "$_os" = "WINNT"; then
    if test -n "`$ZIP -h | grep -i WinNT`" ; then
as_fn_error "$ZIP found in the path is not the required cygwin version of Info-ZIPs zip.exe." "$LINENO" 5
echo "$as_me: error: $ZIP found in the path is not the required cygwin version of Info-ZIPs zip.exe." >&2;}
   { (exit 1); exit 1; }; }
    fi
fi


if test "$_os" = "WINNT"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for unicows.dll" >&5
$as_echo_n "checking for unicows.dll... " >&6; }
   if test -x ./external/unicows/unicows.dll; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
$as_echo "found" >&6; }
   else
      as_fn_error "The Microsoft Layer for Unicode (unicows.dll) is missing in external/unicows/.
Get it from the Microsoft site and put it into external/unicows.
(Note: Microsoft seems to enjoy changing the exact location of this file. You
may have to search Microsoft's website.) Last time it was seen at:
<http://download.microsoft.com/download/b/7/5/b75eace3-00e2-4aa0-9a6f-0b6882c71642/unicows.exe>." "$LINENO" 5
echo "$as_me: error: The Microsoft Layer for Unicode (unicows.dll) is missing in external/unicows/.
Get it from the Microsoft site and put it into external/unicows.
(Note: Microsoft seems to enjoy changing the exact location of this file. You
may have to search Microsoft's website.) Last time it was seen at:
<http://download.microsoft.com/download/b/7/5/b75eace3-00e2-4aa0-9a6f-0b6882c71642/unicows.exe>." >&2;}
   { (exit 1); exit 1; }; }
   fi
fi

if test "$_os" = "WINNT"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dbghelp.dll" >&5
$as_echo_n "checking for dbghelp.dll... " >&6; }
   if test -x ./external/dbghelp/dbghelp.dll; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
$as_echo "found" >&6; }
   else
      as_fn_error "dbghelp.dll is missing in external/dbghelp/.
Get it from the Microsoft site and put it into external/dbghelp.
(Note: Microsoft seems to enjoy changing the exact location of this file. You
may have to search Microsoft's website.) Last time it was seen at:
<http://www.microsoft.com/downloads/release.asp?releaseid=30682>." "$LINENO" 5
echo "$as_me: error: dbghelp.dll is missing in external/dbghelp/.
Get it from the Microsoft site and put it into external/dbghelp.
(Note: Microsoft seems to enjoy changing the exact location of this file. You
may have to search Microsoft's website.) Last time it was seen at:
<http://www.microsoft.com/downloads/release.asp?releaseid=30682>." >&2;}
   { (exit 1); exit 1; }; }
   fi
fi


       if ./oowintool --msvc-copy-dlls ./external/msvcp ; then
          :
       else
          as_fn_error "oowintool failed to copy CRT" "$LINENO" 5
echo "$as_me: error: oowintool failed to copy CRT" >&2;}
   { (exit 1); exit 1; }; }
       fi
fi

if test "$_os" = "WINNT"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gdiplus.dll" >&5
$as_echo_n "checking for gdiplus.dll... " >&6; }
   if test -x ./external/gdiplus/gdiplus.dll; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
$as_echo "found" >&6; }
   else
      as_fn_error "gdiplus.dll is missing in external/gdiplus/.
Get it from the Microsoft site and put it into external/gdiplus.
You may have to search Microsoft's website. Last time it was seen at:
<http://www.microsoft.com/downloads/details.aspx?familyid=6A63AB9C-DF12-4D41-933C-BE590FEAA05A&displaylang=en>." "$LINENO" 5
echo "$as_me: error: gdiplus.dll is missing in external/gdiplus/.
Get it from the Microsoft site and put it into external/gdiplus.
You may have to search Microsoft's website. Last time it was seen at:
<http://www.microsoft.com/downloads/details.aspx?familyid=6A63AB9C-DF12-4D41-933C-BE590FEAA05A&displaylang=en>." >&2;}
   { (exit 1); exit 1; }; }
   fi
fi



if test "$_os" = "WINNT"; then
   if test  "$WITH_MINGWIN" = "yes" || test "$COMEX" -ge "10"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for instmsia.exe/instmsiw.exe" >&5
$as_echo_n "checking for instmsia.exe/instmsiw.exe... " >&6; }
   if test -x ./external/msi/instmsia.exe -a -x ./external/msi/instmsiw.exe; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
$as_echo "found" >&6; }
   else
      MSIAPATH=`/bin/find "$COMPATH/.." -iname instmsia.exe | head -n 1`
      MSIWPATH=`/bin/find "$COMPATH/.." -iname instmsiw.exe | head -n 1`

         cp "$MSIWPATH" ./external/msi/ && chmod +x ./external/msi/instmsiw.exe && MSIWCOPY="OK"
      fi
      if test -z "$MSIACOPY" -o -z "$MSIWCOPY"; then
         as_fn_error "instmsia.exe and/or instmsiw.exe are/is missing in the default location.
These programs are part of the Visual Studio installation and should be found in a
directory similar to:
\"c:\\Program Files\\Microsoft Visual Studio .NET 2003\\Common7\\Tools\\Deployment\\MsiRedist\\\"
As the automatic detection fails please copy the files to external/msi/." "$LINENO" 5
      else
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: found and copied" >&5
$as_echo "found and copied" >&6; }
      fi
   fi
fi
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which VCLplugs shall be built" >&5
$as_echo_n "checking which VCLplugs shall be built... " >&6; }
   fi
fi
fi

echo "$as_me:$LINENO: checking which VCLplugs shall be built" >&5
echo $ECHO_N "checking which VCLplugs shall be built... $ECHO_C" >&6
ENABLE_GTK=""
if test "x$enable_gtk" = "xyes"; then
    ENABLE_GTK="TRUE"



if test -z "$R"; then
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
$as_echo "none" >&6; }
else
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $R" >&5
$as_echo "$R" >&6; }
fi


ENABLE_GCONF=""
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable GConf support" >&5
$as_echo_n "checking whether to enable GConf support... " >&6; }
if test "$_os" != "WINNT" -a "$_os" != "Darwin" -a "$_os" != "OS2" -a "$enable_gconf" = "yes"; then
    ENABLE_GCONF="TRUE"
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }

  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gconf-2.0 " >&5
$as_echo_n "checking for gconf-2.0 ... " >&6; }

        if $PKG_CONFIG --exists "gconf-2.0 " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking GCONF_CFLAGS" >&5
$as_echo_n "checking GCONF_CFLAGS... " >&6; }
            GCONF_CFLAGS=`$PKG_CONFIG --cflags "gconf-2.0 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GCONF_CFLAGS" >&5
$as_echo "$GCONF_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking GCONF_LIBS" >&5
$as_echo_n "checking GCONF_LIBS... " >&6; }
            GCONF_LIBS=`$PKG_CONFIG --libs "gconf-2.0 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GCONF_LIBS" >&5
$as_echo "$GCONF_LIBS" >&6; }
        else
            GCONF_CFLAGS=""
            GCONF_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (gconf-2.0 ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
  fi

else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    echo "$as_me:$LINENO: result: no" >&5
echo "${ECHO_T}no" >&6
fi



ENABLE_GNOMEVFS=""
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable GNOME VFS support" >&5
$as_echo_n "checking whether to enable GNOME VFS support... " >&6; }
if test "$_os" != "WINNT" -a "$_os" != "Darwin" -a "$enable_gnome_vfs" = "yes"; then
    ENABLE_GNOMEVFS="TRUE"
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }

  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gnome-vfs-2.0 >= 2.6.0 " >&5
$as_echo_n "checking for gnome-vfs-2.0 >= 2.6.0 ... " >&6; }

        if $PKG_CONFIG --exists "gnome-vfs-2.0 >= 2.6.0 " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking GNOMEVFS_CFLAGS" >&5
$as_echo_n "checking GNOMEVFS_CFLAGS... " >&6; }
            GNOMEVFS_CFLAGS=`$PKG_CONFIG --cflags "gnome-vfs-2.0 >= 2.6.0 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNOMEVFS_CFLAGS" >&5
$as_echo "$GNOMEVFS_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking GNOMEVFS_LIBS" >&5
$as_echo_n "checking GNOMEVFS_LIBS... " >&6; }
            GNOMEVFS_LIBS=`$PKG_CONFIG --libs "gnome-vfs-2.0 >= 2.6.0 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNOMEVFS_LIBS" >&5
$as_echo "$GNOMEVFS_LIBS" >&6; }
        else
            GNOMEVFS_CFLAGS=""
            GNOMEVFS_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (gnome-vfs-2.0 >= 2.6.0 ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
echo "$as_me: error: Library requirements (gnome-vfs-2.0 >= 2.6.0 ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." >&2;}
   { (exit 1); exit 1; }; }
  fi

    if test "$ENABLE_GCONF" != "TRUE"; then

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gconf-2.0 " >&5
$as_echo_n "checking for gconf-2.0 ... " >&6; }

        if $PKG_CONFIG --exists "gconf-2.0 " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking GCONF_CFLAGS" >&5
$as_echo_n "checking GCONF_CFLAGS... " >&6; }
            GCONF_CFLAGS=`$PKG_CONFIG --cflags "gconf-2.0 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GCONF_CFLAGS" >&5
$as_echo "$GCONF_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking GCONF_LIBS" >&5
$as_echo_n "checking GCONF_LIBS... " >&6; }
            GCONF_LIBS=`$PKG_CONFIG --libs "gconf-2.0 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GCONF_LIBS" >&5
$as_echo "$GCONF_LIBS" >&6; }
        else
            GCONF_CFLAGS=""
            GCONF_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (gconf-2.0 ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
  fi

    fi
else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    echo "$as_me:$LINENO: result: no" >&5
echo "${ECHO_T}no" >&6
fi



  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gtk+-2.0 >= 2.4 gdk-pixbuf-xlib-2.0 >= 2.2 " >&5
$as_echo_n "checking for gtk+-2.0 >= 2.4 gdk-pixbuf-xlib-2.0 >= 2.2 ... " >&6; }

        if $PKG_CONFIG --exists "gtk+-2.0 >= 2.4 gdk-pixbuf-xlib-2.0 >= 2.2 " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking GTK_CFLAGS" >&5
$as_echo_n "checking GTK_CFLAGS... " >&6; }
            GTK_CFLAGS=`$PKG_CONFIG --cflags "gtk+-2.0 >= 2.4 gdk-pixbuf-xlib-2.0 >= 2.2 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GTK_CFLAGS" >&5
$as_echo "$GTK_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking GTK_LIBS" >&5
$as_echo_n "checking GTK_LIBS... " >&6; }
            GTK_LIBS=`$PKG_CONFIG --libs "gtk+-2.0 >= 2.4 gdk-pixbuf-xlib-2.0 >= 2.2 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GTK_LIBS" >&5
$as_echo "$GTK_LIBS" >&6; }
        else
            GTK_CFLAGS=""
            GTK_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "requirements to build the gtk-plugin not met. Use --disable-gtk or install the missing packages" "$LINENO" 5
echo "$as_me: error: requirements to build the gtk-plugin not met. Use --disable-gtk or install the missing packages" >&2;}
   { (exit 1); exit 1; }; }
  fi

      BUILD_TYPE="$BUILD_TYPE GTK"

         BUILD_TYPE="$BUILD_TYPE SYSTRAY_GTK"
      fi

      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable DBUS support" >&5
$as_echo_n "checking whether to enable DBUS support... " >&6; }
      if test "$_os" != "WINNT" -a "$_os" != "Darwin" -a "$enable_dbus" = "yes"; then
          ENABLE_DBUS="TRUE"
          { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }

  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dbus-glib-1 >= 0.70 " >&5
$as_echo_n "checking for dbus-glib-1 >= 0.70 ... " >&6; }

        if $PKG_CONFIG --exists "dbus-glib-1 >= 0.70 " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking DBUS_CFLAGS" >&5
$as_echo_n "checking DBUS_CFLAGS... " >&6; }
            DBUS_CFLAGS=`$PKG_CONFIG --cflags "dbus-glib-1 >= 0.70 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DBUS_CFLAGS" >&5
$as_echo "$DBUS_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking DBUS_LIBS" >&5
$as_echo_n "checking DBUS_LIBS... " >&6; }
            DBUS_LIBS=`$PKG_CONFIG --libs "dbus-glib-1 >= 0.70 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DBUS_LIBS" >&5
$as_echo "$DBUS_LIBS" >&6; }
        else
            DBUS_CFLAGS=""
            DBUS_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (dbus-glib-1 >= 0.70 ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
  fi

      else
          { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
      fi

      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable GIO support" >&5
$as_echo_n "checking whether to enable GIO support... " >&6; }
      echo "$as_me:$LINENO: checking whether to enable GIO support" >&5
echo $ECHO_N "checking whether to enable GIO support... $ECHO_C" >&6
      if test "$_os" != "WINNT" -a "$_os" != "Darwin" -a "$enable_gio" = "yes"; then
          if test "$ENABLE_GNOMEVFS" = "TRUE" ; then
             as_fn_error "please use --enable-gio only together with --disable-gnome-vfs." "$LINENO" 5
echo "$as_me: error: please use --enable-gio only together with --disable-gnome-vfs." >&2;}
   { (exit 1); exit 1; }; }
          fi
          ENABLE_GIO="TRUE"
          { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }

  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gio-2.0 " >&5
$as_echo_n "checking for gio-2.0 ... " >&6; }

        if $PKG_CONFIG --exists "gio-2.0 " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking GIO_CFLAGS" >&5
$as_echo_n "checking GIO_CFLAGS... " >&6; }
            GIO_CFLAGS=`$PKG_CONFIG --cflags "gio-2.0 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GIO_CFLAGS" >&5
$as_echo "$GIO_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking GIO_LIBS" >&5
$as_echo_n "checking GIO_LIBS... " >&6; }
            GIO_LIBS=`$PKG_CONFIG --libs "gio-2.0 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GIO_LIBS" >&5
$as_echo "$GIO_LIBS" >&6; }
        else
            GIO_CFLAGS=""
            GIO_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (gio-2.0 ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
  fi

      else
          { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
          echo "$as_me:$LINENO: result: no" >&5
echo "${ECHO_T}no" >&6
      fi

   fi


if test  "$test_cairo" = "yes"; then

    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use cairo" >&5
$as_echo_n "checking whether to use cairo... " >&6; }
    if test "x$enable_cairo" != "xno" ; then
        ENABLE_CAIRO="TRUE"
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking which cairo to use" >&5
$as_echo_n "checking which cairo to use... " >&6; }
        if test -n "$with_system_cairo" -o -n "$with_system_libs" && \
           test "$with_system_cairo" != "no"; then
           { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
           SYSTEM_CAIRO=YES



  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for cairo >= 1.0.2 " >&5
$as_echo_n "checking for cairo >= 1.0.2 ... " >&6; }

        if $PKG_CONFIG --exists "cairo >= 1.0.2 " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking CAIRO_CFLAGS" >&5
$as_echo_n "checking CAIRO_CFLAGS... " >&6; }
            CAIRO_CFLAGS=`$PKG_CONFIG --cflags "cairo >= 1.0.2 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAIRO_CFLAGS" >&5
$as_echo "$CAIRO_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking CAIRO_LIBS" >&5
$as_echo_n "checking CAIRO_LIBS... " >&6; }
            CAIRO_LIBS=`$PKG_CONFIG --libs "cairo >= 1.0.2 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAIRO_LIBS" >&5
$as_echo "$CAIRO_LIBS" >&6; }
        else
            CAIRO_CFLAGS=""
            CAIRO_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (cairo >= 1.0.2 ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
echo "$as_me: error: Library requirements (cairo >= 1.0.2 ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." >&2;}
   { (exit 1); exit 1; }; }
  fi

	   if test "$_os" != "WINNT" -a "$_os" != "Darwin" -a "$ENABLE_FONTCONFIG" != "TRUE" ; then
	      as_fn_error "Cairo library requires fontconfig." "$LINENO" 5
echo "$as_me: error: Cairo library requires fontconfig." >&2;}
   { (exit 1); exit 1; }; }
	   fi
           if test "$with_system_xrender_headers" = "yes"; then
              { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether Xrender.h defines PictStandardA8" >&5
$as_echo_n "checking whether Xrender.h defines PictStandardA8... " >&6; }
              if test "$cross_compiling" = yes; then :
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error "cannot run test program while cross compiling
See \`config.log' for more details." "$LINENO" 5; }
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

#include <X11/extensions/Xrender.h>

}

_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
  as_fn_error "no, X headers too old." "$LINENO" 5
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

  (exit $ac_status); }; }; then
  echo "$as_me:$LINENO: result: yes" >&5
echo "${ECHO_T}yes" >&6
else
  echo "$as_me: program exited with status $ac_status" >&5
echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

( exit $ac_status )
{ { echo "$as_me:$LINENO: error: no, X headers too old." >&5
echo "$as_me: error: no, X headers too old." >&2;}
   { (exit 1); exit 1; }; }
fi
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
fi
           fi
        else
           BUILD_TYPE="$BUILD_TYPE CAIRO"
	   	   if test "$build_cpu" != "x86_64"; then
	      BUILD_PIXMAN=YES
	   fi
           { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
        fi
    else
	   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    fi
fi








{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build the OpenGL Transitions component" >&5
$as_echo_n "checking whether to build the OpenGL Transitions component... " >&6; }
ENABLE_OPENGL=

if test "x$enable_opengl" != "xno" ; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   ac_fn_c_check_header_mongrel "$LINENO" "GL/gl.h" "ac_cv_header_GL_gl_h" "$ac_includes_default"
if test "x$ac_cv_header_GL_gl_h" = x""yes; then :

else
  as_fn_error "OpenGL headers not found" "$LINENO" 5
fi


   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lGL" >&5
$as_echo_n "checking for main in -lGL... " >&6; }
if test "${ac_cv_lib_GL_main+set}" = set; then :
  $as_echo_n "(cached) " >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <GL/gl.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking GL/gl.h presence" >&5
echo $ECHO_N "checking GL/gl.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <GL/gl.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: GL/gl.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: GL/gl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: GL/gl.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: GL/gl.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: GL/gl.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: GL/gl.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: GL/gl.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: GL/gl.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: GL/gl.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: GL/gl.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: GL/gl.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: GL/gl.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: GL/gl.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: GL/gl.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: GL/gl.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: GL/gl.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for GL/gl.h" >&5
echo $ECHO_N "checking for GL/gl.h... $ECHO_C" >&6
if test "${ac_cv_header_GL_gl_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_GL_gl_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_GL_gl_h" >&5
echo "${ECHO_T}$ac_cv_header_GL_gl_h" >&6

fi
if test $ac_cv_header_GL_gl_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: OpenGL headers not found" >&5
echo "$as_me: error: OpenGL headers not found" >&2;}
   { (exit 1); exit 1; }; }
fi



echo "$as_me:$LINENO: checking for main in -lGL" >&5
echo $ECHO_N "checking for main in -lGL... $ECHO_C" >&6
if test "${ac_cv_lib_GL_main+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lGL  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */


int
main ()
{
return main ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_GL_main=yes
else
  ac_cv_lib_GL_main=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_GL_main" >&5
$as_echo "$ac_cv_lib_GL_main" >&6; }
if test "x$ac_cv_lib_GL_main" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBGL 1
_ACEOF

  LIBS="-lGL $LIBS"

else
  as_fn_error "libGL not installed or functional" "$LINENO" 5
fi

   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lGLU" >&5
$as_echo_n "checking for main in -lGLU... " >&6; }
if test "${ac_cv_lib_GLU_main+set}" = set; then :
  $as_echo_n "(cached) " >&6
echo $ECHO_N "checking for main in -lGLU... $ECHO_C" >&6
if test "${ac_cv_lib_GLU_main+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lGLU  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */


int
main ()
{
return main ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_GLU_main=yes
else
  ac_cv_lib_GLU_main=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_GLU_main" >&5
$as_echo "$ac_cv_lib_GLU_main" >&6; }
if test "x$ac_cv_lib_GLU_main" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBGLU 1
_ACEOF

  LIBS="-lGLU $LIBS"

else
  as_fn_error "libGLU not installed or functional" "$LINENO" 5
echo "$as_me: error: libGLU not installed or functional" >&2;}
   { (exit 1); exit 1; }; }
fi

   ENABLE_OPENGL=TRUE
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi



{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build extra presenter ui" >&5
$as_echo_n "checking whether to build extra presenter ui... " >&6; }
if test -n "$enable_presenter_extra_ui" -a "$enable_presenter_extra_ui" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   ENABLE_PRESENTER_EXTRA_UI=YES
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   ENABLE_PRESENTER_EXTRA_UI=NO
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build the Presentation Minimizer extension" >&5
$as_echo_n "checking whether to build the Presentation Minimizer extension... " >&6; }
if test -n "$enable_minimizer" -a "$enable_minimizer" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   ENABLE_MINIMIZER=YES
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   ENABLE_MINIMIZER=NO
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build the Presenter Screen extension" >&5
$as_echo_n "checking whether to build the Presenter Screen extension... " >&6; }
if test -n "$enable_presenter_console" -a "$enable_presenter_screen" != "no"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   ENABLE_PRESENTER_SCREEN=YES
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   ENABLE_PRESENTER_SCREEN=NO
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build the PDF Import extension" >&5
$as_echo_n "checking whether to build the PDF Import extension... " >&6; }
if test -n "$enable_pdfimport" -a "$enable_pdfimport" != "no"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
  ENABLE_PDFIMPORT=YES

        { $as_echo "$as_me:${as_lineno-$LINENO}: checking which pdf backend to use" >&5
$as_echo_n "checking which pdf backend to use... " >&6; }
  if test -n "$with_system_poppler" -o -n "$with_system_libs" && \
       test "$with_system_poppler" != "no"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
      SYSTEM_POPPLER=YES

  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for poppler >= 0.8.0 " >&5
$as_echo_n "checking for poppler >= 0.8.0 ... " >&6; }

        if $PKG_CONFIG --exists "poppler >= 0.8.0 " ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking POPPLER_CFLAGS" >&5
$as_echo_n "checking POPPLER_CFLAGS... " >&6; }
            POPPLER_CFLAGS=`$PKG_CONFIG --cflags "poppler >= 0.8.0 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POPPLER_CFLAGS" >&5
$as_echo "$POPPLER_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking POPPLER_LIBS" >&5
$as_echo_n "checking POPPLER_LIBS... " >&6; }
            POPPLER_LIBS=`$PKG_CONFIG --libs "poppler >= 0.8.0 "`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POPPLER_LIBS" >&5
$as_echo "$POPPLER_LIBS" >&6; }
        else
            POPPLER_CFLAGS=""
            POPPLER_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (poppler >= 0.8.0 ) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
  fi

  else
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
      echo "$as_me:$LINENO: result: internal" >&5
echo "${ECHO_T}internal" >&6
      SYSTEM_POPPLER=NO
      BUILD_TYPE="$BUILD_TYPE XPDF"
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for xpdf module" >&5
$as_echo_n "checking for xpdf module... " >&6; }
      if test -d ./xpdf; then
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: OK" >&5
$as_echo "OK" >&6; }
      else
        as_fn_error "not existing. get it (did you get the -extensions tarball?)" "$LINENO" 5
      fi
  fi
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   echo "$as_me:$LINENO: result: no" >&5
echo "${ECHO_T}no" >&6
   ENABLE_PDFIMPORT=NO
fi




if test "$ENABLE_PRESENTER_SCREEN" = "YES" -o "$ENABLE_MINIMIZER" = "YES" -o "$ENABLE_PDFIMPORT" = "YES"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdext module" >&5
$as_echo_n "checking for sdext module... " >&6; }
  if test -d ./sdext; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: OK" >&5
$as_echo "OK" >&6; }
  else
   as_fn_error "not existing. get it (did you get the -extensions tarball?)" "$LINENO" 5
echo "$as_me: error: not existing. get it (did you get the -extensions tarball?)" >&2;}
   { (exit 1); exit 1; }; }
  fi
  BUILD_TYPE="$BUILD_TYPE SDEXT"
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build the Wiki Publisher extension" >&5
$as_echo_n "checking whether to build the Wiki Publisher extension... " >&6; }
if test -n "$enable_wiki_publisher" -a "$enable_wiki_publisher" != "no" && test  "$WITH_JAVA" != "no"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for swext module" >&5
$as_echo_n "checking for swext module... " >&6; }
  if test -d ./swext; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: OK" >&5
$as_echo "OK" >&6; }
  else
   as_fn_error "not existing. get it (did you get the -extensions tarball?)" "$LINENO" 5
echo "$as_me: error: not existing. get it (did you get the -extensions tarball?)" >&2;}
   { (exit 1); exit 1; }; }
  fi
  ENABLE_MEDIAWIKI=YES
  BUILD_TYPE="$BUILD_TYPE SWEXT"
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
  ENABLE_MEDIAWIKI=NO
fi


if test "$ENABLE_MEDIAWIKI" == "YES"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking which Servlet API Jar to use" >&5
$as_echo_n "checking which Servlet API Jar to use... " >&6; }
  if test -n "$with_system_servlet_api"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
    SYSTEM_SERVLETAPI=YES
      if test -z "$SERVLETAPI_JAR"; then
	SERVLETAPI_JAR=/usr/share/java/servlet-api.jar
      fi
      as_ac_File=`$as_echo "ac_cv_file_$SERVLETAPI_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $SERVLETAPI_JAR" >&5
$as_echo_n "checking for $SERVLETAPI_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$SERVLETAPI_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "servlet-api.jar not found." "$LINENO" 5
fi

  else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    SYSTEM_SERVLETAPI=NO
    BUILD_TYPE="$BUILD_TYPE TOMCAT"
  fi




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build the Report Builder extension" >&5
$as_echo_n "checking whether to build the Report Builder extension... " >&6; }
if test -n "$enable_report_builder" -a "$enable_report_builder" != "no" && test "$WITH_JAVA" != "no"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
  ENABLE_REPORTBUILDER=YES
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for reportbuilder module" >&5
$as_echo_n "checking for reportbuilder module... " >&6; }
  if test -d ./reportbuilder; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: OK" >&5
$as_echo "OK" >&6; }
  else
    as_fn_error "not existing. get it (did you get the -extensions tarball?)" "$LINENO" 5
  fi
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking which jfreereport libs to use" >&5
$as_echo_n "checking which jfreereport libs to use... " >&6; }
  echo "$as_me:$LINENO: checking which jfreereport libs to use" >&5
echo $ECHO_N "checking which jfreereport libs to use... $ECHO_C" >&6
  if test "$with_system_jfreereport" == "yes"; then
   	SYSTEM_JFREEREPORT=YES
  	   { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
      if test -z $SAC_JAR; then
             SAC_JAR=/usr/share/java/sac.jar
      fi
      as_ac_File=`$as_echo "ac_cv_file_$SAC_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $SAC_JAR" >&5
$as_echo_n "checking for $SAC_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$SAC_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "sac.jar not found." "$LINENO" 5
fi


      if test -z $LIBXML_JAR; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/libxml-1.0.0.jar" >&5
$as_echo_n "checking for /usr/share/java/libxml-1.0.0.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_libxml_1_0_0_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/libxml-1.0.0.jar"; then
  ac_cv_file__usr_share_java_libxml_1_0_0_jar=yes
else
  ac_cv_file__usr_share_java_libxml_1_0_0_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_libxml_1_0_0_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_libxml_1_0_0_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_libxml_1_0_0_jar" = x""yes; then :
   LIBXML_JAR=/usr/share/java/libxml-1.0.0.jar
else

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/libxml.jar" >&5
$as_echo_n "checking for /usr/share/java/libxml.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_libxml_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/libxml.jar"; then
  ac_cv_file__usr_share_java_libxml_jar=yes
else
  ac_cv_file__usr_share_java_libxml_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_libxml_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_libxml_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_libxml_jar" = x""yes; then :
   LIBXML_JAR=/usr/share/java/libxml.jar
else
  as_fn_error "libxml.jar replacement not found." "$LINENO" 5

fi



fi

      else
        as_ac_File=`$as_echo "ac_cv_file_$LIBXML_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LIBXML_JAR" >&5
$as_echo_n "checking for $LIBXML_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$LIBXML_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "libxml.jar not found." "$LINENO" 5
fi

      fi

      if test -z $FLUTE_JAR; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/flute-1.3.0.jar" >&5
$as_echo_n "checking for /usr/share/java/flute-1.3.0.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_flute_1_3_0_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/flute-1.3.0.jar"; then
  ac_cv_file__usr_share_java_flute_1_3_0_jar=yes
else
  ac_cv_file__usr_share_java_flute_1_3_0_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_flute_1_3_0_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_flute_1_3_0_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_flute_1_3_0_jar" = x""yes; then :
   FLUTE_JAR=/usr/share/java/flute-1.3.0.jar
else

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/flute.jar" >&5
$as_echo_n "checking for /usr/share/java/flute.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_flute_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/flute.jar"; then
  ac_cv_file__usr_share_java_flute_jar=yes
else
  ac_cv_file__usr_share_java_flute_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_flute_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_flute_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_flute_jar" = x""yes; then :
   FLUTE_JAR=/usr/share/java/flute.jar
else
   as_fn_error "flute-1.3.0.jar replacement not found." "$LINENO" 5

fi



fi

      else
        as_ac_File=`$as_echo "ac_cv_file_$FLUTE_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $FLUTE_JAR" >&5
$as_echo_n "checking for $FLUTE_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$FLUTE_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "flute-1.3.0.jar not found." "$LINENO" 5
fi

      fi

      if test -z $JFREEREPORT_JAR; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/flow-engine-0.9.2.jar" >&5
$as_echo_n "checking for /usr/share/java/flow-engine-0.9.2.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_flow_engine_0_9_2_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/flow-engine-0.9.2.jar"; then
  ac_cv_file__usr_share_java_flow_engine_0_9_2_jar=yes
else
  ac_cv_file__usr_share_java_flow_engine_0_9_2_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_flow_engine_0_9_2_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_flow_engine_0_9_2_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_flow_engine_0_9_2_jar" = x""yes; then :
   JFREEREPORT_JAR=/usr/share/java/flow-engine-0.9.2.jar
else

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/flow-engine.jar" >&5
$as_echo_n "checking for /usr/share/java/flow-engine.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_flow_engine_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/flow-engine.jar"; then
  ac_cv_file__usr_share_java_flow_engine_jar=yes
else
  ac_cv_file__usr_share_java_flow_engine_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_flow_engine_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_flow_engine_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_flow_engine_jar" = x""yes; then :
   JFREEREPORT_JAR=/usr/share/java/flow-engine.jar
else
  as_fn_error "jfreereport.jar replacement not found." "$LINENO" 5

fi



fi

      else
        as_ac_File=`$as_echo "ac_cv_file_$JFREEREPORT_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $JFREEREPORT_JAR" >&5
$as_echo_n "checking for $JFREEREPORT_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$JFREEREPORT_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "jfreereport.jar not found." "$LINENO" 5
fi

      fi

      if test -z $LIBLAYOUT_JAR; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/liblayout-0.2.9.jar" >&5
$as_echo_n "checking for /usr/share/java/liblayout-0.2.9.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_liblayout_0_2_9_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/liblayout-0.2.9.jar"; then
  ac_cv_file__usr_share_java_liblayout_0_2_9_jar=yes
else
  ac_cv_file__usr_share_java_liblayout_0_2_9_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_liblayout_0_2_9_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_liblayout_0_2_9_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_liblayout_0_2_9_jar" = x""yes; then :
   LIBLAYOUT_JAR=/usr/share/java/liblayout-0.2.9.jar
else

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/liblayout.jar" >&5
$as_echo_n "checking for /usr/share/java/liblayout.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_liblayout_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/liblayout.jar"; then
  ac_cv_file__usr_share_java_liblayout_jar=yes
else
  ac_cv_file__usr_share_java_liblayout_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_liblayout_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_liblayout_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_liblayout_jar" = x""yes; then :
   LIBLAYOUT_JAR=/usr/share/java/liblayout.jar
else
  as_fn_error "liblayout.jar replacement not found." "$LINENO" 5

fi



fi

      else
        as_ac_File=`$as_echo "ac_cv_file_$LIBLAYOUT_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LIBLAYOUT_JAR" >&5
$as_echo_n "checking for $LIBLAYOUT_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$LIBLAYOUT_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "liblayout.jar not found." "$LINENO" 5
fi

      fi

      if test -z $LIBLOADER_JAR; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/libloader-1.0.0.jar" >&5
$as_echo_n "checking for /usr/share/java/libloader-1.0.0.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_libloader_1_0_0_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/libloader-1.0.0.jar"; then
  ac_cv_file__usr_share_java_libloader_1_0_0_jar=yes
else
  ac_cv_file__usr_share_java_libloader_1_0_0_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_libloader_1_0_0_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_libloader_1_0_0_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_libloader_1_0_0_jar" = x""yes; then :
   LIBLOADER_JAR=/usr/share/java/libloader-1.0.0.jar
else

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/libloader.jar" >&5
$as_echo_n "checking for /usr/share/java/libloader.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_libloader_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/libloader.jar"; then
  ac_cv_file__usr_share_java_libloader_jar=yes
else
  ac_cv_file__usr_share_java_libloader_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_libloader_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_libloader_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_libloader_jar" = x""yes; then :
   LIBLOADER_JAR=/usr/share/java/libloader.jar
else
  as_fn_error "libloader.jar replacement not found." "$LINENO" 5

fi



fi

      else
        as_ac_File=`$as_echo "ac_cv_file_$LIBLOADER_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LIBLOADER_JAR" >&5
$as_echo_n "checking for $LIBLOADER_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$LIBLOADER_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "libloader.jar not found." "$LINENO" 5
fi

      fi

      if test -z $LIBFORMULA_JAR; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/libformula-0.2.0.jar" >&5
$as_echo_n "checking for /usr/share/java/libformula-0.2.0.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_libformula_0_2_0_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/libformula-0.2.0.jar"; then
  ac_cv_file__usr_share_java_libformula_0_2_0_jar=yes
else
  ac_cv_file__usr_share_java_libformula_0_2_0_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_libformula_0_2_0_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_libformula_0_2_0_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_libformula_0_2_0_jar" = x""yes; then :
   LIBFORMULA_JAR=/usr/share/java/libformula-0.2.0.jar
else

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/libformula.jar" >&5
$as_echo_n "checking for /usr/share/java/libformula.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_libformula_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/libformula.jar"; then
  ac_cv_file__usr_share_java_libformula_jar=yes
else
  ac_cv_file__usr_share_java_libformula_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_libformula_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_libformula_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_libformula_jar" = x""yes; then :
   LIBFORMULA_JAR=/usr/share/java/libformula.jar
else
  as_fn_error "libformula.jar replacement not found." "$LINENO" 5

fi



fi

      else
        as_ac_File=`$as_echo "ac_cv_file_$LIBFORMULA_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LIBFORMULA_JAR" >&5
$as_echo_n "checking for $LIBFORMULA_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$LIBFORMULA_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "libformula.jar not found." "$LINENO" 5
fi

      fi

      if test -z $LIBREPOSITORY_JAR; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/librepository-1.0.0.jar" >&5
$as_echo_n "checking for /usr/share/java/librepository-1.0.0.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_librepository_1_0_0_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/librepository-1.0.0.jar"; then
  ac_cv_file__usr_share_java_librepository_1_0_0_jar=yes
else
  ac_cv_file__usr_share_java_librepository_1_0_0_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_librepository_1_0_0_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_librepository_1_0_0_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_librepository_1_0_0_jar" = x""yes; then :
   LIBREPOSITORY_JAR=/usr/share/java/librepository-1.0.0.jar
else

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/librepository.jar" >&5
$as_echo_n "checking for /usr/share/java/librepository.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_librepository_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/librepository.jar"; then
  ac_cv_file__usr_share_java_librepository_jar=yes
else
  ac_cv_file__usr_share_java_librepository_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_librepository_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_librepository_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_librepository_jar" = x""yes; then :
   LIBREPOSITORY_JAR=/usr/share/java/librepository.jar
else
  as_fn_error "librepository.jar replacement not found." "$LINENO" 5

fi



fi

      else
        as_ac_File=`$as_echo "ac_cv_file_$LIBREPOSITORY_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LIBREPOSITORY_JAR" >&5
$as_echo_n "checking for $LIBREPOSITORY_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$LIBREPOSITORY_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "librepository.jar not found." "$LINENO" 5
fi

      fi

      if test -z $LIBFONTS_JAR; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/libfonts-1.0.0.jar" >&5
$as_echo_n "checking for /usr/share/java/libfonts-1.0.0.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_libfonts_1_0_0_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/libfonts-1.0.0.jar"; then
  ac_cv_file__usr_share_java_libfonts_1_0_0_jar=yes
else
  ac_cv_file__usr_share_java_libfonts_1_0_0_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_libfonts_1_0_0_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_libfonts_1_0_0_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_libfonts_1_0_0_jar" = x""yes; then :
   LIBFONTS_JAR=/usr/share/java/libfonts-1.0.0.jar
else

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/libfonts.jar" >&5
$as_echo_n "checking for /usr/share/java/libfonts.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_libfonts_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/libfonts.jar"; then
  ac_cv_file__usr_share_java_libfonts_jar=yes
else
  ac_cv_file__usr_share_java_libfonts_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_libfonts_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_libfonts_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_libfonts_jar" = x""yes; then :
   LIBFONTS_JAR=/usr/share/java/libfonts.jar
else
  as_fn_error "libfonts.jar replacement not found." "$LINENO" 5

fi



fi

      else
        as_ac_File=`$as_echo "ac_cv_file_$LIBFONTS_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LIBFONTS_JAR" >&5
$as_echo_n "checking for $LIBFONTS_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$LIBFONTS_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "libfonts.jar not found." "$LINENO" 5
fi

      fi

      if test -z $LIBSERIALIZER_JAR; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/libserializer-1.0.0.jar" >&5
$as_echo_n "checking for /usr/share/java/libserializer-1.0.0.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_libserializer_1_0_0_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/libserializer-1.0.0.jar"; then
  ac_cv_file__usr_share_java_libserializer_1_0_0_jar=yes
else
  ac_cv_file__usr_share_java_libserializer_1_0_0_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_libserializer_1_0_0_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_libserializer_1_0_0_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_libserializer_1_0_0_jar" = x""yes; then :
   LIBSERIALIZER_JAR=/usr/share/java/libserializer-1.0.0.jar
else

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/libserializer.jar" >&5
$as_echo_n "checking for /usr/share/java/libserializer.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_libserializer_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/libserializer.jar"; then
  ac_cv_file__usr_share_java_libserializer_jar=yes
else
  ac_cv_file__usr_share_java_libserializer_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_libserializer_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_libserializer_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_libserializer_jar" = x""yes; then :
   LIBSERIALIZER_JAR=/usr/share/java/libserializer.jar
else
  as_fn_error "libserializer.jar replacement not found." "$LINENO" 5

fi



fi

      else
        as_ac_File=`$as_echo "ac_cv_file_$LIBSERIALIZER_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LIBSERIALIZER_JAR" >&5
$as_echo_n "checking for $LIBSERIALIZER_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$LIBSERIALIZER_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "libserializer.jar not found." "$LINENO" 5
fi

      fi


      if test -z $LIBBASE_JAR; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/libbase-1.0.0.jar" >&5
$as_echo_n "checking for /usr/share/java/libbase-1.0.0.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_libbase_1_0_0_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/libbase-1.0.0.jar"; then
  ac_cv_file__usr_share_java_libbase_1_0_0_jar=yes
else
  ac_cv_file__usr_share_java_libbase_1_0_0_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_libbase_1_0_0_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_libbase_1_0_0_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_libbase_1_0_0_jar" = x""yes; then :
   LIBBASE_JAR=/usr/share/java/libbase-1.0.0.jar
else

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/libbase.jar" >&5
$as_echo_n "checking for /usr/share/java/libbase.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_libbase_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/libbase.jar"; then
  ac_cv_file__usr_share_java_libbase_jar=yes
else
  ac_cv_file__usr_share_java_libbase_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_libbase_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_libbase_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_libbase_jar" = x""yes; then :
   LIBBASE_JAR=/usr/share/java/libbase.jar
else
  as_fn_error "libbase.jar replacement not found." "$LINENO" 5

fi



fi

      else
        as_ac_File=`$as_echo "ac_cv_file_$LIBBASE_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LIBBASE_JAR" >&5
$as_echo_n "checking for $LIBBASE_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$LIBBASE_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "libbase.jar not found." "$LINENO" 5
fi

      fi

  else
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jfreereport module" >&5
$as_echo_n "checking for jfreereport module... " >&6; }
     if test -d ./jfreereport; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: OK" >&5
$as_echo "OK" >&6; }
     else
      as_fn_error "not existing. get it (did you get the -extensions tarball?)" "$LINENO" 5
echo "$as_me: error: not existing. get it (did you get the -extensions tarball?)" >&2;}
   { (exit 1); exit 1; }; }
     fi
     SYSTEM_JFREEREPORT=NO
     BUILD_TYPE="$BUILD_TYPE JFREEREPORT"
  fi
  BUILD_TYPE="$BUILD_TYPE REPORTBUILDER"
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
  ENABLE_REPORTBUILDER=NO
  SYSTEM_JFREEREPORT=NO
fi

# this has to be here because both the wiki publisher and the SRB use
# commons-logging
if test "$ENABLE_MEDIAWIKI" = "YES" -o "$ENABLE_REPORTBUILDER" = "YES"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking which Apache commons-* libs to use" >&5
$as_echo_n "checking which Apache commons-* libs to use... " >&6; }
  if test "$with_system_apache_commons" = "yes"; then
    SYSTEM_APACHE_COMMONS=YES
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: external" >&5
$as_echo "external" >&6; }
    if test "$ENABLE_MEDIAWIKI" = "YES"; then
      if test -z $COMMONS_CODEC_JAR; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/commons-codec-1.3.jar" >&5
$as_echo_n "checking for /usr/share/java/commons-codec-1.3.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_commons_codec_1_3_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/commons-codec-1.3.jar"; then
  ac_cv_file__usr_share_java_commons_codec_1_3_jar=yes
else
  ac_cv_file__usr_share_java_commons_codec_1_3_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_commons_codec_1_3_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_commons_codec_1_3_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_commons_codec_1_3_jar" = x""yes; then :
   COMMONS_CODEC_JAR=/usr/share/java/commons-codec-1.3.jar
else

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/commons-codec.jar" >&5
$as_echo_n "checking for /usr/share/java/commons-codec.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_commons_codec_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/commons-codec.jar"; then
  ac_cv_file__usr_share_java_commons_codec_jar=yes
else
  ac_cv_file__usr_share_java_commons_codec_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_commons_codec_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_commons_codec_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_commons_codec_jar" = x""yes; then :
   COMMONS_CODEC_JAR=/usr/share/java/commons-codecs.jar
else
  as_fn_error "commons-codec.jar replacement not found." "$LINENO" 5

fi



fi

      else
        as_ac_File=`$as_echo "ac_cv_file_$COMMONS_CODEC_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $COMMONS_CODEC_JAR" >&5
$as_echo_n "checking for $COMMONS_CODEC_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$COMMONS_CODEC_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "commons-codec.jar not found." "$LINENO" 5
fi

      fi

      if test -z $COMMONS_LANG_JAR; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/commons-lang-2.3.jar" >&5
$as_echo_n "checking for /usr/share/java/commons-lang-2.3.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_commons_lang_2_3_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/commons-lang-2.3.jar"; then
  ac_cv_file__usr_share_java_commons_lang_2_3_jar=yes
else
  ac_cv_file__usr_share_java_commons_lang_2_3_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_commons_lang_2_3_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_commons_lang_2_3_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_commons_lang_2_3_jar" = x""yes; then :
   COMMONS_LANG_JAR=/usr/share/java/commons-lang-2.3.jar
else

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/commons-lang.jar" >&5
$as_echo_n "checking for /usr/share/java/commons-lang.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_commons_lang_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/commons-lang.jar"; then
  ac_cv_file__usr_share_java_commons_lang_jar=yes
else
  ac_cv_file__usr_share_java_commons_lang_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_commons_lang_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_commons_lang_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_commons_lang_jar" = x""yes; then :
   COMMONS_LANG_JAR=/usr/share/java/commons-lang.jar
else
  as_fn_error "commons-lang.jar replacement not found." "$LINENO" 5

fi



fi

      else
        as_ac_File=`$as_echo "ac_cv_file_$COMMONS_LANG_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $COMMONS_LANG_JAR" >&5
$as_echo_n "checking for $COMMONS_LANG_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$COMMONS_LANG_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "commons-lang.jar not found." "$LINENO" 5
fi

      fi

      if test -z $COMMONS_HTTPCLIENT_JAR; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/commons-httpclient-3.1.jar" >&5
$as_echo_n "checking for /usr/share/java/commons-httpclient-3.1.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_commons_httpclient_3_1_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/commons-httpclient-3.1.jar"; then
  ac_cv_file__usr_share_java_commons_httpclient_3_1_jar=yes
else
  ac_cv_file__usr_share_java_commons_httpclient_3_1_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_commons_httpclient_3_1_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_commons_httpclient_3_1_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_commons_httpclient_3_1_jar" = x""yes; then :
   COMMONS_HTTPCLIENT_JAR=/usr/share/java/commons-httpclient-3.1.jar
else

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/commons-httpclient.jar" >&5
$as_echo_n "checking for /usr/share/java/commons-httpclient.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_commons_httpclient_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/commons-httpclient.jar"; then
  ac_cv_file__usr_share_java_commons_httpclient_jar=yes
else
  ac_cv_file__usr_share_java_commons_httpclient_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_commons_httpclient_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_commons_httpclient_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_commons_httpclient_jar" = x""yes; then :
   COMMONS_HTTPCLIENT_JAR=/usr/share/java/commons-httpclient.jar
else
  as_fn_error "commons-httpclient.jar replacement not found." "$LINENO" 5

fi



fi

      else
        as_ac_File=`$as_echo "ac_cv_file_$COMMONS_HTTPCLIENT_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $COMMONS_HTTPCLIENT_JAR" >&5
$as_echo_n "checking for $COMMONS_HTTPCLIENT_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$COMMONS_HTTPCLIENT_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "commons-httpclient.jar not found." "$LINENO" 5
fi

      fi
    fi
    if test "$ENABLE_MEDIAWIKI" = "YES" -o "$ENABLE_REPORTBUILDER" = "YES"; then
      if test -z $COMMONS_LOGGING_JAR; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/commons-logging-1.1.1.jar" >&5
$as_echo_n "checking for /usr/share/java/commons-logging-1.1.1.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_commons_logging_1_1_1_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/commons-logging-1.1.1.jar"; then
  ac_cv_file__usr_share_java_commons_logging_1_1_1_jar=yes
else
  ac_cv_file__usr_share_java_commons_logging_1_1_1_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_commons_logging_1_1_1_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_commons_logging_1_1_1_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_commons_logging_1_1_1_jar" = x""yes; then :
   COMMONS_LOGGING_JAR=/usr/share/java/commons-logging-1.1.1.jar
else

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/java/commons-logging.jar" >&5
$as_echo_n "checking for /usr/share/java/commons-logging.jar... " >&6; }
if test "${ac_cv_file__usr_share_java_commons_logging_jar+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "/usr/share/java/commons-logging.jar"; then
  ac_cv_file__usr_share_java_commons_logging_jar=yes
else
  ac_cv_file__usr_share_java_commons_logging_jar=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_java_commons_logging_jar" >&5
$as_echo "$ac_cv_file__usr_share_java_commons_logging_jar" >&6; }
if test "x$ac_cv_file__usr_share_java_commons_logging_jar" = x""yes; then :
   COMMONS_LOGGING_JAR=/usr/share/java/commons-logging.jar
else
  as_fn_error "commons-logging.jar replacement not found." "$LINENO" 5

fi



fi

      else
        as_ac_File=`$as_echo "ac_cv_file_$COMMONS_LOGGING_JAR" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $COMMONS_LOGGING_JAR" >&5
$as_echo_n "checking for $COMMONS_LOGGING_JAR... " >&6; }
if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then :
  $as_echo_n "(cached) " >&6
else
  test "$cross_compiling" = yes &&
  as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5
  test "$cross_compiling" = yes &&
  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }
if test -r "$COMMONS_LOGGING_JAR"; then
  eval "$as_ac_File=yes"
else
  eval "$as_ac_File=no"
fi
fi
eval ac_res=\$$as_ac_File
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval as_val=\$$as_ac_File
   if test "x$as_val" = x""yes; then :

else
  as_fn_error "commons-logging.jar not found." "$LINENO" 5
fi

      fi
    fi
  else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: internal" >&5
$as_echo "internal" >&6; }
    SYSTEM_APACHE_COMMONS=NO
    BUILD_TYPE="$BUILD_TYPE APACHE_COMMONS TOMCAT"
  fi

    kde_test_include="ksharedptr.h"
    kde_test_library="libkdeui.so"

        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Qt headers" >&5
$as_echo_n "checking for Qt headers... " >&6; }
    qt_incdir="no"
    for kde_check in $qt_incdirs ; do
        if test -r "$kde_check/$qt_test_include" ; then

            break
        fi
    done
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $qt_incdir" >&5
$as_echo "$qt_incdir" >&6; }
    if test "x$qt_incdir" = "xno" ; then
        as_fn_error "Qt headers not found.  Please specify the root of
your Qt installation by exporting QTDIR before running \"configure\"." "$LINENO" 5
    fi

        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Qt libraries" >&5
$as_echo_n "checking for Qt libraries... " >&6; }

        echo "$as_me:$LINENO: checking for Qt libraries" >&5
echo $ECHO_N "checking for Qt libraries... $ECHO_C" >&6
    qt_libdir="no"
    for qt_check in $qt_libdirs ; do
        if test -r "$qt_check/$qt_test_library" ; then

            break
        fi
    done
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $qt_libdir" >&5
$as_echo "$qt_libdir" >&6; }
    if test "x$qt_libdir" = "xno" ; then
        as_fn_error "Qt libraries not found.  Please specify the root of
your Qt installation by exporting QTDIR before running \"configure\"." "$LINENO" 5
echo "$as_me: error: Qt libraries not found.  Please specify the root of
your Qt installation by exporting QTDIR before running \"configure\"." >&2;}
   { (exit 1); exit 1; }; }
    fi

        # Extract the first word of "moc", so it can be a program name with args.
set dummy moc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_MOC+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $MOC in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_MOC="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_MOC" && ac_cv_path_MOC="no"
  ;;
esac
fi
MOC=$ac_cv_path_MOC

if test -n "$MOC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOC" >&5
$as_echo "$MOC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    if test "$MOC" = "no" ; then
        as_fn_error "Qt Meta Object Compiler not found.  Please specify
the root of your Qt installation by exporting QTDIR before running \"configure\"." "$LINENO" 5
    fi

        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for KDE headers" >&5
$as_echo_n "checking for KDE headers... " >&6; }

        echo "$as_me:$LINENO: checking for KDE headers" >&5
echo $ECHO_N "checking for KDE headers... $ECHO_C" >&6
    kde_incdir="no"
    for kde_check in $kde_incdirs ; do
        if test -r "$kde_check/$kde_test_include" ; then

            break
        fi
    done
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $kde_incdir" >&5
$as_echo "$kde_incdir" >&6; }
    if test "x$kde_incdir" = "xno" ; then
        as_fn_error "KDE headers not found.  Please specify the root of
your KDE installation by exporting KDEDIR before running \"configure\"." "$LINENO" 5
    fi

        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for KDE libraries" >&5
$as_echo_n "checking for KDE libraries... " >&6; }

        echo "$as_me:$LINENO: checking for KDE libraries" >&5
echo $ECHO_N "checking for KDE libraries... $ECHO_C" >&6
    kde_libdir="no"
    for kde_check in $kde_libdirs ; do
        if test -r "$kde_check/$kde_test_library" ; then

            break
        fi
    done
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $kde_libdir" >&5
$as_echo "$kde_libdir" >&6; }
    if test "x$kde_libdir" = "xno" ; then
        as_fn_error "KDE libraries not found.  Please specify the root of
your KDE installation by exporting KDEDIR before running \"configure\"." "$LINENO" 5
echo "$as_me: error: KDE libraries not found.  Please specify the root of
your KDE installation by exporting KDEDIR before running \"configure\"." >&2;}
   { (exit 1); exit 1; }; }
    fi

        KDE_CFLAGS="-I$qt_incdir -I$kde_incdir -DQT_CLEAN_NAMESPACE -DQT_THREAD_SUPPORT"

   kde_test_include="ksharedptr.h"
   kde_test_library="libkdeui.so"

   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Qt4 headers" >&5
$as_echo_n "checking for Qt4 headers... " >&6; }
   qt_header_dir="no"
   for inc_dir in $qt_incdirs ; do
      if test -r "$inc_dir/$qt_test_include" ; then

      fi
   done

   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $qt_header_dir" >&5
$as_echo "$qt_header_dir" >&6; }
   if test "x$qt_header_dir" = "xno" ; then
      as_fn_error "Qt4 headers not found.  Please specify the root of your Qt4 installation by exporting QT4DIR before running \"configure\"." "$LINENO" 5
   fi

   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Qt4 libraries" >&5
$as_echo_n "checking for Qt4 libraries... " >&6; }
   echo "$as_me:$LINENO: checking for Qt4 libraries" >&5
echo $ECHO_N "checking for Qt4 libraries... $ECHO_C" >&6
   qt_lib_dir="no"
   for lib_dir in $qt_libdirs ; do
      if test -r "$lib_dir/$qt_test_library" ; then

      fi
   done

   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $qt_lib_dir" >&5
$as_echo "$qt_lib_dir" >&6; }

   if test "x$qt_lib_dir" = "xno" ; then
      as_fn_error "Qt4 libraries not found.  Please specify the root of your Qt4 installation by exporting QT4DIR before running \"configure\"." "$LINENO" 5
echo "$as_me: error: Qt4 libraries not found.  Please specify the root of your Qt4 installation by exporting QT4DIR before running \"configure\"." >&2;}
   { (exit 1); exit 1; }; }
   fi

      # Extract the first word of "moc", so it can be a program name with args.
set dummy moc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_MOC4+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $MOC4 in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_MOC4="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_MOC4" && ac_cv_path_MOC4="no"
  ;;
esac
fi
MOC4=$ac_cv_path_MOC4

if test -n "$MOC4"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOC4" >&5
$as_echo "$MOC4" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


   if test "$MOC4" = "no" ; then
      as_fn_error "Qt Meta Object Compiler not found.  Please specify
the root of your Qt installation by exporting QT4DIR before running \"configure\"." "$LINENO" 5
   fi

      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for KDE4 headers" >&5
$as_echo_n "checking for KDE4 headers... " >&6; }

      echo "$as_me:$LINENO: checking for KDE4 headers" >&5
echo $ECHO_N "checking for KDE4 headers... $ECHO_C" >&6
   kde_incdir="no"
   for kde_check in $kde_incdirs ; do
      if test -r "$kde_check/$kde_test_include" ; then

         break
      fi
   done
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $kde_incdir" >&5
$as_echo "$kde_incdir" >&6; }
   if test "x$kde_incdir" = "xno" ; then
      as_fn_error "KDE4 headers not found.  Please specify the root of your KDE4 installation by exporting KDE4DIR before running \"configure\"." "$LINENO" 5
   fi

      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for KDE4 libraries" >&5
$as_echo_n "checking for KDE4 libraries... " >&6; }
      echo "$as_me:$LINENO: checking for KDE4 libraries" >&5
echo $ECHO_N "checking for KDE4 libraries... $ECHO_C" >&6
   kde_libdir="no"
   for kde_check in $kde_libdirs ; do
      if test -r "$kde_check/$kde_test_library" ; then

      fi
   done

   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $kde_libdir" >&5
$as_echo "$kde_libdir" >&6; }
   if test "x$kde_libdir" = "xno" ; then
      as_fn_error "KDE4 libraries not found.  Please specify the root of your KDE4 installation by exporting KDE4DIR before running \"configure\"." "$LINENO" 5
echo "$as_me: error: KDE4 libraries not found.  Please specify the root of your KDE4 installation by exporting KDE4DIR before running \"configure\"." >&2;}
   { (exit 1); exit 1; }; }
   fi

   KDE4_CFLAGS="`pkg-config --cflags QtCore` `pkg-config --cflags QtGui` -I$kde_incdir -DQT_CLEAN_NAMESPACE -DQT_THREAD_SUPPORT"




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable the lockdown pieces" >&5
$as_echo_n "checking whether to enable the lockdown pieces... " >&6; }
ENABLE_LOCKDOWN=""
if test -n "$enable_lockdown" && test "$enable_lockdown" != "no"; then
  ENABLE_LOCKDOWN=YES
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable evolution 2 support" >&5
$as_echo_n "checking whether to enable evolution 2 support... " >&6; }
if test "$enable_evolution2" = "yes" -o "$enable_evolution2" = "TRUE"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }

  succeeded=no

  if test -z "$PKG_CONFIG"; then
    # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no"
  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG

if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi


  else
     PKG_CONFIG_MIN_VERSION=0.9.0
     if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gobject-2.0" >&5
$as_echo_n "checking for gobject-2.0... " >&6; }

        if $PKG_CONFIG --exists "gobject-2.0" ; then
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
            succeeded=yes

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking GOBJECT_CFLAGS" >&5
$as_echo_n "checking GOBJECT_CFLAGS... " >&6; }
            GOBJECT_CFLAGS=`$PKG_CONFIG --cflags "gobject-2.0"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GOBJECT_CFLAGS" >&5
$as_echo "$GOBJECT_CFLAGS" >&6; }

            { $as_echo "$as_me:${as_lineno-$LINENO}: checking GOBJECT_LIBS" >&5
$as_echo_n "checking GOBJECT_LIBS... " >&6; }
            GOBJECT_LIBS=`$PKG_CONFIG --libs "gobject-2.0"`
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GOBJECT_LIBS" >&5
$as_echo "$GOBJECT_LIBS" >&6; }
        else
            GOBJECT_CFLAGS=""
            GOBJECT_LIBS=""

  if test $succeeded = yes; then
     :
  else
     as_fn_error "Library requirements (gobject-2.0) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." "$LINENO" 5
echo "$as_me: error: Library requirements (gobject-2.0) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them." >&2;}
   { (exit 1); exit 1; }; }
  fi

   ENABLE_EVOAB2="TRUE"
else
   ENABLE_EVOAB2=""
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable KDE address book support" >&5
$as_echo_n "checking whether to enable KDE address book support... " >&6; }
if test "$enable_kdeab" = "yes" && test "$enable_kde" = "yes"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
   ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'


   save_CXXFLAGS=$CXXFLAGS
   CXXFLAGS="$CXXFLAGS $KDE_CFLAGS"
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether KDE is between 3.2 and 3.6" >&5
$as_echo_n "checking whether KDE is between 3.2 and 3.6... " >&6; }
       if test "$cross_compiling" = yes; then :
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error "cannot run test program while cross compiling
See \`config.log' for more details." "$LINENO" 5; }
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

#include <kdeversion.h>

}

_ACEOF
if ac_fn_cxx_try_run "$LINENO"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
  as_fn_error "KDE version too old or too recent, please use another version of KDE or disable KDE address book support" "$LINENO" 5
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

  (exit $ac_status); }; }; then
  echo "$as_me:$LINENO: result: yes" >&5
echo "${ECHO_T}yes" >&6
else
  echo "$as_me: program exited with status $ac_status" >&5
echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

( exit $ac_status )
{ { echo "$as_me:$LINENO: error: KDE version too old or too recent, please use another version of KDE or disable KDE address book support" >&5
echo "$as_me: error: KDE version too old or too recent, please use another version of KDE or disable KDE address book support" >&2;}
   { (exit 1); exit 1; }; }
fi
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
fi
   CXXFLAGS=$save_CXXFLAGS
   ac_ext=c
ac_cpp='$CPP $CPPFLAGS'


   ENABLE_KAB=TRUE
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   ENABLE_KAB=
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to include MathMLDTD" >&5
$as_echo_n "checking whether to include MathMLDTD... " >&6; }
if test -n "$enable_mathmldtd"; then
  if test "$enable_mathmldtd" = "no"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    SCPDEFS="$SCPDEFS -DWITHOUT_MATHMLDTD"
  else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
    BUILD_TYPE="$BUILD_TYPE MATHMLDTD"
  fi
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
  SCPDEFS="$SCPDEFS -DWITHOUT_MATHMLDTD"
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to include Bitstream Vera fonts" >&5
$as_echo_n "checking whether to include Bitstream Vera fonts... " >&6; }
if test "$with_fonts" != "no" ; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
  WITH_FONTS=YES
  BUILD_TYPE="$BUILD_TYPE BITSTREAM_VERA_FONTS"
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
  WITH_FONTS=NO
  SCPDEFS="$SCPDEFS -DWITHOUT_FONTS"
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to include PPDs" >&5
$as_echo_n "checking whether to include PPDs... " >&6; }
if test "$with_ppds" != "no"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
  WITHOUT_PPDS=YES
  SCPDEFS="$SCPDEFS -DWITHOUT_PPDS"
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to include AFMs" >&5
$as_echo_n "checking whether to include AFMs... " >&6; }
if test "$with_afms" != "no"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
  WITHOUT_AFMS=YES
  SCPDEFS="$SCPDEFS -DWITHOUT_AFMS"
fi




{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether and how to use Xinerama" >&5
$as_echo_n "checking whether and how to use Xinerama... " >&6; }
if test "$_os" = "Darwin"; then
   USE_XINERAMA=YES
   XINERAMA_LINK=dynamic
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
elif test "$_os" = "Linux" -o "$_os" = "FreeBSD"; then
   if test -e "$XLIB/libXinerama.so" -a -e "$XLIB/libXinerama.a"; then
      # we have both versions, let the user decide but use the dynamic one

      XINERAMA_LINK=none
   fi
   if test "$USE_XINERAMA" = "YES"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, with $XINERAMA_LINK linking" >&5
$as_echo "yes, with $XINERAMA_LINK linking" >&6; }
      ac_fn_c_check_header_mongrel "$LINENO" "X11/extensions/Xinerama.h" "ac_cv_header_X11_extensions_Xinerama_h" "$ac_includes_default"
if test "x$ac_cv_header_X11_extensions_Xinerama_h" = x""yes; then :

else
  as_fn_error "Xinerama header not found." "$LINENO" 5
fi
echo "$as_me:$LINENO: result: $ac_cv_header_X11_extensions_Xinerama_h" >&5
echo "${ECHO_T}$ac_cv_header_X11_extensions_Xinerama_h" >&6
else
  # Is the header compilable?
echo "$as_me:$LINENO: checking X11/extensions/Xinerama.h usability" >&5
echo $ECHO_N "checking X11/extensions/Xinerama.h usability... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
$ac_includes_default
#include <X11/extensions/Xinerama.h>
_ACEOF
rm -f conftest.$ac_objext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
  (eval $ac_compile) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest.$ac_objext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_header_compiler=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

ac_header_compiler=no
fi
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
echo "${ECHO_T}$ac_header_compiler" >&6

# Is the header present?
echo "$as_me:$LINENO: checking X11/extensions/Xinerama.h presence" >&5
echo $ECHO_N "checking X11/extensions/Xinerama.h presence... $ECHO_C" >&6
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h.  */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */
#include <X11/extensions/Xinerama.h>
_ACEOF
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } >/dev/null; then
  if test -s conftest.err; then
    ac_cpp_err=$ac_c_preproc_warn_flag
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
  else
    ac_cpp_err=
  fi
else
  ac_cpp_err=yes
fi
if test -z "$ac_cpp_err"; then
  ac_header_preproc=yes
else
  echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

  ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
echo "${ECHO_T}$ac_header_preproc" >&6

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
  yes:no: )
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xinerama.h: accepted by the compiler, rejected by the preprocessor!" >&5
echo "$as_me: WARNING: X11/extensions/Xinerama.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xinerama.h: proceeding with the compiler's result" >&5
echo "$as_me: WARNING: X11/extensions/Xinerama.h: proceeding with the compiler's result" >&2;}
    ac_header_preproc=yes
    ;;
  no:yes:* )
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xinerama.h: present but cannot be compiled" >&5
echo "$as_me: WARNING: X11/extensions/Xinerama.h: present but cannot be compiled" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xinerama.h:     check for missing prerequisite headers?" >&5
echo "$as_me: WARNING: X11/extensions/Xinerama.h:     check for missing prerequisite headers?" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xinerama.h: see the Autoconf documentation" >&5
echo "$as_me: WARNING: X11/extensions/Xinerama.h: see the Autoconf documentation" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xinerama.h:     section \"Present But Cannot Be Compiled\"" >&5
echo "$as_me: WARNING: X11/extensions/Xinerama.h:     section \"Present But Cannot Be Compiled\"" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xinerama.h: proceeding with the preprocessor's result" >&5
echo "$as_me: WARNING: X11/extensions/Xinerama.h: proceeding with the preprocessor's result" >&2;}
    { echo "$as_me:$LINENO: WARNING: X11/extensions/Xinerama.h: in the future, the compiler will take precedence" >&5
echo "$as_me: WARNING: X11/extensions/Xinerama.h: in the future, the compiler will take precedence" >&2;}
    (
      cat <<\_ASBOX
## ------------------------------------------ ##
## Report this to the AC_PACKAGE_NAME lists.  ##
## ------------------------------------------ ##
_ASBOX
    ) |
      sed "s/^/$as_me: WARNING:     /" >&2
    ;;
esac
echo "$as_me:$LINENO: checking for X11/extensions/Xinerama.h" >&5
echo $ECHO_N "checking for X11/extensions/Xinerama.h... $ECHO_C" >&6
if test "${ac_cv_header_X11_extensions_Xinerama_h+set}" = set; then
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_cv_header_X11_extensions_Xinerama_h=$ac_header_preproc
fi
echo "$as_me:$LINENO: result: $ac_cv_header_X11_extensions_Xinerama_h" >&5
echo "${ECHO_T}$ac_cv_header_X11_extensions_Xinerama_h" >&6

fi
if test $ac_cv_header_X11_extensions_Xinerama_h = yes; then
  :
else
  { { echo "$as_me:$LINENO: error: Xinerama header not found." >&5
echo "$as_me: error: Xinerama header not found." >&2;}
   { (exit 1); exit 1; }; }
fi



      if test "$_os" = "Linux"; then
          XINERAMA_EXTRA_LIBS="$XINERAMA_EXTRA_LIBS -ldl"
      fi
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XineramaIsActive in -lXinerama" >&5
$as_echo_n "checking for XineramaIsActive in -lXinerama... " >&6; }
if test "${ac_cv_lib_Xinerama_XineramaIsActive+set}" = set; then :
  $as_echo_n "(cached) " >&6
  echo $ECHO_N "(cached) $ECHO_C" >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lXinerama $XINERAMA_EXTRA_LIBS $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */

/* Override any gcc2 internal prototype to avoid an error.  */
#ifdef __cplusplus
extern "C"
#endif
/* We use char because int might match the return type of a gcc2
   builtin and then its argument prototype would still apply.  */
char XineramaIsActive ();
int
main ()
{
return XineramaIsActive ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
  (eval $ac_link) 2>conftest.er1
  ac_status=$?
  grep -v '^ *+' conftest.er1 >conftest.err
  rm -f conftest.er1
  cat conftest.err >&5
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); } &&
	 { ac_try='test -z "$ac_c_werror_flag"
			 || test ! -s conftest.err'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; } &&
	 { ac_try='test -s conftest$ac_exeext'
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
  (eval $ac_try) 2>&5
  ac_status=$?
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
  (exit $ac_status); }; }; then
  ac_cv_lib_Xinerama_XineramaIsActive=yes
else
  ac_cv_lib_Xinerama_XineramaIsActive=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
rm -f conftest.err conftest.$ac_objext \
      conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xinerama_XineramaIsActive" >&5
$as_echo "$ac_cv_lib_Xinerama_XineramaIsActive" >&6; }
if test "x$ac_cv_lib_Xinerama_XineramaIsActive" = x""yes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_LIBXINERAMA 1
_ACEOF

  LIBS="-lXinerama $LIBS"

else
  as_fn_error "Xinerama not functional?" "$LINENO" 5
fi

   else
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, libXinerama not found or wrong architecture." >&5
$as_echo "no, libXinerama not found or wrong architecture." >&6; }
   fi
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
   echo "$as_me:$LINENO: result: no" >&5
echo "${ECHO_T}no" >&6
fi



do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_ANT+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $ANT in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_ANT="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
ANT=$ac_cv_path_ANT

if test -n "$ANT"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ANT" >&5
$as_echo "$ANT" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ANT" && break
done

do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_path_ANT+set}" = set; then :
  $as_echo_n "(cached) " >&6
else
  case $ANT in
  [\\/]* | ?:[\\/]*)

do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    ac_cv_path_ANT="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
ANT=$ac_cv_path_ANT

if test -n "$ANT"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ANT" >&5
$as_echo "$ANT" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ANT" && break
done

fi

if test -z "$ANT"; then
  as_fn_error "Ant not found - Make sure it's in the path or use --with-ant-home" "$LINENO" 5
echo "$as_me: error: Ant not found - Make sure it's in the path or use --with-ant-home" >&2;}
   { (exit 1); exit 1; }; }
else
  # resolve relative or absolute symlink
  while test -h "$ANT"; do

  fi
  ant_minminor1=`echo $ant_minver | cut -d"." -f2`

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ant is >= $ant_minver" >&5
$as_echo_n "checking whether ant is >= $ant_minver... " >&6; }
  ant_version=`$ANT -version | $AWK '{ print $4; }'`
  ant_version_major=`echo $ant_version | cut -d. -f1`
  ant_version_minor=`echo $ant_version | cut -d. -f2`

echo "configure: ant_version_major $ant_version_major " >&5
echo "configure: ant_version_minor $ant_version_minor " >&5
  if test "$ant_version_major" -ge "2"; then
  	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, $ant_version" >&5
$as_echo "yes, $ant_version" >&6; }
  elif test "$ant_version_major" = "1" && test "$ant_version_minor" -ge "$ant_minminor1"; then
  	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, $ant_version" >&5
$as_echo "yes, $ant_version" >&6; }
  else
  	as_fn_error "no, you need at least ant >= $ant_minver" "$LINENO" 5
  fi
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $ANT works" >&5
$as_echo_n "checking if $ANT works... " >&6; }
  echo "$as_me:$LINENO: checking if $ANT works" >&5
echo $ECHO_N "checking if $ANT works... $ECHO_C" >&6
cat > conftest.java << EOF
    public class conftest {
	int testmethod(int a, int b) {

  else
    ant_cmd="$ANT -buildfile conftest.xml 1>&2"
  fi
  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ant_cmd\""; } >&5
  (eval $ant_cmd) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
  if test $? = 0 && test -f ./conftest.class ; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: Ant works" >&5
$as_echo "Ant works" >&6; }
    if test -z "$WITH_ANT_HOME"; then
        ANT_HOME=`$ANT -diagnostics | $EGREP "ant.home :" | $SED -e "s#ant.home : ##g"`
        if test -z "$ANT_HOME"; then

    echo "configure: Ant test failed" >&5
    cat conftest.java >&5
    cat conftest.xml >&5
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ant does not work - Some Java projects will not build!" >&5
$as_echo "$as_me: WARNING: Ant does not work - Some Java projects will not build!" >&2;}
    ANT_HOME=""
    echo "Ant does not work - Some Java projects will not build!" >>warn
  fi



if test "$ANT_HOME" != "NO_ANT_HOME"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking Ant lib directory" >&5
$as_echo_n "checking Ant lib directory... " >&6; }
   if test -f $ANT_HOME/lib/ant.jar; then
	  ANT_LIB="$ANT_HOME/lib"
   else

                if test -f $ANT_HOME/lib/ant/ant.jar; then
                    ANT_LIB="$ANT_HOME/lib/ant"
                else
                    as_fn_error "Ant libraries not found!" "$LINENO" 5
echo "$as_me: error: Ant libraries not found!" >&2;}
   { (exit 1); exit 1; }; }
                fi
             fi
          fi
      fi
   fi
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: Ant lib directory found." >&5
$as_echo "Ant lib directory found." >&6; }
fi

fi

if test "$ENABLE_MEDIAWIKI" = "YES"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ant supports mapper type=\"regexp\"" >&5
$as_echo_n "checking whether ant supports mapper type=\"regexp\"... " >&6; }
rm -rf confdir
mkdir confdir
cat > conftest.java << EOF

  else
    ant_cmd="$ANT -buildfile conftest.xml 1>&2"
  fi
  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ant_cmd\""; } >&5
  (eval $ant_cmd) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
  if test $? = 0 && test -f ./conftest.class ; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
    rm -rf confdir
  else
    echo "configure: Ant test failed" >&5
    cat conftest.java >&5
    cat conftest.xml >&5
    rm -rf confdir
    as_fn_error "no. Did you install ant-apache-regexp?" "$LINENO" 5
echo "$as_me: error: no. Did you install ant-apache-regexp?" >&2;}
   { (exit 1); exit 1; }; }
  fi
fi
rm -f conftest* core core.* *.core

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which languages to be built" >&5
$as_echo_n "checking which languages to be built... " >&6; }
WITH_LANG="$with_lang"
if test -z "$WITH_LANG"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: en-US" >&5
$as_echo "en-US" >&6; }
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WITH_LANG" >&5
$as_echo "$WITH_LANG" >&6; }
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which languages have poor help localizations" >&5
$as_echo_n "checking which languages have poor help localizations... " >&6; }
WITH_POOR_HELP_LOCALIZATIONS="$with_poor_help_localizations"
if test -z "$WITH_POOR_HELP_LOCALIZATIONS"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
$as_echo "none" >&6; }
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WITH_POOR_HELP_LOCALIZATIONS" >&5
$as_echo "$WITH_POOR_HELP_LOCALIZATIONS" >&6; }
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which dictionaries to include" >&5
$as_echo_n "checking which dictionaries to include... " >&6; }
if test -z "$with_dict"; then
   WITH_DICT=,ALL,
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: ALL" >&5
$as_echo "ALL" >&6; }
else
   WITH_DICT=","$with_dict","
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_dict" >&5
$as_echo "$with_dict" >&6; }
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for additional 'intro' bitmaps" >&5
$as_echo_n "checking for additional 'intro' bitmaps... " >&6; }
INTRO_BITMAPS=
if test -z "$with_intro_bitmaps" -o "$with_intro_bitmaps" = "no" ; then
   INTRO_BITMAPS=
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
$as_echo "none" >&6; }
else
   for bitmap in `echo $with_intro_bitmaps | tr ',' ' '` ; do
      case "$bitmap" in
         *.bmp) ;;
         *)     bitmap= ; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Intro bitmaps should be .bmp files!" >&5
$as_echo "$as_me: WARNING: Intro bitmaps should be .bmp files!" >&2;} ;;
      esac
      if test -n "$bitmap" ; then
         INTRO_BITMAPS="$INTRO_BITMAPS $bitmap"
      fi
   done
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $INTRO_BITMAPS" >&5
$as_echo "$INTRO_BITMAPS" >&6; }
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for additional 'about' bitmaps" >&5
$as_echo_n "checking for additional 'about' bitmaps... " >&6; }
ABOUT_BITMAPS=
if test -z "$with_about_bitmaps" -o "$with_about_bitmaps" = "no" ; then
   ABOUT_BITMAPS=
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
$as_echo "none" >&6; }
else
   for bitmap in `echo $with_about_bitmaps | tr ',' ' '` ; do
      case "$bitmap" in
         *.bmp) ;;
         *)     bitmap= ; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: About bitmaps should be .bmp files!" >&5
$as_echo "$as_me: WARNING: About bitmaps should be .bmp files!" >&2;} ;;
      esac
      if test -n "$bitmap" ; then
         ABOUT_BITMAPS="$ABOUT_BITMAPS $bitmap"
      fi
   done
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ABOUT_BITMAPS" >&5
$as_echo "$ABOUT_BITMAPS" >&6; }
fi


OOO_VENDOR=
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for vendor" >&5
$as_echo_n "checking for vendor... " >&6; }
if test -z "$with_vendor" -o "$with_vendor" = "no" ; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: not set" >&5
$as_echo "not set" >&6; }
else
   OOO_VENDOR="$with_vendor"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OOO_VENDOR" >&5
$as_echo "$OOO_VENDOR" >&6; }
fi


UNIXWRAPPERNAME=
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIX wrapper name" >&5
$as_echo_n "checking for UNIX wrapper name... " >&6; }
if test -z "$with_unix_wrapper" -o "$with_unix_wrapper" = "no"  -o "$with_unix_wrapper" = "yes" ; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: not set" >&5
$as_echo "not set" >&6; }
else
   UNIXWRAPPERNAME="$with_unix_wrapper"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIXWRAPPERNAME" >&5
$as_echo "$UNIXWRAPPERNAME" >&6; }
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to statically link to Gtk" >&5
$as_echo_n "checking whether to statically link to Gtk... " >&6; }
if test -n "$enable_static_gtk" && test "$enable_static_gtk" != "no"; then
   ENABLE_STATIC_GTK="TRUE"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
   ENABLE_STATIC_GTK="FALSE"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use layout dialogs" >&5
$as_echo_n "checking whether to use layout dialogs... " >&6; }
if test -n "$enable_layout" && test "$enable_layout" != "no"; then
   ENABLE_LAYOUT="TRUE"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
   ENABLE_LAYOUT="FALSE"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


# ===================================================================
# De- or increase default verbosity of build process
# ===================================================================
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build verbosity" >&5
$as_echo_n "checking build verbosity... " >&6; }
if test -n "$enable_verbose"; then
   if test "$enable_verbose" == "yes"; then
      VERBOSE="TRUE"
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: high" >&5
$as_echo "high" >&6; }
   fi
   if test "$enable_verbose" == "no"; then
      VERBOSE="FALSE"
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: low" >&5
$as_echo "low" >&6; }
   fi
else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: not set" >&5
$as_echo "not set" >&6; }
fi



echo "********************************************************************"

if test -z "$COMPATH"; then
   as_fn_error "No compiler found." "$LINENO" 5
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking solver path" >&5
$as_echo_n "checking solver path... " >&6; }
echo "$as_me:$LINENO: checking solver path" >&5
echo $ECHO_N "checking solver path... $ECHO_C" >&6
if test -z "$with_local_solver"; then
   LOCAL_SOLVER="DEFAULT"
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: default" >&5
$as_echo "default" >&6; }
else
   LOCAL_SOLVER=$with_local_solver
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_local_solver" >&5
$as_echo "$with_local_solver" >&6; }
fi



# make sure config.guess is +x; we execute config.guess, so it has to be so;
chmod +x ./config.guess

ac_config_files="$ac_config_files set_soenv Makefile"

cat >confcache <<\_ACEOF
# This file is a shell script that caches the results of configure
# tests run on this system so they can be shared between configure


# The following way of writing the cache mishandles newlines in values,
# but we know of no workaround that is simple, portable, and efficient.
# So, we kill variables containing newlines.
# Ultrix sh set writes to stderr and can't be redirected directly,
# and sets the high bit in the cache file unless we assign to the vars.
(
  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
    eval ac_val=\$$ac_var
    case $ac_val in #(
    *${as_nl}*)
      case $ac_var in #(
      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
      esac
      case $ac_var in #(
      _ | IFS | as_nl) ;; #(
      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
      *) { eval $ac_var=; unset $ac_var;} ;;
      esac ;;
    esac
  done

  (set) 2>&1 |
    case $as_nl`(ac_space=' '; set) 2>&1` in #(
    *${as_nl}ac_space=\ *)
      # `set' does not quote correctly, so add quotes: double-quote
      # substitution turns \\\\ into \\, and sed turns \\ into \.
      sed -n \
	"s/'/'\\\\''/g;
	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
      ;; #(
    *)
      # `set' quotes correctly as required by POSIX, so do not add quotes.
      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
      ;;
    esac |
    sort
) |
  sed '
     /^ac_cv_env_/b end
     t clear
     :clear
     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
     t end
     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
     :end' >>confcache
if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
  if test -w "$cache_file"; then
    test "x$cache_file" != "x/dev/null" &&
      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
$as_echo "$as_me: updating cache $cache_file" >&6;}
    cat confcache >$cache_file
  else
    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
  fi
fi
rm -f confcache

# Let make expand exec_prefix.
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'

# Transform confdefs.h into DEFS.
# Protect against shell expansion while executing Makefile rules.
# Protect against Makefile macro expansion.
#
# If the first sed substitution is executed (which looks for macros that
# take arguments), then branch to the quote section.  Otherwise,
# look for a macro that doesn't take arguments.
ac_script='
:mline
/\\$/{
 N
 s,\\\n,,
 b mline
}
t clear
:clear
s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*([^)]*)\)[	 ]*\(.*\)/-D\1=\2/g
t quote
s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\)/-D\1=\2/g
t quote
b any
:quote
s/[	 `~#$^&*(){}\\|;'\''"<>?]/\\&/g
s/\[/\\&/g
s/\]/\\&/g
s/\$/$$/g
H
:any
${
	g
	s/^\n//
	s/\n/ /g
	p
}
'
DEFS=`sed -n "$ac_script" confdefs.h`


ac_libobjs=
ac_ltlibobjs=
for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
  # 1. Remove the extension, and $U if already installed.
  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
  #    will be set to the directory where LIBOBJS objects are built.
  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
done
LIBOBJS=$ac_libobjs

LTLIBOBJS=$ac_ltlibobjs




: ${CONFIG_STATUS=./config.status}
ac_write_fail=0
ac_clean_files_save=$ac_clean_files
ac_clean_files="$ac_clean_files $CONFIG_STATUS"
{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
as_write_fail=0
cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
#! $SHELL
# Generated by $as_me.
# Run this file to recreate the current configuration.
# Compiler output produced by configure, useful for debugging
# configure, is in config.log if it exists.

debug=false
ac_cs_recheck=false
ac_cs_silent=false

SHELL=\${CONFIG_SHELL-$SHELL}
export SHELL
_ASEOF
cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##

# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi


as_nl='
'
export as_nl
# Printing a long string crashes Solaris 7 /usr/bin/printf.
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
# Prefer a ksh shell builtin over an external printf program on Solaris,
# but without wasting forks for bash or zsh.
if test -z "$BASH_VERSION$ZSH_VERSION" \
    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='print -r --'
  as_echo_n='print -rn --'
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='printf %s\n'
  as_echo_n='printf %s'
else
  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
    as_echo_n='/usr/ucb/echo -n'
  else
    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
    as_echo_n_body='eval
      arg=$1;
      case $arg in #(
      *"$as_nl"*)
	expr "X$arg" : "X\\(.*\\)$as_nl";
	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
      esac;
      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
    '
    export as_echo_n_body
    as_echo_n='sh -c $as_echo_n_body as_echo'
  fi
  export as_echo_body
  as_echo='sh -c $as_echo_body as_echo'
fi

# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
  PATH_SEPARATOR=:
  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
      PATH_SEPARATOR=';'
  }
fi


# IFS
# We need space, tab and new line, in precisely that order.  Quoting is
# there to prevent editors from complaining about space-tab.
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
# splitting by setting IFS to empty value.)
IFS=" ""	$as_nl"

# Find who we are.  Look in the path if we contain no directory separator.
case $0 in #((
  *[\\/]* ) as_myself=$0 ;;
  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
  done
IFS=$as_save_IFS

     ;;
esac
# We did not find ourselves, most probably we were run as `sh COMMAND'
# in which case we are not to be found in the path.
if test "x$as_myself" = x; then
  as_myself=$0
fi
if test ! -f "$as_myself"; then
  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
  exit 1
fi

# Unset variables that we do not need and which cause bugs (e.g. in
# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
# suppresses any "Segmentation fault" message there.  '((' could
# trigger a bug in pdksh 5.2.14.
for as_var in BASH_ENV ENV MAIL MAILPATH
do eval test x\${$as_var+set} = xset \
  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
PS1='$ '
PS2='> '
PS4='+ '

# NLS nuisances.
LC_ALL=C
export LC_ALL
LANGUAGE=C
export LANGUAGE

# CDPATH.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH


# as_fn_error ERROR [LINENO LOG_FD]
# ---------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with status $?, using 1 if that was 0.
as_fn_error ()
{
  as_status=$?; test $as_status -eq 0 && as_status=1
  if test "$3"; then
    as_lineno=${as_lineno-"$2"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    $as_echo "$as_me:${as_lineno-$LINENO}: error: $1" >&$3
  fi
  $as_echo "$as_me: error: $1" >&2
  as_fn_exit $as_status
} # as_fn_error


# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
  return $1
} # as_fn_set_status

# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
  set +e
  as_fn_set_status $1
  exit $1
} # as_fn_exit

# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
  { eval $1=; unset $1;}
}
as_unset=as_fn_unset
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
  eval 'as_fn_append ()
  {
    eval $1+=\$2
  }'
else
  as_fn_append ()
  {
    eval $1=\$$1\$2
  }
fi # as_fn_append

# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
  eval 'as_fn_arith ()
  {
    as_val=$(( $* ))
  }'
else
  as_fn_arith ()
  {
    as_val=`expr "$@" || test $? -eq 1`
  }
fi # as_fn_arith


if expr a : '\(a\)' >/dev/null 2>&1 &&
   test "X`expr 00001 : '.*\(...\)'`" = X001; then
  as_expr=expr
else
  as_expr=false
fi

if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
  as_basename=basename
else
  as_basename=false
fi

if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
  as_dirname=dirname
else
  as_dirname=false
fi

as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
	 X"$0" : 'X\(//\)$' \| \
	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X/"$0" |
    sed '/^.*\/\([^/][^/]*\)\/*$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`

# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits

ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in #(((((
-n*)
  case `echo 'xy\c'` in
  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
  xy)  ECHO_C='\c';;
  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
       ECHO_T='	';;
  esac;;
*)
  ECHO_N='-n';;
esac

rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
  rm -f conf$$.dir/conf$$.file
else
  rm -f conf$$.dir
  mkdir conf$$.dir 2>/dev/null
fi
if (echo >conf$$.file) 2>/dev/null; then
  if ln -s conf$$.file conf$$ 2>/dev/null; then
    as_ln_s='ln -s'
    # ... but there are two gotchas:
    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
    # In both cases, we have to default to `cp -p'.
    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
      as_ln_s='cp -p'
  elif ln conf$$.file conf$$ 2>/dev/null; then
    as_ln_s=ln
  else
    as_ln_s='cp -p'
  fi
else
  as_ln_s='cp -p'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null


# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{

  case $as_dir in #(
  -*) as_dir=./$as_dir;;
  esac
  test -d "$as_dir" || eval $as_mkdir_p || {
    as_dirs=
    while :; do
      case $as_dir in #(
      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
      *) as_qdir=$as_dir;;
      esac
      as_dirs="'$as_qdir' $as_dirs"
      as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_dir" : 'X\(//\)[^/]' \| \
	 X"$as_dir" : 'X\(//\)$' \| \
	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
      test -d "$as_dir" && break
    done
    test -z "$as_dirs" || eval "mkdir $as_dirs"
  } || test -d "$as_dir" || as_fn_error "cannot create directory $as_dir"


} # as_fn_mkdir_p
if mkdir -p . 2>/dev/null; then
  as_mkdir_p='mkdir -p "$as_dir"'
else
  test -d ./-p && rmdir ./-p
  as_mkdir_p=false
fi

if test -x / >/dev/null 2>&1; then
  as_test_x='test -x'
else
  if ls -dL / >/dev/null 2>&1; then
    as_ls_L_option=L
  else
    as_ls_L_option=
  fi
  as_test_x='
    eval sh -c '\''
      if test -d "$1"; then
	test -d "$1/.";
      else
	case $1 in #(
	-*)set "./$1";;
	esac;
	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
	???[sx]*):;;*)false;;esac;fi
    '\'' sh
  '
fi
as_executable_p=$as_test_x

# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

# Sed expression to map a string onto a valid variable name.
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"


exec 6>&1
## ----------------------------------- ##
## Main body of $CONFIG_STATUS script. ##
## ----------------------------------- ##
_ASEOF
test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# Save the log message, to keep $0 and so on meaningful, and to
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.
ac_log="
This file was extended by $as_me, which was
generated by GNU Autoconf 2.65.  Invocation command line was

  CONFIG_FILES    = $CONFIG_FILES
  CONFIG_HEADERS  = $CONFIG_HEADERS
  CONFIG_LINKS    = $CONFIG_LINKS
  CONFIG_COMMANDS = $CONFIG_COMMANDS
  $ $0 $@

on `(hostname || uname -n) 2>/dev/null | sed 1q`
"

_ACEOF

case $ac_config_files in *"
"*) set x $ac_config_files; shift; ac_config_files=$*;;
esac



cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
# Files that config.status was made for.
config_files="$ac_config_files"

_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
ac_cs_usage="\
\`$as_me' instantiates files and other configuration actions
from templates according to the current configuration.  Unless the files
and actions are specified as TAGs, all are instantiated by default.

Usage: $0 [OPTION]... [TAG]...

  -h, --help       print this help, then exit
  -V, --version    print version number and configuration settings, then exit
      --config     print configuration, then exit
  -q, --quiet, --silent
                   do not print progress messages
  -d, --debug      don't remove temporary files
      --recheck    update $as_me by reconfiguring in the same conditions
      --file=FILE[:TEMPLATE]
                   instantiate the configuration file FILE

Configuration files:
$config_files

Report bugs to the package provider."

_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
ac_cs_version="\\
config.status
configured by $0, generated by GNU Autoconf 2.65,
  with options \\"\$ac_cs_config\\"

Copyright (C) 2009 Free Software Foundation, Inc.
This config.status script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it."

ac_pwd='$ac_pwd'
srcdir='$srcdir'
AWK='$AWK'
test -n "\$AWK" || AWK=awk
_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# The default lists apply if the user does not specify any file.
ac_need_defaults=:
while test $# != 0
do
  case $1 in
  --*=*)
    ac_option=`expr "X$1" : 'X\([^=]*\)='`
    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
    ac_shift=:
    ;;
  *)
    ac_option=$1
    ac_optarg=$2
    ac_shift=shift
    ;;
  esac

  case $ac_option in
  # Handling of the options.
  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
    ac_cs_recheck=: ;;
  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
    $as_echo "$ac_cs_version"; exit ;;
  --config | --confi | --conf | --con | --co | --c )
    $as_echo "$ac_cs_config"; exit ;;
  --debug | --debu | --deb | --de | --d | -d )
    debug=: ;;
  --file | --fil | --fi | --f )
    $ac_shift
    case $ac_optarg in
    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
    esac
    as_fn_append CONFIG_FILES " '$ac_optarg'"
    ac_need_defaults=false;;
  --he | --h |  --help | --hel | -h )
    $as_echo "$ac_cs_usage"; exit ;;
  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil | --si | --s)
    ac_cs_silent=: ;;

  # This is an error.
  -*) as_fn_error "unrecognized option: \`$1'
Try \`$0 --help' for more information." ;;

  *) as_fn_append ac_config_targets " $1"
     ac_need_defaults=false ;;

  esac
  shift
done

ac_configure_extra_args=

if $ac_cs_silent; then
  exec 6>/dev/null
  ac_configure_extra_args="$ac_configure_extra_args --silent"
fi

_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
if \$ac_cs_recheck; then
  set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
  shift
  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
  CONFIG_SHELL='$SHELL'
  export CONFIG_SHELL
  exec "\$@"
fi

_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
exec 5>>config.log
{
  echo
  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## Running $as_me. ##
_ASBOX
  $as_echo "$ac_log"
} >&5

_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1

# Handling of arguments.
for ac_config_target in $ac_config_targets
do
  case $ac_config_target in
    "set_soenv") CONFIG_FILES="$CONFIG_FILES set_soenv" ;;
    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;

  *) as_fn_error "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
  esac
done


# If the user did not use the arguments to specify the items to instantiate,
# then the envvar interface is used.  Set only those that are not.
# We use the long form for the default assignment because of an extremely
# bizarre bug on SunOS 4.1.3.
if $ac_need_defaults; then
  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
fi

# Have a temporary directory for convenience.  Make it in the build tree
# simply because there is no reason against having it here, and in addition,
# creating and moving files from /tmp can sometimes cause problems.
# Hook for its removal unless debugging.
# Note that there is a small window in which the directory will not be cleaned:
# after its creation but before its name has been assigned to `$tmp'.
$debug ||
{
  tmp=
  trap 'exit_status=$?
  { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
' 0
  trap 'as_fn_exit 1' 1 2 13 15
}
# Create a (secure) tmp directory for tmp files.

{
  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
  test -n "$tmp" && test -d "$tmp"
}  ||
{
  tmp=./conf$$-$RANDOM
  (umask 077 && mkdir "$tmp")
} || as_fn_error "cannot create a temporary directory in ." "$LINENO" 5

# Set up the scripts for CONFIG_FILES section.
# No need to generate them if there are no CONFIG_FILES.
# This happens for instance with `./config.status config.h'.
if test -n "$CONFIG_FILES"; then


ac_cr=`echo X | tr X '\015'`
# On cygwin, bash can eat \r inside `` if the user requested igncr.
# But we know of no other shell where ac_cr would be empty at this
# point, so we can use a bashism as a fallback.
if test "x$ac_cr" = x; then
  eval ac_cr=\$\'\\r\'
fi
ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
  ac_cs_awk_cr='\r'
else
  ac_cs_awk_cr=$ac_cr
fi

echo 'BEGIN {' >"$tmp/subs1.awk" &&
_ACEOF


{
  echo "cat >conf$$subs.awk <<_ACEOF" &&
  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
  echo "_ACEOF"
} >conf$$subs.sh ||
  as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5
ac_delim_num=`echo "$ac_subst_vars" | grep -c '$'`
ac_delim='%!_!# '
for ac_last_try in false false false false false :; do
  . ./conf$$subs.sh ||
    as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5

  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
  if test $ac_delim_n = $ac_delim_num; then
    break
  elif $ac_last_try; then
    as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5
  else
    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
  fi
done
rm -f conf$$subs.sh

cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
cat >>"\$tmp/subs1.awk" <<\\_ACAWK &&
_ACEOF
sed -n '
h
s/^/S["/; s/!.*/"]=/
p
g
s/^[^!]*!//
:repl
t repl
s/'"$ac_delim"'$//
t delim
:nl
h
s/\(.\{148\}\)..*/\1/
t more1
s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
p
n
b repl
:more1
s/["\\]/\\&/g; s/^/"/; s/$/"\\/
p
g
s/.\{148\}//
t nl
:delim
h
s/\(.\{148\}\)..*/\1/
t more2
s/["\\]/\\&/g; s/^/"/; s/$/"/
p
b
:more2
s/["\\]/\\&/g; s/^/"/; s/$/"\\/
p
g
s/.\{148\}//
t delim
' <conf$$subs.awk | sed '
/^[^""]/{
  N
  s/\n//
}
' >>$CONFIG_STATUS || ac_write_fail=1
rm -f conf$$subs.awk
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
_ACAWK
cat >>"\$tmp/subs1.awk" <<_ACAWK &&
  for (key in S) S_is_set[key] = 1
  FS = ""

}
{
  line = $ 0
  nfields = split(line, field, "@")
  substed = 0
  len = length(field[1])
  for (i = 2; i < nfields; i++) {
    key = field[i]
    keylen = length(key)
    if (S_is_set[key]) {
      value = S[key]
      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
      len += length(value) + length(field[++i])
      substed = 1
    } else
      len += 1 + keylen
  }

  print line
}

_ACAWK
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
else
  cat
fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \
  || as_fn_error "could not setup config files machinery" "$LINENO" 5
_ACEOF

# VPATH may cause trouble with some makes, so we remove $(srcdir),
# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
# trailing colons and then remove the whole line if VPATH becomes empty
# (actually we leave an empty line to preserve line numbers).
if test "x$srcdir" = x.; then
  ac_vpsub='/^[	 ]*VPATH[	 ]*=/{
s/:*\$(srcdir):*/:/
s/:*\${srcdir}:*/:/
s/:*@srcdir@:*/:/
s/^\([^=]*=[	 ]*\):*/\1/
s/:*$//
s/^[^=]*=[	 ]*$//
}'
fi

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
fi # test -n "$CONFIG_FILES"


eval set X "  :F $CONFIG_FILES      "
shift
for ac_tag
do
  case $ac_tag in
  :[FHLC]) ac_mode=$ac_tag; continue;;
s,^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*([^)]*)\)[	 ]*\(.*\),-D\1=\2,g
t quote
s,^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\),-D\1=\2,g
t quote
d
: quote
s,[	 `~#$^&*(){}\\|;'"<>?],\\&,g
s,\[,\\&,g
s,\],\\&,g
s,\$,$$,g
p
_ACEOF
# We use echo to avoid assuming a particular line-breaking character.
# The extra dot is to prevent the shell from consuming trailing
# line-breaks from the sub-command output.  A line-break within
# single-quotes doesn't work because, if this script is created in a
# platform that uses two characters for line-breaks (e.g., DOS), tr
# would break.
ac_LF_and_DOT=`echo; echo .`
DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
rm -f confdef2opt.sed


ac_libobjs=
ac_ltlibobjs=
for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
  # 1. Remove the extension, and $U if already installed.
  ac_i=`echo "$ac_i" |
	 sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
  # 2. Add them.
  ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
  ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
done
LIBOBJS=$ac_libobjs

LTLIBOBJS=$ac_ltlibobjs



: ${CONFIG_STATUS=./config.status}
ac_clean_files_save=$ac_clean_files
ac_clean_files="$ac_clean_files $CONFIG_STATUS"
{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
echo "$as_me: creating $CONFIG_STATUS" >&6;}
cat >$CONFIG_STATUS <<_ACEOF
#! $SHELL
# Generated by $as_me.
# Run this file to recreate the current configuration.
# Compiler output produced by configure, useful for debugging
# configure, is in config.log if it exists.

debug=false
ac_cs_recheck=false
ac_cs_silent=false
SHELL=\${CONFIG_SHELL-$SHELL}
_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF
## --------------------- ##
## M4sh Initialization.  ##
## --------------------- ##

# Be Bourne compatible
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  emulate sh
  NULLCMD=:
  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  set -o posix
fi
DUALCASE=1; export DUALCASE # for MKS sh

# Support unset when possible.
if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  as_unset=unset
else
  as_unset=false
fi


# Work around bugs in pre-3.0 UWIN ksh.
$as_unset ENV MAIL MAILPATH
PS1='$ '
PS2='> '
PS4='+ '

# NLS nuisances.
for as_var in \
  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  LC_TELEPHONE LC_TIME
do
  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
    eval $as_var=C; export $as_var
  else
    $as_unset $as_var
  fi
done

# Required to use basename.
if expr a : '\(a\)' >/dev/null 2>&1; then
  as_expr=expr
else
  as_expr=false
fi

if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  as_basename=basename
else
  as_basename=false
fi


# Name of the executable.
as_me=`$as_basename "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
	 X"$0" : 'X\(//\)$' \| \
	 X"$0" : 'X\(/\)$' \| \
	 .     : '\(.\)' 2>/dev/null ||
echo X/"$0" |
    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  	  /^X\/\(\/\/\)$/{ s//\1/; q; }
  	  /^X\/\(\/\).*/{ s//\1/; q; }
  	  s/.*/./; q'`


# PATH needs CR, and LINENO needs CR and PATH.
# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits

# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
  echo "#! /bin/sh" >conf$$.sh
  echo  "exit 0"   >>conf$$.sh
  chmod +x conf$$.sh
  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
    PATH_SEPARATOR=';'
  else
    PATH_SEPARATOR=:
  fi
  rm -f conf$$.sh
fi


  as_lineno_1=$LINENO
  as_lineno_2=$LINENO
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
  test "x$as_lineno_1" != "x$as_lineno_2" &&
  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
  # Find who we are.  Look in the path if we contain no path at all
  # relative or not.
  case $0 in
    *[\\/]* ) as_myself=$0 ;;
    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
done

       ;;
  esac
  case $ac_mode$ac_tag in
  :[FHL]*:*);;
  :L* | :C*:*) as_fn_error "invalid tag \`$ac_tag'" "$LINENO" 5;;
  :[FH]-) ac_tag=-:-;;
  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
  if test ! -f "$as_myself"; then
    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
   { (exit 1); exit 1; }; }
  fi
  case $CONFIG_SHELL in
  '')
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  for as_base in sh bash ksh sh5; do
	 case $as_dir in
	 /*)
	   if ("$as_dir/$as_base" -c '
  as_lineno_1=$LINENO
  as_lineno_2=$LINENO
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
  test "x$as_lineno_1" != "x$as_lineno_2" &&
  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
	     $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
	     $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
	     CONFIG_SHELL=$as_dir/$as_base
	     export CONFIG_SHELL
	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}
	   fi;;
	 esac
       done
done
;;
  esac
  ac_save_IFS=$IFS
  IFS=:
  set x $ac_tag
  IFS=$ac_save_IFS
  shift
  ac_file=$1
  shift

  case $ac_mode in
  :L) ac_source=$1;;
  :[FH])
    ac_file_inputs=
    for ac_f
    do
      case $ac_f in
      -) ac_f="$tmp/stdin";;
      *) # Look for the file first in the build tree, then in the source tree
	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
	 # because $ac_f cannot contain `:'.
	 test -f "$ac_f" ||
	   case $ac_f in
	   [\\/$]*) false;;
	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
	   esac ||
	   as_fn_error "cannot find input file: \`$ac_f'" "$LINENO" 5;;
      esac
      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
      as_fn_append ac_file_inputs " '$ac_f'"
    done

    # Let's still pretend it is `configure' which instantiates (i.e., don't
    # use $as_me), people would be surprised to read:
    #    /* config.h.  Generated by config.status.  */
    configure_input='Generated from '`
	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
	`' by configure.'
    if test x"$ac_file" != x-; then
      configure_input="$ac_file.  $configure_input"
      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
$as_echo "$as_me: creating $ac_file" >&6;}
    fi
    # Neutralize special characters interpreted by sed in replacement strings.
    case $configure_input in #(
    *\&* | *\|* | *\\* )
       ac_sed_conf_input=`$as_echo "$configure_input" |
       sed 's/[\\\\&|]/\\\\&/g'`;; #(
    *) ac_sed_conf_input=$configure_input;;
    esac

    case $ac_tag in
    *:-:* | *:-) cat >"$tmp/stdin" \
      || as_fn_error "could not create $ac_file" "$LINENO" 5 ;;
    esac
    as_ln_s='cp -p'
  else
    as_ln_s='ln -s'
  fi
elif ln conf$$.file conf$$ 2>/dev/null; then
  as_ln_s=ln
else
  as_ln_s='cp -p'
fi
rm -f conf$$ conf$$.exe conf$$.file

if mkdir -p . 2>/dev/null; then
  as_mkdir_p=:
else
  test -d ./-p && rmdir ./-p
  as_mkdir_p=false
fi

as_executable_p="test -f"

# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

# Sed expression to map a string onto a valid variable name.
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"


# IFS
# We need space, tab and new line, in precisely that order.
as_nl='
'
IFS=" 	$as_nl"

# CDPATH.
$as_unset CDPATH

exec 6>&1

# Open the log real soon, to keep \$[0] and so on meaningful, and to
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.  Logging --version etc. is OK.
exec 5>>config.log
{
  echo
  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## Running $as_me. ##
_ASBOX
} >&5
cat >&5 <<_CSEOF

This file was extended by $as_me, which was
generated by GNU Autoconf 2.59.  Invocation command line was

  CONFIG_FILES    = $CONFIG_FILES
  CONFIG_HEADERS  = $CONFIG_HEADERS
  CONFIG_LINKS    = $CONFIG_LINKS
  CONFIG_COMMANDS = $CONFIG_COMMANDS
  $ $0 $@

_CSEOF
echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
echo >&5
_ACEOF

# Files that config.status was made for.
if test -n "$ac_config_files"; then
  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
fi

if test -n "$ac_config_headers"; then
  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
fi

if test -n "$ac_config_links"; then
  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
fi

if test -n "$ac_config_commands"; then
  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
fi

cat >>$CONFIG_STATUS <<\_ACEOF

ac_cs_usage="\
\`$as_me' instantiates files from templates according to the
current configuration.

Usage: $0 [OPTIONS] [FILE]...

  -h, --help       print this help, then exit
  -V, --version    print version number, then exit
  -q, --quiet      do not print progress messages
  -d, --debug      don't remove temporary files
      --recheck    update $as_me by reconfiguring in the same conditions
  --file=FILE[:TEMPLATE]
		   instantiate the configuration file FILE

Configuration files:
$config_files

Report bugs to <bug-autoconf@gnu.org>."
_ACEOF

cat >>$CONFIG_STATUS <<_ACEOF
ac_cs_version="\\
config.status
configured by $0, generated by GNU Autoconf 2.59,
  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"

Copyright (C) 2003 Free Software Foundation, Inc.
This config.status script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it."
srcdir=$srcdir
_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF
# If no file are specified by the user, then we need to provide default
# value.  By we need to know if files were specified by the user.
ac_need_defaults=:
while test $# != 0
do
  case $1 in
  --*=*)
    ac_option=`expr "x$1" : 'x\([^=]*\)='`
    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
    ac_shift=:
    ;;
  -*)
    ac_option=$1
    ac_optarg=$2
    ac_shift=shift
    ;;
  *) # This is not an option, so the user has probably given explicit
     # arguments.
     ac_option=$1
     ac_need_defaults=false;;
  esac

  ac_dir=`$as_dirname -- "$ac_file" ||
  # Handling of the options.
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF
  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
    ac_cs_recheck=: ;;
  --version | --vers* | -V )
    echo "$ac_cs_version"; exit 0 ;;
  --he | --h)
    # Conflict between --help and --header
    { { echo "$as_me:$LINENO: error: ambiguous option: $1
Try \`$0 --help' for more information." >&5
echo "$as_me: error: ambiguous option: $1
Try \`$0 --help' for more information." >&2;}
   { (exit 1); exit 1; }; };;
  --help | --hel | -h )
    echo "$ac_cs_usage"; exit 0 ;;
  --debug | --d* | -d )
    debug=: ;;
  --file | --fil | --fi | --f )
    $ac_shift
    CONFIG_FILES="$CONFIG_FILES $ac_optarg"
    ac_need_defaults=false;;
  --header | --heade | --head | --hea )
    $ac_shift
    CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
    ac_need_defaults=false;;
  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil | --si | --s)
    ac_cs_silent=: ;;

  # This is an error.
  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
Try \`$0 --help' for more information." >&5
echo "$as_me: error: unrecognized option: $1
Try \`$0 --help' for more information." >&2;}
   { (exit 1); exit 1; }; } ;;

  *) ac_config_targets="$ac_config_targets $1" ;;

  esac
  shift
done

ac_configure_extra_args=

if $ac_cs_silent; then
  exec 6>/dev/null
  ac_configure_extra_args="$ac_configure_extra_args --silent"
fi

_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF
if \$ac_cs_recheck; then
  echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
  exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
fi

_ACEOF





cat >>$CONFIG_STATUS <<\_ACEOF
for ac_config_target in $ac_config_targets
do
  case "$ac_config_target" in
  # Handling of arguments.
  "set_soenv" ) CONFIG_FILES="$CONFIG_FILES set_soenv" ;;
  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
   { (exit 1); exit 1; }; };;
  esac
done

# If the user did not use the arguments to specify the items to instantiate,
# then the envvar interface is used.  Set only those that are not.
# We use the long form for the default assignment because of an extremely
# bizarre bug on SunOS 4.1.3.
if $ac_need_defaults; then
  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
fi

# Have a temporary directory for convenience.  Make it in the build tree
# simply because there is no reason to put it here, and in addition,
# creating and moving files from /tmp can sometimes cause problems.
# Create a temporary directory, and hook for its removal unless debugging.
$debug ||
{
  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
  trap '{ (exit 1); exit 1; }' 1 2 13 15
}

# Create a (secure) tmp directory for tmp files.

{
  tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
  test -n "$tmp" && test -d "$tmp"
}  ||
{
  tmp=./confstat$$-$RANDOM
  (umask 077 && mkdir $tmp)
} ||
{
   echo "$me: cannot create a temporary directory in ." >&2
   { (exit 1); exit 1; }
}

_ACEOF

cat >>$CONFIG_STATUS <<_ACEOF

#
# CONFIG_FILES section.
#

# No need to generate the scripts if there are no CONFIG_FILES.
# This happens for instance when ./config.status config.h
if test -n "\$CONFIG_FILES"; then
  # Protect against being on the right side of a sed subst in config.status.
  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
s,@SHELL@,$SHELL,;t t
s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
s,@exec_prefix@,$exec_prefix,;t t
s,@prefix@,$prefix,;t t
s,@program_transform_name@,$program_transform_name,;t t
s,@bindir@,$bindir,;t t
s,@sbindir@,$sbindir,;t t
s,@libexecdir@,$libexecdir,;t t
s,@datadir@,$datadir,;t t
s,@sysconfdir@,$sysconfdir,;t t
s,@sharedstatedir@,$sharedstatedir,;t t
s,@localstatedir@,$localstatedir,;t t
s,@libdir@,$libdir,;t t
s,@includedir@,$includedir,;t t
s,@oldincludedir@,$oldincludedir,;t t
s,@infodir@,$infodir,;t t
s,@mandir@,$mandir,;t t
s,@build_alias@,$build_alias,;t t
s,@host_alias@,$host_alias,;t t
s,@target_alias@,$target_alias,;t t
s,@DEFS@,$DEFS,;t t
s,@ECHO_C@,$ECHO_C,;t t
s,@ECHO_N@,$ECHO_N,;t t
s,@ECHO_T@,$ECHO_T,;t t
s,@LIBS@,$LIBS,;t t
s,@EGREP@,$EGREP,;t t
s,@AWK@,$AWK,;t t
s,@SED@,$SED,;t t
s,@LOCAL_SOLENV@,$LOCAL_SOLENV,;t t
s,@_solenv@,$_solenv,;t t
s,@UPD@,$UPD,;t t
s,@SOURCEVERSION@,$SOURCEVERSION,;t t
s,@build@,$build,;t t
s,@build_cpu@,$build_cpu,;t t
s,@build_vendor@,$build_vendor,;t t
s,@build_os@,$build_os,;t t
s,@host@,$host,;t t
s,@host_cpu@,$host_cpu,;t t
s,@host_vendor@,$host_vendor,;t t
s,@host_os@,$host_os,;t t
s,@target@,$target,;t t
s,@target_cpu@,$target_cpu,;t t
s,@target_vendor@,$target_vendor,;t t
s,@target_os@,$target_os,;t t
s,@GNUTAR@,$GNUTAR,;t t
s,@OSVERSION@,$OSVERSION,;t t
s,@PTHREAD_CFLAGS@,$PTHREAD_CFLAGS,;t t
s,@PTHREAD_LIBS@,$PTHREAD_LIBS,;t t
s,@ENABLE_CRASHDUMP@,$ENABLE_CRASHDUMP,;t t
s,@VC_STANDARD@,$VC_STANDARD,;t t
s,@ENABLE_WERROR@,$ENABLE_WERROR,;t t
s,@ENABLE_DEBUG@,$ENABLE_DEBUG,;t t
s,@PRODUCT@,$PRODUCT,;t t
s,@PROFULLSWITCH@,$PROFULLSWITCH,;t t
s,@PROEXT@,$PROEXT,;t t
s,@ENABLE_SYMBOLS@,$ENABLE_SYMBOLS,;t t
s,@DISABLE_STRIP@,$DISABLE_STRIP,;t t
s,@ENABLE_CUPS@,$ENABLE_CUPS,;t t
s,@ENABLE_FONTCONFIG@,$ENABLE_FONTCONFIG,;t t
s,@WITH_BINFILTER@,$WITH_BINFILTER,;t t
s,@ENABLE_DIRECTX@,$ENABLE_DIRECTX,;t t
s,@DISABLE_ACTIVEX@,$DISABLE_ACTIVEX,;t t
s,@DISABLE_ATL@,$DISABLE_ATL,;t t
s,@ENABLE_RPATH@,$ENABLE_RPATH,;t t
s,@WITH_MYSPELL_DICTS@,$WITH_MYSPELL_DICTS,;t t
s,@SYSTEM_DICTS@,$SYSTEM_DICTS,;t t
s,@DICT_SYSTEM_DIR@,$DICT_SYSTEM_DIR,;t t
s,@HYPH_SYSTEM_DIR@,$HYPH_SYSTEM_DIR,;t t
s,@THES_SYSTEM_DIR@,$THES_SYSTEM_DIR,;t t
s,@USE_SHELL@,$USE_SHELL,;t t
s,@WITH_MINGWIN@,$WITH_MINGWIN,;t t
s,@SHELLPATH@,$SHELLPATH,;t t
s,@GCC_HOME@,$GCC_HOME,;t t
s,@CC@,$CC,;t t
s,@CFLAGS@,$CFLAGS,;t t
s,@LDFLAGS@,$LDFLAGS,;t t
s,@CPPFLAGS@,$CPPFLAGS,;t t
s,@ac_ct_CC@,$ac_ct_CC,;t t
s,@EXEEXT@,$EXEEXT,;t t
s,@OBJEXT@,$OBJEXT,;t t
s,@COMPATH@,$COMPATH,;t t
s,@GCCVER@,$GCCVER,;t t
s,@HAVE_LD_BSYMBOLIC_FUNCTIONS@,$HAVE_LD_BSYMBOLIC_FUNCTIONS,;t t
s,@ENABLE_PCH@,$ENABLE_PCH,;t t
s,@NO_HIDS@,$NO_HIDS,;t t
s,@GNUMAKE@,$GNUMAKE,;t t
s,@_cc@,$_cc,;t t
s,@HAVE_LD_HASH_STYLE@,$HAVE_LD_HASH_STYLE,;t t
s,@PERL@,$PERL,;t t
s,@MSPDB_PATH@,$MSPDB_PATH,;t t
s,@COMEX@,$COMEX,;t t
s,@USE_MINGW@,$USE_MINGW,;t t
s,@MIDL_PATH@,$MIDL_PATH,;t t
s,@CSC_PATH@,$CSC_PATH,;t t
s,@FRAME_HOME@,$FRAME_HOME,;t t
s,@CPP@,$CPP,;t t
s,@CXX@,$CXX,;t t
s,@CXXFLAGS@,$CXXFLAGS,;t t
s,@ac_ct_CXX@,$ac_ct_CXX,;t t
s,@CXXCPP@,$CXXCPP,;t t
s,@SIZEOF_LONG@,$SIZEOF_LONG,;t t
s,@WORDS_BIGENDIAN@,$WORDS_BIGENDIAN,;t t
s,@LFS_CFLAGS@,$LFS_CFLAGS,;t t
s,@ENABLE_VBA@,$ENABLE_VBA,;t t
s,@VBA_EXTENSION@,$VBA_EXTENSION,;t t
s,@PAM@,$PAM,;t t
s,@NEW_SHADOW_API@,$NEW_SHADOW_API,;t t
s,@PAM_LINK@,$PAM_LINK,;t t
s,@CRYPT_LINK@,$CRYPT_LINK,;t t
s,@GXX_INCLUDE_PATH@,$GXX_INCLUDE_PATH,;t t
s,@MINGW_LIB_INCLUDE_PATH@,$MINGW_LIB_INCLUDE_PATH,;t t
s,@MINGW_BACKWARD_INCLUDE_PATH@,$MINGW_BACKWARD_INCLUDE_PATH,;t t
s,@MINGW_CLIB_DIR@,$MINGW_CLIB_DIR,;t t
s,@MINGW_SHARED_GCCLIB@,$MINGW_SHARED_GCCLIB,;t t
s,@MINGW_GCCLIB_EH@,$MINGW_GCCLIB_EH,;t t
s,@MINGW_SHARED_GXXLIB@,$MINGW_SHARED_GXXLIB,;t t
s,@MINGW_GCCDLL@,$MINGW_GCCDLL,;t t
s,@MINGW_GXXDLL@,$MINGW_GXXDLL,;t t
s,@EXCEPTIONS@,$EXCEPTIONS,;t t
s,@STLPORT4@,$STLPORT4,;t t
s,@STLPORT_VER@,$STLPORT_VER,;t t
s,@USE_SYSTEM_STL@,$USE_SYSTEM_STL,;t t
s,@USE_CCACHE@,$USE_CCACHE,;t t
s,@CCACHE@,$CCACHE,;t t
s,@HAVE_GCC_VISIBILITY_FEATURE@,$HAVE_GCC_VISIBILITY_FEATURE,;t t
s,@ALLOC@,$ALLOC,;t t
s,@BUILD_VER_STRING@,$BUILD_VER_STRING,;t t
s,@SOLAR_JAVA@,$SOLAR_JAVA,;t t
s,@JAVAINTERPRETER@,$JAVAINTERPRETER,;t t
s,@JAVACOMPILER@,$JAVACOMPILER,;t t
s,@JAVACISGCJ@,$JAVACISGCJ,;t t
s,@JAVADOC@,$JAVADOC,;t t
s,@AWTLIB@,$AWTLIB,;t t
s,@JAVAAOTCOMPILER@,$JAVAAOTCOMPILER,;t t
s,@JAVA_HOME@,$JAVA_HOME,;t t
s,@JDK@,$JDK,;t t
s,@JAVAFLAGS@,$JAVAFLAGS,;t t
s,@DMAKE@,$DMAKE,;t t
s,@BUILD_DMAKE@,$BUILD_DMAKE,;t t
s,@EPM@,$EPM,;t t
s,@DPKG@,$DPKG,;t t
s,@PKGMK@,$PKGMK,;t t
s,@BUILD_EPM@,$BUILD_EPM,;t t
s,@PKGFORMAT@,$PKGFORMAT,;t t
s,@RPM@,$RPM,;t t
s,@GPERF@,$GPERF,;t t
s,@MINGWCXX@,$MINGWCXX,;t t
s,@ac_ct_MINGWCXX@,$ac_ct_MINGWCXX,;t t
s,@MINGWSTRIP@,$MINGWSTRIP,;t t
s,@ac_ct_MINGWSTRIP@,$ac_ct_MINGWSTRIP,;t t
s,@BUILD_UNOWINREG@,$BUILD_UNOWINREG,;t t
s,@BUILD_QADEVOOO@,$BUILD_QADEVOOO,;t t
s,@SYSTEM_STDLIBS@,$SYSTEM_STDLIBS,;t t
s,@SYSTEM_ZLIB@,$SYSTEM_ZLIB,;t t
s,@SYSTEM_JPEG@,$SYSTEM_JPEG,;t t
s,@SYSTEM_EXPAT@,$SYSTEM_EXPAT,;t t
s,@PKG_CONFIG@,$PKG_CONFIG,;t t
s,@LIBWPD_CFLAGS@,$LIBWPD_CFLAGS,;t t
s,@LIBWPD_LIBS@,$LIBWPD_LIBS,;t t
s,@SYSTEM_LIBWPD@,$SYSTEM_LIBWPD,;t t
s,@FREETYPE_CFLAGS@,$FREETYPE_CFLAGS,;t t
s,@FREETYPE_LIBS@,$FREETYPE_LIBS,;t t
s,@USE_FT_EMBOLDEN@,$USE_FT_EMBOLDEN,;t t
s,@LIBXSLT_CFLAGS@,$LIBXSLT_CFLAGS,;t t
s,@LIBXSLT_LIBS@,$LIBXSLT_LIBS,;t t
s,@XSLTPROC@,$XSLTPROC,;t t
s,@SYSTEM_LIBXSLT@,$SYSTEM_LIBXSLT,;t t
s,@LIBXML_CFLAGS@,$LIBXML_CFLAGS,;t t
s,@LIBXML_LIBS@,$LIBXML_LIBS,;t t
s,@SYSTEM_LIBXML@,$SYSTEM_LIBXML,;t t
s,@PYTHON@,$PYTHON,;t t
s,@PYTHON_VERSION@,$PYTHON_VERSION,;t t
s,@PYTHON_PREFIX@,$PYTHON_PREFIX,;t t
s,@PYTHON_EXEC_PREFIX@,$PYTHON_EXEC_PREFIX,;t t
s,@PYTHON_PLATFORM@,$PYTHON_PLATFORM,;t t
s,@pythondir@,$pythondir,;t t
s,@pkgpythondir@,$pkgpythondir,;t t
s,@pyexecdir@,$pyexecdir,;t t
s,@pkgpyexecdir@,$pkgpyexecdir,;t t
s,@BZIP2@,$BZIP2,;t t
s,@SYSTEM_PYTHON@,$SYSTEM_PYTHON,;t t
s,@PYTHON_CFLAGS@,$PYTHON_CFLAGS,;t t
s,@PYTHON_LIBS@,$PYTHON_LIBS,;t t
s,@HOME@,$HOME,;t t
s,@SYSTEM_DB@,$SYSTEM_DB,;t t
s,@DB_VERSION@,$DB_VERSION,;t t
s,@DB_INCLUDES@,$DB_INCLUDES,;t t
s,@DB_JAR@,$DB_JAR,;t t
s,@SYSTEM_LUCENE@,$SYSTEM_LUCENE,;t t
s,@LUCENE_CORE_JAR@,$LUCENE_CORE_JAR,;t t
s,@LUCENE_ANALYZERS_JAR@,$LUCENE_ANALYZERS_JAR,;t t
s,@ENABLE_MYSQLC@,$ENABLE_MYSQLC,;t t
s,@MYSQLCONFIG@,$MYSQLCONFIG,;t t
s,@SYSTEM_MYSQL@,$SYSTEM_MYSQL,;t t
s,@MYSQL_INC@,$MYSQL_INC,;t t
s,@MYSQL_LIB@,$MYSQL_LIB,;t t
s,@MYSQL_DEFINES@,$MYSQL_DEFINES,;t t
s,@LIBMYSQL_PATH@,$LIBMYSQL_PATH,;t t
s,@SYSTEM_MYSQL_CPPCONN@,$SYSTEM_MYSQL_CPPCONN,;t t
s,@SYSTEM_HSQLDB@,$SYSTEM_HSQLDB,;t t
s,@HSQLDB_JAR@,$HSQLDB_JAR,;t t
s,@SYSTEM_BSH@,$SYSTEM_BSH,;t t
s,@BSH_JAR@,$BSH_JAR,;t t
s,@SERIALIZER_JAR@,$SERIALIZER_JAR,;t t
s,@SYSTEM_SAXON@,$SYSTEM_SAXON,;t t
s,@SAXON_JAR@,$SAXON_JAR,;t t
s,@CURLCONFIG@,$CURLCONFIG,;t t
s,@SYSTEM_CURL@,$SYSTEM_CURL,;t t
s,@CURL_CFLAGS@,$CURL_CFLAGS,;t t
s,@CURL_LIBS@,$CURL_LIBS,;t t
s,@SYSTEM_BOOST@,$SYSTEM_BOOST,;t t
s,@SYSTEM_VIGRA@,$SYSTEM_VIGRA,;t t
s,@SYSTEM_ODBC_HEADERS@,$SYSTEM_ODBC_HEADERS,;t t
s,@WITH_MOZILLA@,$WITH_MOZILLA,;t t
s,@WITH_LDAP@,$WITH_LDAP,;t t
s,@WITH_OPENLDAP@,$WITH_OPENLDAP,;t t
s,@MOZ_NSS_CFLAGS@,$MOZ_NSS_CFLAGS,;t t
s,@MOZ_NSS_LIBS@,$MOZ_NSS_LIBS,;t t
s,@NSS_LIB@,$NSS_LIB,;t t
s,@MOZ_NSPR_CFLAGS@,$MOZ_NSPR_CFLAGS,;t t
s,@MOZ_NSPR_LIBS@,$MOZ_NSPR_LIBS,;t t
s,@NSPR_LIB@,$NSPR_LIB,;t t
s,@MOZILLAXPCOM_CFLAGS@,$MOZILLAXPCOM_CFLAGS,;t t
s,@MOZILLAXPCOM_LIBS@,$MOZILLAXPCOM_LIBS,;t t
s,@MOZILLA_VERSION@,$MOZILLA_VERSION,;t t
s,@MOZILLA_TOOLKIT@,$MOZILLA_TOOLKIT,;t t
s,@MOZGTK2_CFLAGS@,$MOZGTK2_CFLAGS,;t t
s,@MOZGTK2_LIBS@,$MOZGTK2_LIBS,;t t
s,@MOZLIBREQ_CFLAGS@,$MOZLIBREQ_CFLAGS,;t t
s,@MOZLIBREQ_LIBS@,$MOZLIBREQ_LIBS,;t t
s,@BUILD_MOZAB@,$BUILD_MOZAB,;t t
s,@ENABLE_NSS_MODULE@,$ENABLE_NSS_MODULE,;t t
s,@MOZILLABUILD@,$MOZILLABUILD,;t t
s,@SYSTEM_MOZILLA@,$SYSTEM_MOZILLA,;t t
s,@MOZ_FLAVOUR@,$MOZ_FLAVOUR,;t t
s,@MOZ_INC@,$MOZ_INC,;t t
s,@MOZ_LIB@,$MOZ_LIB,;t t
s,@MOZ_LIB_XPCOM@,$MOZ_LIB_XPCOM,;t t
s,@MOZ_LDAP_CFLAGS@,$MOZ_LDAP_CFLAGS,;t t
s,@SYSTEM_SANE_HEADER@,$SYSTEM_SANE_HEADER,;t t
s,@SYSTEM_GENBRK@,$SYSTEM_GENBRK,;t t
s,@SYSTEM_GENCCODE@,$SYSTEM_GENCCODE,;t t
s,@SYSTEM_GENCMN@,$SYSTEM_GENCMN,;t t
s,@SYSTEM_ICU@,$SYSTEM_ICU,;t t
s,@GRAPHITE_CFLAGS@,$GRAPHITE_CFLAGS,;t t
s,@GRAPHITE_LIBS@,$GRAPHITE_LIBS,;t t
s,@ENABLE_GRAPHITE@,$ENABLE_GRAPHITE,;t t
s,@SYSTEM_GRAPHITE@,$SYSTEM_GRAPHITE,;t t
s,@X_CFLAGS@,$X_CFLAGS,;t t
s,@X_PRE_LIBS@,$X_PRE_LIBS,;t t
s,@X_LIBS@,$X_LIBS,;t t
s,@X_EXTRA_LIBS@,$X_EXTRA_LIBS,;t t
s,@XINC@,$XINC,;t t
s,@XLIB@,$XLIB,;t t
s,@XAU_LIBS@,$XAU_LIBS,;t t
s,@DISABLE_XAW@,$DISABLE_XAW,;t t
s,@SYSTEM_XRENDER_HEADERS@,$SYSTEM_XRENDER_HEADERS,;t t
s,@XRENDER_LINK@,$XRENDER_LINK,;t t
s,@XRANDR_CFLAGS@,$XRANDR_CFLAGS,;t t
s,@XRANDR_LIBS@,$XRANDR_LIBS,;t t
s,@XRANDR_DLOPEN@,$XRANDR_DLOPEN,;t t
s,@ENABLE_RANDR@,$ENABLE_RANDR,;t t
s,@DISABLE_NEON@,$DISABLE_NEON,;t t
s,@NEON_CFLAGS@,$NEON_CFLAGS,;t t
s,@NEON_LIBS@,$NEON_LIBS,;t t
s,@SYSTEM_NEON@,$SYSTEM_NEON,;t t
s,@NEON_VERSION@,$NEON_VERSION,;t t
s,@OPENSSL_CFLAGS@,$OPENSSL_CFLAGS,;t t
s,@OPENSSL_LIBS@,$OPENSSL_LIBS,;t t
s,@SYSTEM_OPENSSL@,$SYSTEM_OPENSSL,;t t
s,@ENABLE_AGG@,$ENABLE_AGG,;t t
s,@AGG_CFLAGS@,$AGG_CFLAGS,;t t
s,@AGG_LIBS@,$AGG_LIBS,;t t
s,@SYSTEM_AGG@,$SYSTEM_AGG,;t t
s,@AGG_VERSION@,$AGG_VERSION,;t t
s,@REDLAND_CFLAGS@,$REDLAND_CFLAGS,;t t
s,@REDLAND_LIBS@,$REDLAND_LIBS,;t t
s,@SYSTEM_REDLAND@,$SYSTEM_REDLAND,;t t
s,@HUNSPELL_CFLAGS@,$HUNSPELL_CFLAGS,;t t
s,@HUNSPELL_LIBS@,$HUNSPELL_LIBS,;t t
s,@SYSTEM_HUNSPELL@,$SYSTEM_HUNSPELL,;t t
s,@SYSTEM_HYPH@,$SYSTEM_HYPH,;t t
s,@HYPHEN_LIB@,$HYPHEN_LIB,;t t
s,@SYSTEM_MYTHES@,$SYSTEM_MYTHES,;t t
s,@SYSTEM_LPSOLVE@,$SYSTEM_LPSOLVE,;t t
s,@PSDK_HOME@,$PSDK_HOME,;t t
s,@WINDOWS_VISTA_PSDK@,$WINDOWS_VISTA_PSDK,;t t
s,@DIRECTXSDK_HOME@,$DIRECTXSDK_HOME,;t t
s,@DIRECTXSDK_LIB@,$DIRECTXSDK_LIB,;t t
s,@NSIS_PATH@,$NSIS_PATH,;t t
s,@BISON@,$BISON,;t t
s,@FLEX@,$FLEX,;t t
s,@PATCH@,$PATCH,;t t
s,@GNUCP@,$GNUCP,;t t
s,@GNUPATCH@,$GNUPATCH,;t t
s,@CYGWIN_PATH@,$CYGWIN_PATH,;t t
s,@ML_EXE@,$ML_EXE,;t t
s,@ASM_HOME@,$ASM_HOME,;t t
s,@ZIP@,$ZIP,;t t
s,@UNZIP@,$UNZIP,;t t
s,@ZIP_HOME@,$ZIP_HOME,;t t
s,@ENABLE_GTK@,$ENABLE_GTK,;t t
s,@ENABLE_KDE@,$ENABLE_KDE,;t t
s,@ENABLE_KDE4@,$ENABLE_KDE4,;t t
s,@GCONF_CFLAGS@,$GCONF_CFLAGS,;t t
s,@GCONF_LIBS@,$GCONF_LIBS,;t t
s,@ENABLE_GCONF@,$ENABLE_GCONF,;t t
s,@GNOMEVFS_CFLAGS@,$GNOMEVFS_CFLAGS,;t t
s,@GNOMEVFS_LIBS@,$GNOMEVFS_LIBS,;t t
s,@ENABLE_GNOMEVFS@,$ENABLE_GNOMEVFS,;t t
s,@GTK_CFLAGS@,$GTK_CFLAGS,;t t
s,@GTK_LIBS@,$GTK_LIBS,;t t
s,@DBUS_CFLAGS@,$DBUS_CFLAGS,;t t
s,@DBUS_LIBS@,$DBUS_LIBS,;t t
s,@GIO_CFLAGS@,$GIO_CFLAGS,;t t
s,@GIO_LIBS@,$GIO_LIBS,;t t
s,@ENABLE_GIO@,$ENABLE_GIO,;t t
s,@ENABLE_DBUS@,$ENABLE_DBUS,;t t
s,@ENABLE_SYSTRAY_GTK@,$ENABLE_SYSTRAY_GTK,;t t
s,@CAIRO_CFLAGS@,$CAIRO_CFLAGS,;t t
s,@CAIRO_LIBS@,$CAIRO_LIBS,;t t
s,@ENABLE_CAIRO@,$ENABLE_CAIRO,;t t
s,@BUILD_PIXMAN@,$BUILD_PIXMAN,;t t
s,@SYSTEM_CAIRO@,$SYSTEM_CAIRO,;t t
s,@ENABLE_OPENGL@,$ENABLE_OPENGL,;t t
s,@ENABLE_PRESENTER_EXTRA_UI@,$ENABLE_PRESENTER_EXTRA_UI,;t t
s,@ENABLE_MINIMIZER@,$ENABLE_MINIMIZER,;t t
s,@ENABLE_PRESENTER_SCREEN@,$ENABLE_PRESENTER_SCREEN,;t t
s,@POPPLER_CFLAGS@,$POPPLER_CFLAGS,;t t
s,@POPPLER_LIBS@,$POPPLER_LIBS,;t t
s,@ENABLE_PDFIMPORT@,$ENABLE_PDFIMPORT,;t t
s,@SYSTEM_POPPLER@,$SYSTEM_POPPLER,;t t
s,@ENABLE_MEDIAWIKI@,$ENABLE_MEDIAWIKI,;t t
s,@SYSTEM_SERVLETAPI@,$SYSTEM_SERVLETAPI,;t t
s,@SERVLETAPI_JAR@,$SERVLETAPI_JAR,;t t
s,@ENABLE_REPORTBUILDER@,$ENABLE_REPORTBUILDER,;t t
s,@SYSTEM_JFREEREPORT@,$SYSTEM_JFREEREPORT,;t t
s,@SAC_JAR@,$SAC_JAR,;t t
s,@LIBXML_JAR@,$LIBXML_JAR,;t t
s,@FLUTE_JAR@,$FLUTE_JAR,;t t
s,@JFREEREPORT_JAR@,$JFREEREPORT_JAR,;t t
s,@LIBBASE_JAR@,$LIBBASE_JAR,;t t
s,@LIBLAYOUT_JAR@,$LIBLAYOUT_JAR,;t t
s,@LIBLOADER_JAR@,$LIBLOADER_JAR,;t t
s,@LIBFORMULA_JAR@,$LIBFORMULA_JAR,;t t
s,@LIBREPOSITORY_JAR@,$LIBREPOSITORY_JAR,;t t
s,@LIBFONTS_JAR@,$LIBFONTS_JAR,;t t
s,@LIBSERIALIZER_JAR@,$LIBSERIALIZER_JAR,;t t
s,@SYSTEM_APACHE_COMMONS@,$SYSTEM_APACHE_COMMONS,;t t
s,@COMMONS_CODEC_JAR@,$COMMONS_CODEC_JAR,;t t
s,@COMMONS_LANG_JAR@,$COMMONS_LANG_JAR,;t t
s,@COMMONS_HTTPCLIENT_JAR@,$COMMONS_HTTPCLIENT_JAR,;t t
s,@COMMONS_LOGGING_JAR@,$COMMONS_LOGGING_JAR,;t t
s,@MOC@,$MOC,;t t
s,@KDE_CFLAGS@,$KDE_CFLAGS,;t t
s,@KDE_LIBS@,$KDE_LIBS,;t t
s,@MOC4@,$MOC4,;t t
s,@KDE4_CFLAGS@,$KDE4_CFLAGS,;t t
s,@KDE4_LIBS@,$KDE4_LIBS,;t t
s,@ENABLE_LOCKDOWN@,$ENABLE_LOCKDOWN,;t t
s,@GOBJECT_CFLAGS@,$GOBJECT_CFLAGS,;t t
s,@GOBJECT_LIBS@,$GOBJECT_LIBS,;t t
s,@ENABLE_EVOAB2@,$ENABLE_EVOAB2,;t t
s,@ENABLE_KAB@,$ENABLE_KAB,;t t
s,@WITH_FONTS@,$WITH_FONTS,;t t
s,@WITHOUT_PPDS@,$WITHOUT_PPDS,;t t
s,@WITHOUT_AFMS@,$WITHOUT_AFMS,;t t
s,@SCPDEFS@,$SCPDEFS,;t t
s,@USE_XINERAMA@,$USE_XINERAMA,;t t
s,@XINERAMA_LINK@,$XINERAMA_LINK,;t t
s,@ANT@,$ANT,;t t
s,@ANT_HOME@,$ANT_HOME,;t t
s,@ANT_LIB@,$ANT_LIB,;t t
s,@WITH_LANG@,$WITH_LANG,;t t
s,@WITH_POOR_HELP_LOCALIZATIONS@,$WITH_POOR_HELP_LOCALIZATIONS,;t t
s,@WITH_DICT@,$WITH_DICT,;t t
s,@INTRO_BITMAPS@,$INTRO_BITMAPS,;t t
s,@ABOUT_BITMAPS@,$ABOUT_BITMAPS,;t t
s,@OOO_VENDOR@,$OOO_VENDOR,;t t
s,@UNIXWRAPPERNAME@,$UNIXWRAPPERNAME,;t t
s,@ENABLE_STATIC_GTK@,$ENABLE_STATIC_GTK,;t t
s,@ENABLE_LAYOUT@,$ENABLE_LAYOUT,;t t
s,@VERBOSE@,$VERBOSE,;t t
s,@LOCAL_SOLVER@,$LOCAL_SOLVER,;t t
s,@BUILD_TYPE@,$BUILD_TYPE,;t t
s,@LIBOBJS@,$LIBOBJS,;t t
s,@LTLIBOBJS@,$LTLIBOBJS,;t t
CEOF

_ACEOF

  cat >>$CONFIG_STATUS <<\_ACEOF
  # Split the substitutions into bite-sized pieces for seds with
  # small command number limits, like on Digital OSF/1 and HP-UX.
  ac_max_sed_lines=48
  ac_sed_frag=1 # Number of current file.
  ac_beg=1 # First line for current file.
  ac_end=$ac_max_sed_lines # Line after last line for current file.
  ac_more_lines=:
  ac_sed_cmds=
  while $ac_more_lines; do
    if test $ac_beg -gt 1; then
      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
    else
      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
    fi
    if test ! -s $tmp/subs.frag; then
      ac_more_lines=false
    else
      # The purpose of the label and of the branching condition is to
      # speed up the sed processing (if there are no `@' at all, there
      # is no need to browse any of the substitutions).
      # These are the two extra sed commands mentioned above.
      (echo ':t
  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
      if test -z "$ac_sed_cmds"; then
	ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
      else
	ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
      fi
      ac_sed_frag=`expr $ac_sed_frag + 1`
      ac_beg=$ac_end
      ac_end=`expr $ac_end + $ac_max_sed_lines`
    fi
  done
  if test -z "$ac_sed_cmds"; then
    ac_sed_cmds=cat
  fi
fi # test -n "$CONFIG_FILES"

_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF
for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
  case $ac_file in
  - | *:- | *:-:* ) # input from stdin
	cat >$tmp/stdin
	ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
  * )   ac_file_in=$ac_file.in ;;
  esac

  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
  ac_dir=`(dirname "$ac_file") 2>/dev/null ||
$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$ac_file" : 'X\(//\)[^/]' \| \
	 X"$ac_file" : 'X\(//\)$' \| \
	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$ac_file" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
  as_dir="$ac_dir"; as_fn_mkdir_p
	 .     : '\(.\)' 2>/dev/null ||
echo X"$as_dir" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
  	  /^X\(\/\/\)$/{ s//\1/; q; }
  	  /^X\(\/\).*/{ s//\1/; q; }
  	  s/.*/./; q'`
    done
    test ! -n "$as_dirs" || mkdir $as_dirs
  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
   { (exit 1); exit 1; }; }; }

  ac_builddir=.

case "$ac_dir" in
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
*)
  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
  # A ".." for each directory in $ac_dir_suffix.
  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
  case $ac_top_builddir_sub in
  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
  esac ;;
esac
ac_abs_top_builddir=$ac_pwd
ac_abs_builddir=$ac_pwd$ac_dir_suffix
# for backward compatibility:
ac_top_builddir=$ac_top_build_prefix

case $srcdir in
  .)  # We are building in place.
    ac_srcdir=.
    ac_top_srcdir=$ac_top_builddir_sub
    ac_abs_top_srcdir=$ac_pwd ;;
  [\\/]* | ?:[\\/]* )  # Absolute name.
       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
    fi ;;
  [\\/]* | ?:[\\/]* )  # Absolute path.
    ac_srcdir=$srcdir$ac_dir_suffix;
    ac_top_srcdir=$srcdir
    ac_abs_top_srcdir=$srcdir ;;
  *) # Relative name.
    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
    ac_top_srcdir=$ac_top_build_prefix$srcdir
    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
esac
ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix


  case $ac_mode in
  :F)
  #
  # CONFIG_FILE
  #

_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# If the template does not know about datarootdir, expand it.
# FIXME: This hack should be removed a few years after 2.60.
ac_datarootdir_hack=; ac_datarootdir_seen=
ac_sed_dataroot='
/datarootdir/ {
  p
  q
}
/@datadir@/p
/@docdir@/p
/@infodir@/p
/@localedir@/p
/@mandir@/p'
case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
*datarootdir*) ac_datarootdir_seen=yes;;
*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
  ac_datarootdir_hack='
  s&@datadir@&$datadir&g
  s&@docdir@&$docdir&g
  s&@infodir@&$infodir&g
  s&@localedir@&$localedir&g
  s&@mandir@&$mandir&g
  s&\\\${datarootdir}&$datarootdir&g' ;;
esac
_ACEOF

# Neutralize VPATH when `$srcdir' = `.'.
# Shell code in configure.ac might set extrasub.
# FIXME: do we really want to maintain this feature?
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_sed_extra="$ac_vpsub
  #    /* config.h.  Generated by config.status.  */
  if test x"$ac_file" = x-; then
    configure_input=
  else
    configure_input="$ac_file.  "
  fi
  configure_input=$configure_input"Generated from `echo $ac_file_in |
				     sed 's,.*/,,'` by configure."

  # First look for the input files in the build tree, otherwise in the
  # src tree.
  ac_file_inputs=`IFS=:
    for f in $ac_file_in; do
      case $f in
      -) echo $tmp/stdin ;;
      [\\/$]*)
	 # Absolute (can't be DOS-style, as IFS=:)
	 test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
echo "$as_me: error: cannot find input file: $f" >&2;}
   { (exit 1); exit 1; }; }
	 echo "$f";;
      *) # Relative
	 if test -f "$f"; then
	   # Build tree
	   echo "$f"
	 elif test -f "$srcdir/$f"; then
	   # Source tree
	   echo "$srcdir/$f"
	 else
	   # /dev/null tree
	   { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
echo "$as_me: error: cannot find input file: $f" >&2;}
   { (exit 1); exit 1; }; }
	 fi;;
      esac
    done` || { (exit 1); exit 1; }
_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF
  sed "$ac_vpsub
$extrasub
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
:t
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
s|@configure_input@|$ac_sed_conf_input|;t t
s&@top_builddir@&$ac_top_builddir_sub&;t t
s&@top_build_prefix@&$ac_top_build_prefix&;t t
s&@srcdir@&$ac_srcdir&;t t
s&@abs_srcdir@&$ac_abs_srcdir&;t t
s&@top_srcdir@&$ac_top_srcdir&;t t
s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
s&@builddir@&$ac_builddir&;t t
s&@abs_builddir@&$ac_abs_builddir&;t t
s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
$ac_datarootdir_hack
"
eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \
  || as_fn_error "could not create $ac_file" "$LINENO" 5

test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
  { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
which seems to be undefined.  Please make sure it is defined." >&5
$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
which seems to be undefined.  Please make sure it is defined." >&2;}

  rm -f "$tmp/stdin"
  case $ac_file in
  -) cat "$tmp/out" && rm -f "$tmp/out";;
  *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";;
  esac \
  || as_fn_error "could not create $ac_file" "$LINENO" 5
 ;;



  esac

done # for ac_tag


as_fn_exit 0
_ACEOF
ac_clean_files=$ac_clean_files_save

test $ac_write_fail = 0 ||
  as_fn_error "write failure creating $CONFIG_STATUS" "$LINENO" 5


# configure is writing to config.log, and then calls config.status.
# config.status does its own redirection, appending to config.log.

  exec 5>>config.log
  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
  # would make configure fail if this is the last instruction.
  $ac_cs_success || as_fn_exit $?
fi
if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
fi






fi
AC_SUBST(WITH_MYSPELL_DICTS)

AC_MSG_CHECKING([whether to use dicts from external paths])
if test -n "$with_system_dicts" -a "$with_system_dicts" = "yes"; then
 AC_MSG_RESULT([yes])
 SYSTEM_DICTS=YES
 AC_MSG_CHECKING([for spelling dictionary directory])
 if test -n "$with_external_dict_dir"; then
 	DICT_SYSTEM_DIR=file://$with_external_dict_dir
 else
 	DICT_SYSTEM_DIR=file:///usr/share/hunspell
 fi
 AC_MSG_RESULT([$DICT_SYSTEM_DIR])
 AC_MSG_CHECKING([for hyphenation patterns directory])
 if test -n "$with_external_hyph_dir"; then
 	HYPH_SYSTEM_DIR=file://$with_external_hyph_dir
 else
 	HYPH_SYSTEM_DIR=file:///usr/share/hyphen
 fi
 AC_MSG_RESULT([$HYPH_SYSTEM_DIR])
 AC_MSG_CHECKING([for thesaurus directory])
 if test -n "$with_external_thes_dir"; then
 	THES_SYSTEM_DIR=file://$with_external_thes_dir
 else
 	THES_SYSTEM_DIR=file:///usr/share/mythes
 fi
 AC_MSG_RESULT([$THES_SYSTEM_DIR])
else
	AC_MSG_RESULT([no])
	SYSTEM_DICTS=NO
fi

fi
AC_SUBST(SYSTEM_DICTS)
AC_SUBST(DICT_SYSTEM_DIR)
AC_SUBST(HYPH_SYSTEM_DIR)

	AC_MSG_CHECKING([MySQL version])
	MYSQL_VERSION=`$MYSQLCONFIG --version` 
	MYSQL_MAJOR=`$MYSQLCONFIG --version | cut -d"." -f1`
	if test "$MYSQL_MAJOR" -ge "2"; then
		AC_MSG_RESULT([OK])
	else
		AC_MSG_ERROR([too old, use 5.0.x or 5.1.x])

Lines 53-59 Link Here

(-)a/dbaccess/source/core/misc/userinformation.cxx (-1 / +1 lines)
53	UserInformation::UserInformation()	53	UserInformation::UserInformation()
54	{	54	{
55	Any aValue = ConfigManager::GetDirectConfigProperty(ConfigManager::LOCALE);	55	Any aValue = ConfigManager::GetDirectConfigProperty(ConfigManager::LOCALE);
56	LanguageType eLanguage = MsLangId::convertIsoStringToLanguage(comphelper::getString(aValue),'-');	56	LanguageType eLanguage = MsLangId::convertIsoStringToLanguage(comphelper::getString(aValue));
57	m_aUserLocale = MsLangId::convertLanguageToLocale(eLanguage);	57	m_aUserLocale = MsLangId::convertLanguageToLocale(eLanguage);
58	}	58	}
59		59




    // -----------------------------

    static void convertLanguageToIsoNames( LanguageType nLang,
            rtl::OUString& rLanguageSubtag, rtl::OUString& rRegionSubtag,
            rtl::OUString& rOtherSubtags );
    static void convertLanguageToIsoNames( LanguageType nLang,
            rtl::OString& rLanguageSubtag, rtl::OString& rRegionSubtag,
            rtl::OString& rOtherSubtags );
    static rtl::OUString convertLanguageToIsoString( LanguageType nLang );
    static rtl::OString convertLanguageToIsoByteString( LanguageType nLang );
            sal_Char cSep = '-' );

    // -----------------------------
    // - ConvertIsoNamesToLanguage -
    // -----------------------------

    static LanguageType convertIsoNamesToLanguage( const rtl::OUString& rLanguageSubtag,
            const rtl::OUString& rRegionSubtag, const rtl::OUString& rOtherSubtags );
    static LanguageType convertIsoNamesToLanguage( const rtl::OString& rLanguageSubtag,
            const rtl::OString& rRegionSubtag, const rtl::OString& rOtherSubtags );
    static LanguageType convertIsoStringToLanguage(
            const rtl::OUString& rString );
    static LanguageType convertIsoByteStringToLanguage(
            const rtl::OString& rString );
    static LanguageType convertUnxByteStringToLanguage(
            const rtl::OString& rString );


        LanguageType  mnLang;
        sal_Char      maLangStr[4];
        sal_Char      maCountry[3];
        sal_Char      maScriptOverride[5];
    };

    /** @internal - Return a pointer to the IsoLangEntry of the underlying table,

Lines 43-48 Link Here

(-)a/i18npool/source/isolang/inunx.cxx (+2 lines)
43	#include <rtl/instance.hxx>	43	#include <rtl/instance.hxx>
44	#include "i18npool/mslangid.hxx"	44	#include "i18npool/mslangid.hxx"
45		45
		46	#include <stdio.h>
		47
46	// =======================================================================	48	// =======================================================================
47		49
48	static LanguageType nImplSystemLanguage = LANGUAGE_DONTKNOW;	50	static LanguageType nImplSystemLanguage = LANGUAGE_DONTKNOW;





#include "i18npool/mslangid.hxx"

#include <deque>
#include <stdio.h>

// =======================================================================

struct IsoLangEngEntry

static MsLangId::IsoLangEntry const aImplIsoLangEntries[] =
{
    // MS-LANGID codes               ISO639-1/2/3 ISO3166
    { LANGUAGE_ENGLISH,                     "en", "",   ""   },
    { LANGUAGE_ENGLISH_US,                  "en", "US", "" },
    { LANGUAGE_ENGLISH_UK,                  "en", "GB", "" },
    { LANGUAGE_ENGLISH_AUS,                 "en", "AU", "" },
    { LANGUAGE_ENGLISH_CAN,                 "en", "CA", "" },
    { LANGUAGE_FRENCH,                      "fr", "FR", "" },
    { LANGUAGE_FRENCH,                      "fr", "",   ""  },
    { LANGUAGE_GERMAN,                      "de", "DE", "" },
    { LANGUAGE_ITALIAN,                     "it", "IT", "" },
    { LANGUAGE_DUTCH,                       "nl", "NL", "" },
    { LANGUAGE_SPANISH_MODERN,              "es", "ES", "" },
    { LANGUAGE_SPANISH_DATED,               "es", "ES", "" },
    { LANGUAGE_PORTUGUESE,                  "pt", "PT", "" },
    { LANGUAGE_PORTUGUESE_BRAZILIAN,        "pt", "BR", "" },
    { LANGUAGE_DANISH,                      "da", "DK", "" },
    { LANGUAGE_GREEK,                       "el", "GR", "" },
    { LANGUAGE_CHINESE,                     "zh", "",   "" },
    { LANGUAGE_CHINESE_SIMPLIFIED,          "zh", "CN", "" },
    { LANGUAGE_CHINESE_TRADITIONAL,         "zh", "TW", "" },
    { LANGUAGE_CHINESE_HONGKONG,            "zh", "HK", "" },
    { LANGUAGE_CHINESE_SINGAPORE,           "zh", "SG", "" },
    { LANGUAGE_CHINESE_MACAU,               "zh", "MO", "" },
    { LANGUAGE_ENGLISH_HONG_KONG_SAR,       "en", "HK", "" },
    { LANGUAGE_JAPANESE,                    "ja", "JP", "" },
    { LANGUAGE_KOREAN,                      "ko", "KR", "" },
    { LANGUAGE_KOREAN_JOHAB,                "ko", "KR", "" },
    { LANGUAGE_USER_KOREAN_NORTH,           "ko", "KP", "" },
    { LANGUAGE_SWEDISH,                     "sv", "SE", "" },
    { LANGUAGE_SWEDISH_FINLAND,             "sv", "FI", "" },
    { LANGUAGE_FINNISH,                     "fi", "FI", "" },
    { LANGUAGE_RUSSIAN,                     "ru", "RU", "" },
    { LANGUAGE_TATAR,                       "tt", "RU", "" },
    { LANGUAGE_ENGLISH_NZ,                  "en", "NZ", "" },
    { LANGUAGE_ENGLISH_EIRE,                "en", "IE", "" },
    { LANGUAGE_DUTCH_BELGIAN,               "nl", "BE", "" },
    { LANGUAGE_FRENCH_BELGIAN,              "fr", "BE", "" },
    { LANGUAGE_FRENCH_CANADIAN,             "fr", "CA", "" },
    { LANGUAGE_FRENCH_SWISS,                "fr", "CH", "" },
    { LANGUAGE_GERMAN_SWISS,                "de", "CH", "" },
    { LANGUAGE_GERMAN_AUSTRIAN,             "de", "AT", "" },
    { LANGUAGE_ITALIAN_SWISS,               "it", "CH", "" },
    { LANGUAGE_ALBANIAN,                    "sq", "AL", "" },
    { LANGUAGE_ARABIC_SAUDI_ARABIA,         "ar", "SA", "" },
    { LANGUAGE_ARABIC_EGYPT,                "ar", "EG", "" },
    { LANGUAGE_ARABIC_UAE,                  "ar", "AE", "" },
    { LANGUAGE_ARABIC_IRAQ,                 "ar", "IQ", "" },
    { LANGUAGE_ARABIC_LIBYA,                "ar", "LY", "" },
    { LANGUAGE_ARABIC_ALGERIA,              "ar", "DZ", "" },
    { LANGUAGE_ARABIC_MOROCCO,              "ar", "MA", "" },
    { LANGUAGE_ARABIC_TUNISIA,              "ar", "TN", "" },
    { LANGUAGE_ARABIC_OMAN,                 "ar", "OM", "" },
    { LANGUAGE_ARABIC_YEMEN,                "ar", "YE", "" },
    { LANGUAGE_ARABIC_SYRIA,                "ar", "SY", "" },
    { LANGUAGE_ARABIC_JORDAN,               "ar", "JO", "" },
    { LANGUAGE_ARABIC_LEBANON,              "ar", "LB", "" },
    { LANGUAGE_ARABIC_KUWAIT,               "ar", "KW", "" },
    { LANGUAGE_ARABIC_BAHRAIN,              "ar", "BH", "" },
    { LANGUAGE_ARABIC_QATAR,                "ar", "QA", "" },
    { LANGUAGE_USER_ARABIC_CHAD,            "ar", "TD", "" },
    { LANGUAGE_USER_ARABIC_COMOROS,         "ar", "KM", "" },
    { LANGUAGE_USER_ARABIC_DJIBOUTI,        "ar", "DJ", "" },
    { LANGUAGE_USER_ARABIC_ERITREA,         "ar", "ER", "" },
    { LANGUAGE_USER_ARABIC_ISRAEL,          "ar", "IL", "" },
    { LANGUAGE_USER_ARABIC_MAURITANIA,      "ar", "MR", "" },
    { LANGUAGE_USER_ARABIC_PALESTINE,       "ar", "PS", "" },
    { LANGUAGE_USER_ARABIC_SOMALIA,         "ar", "SO", "" },
    { LANGUAGE_USER_ARABIC_SUDAN,           "ar", "SD", "" },
    { LANGUAGE_ARABIC_PRIMARY_ONLY,         "ar", "",   "" },
    { LANGUAGE_BASQUE,                      "eu", "",   "" },
    { LANGUAGE_BULGARIAN,                   "bg", "BG", "" },
    { LANGUAGE_CZECH,                       "cs", "CZ", "" },
    { LANGUAGE_CZECH,                       "cz", "",   "" },
    { LANGUAGE_ENGLISH_JAMAICA,             "en", "JM", "" },
    { LANGUAGE_ENGLISH_CARRIBEAN,           "en", "BS", "" },   // not 100%, because AG is Bahamas
    { LANGUAGE_ENGLISH_BELIZE,              "en", "BZ", "" },
    { LANGUAGE_ENGLISH_TRINIDAD,            "en", "TT", "" },
    { LANGUAGE_ENGLISH_ZIMBABWE,            "en", "ZW", "" },
    { LANGUAGE_ENGLISH_INDONESIA,           "en", "ID", "" },
    { LANGUAGE_ESTONIAN,                    "et", "EE", "" },
    { LANGUAGE_FAEROESE,                    "fo", "FO", "" },
    { LANGUAGE_FARSI,                       "fa", "IR", "" },
    { LANGUAGE_FRENCH_LUXEMBOURG,           "fr", "LU", "" },
    { LANGUAGE_FRENCH_MONACO,               "fr", "MC", "" },
    { LANGUAGE_GERMAN_LUXEMBOURG,           "de", "LU", "" },
    { LANGUAGE_GERMAN_LIECHTENSTEIN,        "de", "LI", "" },
    { LANGUAGE_HEBREW,                      "he", "IL", "" },   // new: old was "iw"
    { LANGUAGE_HEBREW,                      "iw", "IL", "" },   // old: new is "he"
    { LANGUAGE_HUNGARIAN,                   "hu", "HU", "" },
    { LANGUAGE_ICELANDIC,                   "is", "IS", "" },
    { LANGUAGE_INDONESIAN,                  "id", "ID", "" },   // new: old was "in"
    { LANGUAGE_INDONESIAN,                  "in", "ID", "" },   // old: new is "id"
    { LANGUAGE_NORWEGIAN,                   "no", "NO", "" },
    { LANGUAGE_NORWEGIAN_BOKMAL,            "nb", "NO", "" },
    { LANGUAGE_NORWEGIAN_NYNORSK,           "nn", "NO", "" },
    { LANGUAGE_POLISH,                      "pl", "PL", "" },
    { LANGUAGE_RHAETO_ROMAN,                "rm", "CH", "" },
    { LANGUAGE_ROMANIAN,                    "ro", "RO", "" },
    { LANGUAGE_ROMANIAN_MOLDOVA,            "ro", "MD", "" },
    { LANGUAGE_SLOVAK,                      "sk", "SK", "" },
    { LANGUAGE_SLOVENIAN,                   "sl", "SI", "" },
    { LANGUAGE_SPANISH_MEXICAN,             "es", "MX", "" },
    { LANGUAGE_SPANISH_GUATEMALA,           "es", "GT", "" },
    { LANGUAGE_SPANISH_COSTARICA,           "es", "CR", "" },
    { LANGUAGE_SPANISH_PANAMA,              "es", "PA", "" },
    { LANGUAGE_SPANISH_DOMINICAN_REPUBLIC,  "es", "DO", "" },
    { LANGUAGE_SPANISH_VENEZUELA,           "es", "VE", "" },
    { LANGUAGE_SPANISH_COLOMBIA,            "es", "CO", "" },
    { LANGUAGE_SPANISH_PERU,                "es", "PE", "" },
    { LANGUAGE_SPANISH_ARGENTINA,           "es", "AR", "" },
    { LANGUAGE_SPANISH_ECUADOR,             "es", "EC", "" },
    { LANGUAGE_SPANISH_CHILE,               "es", "CL", "" },
    { LANGUAGE_SPANISH_URUGUAY,             "es", "UY", "" },
    { LANGUAGE_SPANISH_PARAGUAY,            "es", "PY", "" },
    { LANGUAGE_SPANISH_BOLIVIA,             "es", "BO", "" },
    { LANGUAGE_SPANISH_EL_SALVADOR,         "es", "SV", "" },
    { LANGUAGE_SPANISH_HONDURAS,            "es", "HN", "" },
    { LANGUAGE_SPANISH_NICARAGUA,           "es", "NI", "" },
    { LANGUAGE_SPANISH_PUERTO_RICO,         "es", "PR", "" },
    { LANGUAGE_SPANISH_UNITED_STATES,       "es", "US", "" },
    { LANGUAGE_SPANISH_LATIN_AMERICA,       "es", ""  , "" },
    { LANGUAGE_TURKISH,                     "tr", "TR", "" },
    { LANGUAGE_UKRAINIAN,                   "uk", "UA", "" },
    { LANGUAGE_VIETNAMESE,                  "vi", "VN", "" },
    { LANGUAGE_LATVIAN,                     "lv", "LV", "" },
    { LANGUAGE_MACEDONIAN,                  "mk", "MK", "" },
    { LANGUAGE_MALAY,                       "ms", ""  , "" },
    { LANGUAGE_MALAY_MALAYSIA,              "ms", "MY", "" },
    { LANGUAGE_MALAY_BRUNEI_DARUSSALAM,     "ms", "BN", "" },
    { LANGUAGE_ENGLISH_MALAYSIA,            "en", "MY", "" },
    { LANGUAGE_THAI,                        "th", "TH", "" },
    { LANGUAGE_LITHUANIAN,                  "lt", "LT", "" },
    { LANGUAGE_LITHUANIAN_CLASSIC,          "lt", "LT", "" },
    { LANGUAGE_CROATIAN,                    "hr", "HR", "" },   // Croatian in Croatia
    { LANGUAGE_CROATIAN_BOSNIA_HERZEGOVINA, "hr", "BA", "" },
    { LANGUAGE_BOSNIAN_LATIN_BOSNIA_HERZEGOVINA,        "bs", "BA", "" },
    { LANGUAGE_BOSNIAN_CYRILLIC_BOSNIA_HERZEGOVINA, "bs", "BA", "Cyrl" },   // script codes not supported yet
    { LANGUAGE_USER_SERBIAN_CYRILLIC_SERBIA,        "sr", "RS", "" },   // Serbian Cyrillic in Serbia
    { LANGUAGE_SERBIAN_CYRILLIC,                    "sr", "YU", "" },   // legacy Serbian Cyrillic in Serbia and Montenegro (former Yugoslavia); kludge, needed to be sr_CS instead, sr_CS not supported by ICU 2.6 (3.4 does)
    { LANGUAGE_SERBIAN_CYRILLIC,                    "sr", "CS", "" },   // alias to be able to integrate localizations, rsc needs it
    { LANGUAGE_USER_SERBIAN_CYRILLIC_MONTENEGRO,    "sr", "ME", "" },
    { LANGUAGE_SERBIAN_CYRILLIC_BOSNIA_HERZEGOVINA, "sr", "BA", "" },
    { LANGUAGE_SERBIAN,                             "sr", ""  , "" },   // SERBIAN is only LID, MS-LCID not defined (was dupe of CROATIAN)
    { LANGUAGE_USER_SERBIAN_LATIN_SERBIA,           "sh", "RS", "" },   // Serbian Latin in Serbia; kludge, sr_Latn_RS is better, but preferred for backwards compatibility where script codes are not support
    { LANGUAGE_USER_SERBIAN_LATIN_SERBIA,           "sr", "RS", "Latn" },   // Serbian Latin in Serbia
    { LANGUAGE_SERBIAN_LATIN,                       "sh", "YU", "" },   // legacy Serbian Latin in Serbia and Montenegro (former Yugoslavia); kludge, needed to be sr_Latn_CS instead, script codes not supported yet
    { LANGUAGE_SERBIAN_LATIN,                       "sr", "YU", "Latn" },   // legacy Serbian Latin in Serbia and Montenegro (former Yugoslavia);
    { LANGUAGE_SERBIAN_LATIN,                       "sh", "CS", "" },   // Serbian Latin in Serbia and Montenegro; kludge, sr_Latn_CS is better, but preferred for backwards compatibility where script codes are not support
    { LANGUAGE_SERBIAN_LATIN,                       "sr", "CS", "Latn" },   // Serbian Latin in Serbia and Montenegro
    { LANGUAGE_USER_SERBIAN_LATIN_MONTENEGRO,       "sh", "ME", "" },   // Serbian Latin in Montenegro; kludge, sr_Latn_ME is better, but preferred for backwards compatibility where script codes are not support
    { LANGUAGE_USER_SERBIAN_LATIN_MONTENEGRO,       "sr", "ME", "Latn" },   // Serbian Latin in Montenegro
    { LANGUAGE_SERBIAN_LATIN_BOSNIA_HERZEGOVINA,    "sh", "BA", "" },
    { LANGUAGE_SERBIAN_LATIN_BOSNIA_HERZEGOVINA,    "sr", "BA", "Latn" },
    { LANGUAGE_SERBIAN_LATIN_NEUTRAL,               "sh", ""  , "" },   // kludge, sr_Latn is better, but preferred for backwards compatibility where script codes are not support
    { LANGUAGE_SERBIAN_LATIN_NEUTRAL,               "sr", ""  , "Latn" },
    { LANGUAGE_ARMENIAN,                    "hy", "AM", "" },
    { LANGUAGE_AZERI,                       "az", ""  , "" },
    { LANGUAGE_AZERI_LATIN,                 "az", "AZ", "" },
    { LANGUAGE_AZERI_CYRILLIC,              "az", "AZ", "Cyrl" },
    { LANGUAGE_UZBEK_LATIN,                 "uz", "UZ", "" },
    { LANGUAGE_UZBEK_CYRILLIC,              "uz", "UZ", "Cyrl" },
    { LANGUAGE_BENGALI_BANGLADESH,          "bn", "BD", "" },
    { LANGUAGE_BENGALI,                     "bn", "IN", "" },
    { LANGUAGE_BURMESE,                     "my", "MM", "" },
    { LANGUAGE_KAZAK,                       "kk", "KZ", "" },
    { LANGUAGE_ENGLISH_INDIA,               "en", "IN", "" },
    { LANGUAGE_URDU,                        "ur", ""  , "" },
    { LANGUAGE_URDU_INDIA,                  "ur", "IN", "" },
    { LANGUAGE_URDU_PAKISTAN,               "ur", "PK", "" },
    { LANGUAGE_HINDI,                       "hi", "IN", "" },
    { LANGUAGE_GUJARATI,                    "gu", "IN", "" },
    { LANGUAGE_KANNADA,                     "kn", "IN", "" },
    { LANGUAGE_ASSAMESE,                    "as", "IN", "" },
    { LANGUAGE_KASHMIRI,                    "ks", ""  , "" },
    { LANGUAGE_KASHMIRI_INDIA,              "ks", "IN", "" },
    { LANGUAGE_MALAYALAM,                   "ml", "IN", "" },
    { LANGUAGE_MANIPURI,                   "mni", "IN", "" },
    { LANGUAGE_MARATHI,                     "mr", "IN", "" },
    { LANGUAGE_KONKANI,                    "kok", "IN", "" },
    { LANGUAGE_NEPALI,                      "ne", "NP", "" },
    { LANGUAGE_NEPALI_INDIA,                "ne", "IN", "" },
    { LANGUAGE_ORIYA,                       "or", "IN", "" },
    { LANGUAGE_PUNJABI,                     "pa", "IN", "" },
    { LANGUAGE_SANSKRIT,                    "sa", "IN", "" },
    { LANGUAGE_SINDHI,                      "sd", "IN", "" },
    { LANGUAGE_TAMIL,                       "ta", "IN", "" },
    { LANGUAGE_TELUGU,                      "te", "IN", "" },
    { LANGUAGE_PUNJABI_PAKISTAN,           "lah", "PK", "" },   // preferring "lah" over "pa" for Western Punjabi, see http://www.ethnologue.com/show_language.asp?code=PNB
    { LANGUAGE_PUNJABI_PAKISTAN,            "pa", "PK", "" },
    { LANGUAGE_SINDHI_PAKISTAN,             "sd", "PK", "" },
    { LANGUAGE_BELARUSIAN,                  "be", "BY", "" },
    { LANGUAGE_CATALAN,                     "ca", "ES", "" },   // Spain (default)
    { LANGUAGE_CATALAN,                     "ca", "AD", "" },   // Andorra
    { LANGUAGE_USER_CATALAN_VALENCIAN,      "ca", "XV", "" },   // XV: ISO 3166 user-assigned; workaround for UI localization only, do not use in document content!
    { LANGUAGE_FRENCH_CAMEROON,             "fr", "CM", "" },
    { LANGUAGE_FRENCH_COTE_D_IVOIRE,        "fr", "CI", "" },
    { LANGUAGE_FRENCH_HAITI,                "fr", "HT", "" },
    { LANGUAGE_FRENCH_MALI,                 "fr", "ML", "" },
    { LANGUAGE_FRENCH_SENEGAL,              "fr", "SN", "" },
    { LANGUAGE_FRENCH_ZAIRE,                "fr", "CD", "" },   // Democratic Republic Of Congo
    { LANGUAGE_FRENCH_MOROCCO,              "fr", "MA", "" },
    { LANGUAGE_FRENCH_REUNION,              "fr", "RE", "" },
    { LANGUAGE_FRENCH_NORTH_AFRICA,         "fr", ""  , "" },
    { LANGUAGE_FRENCH_WEST_INDIES,          "fr", ""  , "" },   // unknown ISO country code
    { LANGUAGE_FRISIAN_NETHERLANDS,         "fy", "NL", "" },
    { LANGUAGE_GAELIC_IRELAND,              "ga", "IE", "" },
    { LANGUAGE_GAELIC_SCOTLAND,             "gd", "GB", "" },
    { LANGUAGE_GALICIAN,                    "gl", "ES", "" },
    { LANGUAGE_GEORGIAN,                    "ka", "GE", "" },
    { LANGUAGE_KHMER,                       "km", "KH", "" },
    { LANGUAGE_KIRGHIZ,                     "ky", "KG", "" },
    { LANGUAGE_LAO,                         "lo", "LA", "" },
    { LANGUAGE_MALTESE,                     "mt", "MT", "" },
    { LANGUAGE_MONGOLIAN,                   "mn", "MN", "" },   // Cyrillic script
    { LANGUAGE_MONGOLIAN_MONGOLIAN,         "mn", "MN", "" },
    { LANGUAGE_RUSSIAN_MOLDOVA,             "mo", "MD", "" },
    { LANGUAGE_SWAHILI,                     "sw", "KE", "" },
    { LANGUAGE_USER_SWAHILI_TANZANIA,       "sw", "TZ", "" },
    { LANGUAGE_TAJIK,                       "tg", "TJ", "" },
    { LANGUAGE_TIBETAN,                     "bo", "CN", "" },   // CN politically correct?
    { LANGUAGE_DZONGKHA,                    "dz", "BT", "" },
    { LANGUAGE_TURKMEN,                     "tk", "TM", "" },
    { LANGUAGE_WELSH,                       "cy", "GB", "" },
    { LANGUAGE_SESOTHO,                     "st", "ZA", "" },
    { LANGUAGE_SEPEDI,                     "nso", "ZA", "" },
    { LANGUAGE_SEPEDI,                      "ns", "ZA", "" },   // fake "ns" for compatibility with existing OOo1.1.x localization to be able to read those documents
    { LANGUAGE_TSONGA,                      "ts", "ZA", "" },
    { LANGUAGE_TSWANA,                      "tn", "ZA", "" },
    { LANGUAGE_ENGLISH_SAFRICA,             "en", "ZA", "" },
    { LANGUAGE_AFRIKAANS,                   "af", "ZA", "" },
    { LANGUAGE_VENDA,                       "ve", "ZA", "" },   // default 639-1
    { LANGUAGE_VENDA,                      "ven", "ZA", "" },   // 639-2 may have been used temporarily since 2004-07-23
    { LANGUAGE_XHOSA,                       "xh", "ZA", "" },
    { LANGUAGE_ZULU,                        "zu", "ZA", "" },
    { LANGUAGE_QUECHUA_ECUADOR,             "qu", "EC", "" },
    { LANGUAGE_QUECHUA_PERU,                "qu", "PE", "" },
    { LANGUAGE_QUECHUA_BOLIVIA,             "qu", "BO", "" },   // macro: quh-BO, qul-BO
    { LANGUAGE_PASHTO,                      "ps", "AF", "" },
    { LANGUAGE_OROMO,                       "om", "ET", "" },
    { LANGUAGE_DHIVEHI,                     "dv", "MV", "" },
    { LANGUAGE_UIGHUR_CHINA,                "ug", "CN", "" },
    { LANGUAGE_TIGRIGNA_ETHIOPIA,           "ti", "ET", "" },
    { LANGUAGE_TIGRIGNA_ERITREA,            "ti", "ER", "" },
    { LANGUAGE_AMHARIC_ETHIOPIA,            "am", "ET", "" },
    { LANGUAGE_GUARANI_PARAGUAY,           "gug", "PY", "" },
    { LANGUAGE_HAWAIIAN_UNITED_STATES,     "haw", "US", "" },
    { LANGUAGE_EDO,                        "bin", "NG", "" },
    { LANGUAGE_FULFULDE_NIGERIA,            "ff", "NG", "" },
    { LANGUAGE_HAUSA_NIGERIA,               "ha", "NG", "" },
    { LANGUAGE_USER_HAUSA_GHANA,            "ha", "GH", "" },
    { LANGUAGE_IGBO_NIGERIA,                "ig", "NG", "" },
    { LANGUAGE_KANURI_NIGERIA,              "kr", "NG", "" },
    { LANGUAGE_YORUBA,                      "yo", "NG", "" },
    { LANGUAGE_SOMALI,                      "so", "SO", "" },
    { LANGUAGE_PAPIAMENTU,                 "pap", "AN", "" },
    { LANGUAGE_ENGLISH_SINGAPORE,           "en", "SG", "" },
    { LANGUAGE_YIDDISH,                     "yi", "IL", "" },   // new: old was "ji"
    { LANGUAGE_YIDDISH,                     "ji", "IL", "" },   // old: new is "yi"
    { LANGUAGE_SYRIAC,                     "syr", "TR", "" },   // "TR" according to http://www.ethnologue.com/show_language.asp?code=SYC
    { LANGUAGE_SINHALESE_SRI_LANKA,         "si", "LK", "" },
    { LANGUAGE_CHEROKEE_UNITED_STATES,     "chr", "US", "" },
    { LANGUAGE_INUKTITUT_LATIN_CANADA,      "iu", "CA", "" },
    { LANGUAGE_INUKTITUT_SYLLABICS_CANADA,  "iu", "CA", "Cans" },
    { LANGUAGE_SAMI_NORTHERN_NORWAY,        "se", "NO", "" },
    { LANGUAGE_SAMI_INARI,                 "smn", "FI", "" },
    { LANGUAGE_SAMI_LULE_NORWAY,           "smj", "NO", "" },
    { LANGUAGE_SAMI_LULE_SWEDEN,           "smj", "SE", "" },
    { LANGUAGE_SAMI_NORTHERN_FINLAND,       "se", "FI", "" },
    { LANGUAGE_SAMI_NORTHERN_SWEDEN,        "se", "SE", "" },
    { LANGUAGE_SAMI_SKOLT,                 "sms", "FI", "" },
    { LANGUAGE_SAMI_SOUTHERN_NORWAY,       "sma", "NO", "" },
    { LANGUAGE_SAMI_SOUTHERN_SWEDEN,       "sma", "SE", "" },
    { LANGUAGE_USER_SAMI_KILDIN_RUSSIA,    "sjd", "RU", "" },
    { LANGUAGE_MAPUDUNGUN_CHILE,           "arn", "CL", "" },
    { LANGUAGE_CORSICAN_FRANCE,             "co", "FR", "" },
    { LANGUAGE_ALSATIAN_FRANCE,            "gsw", "FR", "" },   // in fact 'gsw' is Schwyzerduetsch (Swiss German), which is a dialect of Alemannic German, as is Alsatian. They aren't distinct languages and share this code.
    { LANGUAGE_YAKUT_RUSSIA,               "sah", "RU", "" },
    { LANGUAGE_MOHAWK_CANADA,              "moh", "CA", "" },
    { LANGUAGE_BASHKIR_RUSSIA,              "ba", "RU", "" },
    { LANGUAGE_KICHE_GUATEMALA,            "qut", "GT", "" },
    { LANGUAGE_DARI_AFGHANISTAN,           "gbz", "AF", "" },
    { LANGUAGE_WOLOF_SENEGAL,               "wo", "SN", "" },
    { LANGUAGE_FILIPINO,                   "fil", "PH", "" },
    { LANGUAGE_USER_TAGALOG,                "tl", "PH", "" },
    { LANGUAGE_ENGLISH_PHILIPPINES,         "en", "PH", "" },
//  { LANGUAGE_IBIBIO_NIGERIA,             "nic", "NG", "" },   // ISO "nic" is only a collective language code
    { LANGUAGE_YI,                          "ii", "CN", "" },
//  { LANGUAGE_TAMAZIGHT_LATIN,            "ber", ""  , "" },   // ISO "ber" only collective!
//  { LANGUAGE_TAMAZIGHT_ARABIC,           "ber", ""  , "" },   // ISO "ber" only collective!
    { LANGUAGE_LATIN,                       "la", "VA", "" },
    { LANGUAGE_OBSOLETE_USER_LATIN,         "la", "VA", "" },
    { LANGUAGE_USER_ESPERANTO,              "eo", ""  , "" },
    { LANGUAGE_USER_INTERLINGUA,            "ia", ""  , "" },
    { LANGUAGE_MAORI_NEW_ZEALAND,           "mi", "NZ", "" },
    { LANGUAGE_OBSOLETE_USER_MAORI,         "mi", "NZ", "" },
    { LANGUAGE_KINYARWANDA_RWANDA,          "rw", "RW", "" },
    { LANGUAGE_OBSOLETE_USER_KINYARWANDA,   "rw", "RW", "" },
    { LANGUAGE_UPPER_SORBIAN_GERMANY,      "hsb", "DE", "" },   // MS maps this to 'wen-DE', which is nonsense. 'wen' is a collective language code, 'WEN' is a SIL code, see http://www.ethnologue.com/14/show_iso639.asp?code=wen and http://www.ethnologue.com/14/show_language.asp?code=WEN
    { LANGUAGE_OBSOLETE_USER_UPPER_SORBIAN,"hsb", "DE", "" },
    { LANGUAGE_LOWER_SORBIAN_GERMANY,      "dsb", "DE", "" },   // MS maps this to 'wee-DE', which is nonsense. 'WEE' is a SIL code, see http://www.ethnologue.com/14/show_language.asp?code=WEE
    { LANGUAGE_OBSOLETE_USER_LOWER_SORBIAN,"dsb", "DE", "" },
    { LANGUAGE_OCCITAN_FRANCE,              "oc", "FR", "" },
    { LANGUAGE_OBSOLETE_USER_OCCITAN,       "oc", "FR", "" },
    { LANGUAGE_USER_KURDISH_TURKEY,         "ku", "TR", "" },
    { LANGUAGE_USER_KURDISH_SYRIA,          "ku", "SY", "" },
    { LANGUAGE_USER_KURDISH_IRAQ,           "ku", "IQ", "" },
    { LANGUAGE_USER_KURDISH_IRAN,           "ku", "IR", "" },
    { LANGUAGE_USER_SARDINIAN,              "sc", "IT", "" },
    { LANGUAGE_BRETON_FRANCE,               "br", "FR", "" },
    { LANGUAGE_OBSOLETE_USER_BRETON,        "br", "FR", "" },
    { LANGUAGE_KALAALLISUT_GREENLAND,       "kl", "GL", "" },
    { LANGUAGE_OBSOLETE_USER_KALAALLISUT,   "kl", "GL", "" },
    { LANGUAGE_USER_SWAZI,                  "ss", "ZA", "" },
    { LANGUAGE_USER_NDEBELE_SOUTH,          "nr", "ZA", "" },
    { LANGUAGE_USER_TSWANA_BOTSWANA,        "tn", "BW", "" },
    { LANGUAGE_USER_MOORE,                 "mos", "BF", "" },
    { LANGUAGE_USER_BAMBARA,                "bm", "ML", "" },
    { LANGUAGE_USER_AKAN,                   "ak", "GH", "" },
    { LANGUAGE_LUXEMBOURGISH_LUXEMBOURG,    "lb", "LU", "" },
    { LANGUAGE_OBSOLETE_USER_LUXEMBOURGISH, "lb", "LU", "" },
    { LANGUAGE_USER_FRIULIAN,              "fur", "IT", "" },
    { LANGUAGE_USER_FIJIAN,                 "fj", "FJ", "" },
    { LANGUAGE_USER_AFRIKAANS_NAMIBIA,      "af", "NA", "" },
    { LANGUAGE_USER_ENGLISH_NAMIBIA,        "en", "NA", "" },
    { LANGUAGE_USER_WALLOON,                "wa", "BE", "" },
    { LANGUAGE_USER_COPTIC,                "cop", "EG", "" },
    { LANGUAGE_USER_GASCON,                "gsc", "FR", "" },
    { LANGUAGE_USER_GERMAN_BELGIUM,         "de", "BE", "" },
    { LANGUAGE_USER_CHUVASH,                "cv", "RU", "" },
    { LANGUAGE_USER_EWE_GHANA,              "ee", "GH", "" },
    { LANGUAGE_USER_ENGLISH_GHANA,          "en", "GH", "" },
    { LANGUAGE_USER_SANGO,                  "sg", "CF", "" },
    { LANGUAGE_USER_GANDA,                  "lg", "UG", "" },
    { LANGUAGE_USER_LINGALA_DRCONGO,        "ln", "CD", "" },
    { LANGUAGE_USER_LOW_GERMAN,            "nds", "DE", "" },
    { LANGUAGE_USER_HILIGAYNON,            "hil", "PH", "" },
    { LANGUAGE_USER_NYANJA,                 "ny", "MW", "" },
    { LANGUAGE_USER_KASHUBIAN,             "csb", "PL", "" },
    { LANGUAGE_USER_SPANISH_CUBA,           "es", "CU", "" },
    { LANGUAGE_USER_QUECHUA_NORTH_BOLIVIA, "qul", "BO", "" },
    { LANGUAGE_USER_QUECHUA_SOUTH_BOLIVIA, "quh", "BO", "" },
    { LANGUAGE_USER_BODO_INDIA,            "brx", "IN", "" },
    { LANGUAGE_USER_DOGRI_INDIA,           "dgo", "IN", "" },
    { LANGUAGE_USER_MAITHILI_INDIA,        "mai", "IN", "" },
    { LANGUAGE_USER_SANTALI_INDIA,         "sat", "IN", "" },
    { LANGUAGE_USER_TETUN,                 "tet", "ID", "" },
    { LANGUAGE_USER_TETUN_TIMOR_LESTE,     "tet", "TL", "" },
    { LANGUAGE_USER_TOK_PISIN,             "tpi", "PG", "" },
    { LANGUAGE_USER_SHUSWAP,               "shs", "CA", "" },
    { LANGUAGE_USER_ANCIENT_GREEK,         "grc", "GR", "" },
    { LANGUAGE_USER_ASTURIAN,              "ast", "ES", "" },
    { LANGUAGE_NONE,                       "zxx", ""  , "" },   // added to ISO 639-2 on 2006-01-11: Used to declare the absence of linguistic information
    { LANGUAGE_DONTKNOW,                    "",   ""  , "" }    // marks end of table
};

static MsLangId::IsoLangEntry aLastResortFallbackEntry =
{ LANGUAGE_ENGLISH_US, "en", "US", "" };

// -----------------------------------------------------------------------



// static
void MsLangId::convertLanguageToIsoNames( LanguageType nLang,
        rtl::OUString& rLanguageSubtag, rtl::OUString& rRegionSubtag,
        rtl::OUString& rOtherSubtags )
{
    if ( nLang == LANGUAGE_SYSTEM )
        nLang = MsLangId::getSystemLanguage();

    {
        if ( pEntry->mnLang == nLang )
        {
            rLanguageSubtag = rtl::OUString::createFromAscii( pEntry->maLangStr );
            rRegionSubtag = rtl::OUString::createFromAscii( pEntry->maCountry );
            rOtherSubtags = rtl::OUString::createFromAscii( pEntry->maScriptOverride );
            return;
        }
        ++pEntry;
    }
    while ( pEntry->mnLang != LANGUAGE_DONTKNOW );

    rOtherSubtags = rtl::OUString();

    // Search for LangID if we didn't find a specific ISO combination.
    // All entries in this table are allowed for mime specifications,
    // but not defined ISO combinations.

    {
        if ( pNoneStdEntry->mnLang == nLang )
        {
            rLanguageSubtag = rtl::OUString::createFromAscii( pNoneStdEntry->maLangStr );
            rRegionSubtag = rtl::OUString::createFromAscii( pNoneStdEntry->maCountry );
            return;
        }
        ++pNoneStdEntry;

    while ( pNoneStdEntry->mnLang != LANGUAGE_DONTKNOW );

    // not found
    rLanguageSubtag = rtl::OUString();
    rRegionSubtag = rtl::OUString();
}

// -----------------------------------------------------------------------

// static
void MsLangId::convertLanguageToIsoNames( LanguageType nLang,
        rtl::OString& rLanguageSubtag, rtl::OString& rRegionSubtag,
        rtl::OString& rOtherSubtags )
{
    if ( nLang == LANGUAGE_SYSTEM )
        nLang = MsLangId::getSystemLanguage();

    {
        if ( pEntry->mnLang == nLang )
        {
            rLanguageSubtag = rtl::OString( pEntry->maLangStr );
            rRegionSubtag = rtl::OString( pEntry->maCountry );
            rOtherSubtags = rtl::OString( pEntry->maScriptOverride );
            return;
        }
        ++pEntry;
    }
    while ( pEntry->mnLang != LANGUAGE_DONTKNOW );

    rOtherSubtags = rtl::OString();

    // Search for LangID if we didn't find a specific ISO combination.
    // All entries in this table are allowed for mime specifications,
    // but not defined ISO combinations.

    {
        if ( pNoneStdEntry->mnLang == nLang )
        {
            rLanguageSubtag = rtl::OString( pNoneStdEntry->maLangStr );
            rRegionSubtag = rtl::OString( pNoneStdEntry->maCountry );
            return;
        }
        ++pNoneStdEntry;

    while ( pNoneStdEntry->mnLang != LANGUAGE_DONTKNOW );

    // not found
    rLanguageSubtag = rtl::OString();
    rRegionSubtag = rtl::OString();
}

// -----------------------------------------------------------------------

// -----------------------------------------------------------------------

// static
rtl::OUString MsLangId::convertLanguageToIsoString( LanguageType nLang )
        sal_Unicode cSep )
{
    rtl::OUString aLanguageSubtag;
    rtl::OUString aRegionSubtag;
    rtl::OUString aOtherSubtags;
    convertLanguageToIsoNames( nLang, aLanguageSubtag, aRegionSubtag, aOtherSubtags );

    rtl::OUStringBuffer aBuf( aLanguageSubtag );

    //Script Subtag is guaranteed to exist as first Subtag if there is any subtags
    //at all, it can be empty
    sal_Int32 nIndex = 0;
    rtl::OUString aScriptSubtag = aOtherSubtags.getToken(0, sal_Unicode('-'), nIndex);
    if ( aScriptSubtag.getLength() )
    {
        aBuf.append( sal_Unicode('-') );
        aBuf.append( aScriptSubtag );
        aBuf.append( aCountry );
        return aBuf.makeStringAndClear();
    }
    if ( aRegionSubtag.getLength() )
    {
        aBuf.append( sal_Unicode('-') );
        aBuf.append( aRegionSubtag );
    }
    //Now append non-Script Subtags
    if (nIndex >= 0)
    {
        aBuf.append( sal_Char('-') );
        aBuf.append( aOtherSubtags.copy(nIndex) );
    }

    return aBuf.makeStringAndClear();
}

// -----------------------------------------------------------------------

// static
rtl::OString MsLangId::convertLanguageToIsoByteString( LanguageType nLang )
        sal_Char cSep )
{
    rtl::OString aLanguageSubtag;
    rtl::OString aRegionSubtag;
    rtl::OString aOtherSubtags;
    convertLanguageToIsoNames( nLang, aLanguageSubtag, aRegionSubtag, aOtherSubtags );

    rtl::OStringBuffer aBuf( aLanguageSubtag );

    //Script Subtag is guaranteed to exist as first Subtag if there is any subtags
    //at all, it can be empty
    sal_Int32 nIndex = 0;
    rtl::OString aScriptSubtag = aOtherSubtags.getToken(0, sal_Unicode('-'), nIndex);
    if ( aScriptSubtag.getLength() )
    {
        aBuf.append( sal_Char('-') );
        aBuf.append( aScriptSubtag );
        aBuf.append( aCountry );
        return aBuf.makeStringAndClear();
    }
    if ( aRegionSubtag.getLength() )
    {
        aBuf.append( sal_Char('-') );
        aBuf.append( aRegionSubtag );
    }
    //Now append non-Script Subtags
    if (nIndex >= 0)
    {
        aBuf.append( sal_Char('-') );
        aBuf.append( aOtherSubtags.copy(nIndex) );
    }

    return aBuf.makeStringAndClear();
}

// =======================================================================

// static
LanguageType MsLangId::convertIsoNamesToLanguage( const rtl::OUString& rLanguageSubtag,
        const rtl::OUString& rRegionSubtag, const rtl::OUString& rOtherSubtags )
{
    // language is lower case in table
    rtl::OUString aLowerLang = rLanguageSubtag.toAsciiLowerCase();
    // country is upper case in table
    rtl::OUString aUpperCountry = rRegionSubtag.toAsciiUpperCase();

    //Script Subtag is guaranteed to exist as first Subtag if there is any subtags
    //at all, it can be empty
    sal_Int32 nIndex = 0;
    rtl::OUString aScriptSubtag = rOtherSubtags.getToken(0, sal_Unicode('-'), nIndex);

    //  first look for exact match
    const IsoLangEntry* pFirstLang = NULL;

        {
            if ( !aUpperCountry.getLength() ||
                 aUpperCountry.equalsAscii( pEntry->maCountry ) )
            {
                if (aScriptSubtag.equalsAscii(pEntry->maScriptOverride))
                    return pEntry->mnLang;
            }
            if ( !pFirstLang )
                pFirstLang = pEntry;
            else if ( !*pEntry->maCountry )


    //  if only the country is set, look for any entry matching the country
    //  (to allow reading country and language in separate steps, in any order)
    if ( rRegionSubtag.getLength() && !rLanguageSubtag.getLength() )
    {
        const IsoLangEntry* pEntry2 = aImplIsoLangEntries;
        do

// -----------------------------------------------------------------------

// static
LanguageType MsLangId::convertIsoNamesToLanguage( const rtl::OString& rLanguageSubtag,
        const rtl::OString& rRegionSubtag, const rtl::OString& rOtherSubtags )
{
    rtl::OUString aLanguageSubtag = OStringToOUString( rLanguageSubtag, RTL_TEXTENCODING_ASCII_US);
    rtl::OUString aRegionSubtag = OStringToOUString( rRegionSubtag, RTL_TEXTENCODING_ASCII_US);
    rtl::OUString aOtherSubtags = OStringToOUString( rOtherSubtags, RTL_TEXTENCODING_ASCII_US);
    return convertIsoNamesToLanguage( aLanguageSubtag, aRegionSubtag, aOtherSubtags );
}

// -----------------------------------------------------------------------

namespace
{
    bool isNumber(const rtl::OUString &rTag)
    {
        const sal_Unicode *pStr = rTag.getStr();
        for (sal_Int32 i = 0; i < rTag.getLength(); ++i)
            if (pStr[i] < '0' || pStr[i] > '9')
                return false;
        return true;
    }
}

// static
LanguageType MsLangId::convertIsoStringToLanguage( const rtl::OUString& rString )
{
    sal_Int32 nIndex = 0;
    std::deque<rtl::OUString> aTagStack;
    do
    {
        aTagStack.push_back(rString.getToken(0, sal_Unicode('-'), nIndex));
    }
    while ( nIndex >= 0 );

    rtl::OUString aLangSubtag = aTagStack.front();
    aTagStack.pop_front();

    rtl::OUString aScriptSubtag;
    rtl::OUString aRegionSubtag;
    do
    {
        if (aTagStack.empty())
            break;

        rtl::OUString aNextTag = aTagStack.front();

        // Script subtags MUST follow any primary and extended language subtags
        // and MUST precede any other type of subtag.
        //
        // Script subtags consist of four letters
        if (aNextTag.getLength() == 4)
        {
            aScriptSubtag = aNextTag;
            aTagStack.pop_front();
            if (aTagStack.empty())
                break;
            aNextTag = aTagStack.front();
        }

        // Region subtags MUST follow any primary language, extended language, or
        // script subtags and MUST precede any other type of subtag.
        //
        // Two-letter region subtags
        //
        // Three-character region subtags consist solely of digit (number)
        // characters
        if (aNextTag.getLength() == 2 || (aNextTag.getLength() == 3 && isNumber(aNextTag)))
        {
            aRegionSubtag = aNextTag;
            aTagStack.pop_front();
            if (aTagStack.empty())
                break;
        }
    } while(0);

    rtl::OUString aOtherSubtags = aScriptSubtag;

    //Because we're retro-fitting this into our Variant field in the Locale class
    //we'll bundle up the ScriptTag and other tags remaining after the Language and
    //Region tags are extracted an make a single string of them. We'll ensure there
    //is always a script entry at the start, empty if needs be, to avoid incorrectly
    //mistaking an extra tag as a script tag later on.
    while (!aTagStack.empty())
    {
        aOtherSubtags = aOtherSubtags + sal_Unicode('-') + aTagStack.front();
        aTagStack.pop_front();
    }

	fprintf(stderr, "lang is %s\n", rtl::OUStringToOString(aLangSubtag, RTL_TEXTENCODING_UTF8).getStr());
	fprintf(stderr, "region is %s\n", rtl::OUStringToOString(aRegionSubtag, RTL_TEXTENCODING_UTF8).getStr());
	fprintf(stderr, "remainder is %s\n", rtl::OUStringToOString(aOtherSubtags, RTL_TEXTENCODING_UTF8).getStr());

    return convertIsoNamesToLanguage( aLangSubtag, aRegionSubtag, aOtherSubtags );
}

// -----------------------------------------------------------------------

// static
LanguageType MsLangId::convertIsoByteStringToLanguage( const rtl::OString& rString )
        const rtl::OUString& rString, sal_Unicode cSep )
{
    return MsLangId::convertIsoStringToLanguage( rtl::OStringToOUString(rString, RTL_TEXTENCODING_ASCII_US) );
    rtl::OUString   aCountry;
    sal_Int32  nSepPos = rString.indexOf( cSep );
    if ( nSepPos >= 0 )
    {
        aLang = rString.copy( 0, nSepPos );
        aCountry = rString.copy( nSepPos+1 );
    }
    else
        aLang = rString;

    return convertIsoNamesToLanguage( aLang, aCountry );
}

// -----------------------------------------------------------------------

struct IsoLangGLIBCModifiersEntry
LanguageType MsLangId::convertIsoByteStringToLanguage(
        const rtl::OString& rString, sal_Char cSep )
{
    LanguageType  mnLang;
    sal_Char      maLangStr[4];
    sal_Char      maCountry[3];
    sal_Char      maAtString[9];
};
        aLang = rString.copy( 0, nSepPos );
        aCountry = rString.copy( nSepPos+1 );
    }
    else
        aLang = rString;

static IsoLangGLIBCModifiersEntry const aImplIsoLangGLIBCModifiersEntries[] =
{
    // MS-LANGID codes               ISO639-1/2/3 ISO3166            glibc modifier
    { LANGUAGE_BOSNIAN_CYRILLIC_BOSNIA_HERZEGOVINA, "bs", "BA", "cyrillic" },
    { LANGUAGE_USER_SERBIAN_LATIN_SERBIA,           "sr", "RS", "latin" },   // Serbian Latin in Serbia
    { LANGUAGE_SERBIAN_LATIN,                       "sr", "CS", "latin" },   // Serbian Latin in Serbia and Montenegro
    { LANGUAGE_USER_SERBIAN_LATIN_MONTENEGRO,       "sr", "ME", "latin" },   // Serbian Latin in Montenegro
    { LANGUAGE_SERBIAN_LATIN_NEUTRAL,               "sr", "",   "latin" },
    { LANGUAGE_AZERI_CYRILLIC,                      "az", "AZ", "cyrillic" },
    { LANGUAGE_UZBEK_CYRILLIC,                      "uz", "UZ", "cyrillic" },
    { LANGUAGE_DONTKNOW,                            "",   "",   ""   }       // marks end of table
};

// -----------------------------------------------------------------------
// convert a unix locale string into LanguageType

// static

{
    rtl::OString  aLang;
    rtl::OString  aCountry;
    rtl::OString  aAtString;
    rtl::OString  aScriptTag;

    sal_Int32  nLangSepPos    = rString.indexOf( (sal_Char)'_' );
    sal_Int32  nCountrySepPos = rString.indexOf( (sal_Char)'.' );
    sal_Int32  nAtPos         = rString.indexOf( (sal_Char)'@' );

    if (nCountrySepPos < 0)
        nCountrySepPos = nAtPos;
    if (nCountrySepPos < 0)
        nCountrySepPos = rString.getLength();

    if (nAtPos >= 0)
        aAtString = rString.copy( nAtPos+1 );

    if (   ((nLangSepPos >= 0) && (nLangSepPos > nCountrySepPos))
        || ((nLangSepPos < 0)) )
    {

        aCountry = rString.copy( nLangSepPos+1, nCountrySepPos - nLangSepPos - 1);
    }

    //  if there is a glibc modifier, first look for exact match in modifier table
    if (aAtString.getLength())
    {
        // language is lower case in table
        rtl::OString aLowerLang = aLang.toAsciiLowerCase();
        // country is upper case in table
        rtl::OString aUpperCountry = aCountry.toAsciiUpperCase();
        const IsoLangGLIBCModifiersEntry* pGLIBCModifiersEntry = aImplIsoLangGLIBCModifiersEntries;
        do
        {
            if (( aLowerLang.equals( pGLIBCModifiersEntry->maLangStr ) ) &&
               ( aAtString.equals( pGLIBCModifiersEntry->maAtString ) ))
            {
                if ( !aUpperCountry.getLength() ||
                     aUpperCountry.equals( pGLIBCModifiersEntry->maCountry ) )
               {
                    return pGLIBCModifiersEntry->mnLang;
               }
            }
            ++pGLIBCModifiersEntry;
        }
        while ( pGLIBCModifiersEntry->mnLang != LANGUAGE_DONTKNOW );

        if (aAtString.equals("latin"))
            aScriptTag = "Latn";
        else if (aAtString.equals("cyrillic"))
            aScriptTag = "Cyrl";
        else if (aAtString.equals("devanagari"))
            aScriptTag = "Deva";
    }

    return convertIsoNamesToLanguage( aLang, aCountry, aScriptTag );
}

// -----------------------------------------------------------------------




void MsLangId::convertLanguageToLocale( LanguageType nLang,
        ::com::sun::star::lang::Locale & rLocale )
{
    convertLanguageToIsoNames( nLang, rLocale.Language, rLocale.Country, rLocale.Variant );
        rLocale.Variant = rtl::OUString();
    convertLanguageToIsoNames( nLang, rLocale.Language, rLocale.Country);
}



        return LANGUAGE_SYSTEM;

    LanguageType nRet = convertIsoNamesToLanguage( rLocale.Language,
            rLocale.Country, rLocale.Variant);
    if (nRet == LANGUAGE_DONTKNOW)
        nRet = LANGUAGE_SYSTEM;





               sal_Int32 nStartIndex = sPath.lastIndexOf(sal_Unicode('/')) + 1;
               if (!sPath.match(aSystemPrefix, nStartIndex))
                   continue;

               nStartIndex += aSystemPrefix.getLength();

               rtl::OUString sChunk = sPath.copy(nStartIndex,
                   sPath.getLength() - aSystemSuffix.getLength() - nStartIndex);

               //Preferred format is BCP47, e.g. de-DE, sr-Latn-RS
               LanguageType nLang = MsLangId::convertIsoStringToLanguage(sChunk);
               if (nLang == LANGUAGE_DONTKNOW || nLang == LANGUAGE_NONE)
               {
                   //Will also accept typical Unix Locale format, e.g de_DE sr_RS@latin
                   nLang = MsLangId::convertUnxByteStringToLanguage(
                       rtl::OUStringToOString(sChunk,osl_getThreadTextEncoding()));
               }

			fprintf(stderr, "lang from %s is %x\n", rtl::OUStringToOString(sChunk,
				RTL_TEXTENCODING_UTF8).getStr(), nLang);

               if (nLang == LANGUAGE_DONTKNOW || nLang == LANGUAGE_NONE)
                   continue;
               rtl::OUString sRegion;
               if (nIndex != -1)
                   sRegion = sChunk.copy( nIndex, sChunk.getLength() - nIndex );

               // Thus we first get the language of the dictionary
               LanguageType nLang = MsLangId::convertIsoNamesToLanguage(
                  sLang, sRegion );

               if (aDicLangInUse.count( nLang ) == 0)
               {

                   aDicEntry.aLocations[0] = sPath;
                   aDicEntry.aFormatName = aFormatName;
                   aDicEntry.aLocaleNames[0] = aLocaleName;
                   fprintf(stderr, "name is %s\n", rtl::OUStringToOString(aLocaleName, RTL_TEXTENCODING_UTF8).getStr());
                   aRes.push_back( aDicEntry );
               }
		else
	           fprintf(stderr, "%x already in there\n", nLang);
           }
       }
    }





	<P>
	The second constructor requires a third argument--the <STRONG>Variant.</STRONG>
	The format of this string is based on BCP-47. Each tag must
	be seperated from the next by "-".

	If used, the first tag must either be empty or a four letter
	script code as described by http://www.rfc-editor.org/rfc/bcp/bcp47.txt.
	Subsequent tags are not associated with any particular
	external standards.

	Typical use is for a Language of sr, a Country of RS and a
	Variant of Latn in order to describe Serbian written as Latin in
	Serbia. An example of use of extra tags to describe a custom
	use speculative variant, might be e.g.  Latn-WIN for Latin
	script on Windows, Cyrl-MAC for Cyrillic script on Macintosh,
	and -POSIX for a non-script-override specific POSIX variant</p>

	<P>
	Because a <code>OLocale</code> object is just an identifier for a region,

Lines 43-48 Link Here

(-)a/sal/osl/unx/nlsupport.c (+8 lines)
43		43
44	#include <string.h>	44	#include <string.h>
45		45
		46	#include <stdio.h>
		47
46	/*****************************************************************************	48	/*****************************************************************************
47	typedefs	49	typedefs
48	*****************************************************************************/	50	*****************************************************************************/
Lines 163-172 Link Here
163		165
164	rtl_string_release( pVariant );	166	rtl_string_release( pVariant );
165	}	167	}
		168
		169	fprintf(stderr, "_compose_locale returns %s\n", buffer);
166		170
167	return buffer;	171	return buffer;
168	}	172	}
169		173
		174	fprintf(stderr, "_compose_locale returns NULL\n");
170	return NULL;	175	return NULL;
171	}	176	}
172		177
Lines 176-181 Link Here
176		181
177	static rtl_Locale * _parse_locale( const char * locale )	182	static rtl_Locale * _parse_locale( const char * locale )
178	{	183	{
		184	fprintf(stderr, "parsing locale of %s\n", locale);
		185
		186
179	static sal_Unicode c_locale[2] = { (sal_Unicode) 'C', 0 };	187	static sal_Unicode c_locale[2] = { (sal_Unicode) 'C', 0 };
180		188
181	/* check if locale contains a valid string */	189	/* check if locale contains a valid string */




    // default locale for test purpose
    void setDefaultLocale()
    {
        rtl::OLocale::setDefault(rtl::OUString::createFromAscii("be"), rtl::OUString::createFromAscii("BY"), /* rtl::OUString() */ rtl::OUString::createFromAscii("Latn") );
    }

class getDefault : public CppUnit::TestFixture


    void getDefault_001()
    {
        // rtl::OLocale::setDefault(rtl::OUString::createFromAscii("be"), rtl::OUString::createFromAscii("BY"), rtl::OUString());
   	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();
        CPPUNIT_ASSERT_MESSAGE("locale must not null", aLocale.getData() != NULL);
    }

   	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();
        rtl::OUString suLanguage = aLocale.getLanguage();
        t_print("Language: %s\n", rtl::OUStringToOString(suLanguage, osl_getThreadTextEncoding()).getStr());
        CPPUNIT_ASSERT_MESSAGE("locale language must be 'be'", suLanguage.equals(rtl::OUString::createFromAscii("be")));
    }
    void getLanguage_002()
    {
   	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();
        rtl::OUString suLanguage = rtl_locale_getLanguage(aLocale.getData());
        t_print("Language: %s\n", rtl::OUStringToOString(suLanguage, osl_getThreadTextEncoding()).getStr());
        CPPUNIT_ASSERT_MESSAGE("locale language must be 'be'", suLanguage.equals(rtl::OUString::createFromAscii("be")));
    }

    // Change the following lines only, if you add, remove or rename

   	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();
        rtl::OUString suCountry = aLocale.getCountry();
        t_print("Country: %s\n", rtl::OUStringToOString(suCountry, osl_getThreadTextEncoding()).getStr());
        CPPUNIT_ASSERT_MESSAGE("locale country must be 'BY'", suCountry.equals(rtl::OUString::createFromAscii("BY")));
    }
    void getCountry_002()
    {
   	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();
        rtl::OUString suCountry = rtl_locale_getCountry(aLocale.getData());
        t_print("Country: %s\n", rtl::OUStringToOString(suCountry, osl_getThreadTextEncoding()).getStr());
        CPPUNIT_ASSERT_MESSAGE("locale country must be 'BY'", suCountry.equals(rtl::OUString::createFromAscii("BY")));
    }

    // Change the following lines only, if you add, remove or rename

   	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();
        rtl::OUString suVariant = aLocale.getVariant();
        t_print("Variant: %s\n", rtl::OUStringToOString(suVariant, osl_getThreadTextEncoding()).getStr());
        CPPUNIT_ASSERT_MESSAGE("locale variant must be 'Latn'", suVariant.equals(rtl::OUString::createFromAscii("Latn")));
    }
    void getVariant_002()
    {
   	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();
        rtl::OUString suVariant = rtl_locale_getVariant(aLocale.getData());
        t_print("Variant: %s\n", rtl::OUStringToOString(suVariant, osl_getThreadTextEncoding()).getStr());
        CPPUNIT_ASSERT_MESSAGE("locale variant must be 'Latn'", suVariant.equals(rtl::OUString::createFromAscii("Latn")));
    }

    // Change the following lines only, if you add, remove or rename

Lines 32-37 Link Here

(-)a/sal/rtl/source/alloc_global.c (+2 lines)
32	#define INCLUDED_STRING_H	32	#define INCLUDED_STRING_H
33	#endif	33	#endif
34		34
		35	#define FORCE_SYSALLOC 1
		36
35	#if !defined(FORCE_SYSALLOC)	37	#if !defined(FORCE_SYSALLOC)
36		38
37	/* ================================================================= *	39	/* ================================================================= *

Lines 32-37 Link Here

(-)a/sal/rtl/source/locale.c (+18 lines)
32		32
33	#include "internal/once.h"	33	#include "internal/once.h"
34		34
		35	#include <stdio.h>
		36
35	static sal_Int32 RTL_HASHTABLE_SIZE[] =	37	static sal_Int32 RTL_HASHTABLE_SIZE[] =
36	{	38	{
37	7, 31, 127, 251, 509, 1021, 2039, 4093	39	7, 31, 127, 251, 509, 1021, 2039, 4093
Lines 269-274 Link Here
269	rtl_uString* sCountry = NULL;	271	rtl_uString* sCountry = NULL;
270	rtl_uString* sVariant = NULL;	272	rtl_uString* sVariant = NULL;
271	rtl_Locale *newLocale = NULL;	273	rtl_Locale *newLocale = NULL;
		274	const sal_Unicode *foo;
272	sal_Int32 hashCode = -1;	275	sal_Int32 hashCode = -1;
273	sal_Int32 key = 0;	276	sal_Int32 key = 0;
274		277
Lines 280-285 Link Here
280	if (!rtl_locale_init())	283	if (!rtl_locale_init())
281	return NULL;	284	return NULL;
282		285
		286	fprintf(stderr, "lang is ");
		287	for (foo = language; *foo; ++foo)
		288	fprintf(stderr, "%c", *foo);
		289	fprintf(stderr, "\n");
		290
		291	fprintf(stderr, "country is ");
		292	for (foo = country; *foo; ++foo)
		293	fprintf(stderr, "%c", *foo);
		294	fprintf(stderr, "\n");
		295
		296	fprintf(stderr, "variant is ");
		297	for (foo = variant; *foo; ++foo)
		298	fprintf(stderr, "%c", *foo);
		299	fprintf(stderr, "\n");
		300
283	hashCode = rtl_ustr_hashCode(language) ^ rtl_ustr_hashCode(country) ^ rtl_ustr_hashCode(variant);	301	hashCode = rtl_ustr_hashCode(language) ^ rtl_ustr_hashCode(country) ^ rtl_ustr_hashCode(variant);
284	key = rtl_hashfunc(g_pLocaleTable, hashCode);	302	key = rtl_hashfunc(g_pLocaleTable, hashCode);
285		303




        const sheet::LocalizedName* pArray = rSequence.getConstArray();
        long i;

        rtl::OUString aLanguageTag, aRegionTag, aOtherTags;
        MsLangId::convertLanguageToIsoNames( eDestLang, aLanguageTag, aRegionTag, aOtherTags);
        rtl::OUString aUserLang = aLanguageTag.toAsciiLowerCase();
        rtl::OUString aUserCountry = aRegionTag.toAsciiUpperCase();
        //Script Subtag is guaranteed to exist as first Subtag if there is any subtags
        //at all, it can be empty
        sal_Int32 nIndex = 0;
        rtl::OUString aUserScriptSubtag = aOtherTags.getToken(0, sal_Unicode('-'), nIndex);

        //  first check for match of all language, country and Script tag

        for ( i=0; i<nSeqLen; i++)
            if ( pArray[i].Locale.Language == aUserLang &&
                    pArray[i].Locale.Country == aUserCountry &&
                    pArray[i].Locale.Variant == aUserScriptSubtag )
            {
                rRetExcelName = pArray[i].Name;
                return TRUE;
            }


        //  second check for match of both language and country

        for ( i=0; i<nSeqLen; i++)
            if ( pArray[i].Locale.Language == aUserLang &&
                    pArray[i].Locale.Country == aUserCountry )
            {
                rRetExcelName = pArray[i].Name;
                return TRUE;
            }

        //  third: check only language

        for ( i=0; i<nSeqLen; i++)
            if ( pArray[i].Locale.Language == aUserLang )

                return TRUE;
            }

        // fourth: #i57772# fall-back to en-US

        if ( eDestLang != LANGUAGE_ENGLISH_US )
            return GetExcelName( LANGUAGE_ENGLISH_US, rRetExcelName );

        // fifth: use first (default) entry

        rRetExcelName = pArray[0].Name;
        return TRUE;

Lines 31-40 Link Here

(-)a/soltools/util/makefile.pmk (-4 lines)
31	# find 'adjustvisibility' in own output tree	31	# find 'adjustvisibility' in own output tree
32	ADJUSTVISIBILITY=$(AUGMENT_LIBRARY_PATH) $(BIN)$/adjustvisibility	32	ADJUSTVISIBILITY=$(AUGMENT_LIBRARY_PATH) $(BIN)$/adjustvisibility
33		33
34	# avoid STLPort
35	NO_DEFAULT_STL=TRUE
36	SOLARINC!:=$(subst,/stl$(SPACECHAR),dont_use_stl$(SPACECHAR) $(SOLARINC))
37
38	.IF "$(OS)"=="SOLARIS"	34	.IF "$(OS)"=="SOLARIS"
39	# hack due to #i53089#	35	# hack due to #i53089#
40	.IF "$(COMPATH:+"x")" != "$(COMPATH:+"x":s/binx//)"	36	.IF "$(COMPATH:+"x")" != "$(COMPATH:+"x":s/binx//)"

Lines 25-31 Link Here

(-)a/tools/inc/tools/preextstl.h (-3 / +11 lines)
25	*	25	*
26	************************************************************************/	26	************************************************************************/
27		27
		28	//1. Force inclusion of a std:: using header to ensure the stlport define
		29	//of std as "stlport"
		30	#include <algorithm>
28	#if defined(ADAPT_EXT_STL)	31	#if defined(ADAPT_EXT_STL)
		32	//2. Force inclusion of stlport headers to get their stlport:: definitions
29	# include <ostream>	33	# include <ostream>
30	# include <istream>	34	# include <istream>
31	# include <fstream>	35	# include <fstream>
Lines 33-44 Link Here
33	# include <vector>	37	# include <vector>
34	# include <list>	38	# include <list>
35	# include <map>	39	# include <map>
36	# include <algorithm>
37	# if defined(std)	40	# if defined(std)
38	# define std_was_redefined_as_stlport std	41	# define std_was_redefined_as_stlport std
39	# undef std	42	# undef std
40	# define _STLP_OUTERMOST_HEADER_ID 0xdeadbeaf	43	# define _STLP_OUTERMOST_HEADER_ID 0xdeadbeaf
41	# pragma GCC visibility push(default)	44	# if defined(_GNUC__)
		45	# pragma GCC visibility push(default)
		46	# endif
		47	//3. Now force inclusion of native headers to get their std:: definitions
42	# include _STLP_NATIVE_HEADER(exception_defines.h)	48	# include _STLP_NATIVE_HEADER(exception_defines.h)
43	# include _STLP_NATIVE_HEADER(limits)	49	# include _STLP_NATIVE_HEADER(limits)
44	# include _STLP_NATIVE_HEADER(memory)	50	# include _STLP_NATIVE_HEADER(memory)
Lines 56-62 Link Here
56	# include _STLP_NATIVE_HEADER(vector)	62	# include _STLP_NATIVE_HEADER(vector)
57	# include _STLP_NATIVE_HEADER(list)	63	# include _STLP_NATIVE_HEADER(list)
58	# include _STLP_NATIVE_HEADER(map)	64	# include _STLP_NATIVE_HEADER(map)
59	# pragma GCC visibility pop	65	# if defined(_GNUC__)
		66	# pragma GCC visibility pop
		67	# endif
60	# endif	68	# endif
61	#endif	69	#endif
62	//ext_std resolves to the std that external c++ libs, e.g. Graphite were built	70	//ext_std resolves to the std that external c++ libs, e.g. Graphite were built




	// DocMerge from xml: field com::sun::star::lang::Locale::Language
	/** specifies an <strong>ISO Language Code</strong>.

		<p>These codes are the lower-case two or three letter codes as defined by
		ISO-639. You can find a full list of these codes at a number of
		sites, such as: <br>
		<a href="http://www.ics.uci.edu/pub/ietf/http/related/iso639.txt">

	//-------------------------------------------------------------------------

	// DocMerge from xml: field com::sun::star::lang::Locale::Variant
	/** contains a sequence of language tags that describe a variant of the locale.
		browser-specific.

		<p>The format of the string is based on BCP-47. Each tag must
                be seperated from the next by -</p>

		<p>If used, the first tag must either be empty or a four letter
                script code as described by http://www.rfc-editor.org/rfc/bcp/bcp47.txt.
		Subsequent tags are not associated with any particular
                external standards.</p>

		<p>Typical use is for a Language of sr, a Country of RS and a
                Variant of Latn in order to describe Serbian written as Latin in
		Serbia. An example of use of extra tags to describe a custom
		use speculative variant, might be e.g.  Latn-WIN for Latin
		script on Windows, Cyrl-MAC for Cyrillic script on Macintosh,
		and -POSIX for a non-script-override specific POSIX variant</p>
	 */
	string Variant;


Lines 483-492 Link Here

(-)a/unotools/source/i18n/localedatawrapper.cxx (-8 / +30 lines)
483	}	483	}
484	if ( eLang != LANGUAGE_DONTKNOW )	484	if ( eLang != LANGUAGE_DONTKNOW )
485	{	485	{
486	rtl::OUString aLanguage, aCountry;	486	rtl::OUString aLanguageTag, aRegionTag, aOtherTags;
487	MsLangId::convertLanguageToIsoNames( eLang, aLanguage, aCountry );	487	MsLangId::convertLanguageToIsoNames( eLang, aLanguageTag, aRegionTag, aOtherTags );
488	if ( xLoc[i].Language != aLanguage \|\|	488	if ( xLoc[i].Language != aLanguageTag \|\|
489	xLoc[i].Country != aCountry )	489	xLoc[i].Country != aRegionTag \|\|
		490	xLoc[i].Variant != aOtherTags )
490	{	491	{
491	// In checks, exclude known problems because no MS-LCID defined	492	// In checks, exclude known problems because no MS-LCID defined
492	// and default for Language found.	493	// and default for Language found.
Lines 503-513 Link Here
503	aMsg.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " -> 0x" ) );	504	aMsg.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " -> 0x" ) );
504	aMsg += String::CreateFromInt32( eLang, 16 );	505	aMsg += String::CreateFromInt32( eLang, 16 );
505	aMsg.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " -> " ) );	506	aMsg.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " -> " ) );
506	aMsg += String( aLanguage);	507
507	if ( aCountry.getLength() )	508	aMsg += String( aLanguageTag );
		509	//Script Subtag is guaranteed to exist as first Subtag if there is any subtags
		510	//at all, it can be empty
		511	sal_Int32 nIndex = 0;
		512	rtl::OUString aScriptSubtag = aOtherTags.getToken(0, sal_Unicode('-'), nIndex);
		513	if ( aScriptSubtag.getLength() )
508	{	514	{
509	aMsg += '_';	515	aMsg += '-';
510	aMsg += String( aCountry);	516	aMsg += String( aScriptSubtag );
		517	}
		518	if ( aRegionTag.getLength() )
		519	{
		520	aMsg += '-';
		521	aMsg += String( aRegionTag );
		522	}
		523	//Now append non-Script Subtags
		524	if (nIndex >= 0)
		525	{
		526	aMsg += '-';
		527	aMsg += String( aOtherTags.copy(nIndex) );
		528	}
		529	if ( aRegionTag.getLength() )
		530	{
		531	aMsg += '-';
		532	aMsg += String( aRegionTag );
511	}	533	}
512	outputCheckMessage( aMsg );	534	outputCheckMessage( aMsg );
513	}	535	}

Lines 1027-1032 Link Here

(-)a/xmloff/inc/xmloff/xmltoken.hxx (+4 lines)
1027	XML_LANGUAGE,	1027	XML_LANGUAGE,
1028	XML_LANGUAGE_ASIAN,	1028	XML_LANGUAGE_ASIAN,
1029	XML_LANGUAGE_COMPLEX,	1029	XML_LANGUAGE_COMPLEX,
		1030	XML_LANGUAGE_TAGS,
		1031	XML_LANGUAGE_TAGS_ASIAN,
		1032	XML_LANGUAGE_TAGS_COMPLEX,
1030	XML_LASER,	1033	XML_LASER,
1031	XML_LAST_COLUMN_SPANNED,	1034	XML_LAST_COLUMN_SPANNED,
1032	XML_LAST_PAGE,	1035	XML_LAST_PAGE,
Lines 2103-2108 Link Here
2103	XML_TRANSLITERATION_FORMAT,	2106	XML_TRANSLITERATION_FORMAT,
2104	XML_TRANSLITERATION_LANGUAGE,	2107	XML_TRANSLITERATION_LANGUAGE,
2105	XML_TRANSLITERATION_COUNTRY,	2108	XML_TRANSLITERATION_COUNTRY,
		2109	XML_TRANSLITERATION_LANGUAGE_TAGS,
2106	XML_TRANSLITERATION_STYLE,	2110	XML_TRANSLITERATION_STYLE,
2107		2111
2108	XML_KEY1_PHONETIC,	2112	XML_KEY1_PHONETIC,

Lines 278-283 Link Here

(-)a/xmloff/inc/xmloff/xmltypes.hxx (+1 lines)
278	#define XML_TYPE_TEXT_OVERLINE_WIDTH (XML_TEXT_TYPES_START + 111)	278	#define XML_TYPE_TEXT_OVERLINE_WIDTH (XML_TEXT_TYPES_START + 111)
279	#define XML_TYPE_TEXT_OVERLINE_COLOR (XML_TEXT_TYPES_START + 112)	279	#define XML_TYPE_TEXT_OVERLINE_COLOR (XML_TEXT_TYPES_START + 112)
280	#define XML_TYPE_TEXT_OVERLINE_HASCOLOR (XML_TEXT_TYPES_START + 113)	280	#define XML_TYPE_TEXT_OVERLINE_HASCOLOR (XML_TEXT_TYPES_START + 113)
		281	#define XML_TYPE_CHAR_LANGUAGE_TAGS (XML_TEXT_TYPES_START + 114)
281		282
282	#define XML_SCH_TYPES_START (0x4 << XML_TYPE_APP_SHIFT)	283	#define XML_SCH_TYPES_START (0x4 << XML_TYPE_APP_SHIFT)
283	#define XML_PM_TYPES_START (0x5 << XML_TYPE_APP_SHIFT) // page master	284	#define XML_PM_TYPES_START (0x5 << XML_TYPE_APP_SHIFT) // page master

Lines 1035-1040 Link Here

(-)a/xmloff/source/core/xmltoken.cxx (+4 lines)
1035	TOKEN( "language", XML_LANGUAGE ),	1035	TOKEN( "language", XML_LANGUAGE ),
1036	TOKEN( "language-asian", XML_LANGUAGE_ASIAN ),	1036	TOKEN( "language-asian", XML_LANGUAGE_ASIAN ),
1037	TOKEN( "language-complex", XML_LANGUAGE_COMPLEX ),	1037	TOKEN( "language-complex", XML_LANGUAGE_COMPLEX ),
		1038	TOKEN( "language-tags", XML_LANGUAGE_TAGS ),
		1039	TOKEN( "language-tags-asian", XML_LANGUAGE_TAGS_ASIAN ),
		1040	TOKEN( "language-tags-complex", XML_LANGUAGE_TAGS_COMPLEX ),
1038	TOKEN( "laser", XML_LASER ),	1041	TOKEN( "laser", XML_LASER ),
1039	TOKEN( "last-column-spanned", XML_LAST_COLUMN_SPANNED ),	1042	TOKEN( "last-column-spanned", XML_LAST_COLUMN_SPANNED ),
1040	TOKEN( "last-page", XML_LAST_PAGE ),	1043	TOKEN( "last-page", XML_LAST_PAGE ),
Lines 2113-2118 Link Here
2113		2116
2114	TOKEN( "transliteration-format", XML_TRANSLITERATION_FORMAT ),	2117	TOKEN( "transliteration-format", XML_TRANSLITERATION_FORMAT ),
2115	TOKEN( "transliteration-language", XML_TRANSLITERATION_LANGUAGE ),	2118	TOKEN( "transliteration-language", XML_TRANSLITERATION_LANGUAGE ),
		2119	TOKEN( "transliteration-language-tags", XML_TRANSLITERATION_LANGUAGE_TAGS ),
2116	TOKEN( "transliteration-country", XML_TRANSLITERATION_COUNTRY ),	2120	TOKEN( "transliteration-country", XML_TRANSLITERATION_COUNTRY ),
2117	TOKEN( "transliteration-style", XML_TRANSLITERATION_STYLE ),	2121	TOKEN( "transliteration-style", XML_TRANSLITERATION_STYLE ),
2118		2122





	return sal_True;
}

XMLCharLanguageTagsHdl::~XMLCharLanguageTagsHdl()
{
	// nothing to do
}

bool XMLCharLanguageTagsHdl::equals( const ::com::sun::star::uno::Any& r1, const ::com::sun::star::uno::Any& r2 ) const
{
	sal_Bool bRet = sal_False;
	lang::Locale aLocale1, aLocale2;

	if( ( r1 >>= aLocale1 ) && ( r2 >>= aLocale2 ) )
		bRet = ( aLocale1.Variant == aLocale2.Variant );

	return bRet;
}

sal_Bool XMLCharLanguageTagsHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
{ 
	lang::Locale aLocale;

	rValue >>= aLocale;

	if( !IsXMLToken( rStrImpValue, XML_NONE ) )
		aLocale.Variant = rStrImpValue;

	rValue <<= aLocale;
	return sal_True; 
}

sal_Bool XMLCharLanguageTagsHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
{ 
	lang::Locale aLocale;
	if(!(rValue >>= aLocale))
		return sal_False;

	rStrExpValue = aLocale.Variant;
	
	if( !rStrExpValue.getLength() )
		rStrExpValue = GetXMLToken( XML_NONE );

	return sal_True;
}




	virtual sal_Bool exportXML( ::rtl::OUString& rStrExpValue, const ::com::sun::star::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const;
};

class XMLCharLanguageTagsHdl : public XMLPropertyHandler
{
public:
	virtual ~XMLCharLanguageTagsHdl();

	virtual bool equals( const ::com::sun::star::uno::Any& r1, const ::com::sun::star::uno::Any& r2 ) const;

	virtual sal_Bool importXML( const ::rtl::OUString& rStrImpValue, ::com::sun::star::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const;
	virtual sal_Bool exportXML( ::rtl::OUString& rStrExpValue, const ::com::sun::star::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const;
};


#endif		// _XMLOFF_PROPERTYHANDLER_CHARLOCALETYPES_HXX


Lines 377-382 Link Here

(-)a/xmloff/source/style/prhdlfac.cxx (+3 lines)
377	case XML_TYPE_CHAR_COUNTRY:	377	case XML_TYPE_CHAR_COUNTRY:
378	pPropHdl = new XMLCharCountryHdl;	378	pPropHdl = new XMLCharCountryHdl;
379	break;	379	break;
		380	case XML_TYPE_CHAR_LANGUAGE_TAGS:
		381	pPropHdl = new XMLCharLanguageTagsHdl;
		382	break;
380	case XML_TYPE_LINE_SPACE_FIXED:	383	case XML_TYPE_LINE_SPACE_FIXED:
381	pPropHdl = new XMLLineHeightHdl;	384	pPropHdl = new XMLLineHeightHdl;
382	break;	385	break;

Lines 371-383 Link Here

(-)a/xmloff/source/style/xmlnumfe.cxx (-6 / +10 lines)
371	{	371	{
372	if ( nLang != LANGUAGE_SYSTEM )	372	if ( nLang != LANGUAGE_SYSTEM )
373	{	373	{
374	OUString aLangStr, aCountryStr;	374	OUString aLanguageTag, aRegionTag, aOtherTags;
375	MsLangId::convertLanguageToIsoNames( (LanguageType)nLang, aLangStr, aCountryStr );	375	MsLangId::convertLanguageToIsoNames( (LanguageType)nLang, aLanguageTag, aRegionTag, aOtherTags);
376		376
377	if (aLangStr.getLength())	377	if (aLanguageTag.getLength())
378	rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_LANGUAGE, aLangStr );	378	rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_LANGUAGE, aLanguageTag );
379	if (aCountryStr.getLength())	379	if (aRegionTag.getLength())
380	rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_COUNTRY, aCountryStr );	380	rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_COUNTRY, aRegionTag );
		381	if (aOtherTags.getLength())
		382	rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_LANGUAGE_TAGS, aOtherTags );
381	}	383	}
382	}	384	}
383		385
Lines 1126-1131 Link Here
1126	aAttr.Locale.Language );	1128	aAttr.Locale.Language );
1127	rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_COUNTRY,	1129	rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_COUNTRY,
1128	aAttr.Locale.Country );	1130	aAttr.Locale.Country );
		1131	rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_LANGUAGE_TAGS,
		1132	aAttr.Locale.Variant );
1129	rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_STYLE,	1133	rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_STYLE,
1130	aAttr.Style );	1134	aAttr.Style );
1131	}	1135	}




	XML_TOK_STYLE_ATTR_NAME,
	XML_TOK_STYLE_ATTR_LANGUAGE,
	XML_TOK_STYLE_ATTR_COUNTRY,
	XML_TOK_STYLE_ATTR_LANGUAGE_TAGS,
	XML_TOK_STYLE_ATTR_TITLE,
	XML_TOK_STYLE_ATTR_AUTOMATIC_ORDER,
	XML_TOK_STYLE_ATTR_FORMAT_SOURCE,

    XML_TOK_STYLE_ATTR_TRANSL_FORMAT,
    XML_TOK_STYLE_ATTR_TRANSL_LANGUAGE,
    XML_TOK_STYLE_ATTR_TRANSL_COUNTRY,
    XML_TOK_STYLE_ATTR_TRANSL_LANGUAGE_TAGS,
    XML_TOK_STYLE_ATTR_TRANSL_STYLE
};


	XML_TOK_ELEM_ATTR_MIN_DENOMINATOR_DIGITS,
	XML_TOK_ELEM_ATTR_LANGUAGE,
	XML_TOK_ELEM_ATTR_COUNTRY,
	XML_TOK_ELEM_ATTR_LANGUAGE_TAGS,
	XML_TOK_ELEM_ATTR_STYLE,
	XML_TOK_ELEM_ATTR_TEXTUAL,
	XML_TOK_ELEM_ATTR_CALENDAR

	        { XML_NAMESPACE_STYLE,  XML_NAME,			 	   XML_TOK_STYLE_ATTR_NAME					},
	        { XML_NAMESPACE_NUMBER, XML_LANGUAGE,		 	   XML_TOK_STYLE_ATTR_LANGUAGE				},
	        { XML_NAMESPACE_NUMBER, XML_COUNTRY,		 	   XML_TOK_STYLE_ATTR_COUNTRY				},
	        { XML_NAMESPACE_NUMBER, XML_LANGUAGE_TAGS,		   XML_TOK_STYLE_ATTR_LANGUAGE_TAGS			},
	        { XML_NAMESPACE_NUMBER, XML_TITLE,			 	   XML_TOK_STYLE_ATTR_TITLE					},
	        { XML_NAMESPACE_NUMBER, XML_AUTOMATIC_ORDER, 	   XML_TOK_STYLE_ATTR_AUTOMATIC_ORDER		},
	        { XML_NAMESPACE_NUMBER, XML_FORMAT_SOURCE, 	       XML_TOK_STYLE_ATTR_FORMAT_SOURCE			},

            { XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_FORMAT,     XML_TOK_STYLE_ATTR_TRANSL_FORMAT    },
            { XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_LANGUAGE,   XML_TOK_STYLE_ATTR_TRANSL_LANGUAGE  },
            { XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_COUNTRY,    XML_TOK_STYLE_ATTR_TRANSL_COUNTRY   },
            { XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_LANGUAGE_TAGS,    XML_TOK_STYLE_ATTR_TRANSL_LANGUAGE_TAGS   },
            { XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_STYLE,      XML_TOK_STYLE_ATTR_TRANSL_STYLE     },
	        XML_TOKEN_MAP_END
        };

	        { XML_NAMESPACE_NUMBER, XML_MIN_DENOMINATOR_DIGITS,  XML_TOK_ELEM_ATTR_MIN_DENOMINATOR_DIGITS },
	        { XML_NAMESPACE_NUMBER, XML_LANGUAGE,			 	 XML_TOK_ELEM_ATTR_LANGUAGE				},
	        { XML_NAMESPACE_NUMBER, XML_COUNTRY,			 	 XML_TOK_ELEM_ATTR_COUNTRY				},
	        { XML_NAMESPACE_NUMBER, XML_LANGUAGE_TAGS,		 	 XML_TOK_ELEM_ATTR_LANGUAGE_TAGS		},
	        { XML_NAMESPACE_NUMBER, XML_STYLE,				 	 XML_TOK_ELEM_ATTR_STYLE				},
	        { XML_NAMESPACE_NUMBER, XML_TEXTUAL,			 	 XML_TOK_ELEM_ATTR_TEXTUAL				},
	        { XML_NAMESPACE_NUMBER, XML_CALENDAR,			 	 XML_TOK_ELEM_ATTR_CALENDAR				},

	bLong( FALSE ),
	bTextual( FALSE )
{
	OUString sLanguageTag, sRegionTag, sOtherTags;
	sal_Int32 nAttrVal;
	sal_Bool bAttrBool;
	sal_uInt16 nAttrEnum;

					aNumInfo.nDenomDigits = nAttrVal;
				break;
			case XML_TOK_ELEM_ATTR_LANGUAGE:
				sLanguageTag = sValue;
				break;
			case XML_TOK_ELEM_ATTR_COUNTRY:
				sRegionTag = sValue;
				break;
			case XML_TOK_ELEM_ATTR_LANGUAGE_TAGS:
				sOtherTags = sValue;
				break;
			case XML_TOK_ELEM_ATTR_STYLE:
				if ( SvXMLUnitConverter::convertEnum( nAttrEnum, sValue, aStyleValueMap ) )

		}
	}

	if ( sLanguageTag.getLength() || sRegionTag.getLength() || sOtherTags.getLength() )
	{
		nElementLang = MsLangId::convertIsoNamesToLanguage( sLanguageTag, sRegionTag, sOtherTags );
		if ( nElementLang == LANGUAGE_DONTKNOW )
			nElementLang = LANGUAGE_SYSTEM;			//! error handling for invalid locales?
	}

	eDateSecs( XML_DEA_NONE ),
	bDateNoDefault( sal_False )
{
	OUString sLanguageTag, sRegionTag, sOtherTags;
    ::com::sun::star::i18n::NativeNumberXmlAttributes aNatNumAttr;
	sal_Bool bAttrBool;
	sal_uInt16 nAttrEnum;

//				aName = sValue;
				break;
			case XML_TOK_STYLE_ATTR_LANGUAGE:
				sLanguageTag = sValue;
				break;
			case XML_TOK_STYLE_ATTR_COUNTRY:
				sRegionTag = sValue;
				break;
			case XML_TOK_STYLE_ATTR_LANGUAGE_TAGS:
				sOtherTags = sValue;
				break;
			case XML_TOK_STYLE_ATTR_TITLE:
				sFormatTitle = sValue;

            case XML_TOK_STYLE_ATTR_TRANSL_COUNTRY:
                aNatNumAttr.Locale.Country = sValue;
                break;
            case XML_TOK_STYLE_ATTR_TRANSL_LANGUAGE_TAGS:
                aNatNumAttr.Locale.Variant = sValue;
                break;
            case XML_TOK_STYLE_ATTR_TRANSL_STYLE:
                aNatNumAttr.Style = sValue;
                break;
		}
	}

	if ( sLanguageTag.getLength() || sRegionTag.getLength() || sOtherTags.getLength() )
	{
		nFormatLang = MsLangId::convertIsoNamesToLanguage( sLanguageTag, sRegionTag, sOtherTags );
		if ( nFormatLang == LANGUAGE_DONTKNOW )
			nFormatLang = LANGUAGE_SYSTEM;			//! error handling for invalid locales?
	}

Lines 187-192 Link Here

(-)a/xmloff/source/text/XMLIndexAlphabeticalSourceContext.cxx (+3 lines)
187	case XML_TOK_INDEXSOURCE_COUNTRY:	187	case XML_TOK_INDEXSOURCE_COUNTRY:
188	aLocale.Country = rValue;	188	aLocale.Country = rValue;
189	break;	189	break;
		190	case XML_TOK_INDEXSOURCE_LANGUAGE_TAGS:
		191	aLocale.Variant = rValue;
		192	break;
190		193
191	default:	194	default:
192	XMLIndexSourceBaseContext::ProcessAttribute(eParam, rValue);	195	XMLIndexSourceBaseContext::ProcessAttribute(eParam, rValue);

Lines 152-157 Link Here

(-)a/xmloff/source/text/XMLIndexBibliographyConfigurationContext.cxx (+4 lines)
152	{	152	{
153	aLocale.Country = sValue;	153	aLocale.Country = sValue;
154	}	154	}
		155	else if( IsXMLToken(sLocalName, XML_LANGUAGE_TAGS) )
		156	{
		157	aLocale.Variant = sValue;
		158	}
155	}	159	}
156	}	160	}
157		161

Lines 148-153 Link Here

(-)a/xmloff/source/text/XMLIndexSourceBaseContext.cxx (+1 lines)
148	XML_TOK_INDEXSOURCE_SORT_ALGORITHM },	148	XML_TOK_INDEXSOURCE_SORT_ALGORITHM },
149	{ XML_NAMESPACE_FO, XML_LANGUAGE, XML_TOK_INDEXSOURCE_LANGUAGE },	149	{ XML_NAMESPACE_FO, XML_LANGUAGE, XML_TOK_INDEXSOURCE_LANGUAGE },
150	{ XML_NAMESPACE_FO, XML_COUNTRY, XML_TOK_INDEXSOURCE_COUNTRY },	150	{ XML_NAMESPACE_FO, XML_COUNTRY, XML_TOK_INDEXSOURCE_COUNTRY },
		151	{ XML_NAMESPACE_FO, XML_LANGUAGE_TAGS, XML_TOK_INDEXSOURCE_LANGUAGE_TAGS },
151	{ XML_NAMESPACE_TEXT, XML_INDEX_NAME, XML_TOK_INDEXSOURCE_USER_INDEX_NAME },	152	{ XML_NAMESPACE_TEXT, XML_INDEX_NAME, XML_TOK_INDEXSOURCE_USER_INDEX_NAME },
152	{ XML_NAMESPACE_TEXT,	153	{ XML_NAMESPACE_TEXT,
153	XML_USE_OUTLINE_LEVEL,	154	XML_USE_OUTLINE_LEVEL,

Lines 71-76 Link Here

(-)a/xmloff/source/text/XMLIndexSourceBaseContext.hxx (+1 lines)
71	XML_TOK_INDEXSOURCE_SORT_ALGORITHM,	71	XML_TOK_INDEXSOURCE_SORT_ALGORITHM,
72	XML_TOK_INDEXSOURCE_LANGUAGE,	72	XML_TOK_INDEXSOURCE_LANGUAGE,
73	XML_TOK_INDEXSOURCE_COUNTRY,	73	XML_TOK_INDEXSOURCE_COUNTRY,
		74	XML_TOK_INDEXSOURCE_LANGUAGE_TAGS,
74	XML_TOK_INDEXSOURCE_USER_INDEX_NAME,	75	XML_TOK_INDEXSOURCE_USER_INDEX_NAME,
75	XML_TOK_INDEXSOURCE_USE_OUTLINE_LEVEL	76	XML_TOK_INDEXSOURCE_USE_OUTLINE_LEVEL
76	};	77	};

Lines 721-730 Link Here

(-)a/xmloff/source/text/XMLSectionExport.cxx (-8 / +18 lines)
721	aAny = rPropertySet->getPropertyValue(sLocale);	721	aAny = rPropertySet->getPropertyValue(sLocale);
722	Locale aLocale;	722	Locale aLocale;
723	aAny >>= aLocale;	723	aAny >>= aLocale;
724	GetExport().AddAttribute(XML_NAMESPACE_FO, XML_LANGUAGE,	724	if (aLocale.Language.getLength())
725	aLocale.Language);	725	GetExport().AddAttribute(XML_NAMESPACE_FO, XML_LANGUAGE,
726	GetExport().AddAttribute(XML_NAMESPACE_FO, XML_COUNTRY,	726	aLocale.Language);
727	aLocale.Country);	727	if (aLocale.Country.getLength())
		728	GetExport().AddAttribute(XML_NAMESPACE_FO, XML_COUNTRY,
		729	aLocale.Country);
		730	if (aLocale.Variant.getLength())
		731	GetExport().AddAttribute(XML_NAMESPACE_FO, XML_LANGUAGE_TAGS,
		732	aLocale.Variant);
728		733
729	ExportBaseIndexSource(TEXT_SECTION_TYPE_ALPHABETICAL, rPropertySet);	734	ExportBaseIndexSource(TEXT_SECTION_TYPE_ALPHABETICAL, rPropertySet);
730	}	735	}
Lines 1711-1720 Link Here
1711	aAny = xPropSet->getPropertyValue(sLocale);	1716	aAny = xPropSet->getPropertyValue(sLocale);
1712	Locale aLocale;	1717	Locale aLocale;
1713	aAny >>= aLocale;	1718	aAny >>= aLocale;
1714	rExport.AddAttribute(XML_NAMESPACE_FO, XML_LANGUAGE,	1719	if (aLocale.Language.getLength())
1715	aLocale.Language);	1720	rExport.AddAttribute(XML_NAMESPACE_FO, XML_LANGUAGE,
1716	rExport.AddAttribute(XML_NAMESPACE_FO, XML_COUNTRY,	1721	aLocale.Language);
1717	aLocale.Country);	1722	if (aLocale.Country.getLength())
		1723	rExport.AddAttribute(XML_NAMESPACE_FO, XML_COUNTRY,
		1724	aLocale.Country);
		1725	if (aLocale.Variant.getLength())
		1726	rExport.AddAttribute(XML_NAMESPACE_FO, XML_LANGUAGE_TAGS,
		1727	aLocale.Variant);
1718		1728
1719	// configuration element	1729	// configuration element
1720	SvXMLElementExport aElement(rExport, XML_NAMESPACE_TEXT,	1730	SvXMLElementExport aElement(rExport, XML_NAMESPACE_TEXT,




	// RES_CHRATR_LANGUAGE
	MT_ED( "CharLocale",		FO,		LANGUAGE, 			XML_TYPE_CHAR_LANGUAGE|MID_FLAG_MERGE_PROPERTY, 0 ),
	MT_ED( "CharLocale",		FO,		COUNTRY, 			XML_TYPE_CHAR_COUNTRY|MID_FLAG_MERGE_PROPERTY, 0 ),
	MT_ED( "CharLocale",		FO,		LANGUAGE_TAGS, 		XML_TYPE_CHAR_LANGUAGE_TAGS|MID_FLAG_MERGE_PROPERTY, 0 ),
	// RES_CHRATR_POSTURE
	MT_E( "CharPosture",		FO,		FONT_STYLE,			XML_TYPE_TEXT_POSTURE, 0 ),
	// RES_CHRATR_PROPORTIONALFONTSIZE

	// RES_CHRATR_CJK_LANGUAGE
	MT_ED( "CharLocaleAsian",		STYLE,		LANGUAGE_ASIAN, 			XML_TYPE_CHAR_LANGUAGE|MID_FLAG_MERGE_PROPERTY, 0 ),
	MT_ED( "CharLocaleAsian",		STYLE,		COUNTRY_ASIAN, 			XML_TYPE_CHAR_COUNTRY|MID_FLAG_MERGE_PROPERTY, 0 ),
	MT_ED( "CharLocaleAsian",		STYLE,		LANGUAGE_TAGS_ASIAN,	XML_TYPE_CHAR_LANGUAGE_TAGS|MID_FLAG_MERGE_PROPERTY, 0 ),
	// RES_CHRATR_CJK_POSTURE
	MT_E( "CharPostureAsian",		STYLE,		FONT_STYLE_ASIAN,			XML_TYPE_TEXT_POSTURE, 0 ),
	// RES_CHRATR_CJK_WEIGHT

	// RES_CHRATR_CTL_LANGUAGE
	MT_ED( "CharLocaleComplex",		STYLE,		LANGUAGE_COMPLEX, 			XML_TYPE_CHAR_LANGUAGE|MID_FLAG_MERGE_PROPERTY, 0 ),
	MT_ED( "CharLocaleComplex",		STYLE,		COUNTRY_COMPLEX, 			XML_TYPE_CHAR_COUNTRY|MID_FLAG_MERGE_PROPERTY, 0 ),
	MT_ED( "CharLocaleComplex",		STYLE,		LANGUAGE_TAGS_COMPLEX, 		XML_TYPE_CHAR_LANGUAGE_TAGS|MID_FLAG_MERGE_PROPERTY, 0 ),
	// RES_CHRATR_CTL_POSTURE
	MT_E( "CharPostureComplex",		STYLE,		FONT_STYLE_COMPLEX,			XML_TYPE_TEXT_POSTURE, 0 ),
	// RES_CHRATR_CTL_WEIGHT

	// RES_CHRATR_LANGUAGE
	MT_ED( "CharLocale",		FO,		LANGUAGE, 			XML_TYPE_CHAR_LANGUAGE|MID_FLAG_MERGE_PROPERTY, 0 ),
	MT_ED( "CharLocale",		FO,		COUNTRY, 			XML_TYPE_CHAR_COUNTRY|MID_FLAG_MERGE_PROPERTY, 0 ),
	MT_ED( "CharLocale",		FO,		LANGUAGE_TAGS, 		XML_TYPE_CHAR_LANGUAGE_TAGS|MID_FLAG_MERGE_PROPERTY, 0 ),
	// RES_CHRATR_POSTURE
	MT_E( "CharPosture",		FO,		FONT_STYLE,			XML_TYPE_TEXT_POSTURE, 0 ),
	// RES_CHRATR_PROPORTIONALFONTSIZE

	// RES_CHRATR_CJK_LANGUAGE
	MT_ED( "CharLocaleAsian",		STYLE,		LANGUAGE_ASIAN, 			XML_TYPE_CHAR_LANGUAGE|MID_FLAG_MERGE_PROPERTY, 0 ),
	MT_ED( "CharLocaleAsian",		STYLE,		COUNTRY_ASIAN, 			XML_TYPE_CHAR_COUNTRY|MID_FLAG_MERGE_PROPERTY, 0 ),
	MT_ED( "CharLocaleAsian",		STYLE,		LANGUAGE_TAGS_ASIAN, 		XML_TYPE_CHAR_LANGUAGE_TAGS|MID_FLAG_MERGE_PROPERTY, 0 ),
	// RES_CHRATR_CJK_POSTURE
	MT_E( "CharPostureAsian",		STYLE,		FONT_STYLE_ASIAN,			XML_TYPE_TEXT_POSTURE, 0 ),
	// RES_CHRATR_CJK_WEIGHT

	// RES_CHRATR_CTL_LANGUAGE
	MT_ED( "CharLocaleComplex",		STYLE,		LANGUAGE_COMPLEX, 			XML_TYPE_CHAR_LANGUAGE|MID_FLAG_MERGE_PROPERTY, 0 ),
	MT_ED( "CharLocaleComplex",		STYLE,		COUNTRY_COMPLEX, 			XML_TYPE_CHAR_COUNTRY|MID_FLAG_MERGE_PROPERTY, 0 ),
	MT_ED( "CharLocaleComplex",		STYLE,		LANGUAGE_TAGS_COMPLEX, 		XML_TYPE_CHAR_LANGUAGE_TAGS|MID_FLAG_MERGE_PROPERTY, 0 ),
	// RES_CHRATR_CTL_POSTURE
	MT_E( "CharPostureComplex",		STYLE,		FONT_STYLE_COMPLEX,			XML_TYPE_TEXT_POSTURE, 0 ),
	// RES_CHRATR_CTL_WEIGHT

Lines 594-599 Link Here

(-)a/xmloff/source/transform/PropertyActionsOOo.cxx (+6 lines)
594	NO_PARAMS }, /* generated entry */	594	NO_PARAMS }, /* generated entry */
595	{ XML_NAMESPACE_STYLE, XML_COUNTRY_COMPLEX, XML_ATACTION_COPY,	595	{ XML_NAMESPACE_STYLE, XML_COUNTRY_COMPLEX, XML_ATACTION_COPY,
596	NO_PARAMS }, /* generated entry */	596	NO_PARAMS }, /* generated entry */
		597	{ XML_NAMESPACE_FO, XML_LANGUAGE_TAGS, XML_ATACTION_COPY,
		598	NO_PARAMS }, /* generated entry */
		599	{ XML_NAMESPACE_STYLE, XML_LANGUAGE_TAGS_ASIAN, XML_ATACTION_COPY,
		600	NO_PARAMS }, /* generated entry */
		601	{ XML_NAMESPACE_STYLE, XML_LANGUAGE_TAGS_COMPLEX, XML_ATACTION_COPY,
		602	NO_PARAMS }, /* generated entry */
597	{ XML_NAMESPACE_FO, XML_FONT_STYLE, XML_ATACTION_COPY,	603	{ XML_NAMESPACE_FO, XML_FONT_STYLE, XML_ATACTION_COPY,
598	NO_PARAMS }, /* generated entry */	604	NO_PARAMS }, /* generated entry */
599	{ XML_NAMESPACE_STYLE, XML_FONT_STYLE_ASIAN, XML_ATACTION_COPY,	605	{ XML_NAMESPACE_STYLE, XML_FONT_STYLE_ASIAN, XML_ATACTION_COPY,

Return to issue 111066

Lines 1269-1305 Link Here

(-)a/configure.in (-32 / +31 lines)
1269	fi	1269	fi
1270	AC_SUBST(WITH_MYSPELL_DICTS)	1270	AC_SUBST(WITH_MYSPELL_DICTS)
1271		1271
1272	if test "$WITH_MYSPELL_DICTS" = "NO"; then	1272	AC_MSG_CHECKING([whether to use dicts from external paths])
1273	AC_MSG_CHECKING([whether to use dicts from external paths])	1273	if test -n "$with_system_dicts" -a "$with_system_dicts" = "yes"; then
1274	if test -n "$with_system_dicts" -a "$with_system_dicts" = "yes"; then	1274	AC_MSG_RESULT([yes])
1275	AC_MSG_RESULT([yes])	1275	SYSTEM_DICTS=YES
1276	SYSTEM_DICTS=YES	1276	AC_MSG_CHECKING([for spelling dictionary directory])
1277	AC_MSG_CHECKING([for spelling dictionary directory])	1277	if test -n "$with_external_dict_dir"; then
1278	if test -n "$with_external_dict_dir"; then	1278	DICT_SYSTEM_DIR=file://$with_external_dict_dir
1279	DICT_SYSTEM_DIR=file://$with_external_dict_dir	1279	else
1280	else	1280	DICT_SYSTEM_DIR=file:///usr/share/hunspell
1281	DICT_SYSTEM_DIR=file:///usr/share/hunspell	1281	fi
1282	fi	1282	AC_MSG_RESULT([$DICT_SYSTEM_DIR])
1283	AC_MSG_RESULT([$DICT_SYSTEM_DIR])	1283	AC_MSG_CHECKING([for hyphenation patterns directory])
1284	AC_MSG_CHECKING([for hyphenation patterns directory])	1284	if test -n "$with_external_hyph_dir"; then
1285	if test -n "$with_external_hyph_dir"; then	1285	HYPH_SYSTEM_DIR=file://$with_external_hyph_dir
1286	HYPH_SYSTEM_DIR=file://$with_external_hyph_dir	1286	else
1287	else	1287	HYPH_SYSTEM_DIR=file:///usr/share/hyphen
1288	HYPH_SYSTEM_DIR=file:///usr/share/hyphen	1288	fi
1289	fi	1289	AC_MSG_RESULT([$HYPH_SYSTEM_DIR])
1290	AC_MSG_RESULT([$HYPH_SYSTEM_DIR])	1290	AC_MSG_CHECKING([for thesaurus directory])
1291	AC_MSG_CHECKING([for thesaurus directory])	1291	if test -n "$with_external_thes_dir"; then
1292	if test -n "$with_external_thes_dir"; then	1292	THES_SYSTEM_DIR=file://$with_external_thes_dir
1293	THES_SYSTEM_DIR=file://$with_external_thes_dir	1293	else
1294	else	1294	THES_SYSTEM_DIR=file:///usr/share/mythes
1295	THES_SYSTEM_DIR=file:///usr/share/mythes	1295	fi
1296	fi	1296	AC_MSG_RESULT([$THES_SYSTEM_DIR])
1297	AC_MSG_RESULT([$THES_SYSTEM_DIR])	1297	else
1298	else	1298	AC_MSG_RESULT([no])
1299	AC_MSG_RESULT([no])	1299	SYSTEM_DICTS=NO
1300	SYSTEM_DICTS=NO	1300	fi
1301	fi	1301
1302	fi
1303	AC_SUBST(SYSTEM_DICTS)	1302	AC_SUBST(SYSTEM_DICTS)
1304	AC_SUBST(DICT_SYSTEM_DIR)	1303	AC_SUBST(DICT_SYSTEM_DIR)
1305	AC_SUBST(HYPH_SYSTEM_DIR)	1304	AC_SUBST(HYPH_SYSTEM_DIR)
Lines 3870-3876 Link Here
3870	AC_MSG_CHECKING([MySQL version])	3869	AC_MSG_CHECKING([MySQL version])
3871	MYSQL_VERSION=`$MYSQLCONFIG --version`	3870	MYSQL_VERSION=`$MYSQLCONFIG --version`
3872	MYSQL_MAJOR=`$MYSQLCONFIG --version \| cut -d"." -f1`	3871	MYSQL_MAJOR=`$MYSQLCONFIG --version \| cut -d"." -f1`
3873	if test "$MYSQL_MAJOR" -ge "5"; then	3872	if test "$MYSQL_MAJOR" -ge "2"; then
3874	AC_MSG_RESULT([OK])	3873	AC_MSG_RESULT([OK])
3875	else	3874	else
3876	AC_MSG_ERROR([too old, use 5.0.x or 5.1.x])	3875	AC_MSG_ERROR([too old, use 5.0.x or 5.1.x])

Lines 360-375 Link Here

(-)a/binfilter/bf_xmloff/source/style/xmloff_xmlnumfe.cxx (-7 / +11 lines)
360	{	360	{
361	if ( nLang != LANGUAGE_SYSTEM )	361	if ( nLang != LANGUAGE_SYSTEM )
362	{	362	{
363	OUString aLangStr, aCountryStr;	363	OUString aLanguageTag, aRegionTag, aOtherTags;
364	MsLangId::convertLanguageToIsoNames( (LanguageType)nLang, aLangStr, aCountryStr );	364	MsLangId::convertLanguageToIsoNames( (LanguageType)nLang, aLanguageTag, aRegionTag, aOtherTags );
365		365
366	if (aLangStr.getLength())	366	if (aLanguageTag.getLength())
367	{	367	{
368	rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_LANGUAGE, aLangStr );	368	rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_LANGUAGE, aLanguageTag );
369	}	369	}
370	if (aCountryStr.getLength())	370	if (aRegionTag.getLength())
371	{	371	{
372	rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_COUNTRY, aCountryStr );	372	rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_COUNTRY, aRegionTag );
		373	}
		374	if (aOtherTags.getLength())
		375	{
		376	rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_LANGUAGE_TAGS, aOtherTags );
373	}	377	}
374	}	378	}
375	}	379	}
Lines 801-807 Link Here
801	// pLocaleData->setLocale( rLocale );	805	// pLocaleData->setLocale( rLocale );
802	// String sCurString = pLocaleData->getCurrSymbol();	806	// String sCurString = pLocaleData->getCurrSymbol();
803		807
804	LanguageType nLang = MsLangId::convertIsoNamesToLanguage( rLocale.Language, rLocale.Country );	808	LanguageType nLang = MsLangId::convertIsoNamesToLanguage( rLocale.Language, rLocale.Country, rLocale.Variant );
805	pFormatter->ChangeIntl( nLang );	809	pFormatter->ChangeIntl( nLang );
806	String sCurString, sDummy;	810	String sCurString, sDummy;
807	pFormatter->GetCompatibilityCurrency( sCurString, sDummy );	811	pFormatter->GetCompatibilityCurrency( sCurString, sDummy );

Lines 268-273 Link Here

(-)a/binfilter/bf_xmloff/source/style/xmloff_xmlnumfi.cxx (-12 / +22 lines)
268	XML_TOK_STYLE_ATTR_NAME,	268	XML_TOK_STYLE_ATTR_NAME,
269	XML_TOK_STYLE_ATTR_LANGUAGE,	269	XML_TOK_STYLE_ATTR_LANGUAGE,
270	XML_TOK_STYLE_ATTR_COUNTRY,	270	XML_TOK_STYLE_ATTR_COUNTRY,
		271	XML_TOK_STYLE_ATTR_LANGUAGE_TAGS,
271	XML_TOK_STYLE_ATTR_TITLE,	272	XML_TOK_STYLE_ATTR_TITLE,
272	XML_TOK_STYLE_ATTR_AUTOMATIC_ORDER,	273	XML_TOK_STYLE_ATTR_AUTOMATIC_ORDER,
273	XML_TOK_STYLE_ATTR_FORMAT_SOURCE,	274	XML_TOK_STYLE_ATTR_FORMAT_SOURCE,
Lines 291-296 Link Here
291	XML_TOK_ELEM_ATTR_MIN_DENOMINATOR_DIGITS,	292	XML_TOK_ELEM_ATTR_MIN_DENOMINATOR_DIGITS,
292	XML_TOK_ELEM_ATTR_LANGUAGE,	293	XML_TOK_ELEM_ATTR_LANGUAGE,
293	XML_TOK_ELEM_ATTR_COUNTRY,	294	XML_TOK_ELEM_ATTR_COUNTRY,
		295	XML_TOK_ELEM_ATTR_LANGUAGE_TAGS,
294	XML_TOK_ELEM_ATTR_STYLE,	296	XML_TOK_ELEM_ATTR_STYLE,
295	XML_TOK_ELEM_ATTR_TEXTUAL,	297	XML_TOK_ELEM_ATTR_TEXTUAL,
296	XML_TOK_ELEM_ATTR_CALENDAR	298	XML_TOK_ELEM_ATTR_CALENDAR
Lines 367-372 Link Here
367	{ XML_NAMESPACE_STYLE, XML_NAME, XML_TOK_STYLE_ATTR_NAME },	369	{ XML_NAMESPACE_STYLE, XML_NAME, XML_TOK_STYLE_ATTR_NAME },
368	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE, XML_TOK_STYLE_ATTR_LANGUAGE },	370	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE, XML_TOK_STYLE_ATTR_LANGUAGE },
369	{ XML_NAMESPACE_NUMBER, XML_COUNTRY, XML_TOK_STYLE_ATTR_COUNTRY },	371	{ XML_NAMESPACE_NUMBER, XML_COUNTRY, XML_TOK_STYLE_ATTR_COUNTRY },
		372	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE_TAGS, XML_TOK_STYLE_ATTR_LANGUAGE_TAGS },
370	{ XML_NAMESPACE_NUMBER, XML_TITLE, XML_TOK_STYLE_ATTR_TITLE },	373	{ XML_NAMESPACE_NUMBER, XML_TITLE, XML_TOK_STYLE_ATTR_TITLE },
371	{ XML_NAMESPACE_NUMBER, XML_AUTOMATIC_ORDER, XML_TOK_STYLE_ATTR_AUTOMATIC_ORDER },	374	{ XML_NAMESPACE_NUMBER, XML_AUTOMATIC_ORDER, XML_TOK_STYLE_ATTR_AUTOMATIC_ORDER },
372	{ XML_NAMESPACE_NUMBER, XML_FORMAT_SOURCE, XML_TOK_STYLE_ATTR_FORMAT_SOURCE },	375	{ XML_NAMESPACE_NUMBER, XML_FORMAT_SOURCE, XML_TOK_STYLE_ATTR_FORMAT_SOURCE },
Lines 392-397 Link Here
392	{ XML_NAMESPACE_NUMBER, XML_MIN_DENOMINATOR_DIGITS, XML_TOK_ELEM_ATTR_MIN_DENOMINATOR_DIGITS },	395	{ XML_NAMESPACE_NUMBER, XML_MIN_DENOMINATOR_DIGITS, XML_TOK_ELEM_ATTR_MIN_DENOMINATOR_DIGITS },
393	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE, XML_TOK_ELEM_ATTR_LANGUAGE },	396	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE, XML_TOK_ELEM_ATTR_LANGUAGE },
394	{ XML_NAMESPACE_NUMBER, XML_COUNTRY, XML_TOK_ELEM_ATTR_COUNTRY },	397	{ XML_NAMESPACE_NUMBER, XML_COUNTRY, XML_TOK_ELEM_ATTR_COUNTRY },
		398	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE_TAGS, XML_TOK_ELEM_ATTR_LANGUAGE_TAGS },
395	{ XML_NAMESPACE_NUMBER, XML_STYLE, XML_TOK_ELEM_ATTR_STYLE },	399	{ XML_NAMESPACE_NUMBER, XML_STYLE, XML_TOK_ELEM_ATTR_STYLE },
396	{ XML_NAMESPACE_NUMBER, XML_TEXTUAL, XML_TOK_ELEM_ATTR_TEXTUAL },	400	{ XML_NAMESPACE_NUMBER, XML_TEXTUAL, XML_TOK_ELEM_ATTR_TEXTUAL },
397	{ XML_NAMESPACE_NUMBER, XML_CALENDAR, XML_TOK_ELEM_ATTR_CALENDAR },	401	{ XML_NAMESPACE_NUMBER, XML_CALENDAR, XML_TOK_ELEM_ATTR_CALENDAR },
Lines 911-917 Link Here
911	bLong( FALSE ),	915	bLong( FALSE ),
912	bTextual( FALSE )	916	bTextual( FALSE )
913	{	917	{
914	OUString sLanguage, sCountry;	918	OUString sLanguageTag, sRegionTag, sOtherTags;
915	sal_Int32 nAttrVal;	919	sal_Int32 nAttrVal;
916	sal_Bool bAttrBool;	920	sal_Bool bAttrBool;
917	sal_uInt16 nAttrEnum;	921	sal_uInt16 nAttrEnum;
Lines 965-974 Link Here
965	aNumInfo.nDenomDigits = nAttrVal;	969	aNumInfo.nDenomDigits = nAttrVal;
966	break;	970	break;
967	case XML_TOK_ELEM_ATTR_LANGUAGE:	971	case XML_TOK_ELEM_ATTR_LANGUAGE:
968	sLanguage = sValue;	972	sLanguageTag = sValue;
969	break;	973	break;
970	case XML_TOK_ELEM_ATTR_COUNTRY:	974	case XML_TOK_ELEM_ATTR_COUNTRY:
971	sCountry = sValue;	975	sRegionTag = sValue;
		976	break;
		977	case XML_TOK_ELEM_ATTR_LANGUAGE_TAGS:
		978	sOtherTags = sValue;
972	break;	979	break;
973	case XML_TOK_ELEM_ATTR_STYLE:	980	case XML_TOK_ELEM_ATTR_STYLE:
974	if ( SvXMLUnitConverter::convertEnum( nAttrEnum, sValue, aStyleValueMap ) )	981	if ( SvXMLUnitConverter::convertEnum( nAttrEnum, sValue, aStyleValueMap ) )
Lines 984-992 Link Here
984	}	991	}
985	}	992	}
986		993
987	if ( sLanguage.getLength() \|\| sCountry.getLength() )	994	if ( sLanguageTag.getLength() \|\| sRegionTag.getLength() \|\| sOtherTags.getLength() )
988	{	995	{
989	nElementLang = MsLangId::convertIsoNamesToLanguage( sLanguage, sCountry );	996	nElementLang = MsLangId::convertIsoNamesToLanguage( sLanguageTag, sRegionTag, sOtherTags );
990	if ( nElementLang == LANGUAGE_DONTKNOW )	997	if ( nElementLang == LANGUAGE_DONTKNOW )
991	nElementLang = LANGUAGE_SYSTEM; //! error handling for invalid locales?	998	nElementLang = LANGUAGE_SYSTEM; //! error handling for invalid locales?
992	}	999	}
Lines 1244-1250 Link Here
1244	eDateSecs( XML_DEA_NONE ),	1251	eDateSecs( XML_DEA_NONE ),
1245	bDateNoDefault( sal_False )	1252	bDateNoDefault( sal_False )
1246	{	1253	{
1247	OUString sLanguage, sCountry;	1254	OUString sLanguageTag, sRegionTag, sOtherTags;
1248	::com::sun::star::i18n::NativeNumberXmlAttributes aNatNumAttr;	1255	::com::sun::star::i18n::NativeNumberXmlAttributes aNatNumAttr;
1249	sal_Bool bAttrBool;	1256	sal_Bool bAttrBool;
1250	sal_uInt16 nAttrEnum;	1257	sal_uInt16 nAttrEnum;
Lines 1265-1274 Link Here
1265	// aName = sValue;	1272	// aName = sValue;
1266	break;	1273	break;
1267	case XML_TOK_STYLE_ATTR_LANGUAGE:	1274	case XML_TOK_STYLE_ATTR_LANGUAGE:
1268	sLanguage = sValue;	1275	sLanguageTag = sValue;
1269	break;	1276	break;
1270	case XML_TOK_STYLE_ATTR_COUNTRY:	1277	case XML_TOK_STYLE_ATTR_COUNTRY:
1271	sCountry = sValue;	1278	sRegionTag = sValue;
		1279	break;
		1280	case XML_TOK_STYLE_ATTR_LANGUAGE_TAGS:
		1281	sOtherTags = sValue;
1272	break;	1282	break;
1273	case XML_TOK_STYLE_ATTR_TITLE:	1283	case XML_TOK_STYLE_ATTR_TITLE:
1274	sFormatTitle = sValue;	1284	sFormatTitle = sValue;
Lines 1306-1314 Link Here
1306	}	1316	}
1307	}	1317	}
1308		1318
1309	if ( sLanguage.getLength() \|\| sCountry.getLength() )	1319	if ( sLanguageTag.getLength() \|\| sRegionTag.getLength() \|\| sOtherTags.getLength() )
1310	{	1320	{
1311	nFormatLang = MsLangId::convertIsoNamesToLanguage( sLanguage, sCountry );	1321	nFormatLang = MsLangId::convertIsoNamesToLanguage( sLanguageTag, sRegionTag, sOtherTags );
1312	if ( nFormatLang == LANGUAGE_DONTKNOW )	1322	if ( nFormatLang == LANGUAGE_DONTKNOW )
1313	nFormatLang = LANGUAGE_SYSTEM; //! error handling for invalid locales?	1323	nFormatLang = LANGUAGE_SYSTEM; //! error handling for invalid locales?
1314	}	1324	}
Lines 1322-1329 Link Here
1322	aFormatCode.appendAscii( RTL_CONSTASCII_STRINGPARAM( "[NatNum" ) );	1332	aFormatCode.appendAscii( RTL_CONSTASCII_STRINGPARAM( "[NatNum" ) );
1323	aFormatCode.append( nNatNum, 10 );	1333	aFormatCode.append( nNatNum, 10 );
1324		1334
1325	LanguageType eLang = MsLangId::convertIsoNamesToLanguage(	1335	LanguageType eLang = MsLangId::convertIsoNamesToLanguage(
1326	aNatNumAttr.Locale.Language, aNatNumAttr.Locale.Country );	1336	aNatNumAttr.Locale.Language, aNatNumAttr.Locale.Country, aNatNumAttr.Locale.Variant );
1327	if ( eLang == LANGUAGE_DONTKNOW )	1337	if ( eLang == LANGUAGE_DONTKNOW )
1328	eLang = LANGUAGE_SYSTEM; //! error handling for invalid locales?	1338	eLang = LANGUAGE_SYSTEM; //! error handling for invalid locales?
1329	if ( eLang != nFormatLang && eLang != LANGUAGE_SYSTEM )	1339	if ( eLang != nFormatLang && eLang != LANGUAGE_SYSTEM )

Lines 57-108 Link Here

(-)a/comphelper/inc/comphelper/locale.hxx (-65 lines)
57		57
58	public:	58	public:
59		59
60	/** @short seperates LANGUAGE and COUNTRY part of an ISO formated Locale. */
61	static const sal_Unicode SEPERATOR_LC;
62
63	/** @short seperates COUNTRY and VARIANT part of an ISO formated Locale. */
64	static const sal_Unicode SEPERATOR_CV;
65
66	/** @short seperates COUNTRY and VARIANT part of an ISO formated Locale.
67	@descr Its true for some linux derivates only :-( */
68	static const sal_Unicode SEPERATOR_CV_LINUX;
69
70	/** @short some predefined Locale objects. */	60	/** @short some predefined Locale objects. */
71	static const Locale EN_US();	61	static const Locale EN_US();
72	static const Locale EN();
73	static const Locale DE_DE();
74	static const Locale DE_CH();
75	static const Locale DE_AT();
76	static const Locale AR();
77	static const Locale CA();
78	static const Locale CS();
79	static const Locale DA();
80	static const Locale EL();
81	static const Locale ES();
82	static const Locale FI();
83	static const Locale FR();
84	static const Locale HE();
85	static const Locale HI_IN();
86	static const Locale HU();
87	static const Locale IT();
88	static const Locale JA();
89	static const Locale KO();
90	static const Locale NL();
91	static const Locale PL();
92	static const Locale PT();
93	static const Locale PT_BR();
94	static const Locale RU();
95	static const Locale SK();
96	static const Locale SL();
97	static const Locale SV();
98	static const Locale TH();
99	static const Locale TR();
100	static const Locale X_DEFAULT();	62	static const Locale X_DEFAULT();
101	static const Locale X_COMMENT();
102	static const Locale X_TRANSLATE();
103	static const Locale X_NOTRANSLATE();	63	static const Locale X_NOTRANSLATE();
104	static const Locale ZH_CN();
105	static const Locale ZH_TW();
106		64
107	//-------------------------------------------	65	//-------------------------------------------
108	// types	66	// types
Lines 380-408 Link Here
380	throw(MalFormedLocaleException);	338	throw(MalFormedLocaleException);
381		339
382	//---------------------------------------	340	//---------------------------------------
383	/** @short search for the next possible fallback locale.
384
385	@descr Instead of getFallback(vector<>, string) this method
386	uses the given locale and decide by using an algorithm
387	which locale can be the next possible one.
388
389	Algorithm:
390	- if locale has country return language only
391	- if locale different "en-US" return "en-US"
392	- if locale "en-US" return "en"
393
394	@param aLocale [in/out]!
395	the incoming value will be used to start
396	search for a possible fallback ...
397	and in case such fallback was found this parameter
398	will be used for return too.
399
400	@return TRUE if the parameter aLocale contains a new fallback value;
401	FALSE otherwise.
402	*/
403	static sal_Bool getFallback(Locale& aLocale);
404
405	//---------------------------------------
406	/** @short assign elements of another locale	341	/** @short assign elements of another locale
407	to this instance.	342	to this instance.
408		343

Lines 39-47 Link Here

(-)a/comphelper/source/misc/locale.cxx (-337 / +7 lines)
39	namespace comphelper{	39	namespace comphelper{
40		40
41	//-----------------------------------------------	41	//-----------------------------------------------
42	const sal_Unicode Locale::SEPERATOR_LC = (sal_Unicode)'-';	42	/** seperates LANGUAGE and COUNTRY part of an ISO formated Locale. */
43	const sal_Unicode Locale::SEPERATOR_CV = (sal_Unicode)'_';	43	const sal_Unicode SEPERATOR_LC = (sal_Unicode)'-';
44	const sal_Unicode Locale::SEPERATOR_CV_LINUX = (sal_Unicode)'.';	44	/** seperates COUNTRY and VARIANT part of an ISO formated Locale. */
		45	const sal_Unicode SEPERATOR_CV = (sal_Unicode)'_';
		46	/** seperates COUNTRY and VARIANT part of an ISO formated Locale.
		47	* It's true for some linux derivates only :-( */
		48	const sal_Unicode SEPERATOR_CV_LINUX = (sal_Unicode)'.';
45		49
46	//-----------------------------------------------	50	//-----------------------------------------------
47	const Locale Locale::X_DEFAULT()	51	const Locale Locale::X_DEFAULT()
Lines 53-67 Link Here
53	}	57	}
54		58
55	//-----------------------------------------------	59	//-----------------------------------------------
56	const Locale Locale::EN()
57	{
58	static Locale aLocale(
59	::rtl::OUString::createFromAscii("en"),
60	::rtl::OUString());
61	return aLocale;
62	}
63
64	//-----------------------------------------------
65	const Locale Locale::EN_US()	60	const Locale Locale::EN_US()
66	{	61	{
67	static Locale aLocale(	62	static Locale aLocale(
Lines 71-337 Link Here
71	}	66	}
72		67
73	//-----------------------------------------------	68	//-----------------------------------------------
74	const Locale Locale::DE_DE()
75	{
76	static Locale aLocale(
77	::rtl::OUString::createFromAscii("de"),
78	::rtl::OUString::createFromAscii("DE"));
79	return aLocale;
80	}
81
82	//-----------------------------------------------
83	const Locale Locale::DE_CH()
84	{
85	static Locale aLocale(
86	::rtl::OUString::createFromAscii("de"),
87	::rtl::OUString::createFromAscii("CH"));
88	return aLocale;
89	}
90
91	//-----------------------------------------------
92	const Locale Locale::DE_AT()
93	{
94	static Locale aLocale(
95	::rtl::OUString::createFromAscii("de"),
96	::rtl::OUString::createFromAscii("AT"));
97	return aLocale;
98	}
99
100	//-----------------------------------------------
101	const Locale Locale::AR()
102	{
103	static Locale aLocale(
104	::rtl::OUString::createFromAscii("ar"),
105	::rtl::OUString());
106	return aLocale;
107	}
108
109	//-----------------------------------------------
110	const Locale Locale::CA()
111	{
112	static Locale aLocale(
113	::rtl::OUString::createFromAscii("ca"),
114	::rtl::OUString());
115	return aLocale;
116	}
117
118	//-----------------------------------------------
119	const Locale Locale::CS()
120	{
121	static Locale aLocale(
122	::rtl::OUString::createFromAscii("cs"),
123	::rtl::OUString());
124	return aLocale;
125	}
126
127	//-----------------------------------------------
128	const Locale Locale::DA()
129	{
130	static Locale aLocale(
131	::rtl::OUString::createFromAscii("da"),
132	::rtl::OUString());
133	return aLocale;
134	}
135
136	//-----------------------------------------------
137	const Locale Locale::EL()
138	{
139	static Locale aLocale(
140	::rtl::OUString::createFromAscii("el"),
141	::rtl::OUString());
142	return aLocale;
143	}
144
145	//-----------------------------------------------
146	const Locale Locale::ES()
147	{
148	static Locale aLocale(
149	::rtl::OUString::createFromAscii("es"),
150	::rtl::OUString());
151	return aLocale;
152	}
153
154	//-----------------------------------------------
155	const Locale Locale::FI()
156	{
157	static Locale aLocale(
158	::rtl::OUString::createFromAscii("fi"),
159	::rtl::OUString());
160	return aLocale;
161	}
162
163	//-----------------------------------------------
164	const Locale Locale::FR()
165	{
166	static Locale aLocale(
167	::rtl::OUString::createFromAscii("fr"),
168	::rtl::OUString());
169	return aLocale;
170	}
171
172	//-----------------------------------------------
173	const Locale Locale::HE()
174	{
175	static Locale aLocale(
176	::rtl::OUString::createFromAscii("he"),
177	::rtl::OUString());
178	return aLocale;
179	}
180
181	//-----------------------------------------------
182	const Locale Locale::HI_IN()
183	{
184	static Locale aLocale(
185	::rtl::OUString::createFromAscii("hi"),
186	::rtl::OUString::createFromAscii("IN"));
187	return aLocale;
188	}
189
190	//-----------------------------------------------
191	const Locale Locale::HU()
192	{
193	static Locale aLocale(
194	::rtl::OUString::createFromAscii("hu"),
195	::rtl::OUString());
196	return aLocale;
197	}
198
199	//-----------------------------------------------
200	const Locale Locale::IT()
201	{
202	static Locale aLocale(
203	::rtl::OUString::createFromAscii("it"),
204	::rtl::OUString());
205	return aLocale;
206	}
207
208	//-----------------------------------------------
209	const Locale Locale::JA()
210	{
211	static Locale aLocale(
212	::rtl::OUString::createFromAscii("ja"),
213	::rtl::OUString());
214	return aLocale;
215	}
216
217	//-----------------------------------------------
218	const Locale Locale::KO()
219	{
220	static Locale aLocale(
221	::rtl::OUString::createFromAscii("ko"),
222	::rtl::OUString());
223	return aLocale;
224	}
225
226	//-----------------------------------------------
227	const Locale Locale::NL()
228	{
229	static Locale aLocale(
230	::rtl::OUString::createFromAscii("nl"),
231	::rtl::OUString());
232	return aLocale;
233	}
234
235	//-----------------------------------------------
236	const Locale Locale::PL()
237	{
238	static Locale aLocale(
239	::rtl::OUString::createFromAscii("pl"),
240	::rtl::OUString());
241	return aLocale;
242	}
243
244	//-----------------------------------------------
245	const Locale Locale::PT()
246	{
247	static Locale aLocale(
248	::rtl::OUString::createFromAscii("pt"),
249	::rtl::OUString());
250	return aLocale;
251	}
252
253	//-----------------------------------------------
254	const Locale Locale::PT_BR()
255	{
256	static Locale aLocale(
257	::rtl::OUString::createFromAscii("pt"),
258	::rtl::OUString::createFromAscii("BR"));
259	return aLocale;
260	}
261
262	//-----------------------------------------------
263	const Locale Locale::RU()
264	{
265	static Locale aLocale(
266	::rtl::OUString::createFromAscii("ru"),
267	::rtl::OUString());
268	return aLocale;
269	}
270
271	//-----------------------------------------------
272	const Locale Locale::SK()
273	{
274	static Locale aLocale(
275	::rtl::OUString::createFromAscii("sk"),
276	::rtl::OUString());
277	return aLocale;
278	}
279
280	//-----------------------------------------------
281	const Locale Locale::SL()
282	{
283	static Locale aLocale(
284	::rtl::OUString::createFromAscii("sl"),
285	::rtl::OUString());
286	return aLocale;
287	}
288
289	//-----------------------------------------------
290	const Locale Locale::SV()
291	{
292	static Locale aLocale(
293	::rtl::OUString::createFromAscii("sv"),
294	::rtl::OUString());
295	return aLocale;
296	}
297
298	//-----------------------------------------------
299	const Locale Locale::TH()
300	{
301	static Locale aLocale(
302	::rtl::OUString::createFromAscii("th"),
303	::rtl::OUString());
304	return aLocale;
305	}
306
307	//-----------------------------------------------
308	const Locale Locale::TR()
309	{
310	static Locale aLocale(
311	::rtl::OUString::createFromAscii("tr"),
312	::rtl::OUString());
313	return aLocale;
314	}
315
316	//-----------------------------------------------
317	const Locale Locale::X_COMMENT()
318	{
319	static Locale aLocale(
320	::rtl::OUString::createFromAscii("x"),
321	::rtl::OUString::createFromAscii("comment"));
322	return aLocale;
323	}
324
325	//-----------------------------------------------
326	const Locale Locale::X_TRANSLATE()
327	{
328	static Locale aLocale(
329	::rtl::OUString::createFromAscii("x"),
330	::rtl::OUString::createFromAscii("translate"));
331	return aLocale;
332	}
333
334	//-----------------------------------------------
335	const Locale Locale::X_NOTRANSLATE()	69	const Locale Locale::X_NOTRANSLATE()
336	{	70	{
337	static Locale aLocale(	71	static Locale aLocale(
Lines 341-364 Link Here
341	}	75	}
342		76
343	//-----------------------------------------------	77	//-----------------------------------------------
344	const Locale Locale::ZH_CN()
345	{
346	static Locale aLocale(
347	::rtl::OUString::createFromAscii("zh"),
348	::rtl::OUString::createFromAscii("CN"));
349	return aLocale;
350	}
351
352	//-----------------------------------------------
353	const Locale Locale::ZH_TW()
354	{
355	static Locale aLocale(
356	::rtl::OUString::createFromAscii("zh"),
357	::rtl::OUString::createFromAscii("TW"));
358	return aLocale;
359	}
360
361	//-----------------------------------------------
362	Locale::Locale(const ::rtl::OUString& sISO)	78	Locale::Locale(const ::rtl::OUString& sISO)
363	throw(Locale::MalFormedLocaleException)	79	throw(Locale::MalFormedLocaleException)
364	{	80	{
Lines 611-662 Link Here
611	}	327	}
612		328
613	//-----------------------------------------------	329	//-----------------------------------------------
614	sal_Bool Locale::getFallback(Locale& aLocale)
615	{
616	// a)
617	// this was our last fallback!
618	// break any further calls to this method ...
619	if (aLocale.equals(X_NOTRANSLATE()))
620	return sal_False;
621
622	// b)
623	// switch from X_DEFAULT to X_NOTRANSLATE
624	// next time we will go to a)
625	if (aLocale.equals(X_DEFAULT()))
626	{
627	aLocale = X_NOTRANSLATE();
628	return sal_True;
629	}
630
631	// c)
632	// switch from EN to X_DEFAULT
633	// next time we will go to b)
634	if (aLocale.equals(EN()))
635	{
636	aLocale = X_DEFAULT();
637	return sal_True;
638	}
639
640	// d) remove country from incoming locale
641	// e.g. "de-DE" => "de" or "en-US" => "en"!
642	if (aLocale.getCountry().getLength())
643	{
644	aLocale.setCountry(::rtl::OUString());
645	return sal_True;
646	}
647
648	// e) "en-US" possible?
649	if (!aLocale.equals(EN_US()))
650	{
651	aLocale = EN_US();
652	return sal_True;
653	}
654
655	// f) no more fallbacks
656	return sal_False;
657	}
658
659	//-----------------------------------------------
660	void Locale::operator=(const Locale& rCopy)	330	void Locale::operator=(const Locale& rCopy)
661	{	331	{
662	// Take over these values without checking ...	332	// Take over these values without checking ...

Lines 167-192 Link Here

(-)a/i18npool/inc/i18npool/mslangid.hxx (-12 / +13 lines)
167	// -----------------------------	167	// -----------------------------
168		168
169	static void convertLanguageToIsoNames( LanguageType nLang,	169	static void convertLanguageToIsoNames( LanguageType nLang,
170	rtl::OUString& rLangStr, rtl::OUString& rCountry );	170	rtl::OUString& rLanguageSubtag, rtl::OUString& rRegionSubtag,
		171	rtl::OUString& rOtherSubtags );
171	static void convertLanguageToIsoNames( LanguageType nLang,	172	static void convertLanguageToIsoNames( LanguageType nLang,
172	rtl::OString& rLangStr, rtl::OString& rCountry );	173	rtl::OString& rLanguageSubtag, rtl::OString& rRegionSubtag,
173	static rtl::OUString convertLanguageToIsoString( LanguageType nLang,	174	rtl::OString& rOtherSubtags );
174	sal_Unicode cSep = '-' );	175	static rtl::OUString convertLanguageToIsoString( LanguageType nLang );
175	static rtl::OString convertLanguageToIsoByteString( LanguageType nLang,	176	static rtl::OString convertLanguageToIsoByteString( LanguageType nLang );
176	sal_Char cSep = '-' );
177		177
178	// -----------------------------	178	// -----------------------------
179	// - ConvertIsoNamesToLanguage -	179	// - ConvertIsoNamesToLanguage -
180	// -----------------------------	180	// -----------------------------
181		181
182	static LanguageType convertIsoNamesToLanguage( const rtl::OUString& rLang,	182	static LanguageType convertIsoNamesToLanguage( const rtl::OUString& rLanguageSubtag,
183	const rtl::OUString& rCountry );	183	const rtl::OUString& rRegionSubtag, const rtl::OUString& rOtherSubtags );
184	static LanguageType convertIsoNamesToLanguage( const rtl::OString& rLang,	184	static LanguageType convertIsoNamesToLanguage( const rtl::OString& rLanguageSubtag,
185	const rtl::OString& rCountry );	185	const rtl::OString& rRegionSubtag, const rtl::OString& rOtherSubtags );
186	static LanguageType convertIsoStringToLanguage(	186	static LanguageType convertIsoStringToLanguage(
187	const rtl::OUString& rString, sal_Unicode cSep = '-' );	187	const rtl::OUString& rString );
188	static LanguageType convertIsoByteStringToLanguage(	188	static LanguageType convertIsoByteStringToLanguage(
189	const rtl::OString& rString, sal_Char cSep = '-' );	189	const rtl::OString& rString );
190	static LanguageType convertUnxByteStringToLanguage(	190	static LanguageType convertUnxByteStringToLanguage(
191	const rtl::OString& rString );	191	const rtl::OString& rString );
192		192
Lines 259-264 Link Here
259	LanguageType mnLang;	259	LanguageType mnLang;
260	sal_Char maLangStr[4];	260	sal_Char maLangStr[4];
261	sal_Char maCountry[3];	261	sal_Char maCountry[3];
		262	sal_Char maScriptOverride[5];
262	};	263	};
263		264
264	/** @internal - Return a pointer to the IsoLangEntry of the underlying table,	265	/** @internal - Return a pointer to the IsoLangEntry of the underlying table,

Lines 174-182 Link Here

(-)a/i18npool/source/isolang/mslangid.cxx (-4 / +2 lines)
174	void MsLangId::convertLanguageToLocale( LanguageType nLang,	174	void MsLangId::convertLanguageToLocale( LanguageType nLang,
175	::com::sun::star::lang::Locale & rLocale )	175	::com::sun::star::lang::Locale & rLocale )
176	{	176	{
177	if (rLocale.Variant.getLength())	177	convertLanguageToIsoNames( nLang, rLocale.Language, rLocale.Country, rLocale.Variant );
178	rLocale.Variant = rtl::OUString();
179	convertLanguageToIsoNames( nLang, rLocale.Language, rLocale.Country);
180	}	178	}
181		179
182		180
Lines 208-214 Link Here
208	return LANGUAGE_SYSTEM;	206	return LANGUAGE_SYSTEM;
209		207
210	LanguageType nRet = convertIsoNamesToLanguage( rLocale.Language,	208	LanguageType nRet = convertIsoNamesToLanguage( rLocale.Language,
211	rLocale.Country);	209	rLocale.Country, rLocale.Variant);
212	if (nRet == LANGUAGE_DONTKNOW)	210	if (nRet == LANGUAGE_DONTKNOW)
213	nRet = LANGUAGE_SYSTEM;	211	nRet = LANGUAGE_SYSTEM;
214		212

Lines 182-199 Link Here

(-)a/lingucomponent/source/lingutil/lingutil.cxx (-11 / +22 lines)
182	sal_Int32 nStartIndex = sPath.lastIndexOf(sal_Unicode('/')) + 1;	182	sal_Int32 nStartIndex = sPath.lastIndexOf(sal_Unicode('/')) + 1;
183	if (!sPath.match(aSystemPrefix, nStartIndex))	183	if (!sPath.match(aSystemPrefix, nStartIndex))
184	continue;	184	continue;
185	rtl::OUString sChunk = sPath.copy(0, sPath.getLength() - aSystemSuffix.getLength());	185
186	sal_Int32 nIndex = nStartIndex + aSystemPrefix.getLength();	186	nStartIndex += aSystemPrefix.getLength();
187	rtl::OUString sLang = sChunk.getToken( 0, '_', nIndex );	187
188	if (!sLang.getLength())	188	rtl::OUString sChunk = sPath.copy(nStartIndex,
		189	sPath.getLength() - aSystemSuffix.getLength() - nStartIndex);
		190
		191	//Preferred format is BCP47, e.g. de-DE, sr-Latn-RS
		192	LanguageType nLang = MsLangId::convertIsoStringToLanguage(sChunk);
		193	if (nLang == LANGUAGE_DONTKNOW \|\| nLang == LANGUAGE_NONE)
		194	{
		195	//Will also accept typical Unix Locale format, e.g de_DE sr_RS@latin
		196	nLang = MsLangId::convertUnxByteStringToLanguage(
		197	rtl::OUStringToOString(sChunk,osl_getThreadTextEncoding()));
		198	}
		199
		200	fprintf(stderr, "lang from %s is %x\n", rtl::OUStringToOString(sChunk,
		201	RTL_TEXTENCODING_UTF8).getStr(), nLang);
		202
		203	if (nLang == LANGUAGE_DONTKNOW \|\| nLang == LANGUAGE_NONE)
189	continue;	204	continue;
190	rtl::OUString sRegion;
191	if (nIndex != -1)
192	sRegion = sChunk.copy( nIndex, sChunk.getLength() - nIndex );
193
194	// Thus we first get the language of the dictionary
195	LanguageType nLang = MsLangId::convertIsoNamesToLanguage(
196	sLang, sRegion );
197		205
198	if (aDicLangInUse.count( nLang ) == 0)	206	if (aDicLangInUse.count( nLang ) == 0)
199	{	207	{
Lines 208-215 Link Here
208	aDicEntry.aLocations[0] = sPath;	216	aDicEntry.aLocations[0] = sPath;
209	aDicEntry.aFormatName = aFormatName;	217	aDicEntry.aFormatName = aFormatName;
210	aDicEntry.aLocaleNames[0] = aLocaleName;	218	aDicEntry.aLocaleNames[0] = aLocaleName;
		219	fprintf(stderr, "name is %s\n", rtl::OUStringToOString(aLocaleName, RTL_TEXTENCODING_UTF8).getStr());
211	aRes.push_back( aDicEntry );	220	aRes.push_back( aDicEntry );
212	}	221	}
		222	else
		223	fprintf(stderr, "%x already in there\n", nLang);
213	}	224	}
214	}	225	}
215	}	226	}

Lines 71-82 Link Here

(-)a/sal/inc/rtl/locale.hxx (-6 / +14 lines)
71		71
72	<P>	72	<P>
73	The second constructor requires a third argument--the <STRONG>Variant.</STRONG>	73	The second constructor requires a third argument--the <STRONG>Variant.</STRONG>
74	The Variant codes are vendor and browser-specific.	74	The format of this string is based on BCP-47. Each tag must
75	For example, use WIN for Windows, MAC for Macintosh, and POSIX for POSIX.	75	be seperated from the next by "-".
76	Where there are two variants, separate them with an underscore, and	76
77	put the most important one first. For	77	If used, the first tag must either be empty or a four letter
78	example, a Traditional Spanish collation might be referenced, with	78	script code as described by http://www.rfc-editor.org/rfc/bcp/bcp47.txt.
79	"ES", "ES", "Traditional_WIN".	79	Subsequent tags are not associated with any particular
		80	external standards.
		81
		82	Typical use is for a Language of sr, a Country of RS and a
		83	Variant of Latn in order to describe Serbian written as Latin in
		84	Serbia. An example of use of extra tags to describe a custom
		85	use speculative variant, might be e.g. Latn-WIN for Latin
		86	script on Windows, Cyrl-MAC for Cyrillic script on Macintosh,
		87	and -POSIX for a non-script-override specific POSIX variant</p>
80		88
81	<P>	89	<P>
82	Because a <code>OLocale</code> object is just an identifier for a region,	90	Because a <code>OLocale</code> object is just an identifier for a region,

Lines 39-45 Link Here

(-)a/sal/qa/rtl/locale/rtl_locale.cxx (-8 / +8 lines)
39	// default locale for test purpose	39	// default locale for test purpose
40	void setDefaultLocale()	40	void setDefaultLocale()
41	{	41	{
42	rtl::OLocale::setDefault(rtl::OUString::createFromAscii("de"), rtl::OUString::createFromAscii("DE"), /* rtl::OUString() */ rtl::OUString::createFromAscii("hochdeutsch") );	42	rtl::OLocale::setDefault(rtl::OUString::createFromAscii("be"), rtl::OUString::createFromAscii("BY"), /* rtl::OUString() */ rtl::OUString::createFromAscii("Latn") );
43	}	43	}
44		44
45	class getDefault : public CppUnit::TestFixture	45	class getDefault : public CppUnit::TestFixture
Lines 68-74 Link Here
68		68
69	void getDefault_001()	69	void getDefault_001()
70	{	70	{
71	// rtl::OLocale::setDefault(rtl::OUString::createFromAscii("de"), rtl::OUString::createFromAscii("DE"), rtl::OUString());	71	// rtl::OLocale::setDefault(rtl::OUString::createFromAscii("be"), rtl::OUString::createFromAscii("BY"), rtl::OUString());
72	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();	72	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();
73	CPPUNIT_ASSERT_MESSAGE("locale must not null", aLocale.getData() != NULL);	73	CPPUNIT_ASSERT_MESSAGE("locale must not null", aLocale.getData() != NULL);
74	}	74	}
Lines 135-148 Link Here
135	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();	135	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();
136	rtl::OUString suLanguage = aLocale.getLanguage();	136	rtl::OUString suLanguage = aLocale.getLanguage();
137	t_print("Language: %s\n", rtl::OUStringToOString(suLanguage, osl_getThreadTextEncoding()).getStr());	137	t_print("Language: %s\n", rtl::OUStringToOString(suLanguage, osl_getThreadTextEncoding()).getStr());
138	CPPUNIT_ASSERT_MESSAGE("locale language must be 'de'", suLanguage.equals(rtl::OUString::createFromAscii("de")));	138	CPPUNIT_ASSERT_MESSAGE("locale language must be 'be'", suLanguage.equals(rtl::OUString::createFromAscii("be")));
139	}	139	}
140	void getLanguage_002()	140	void getLanguage_002()
141	{	141	{
142	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();	142	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();
143	rtl::OUString suLanguage = rtl_locale_getLanguage(aLocale.getData());	143	rtl::OUString suLanguage = rtl_locale_getLanguage(aLocale.getData());
144	t_print("Language: %s\n", rtl::OUStringToOString(suLanguage, osl_getThreadTextEncoding()).getStr());	144	t_print("Language: %s\n", rtl::OUStringToOString(suLanguage, osl_getThreadTextEncoding()).getStr());
145	CPPUNIT_ASSERT_MESSAGE("locale language must be 'de'", suLanguage.equals(rtl::OUString::createFromAscii("de")));	145	CPPUNIT_ASSERT_MESSAGE("locale language must be 'be'", suLanguage.equals(rtl::OUString::createFromAscii("be")));
146	}	146	}
147		147
148	// Change the following lines only, if you add, remove or rename	148	// Change the following lines only, if you add, remove or rename
Lines 174-187 Link Here
174	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();	174	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();
175	rtl::OUString suCountry = aLocale.getCountry();	175	rtl::OUString suCountry = aLocale.getCountry();
176	t_print("Country: %s\n", rtl::OUStringToOString(suCountry, osl_getThreadTextEncoding()).getStr());	176	t_print("Country: %s\n", rtl::OUStringToOString(suCountry, osl_getThreadTextEncoding()).getStr());
177	CPPUNIT_ASSERT_MESSAGE("locale country must be 'DE'", suCountry.equals(rtl::OUString::createFromAscii("DE")));	177	CPPUNIT_ASSERT_MESSAGE("locale country must be 'BY'", suCountry.equals(rtl::OUString::createFromAscii("BY")));
178	}	178	}
179	void getCountry_002()	179	void getCountry_002()
180	{	180	{
181	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();	181	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();
182	rtl::OUString suCountry = rtl_locale_getCountry(aLocale.getData());	182	rtl::OUString suCountry = rtl_locale_getCountry(aLocale.getData());
183	t_print("Country: %s\n", rtl::OUStringToOString(suCountry, osl_getThreadTextEncoding()).getStr());	183	t_print("Country: %s\n", rtl::OUStringToOString(suCountry, osl_getThreadTextEncoding()).getStr());
184	CPPUNIT_ASSERT_MESSAGE("locale country must be 'DE'", suCountry.equals(rtl::OUString::createFromAscii("DE")));	184	CPPUNIT_ASSERT_MESSAGE("locale country must be 'BY'", suCountry.equals(rtl::OUString::createFromAscii("BY")));
185	}	185	}
186		186
187	// Change the following lines only, if you add, remove or rename	187	// Change the following lines only, if you add, remove or rename
Lines 213-226 Link Here
213	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();	213	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();
214	rtl::OUString suVariant = aLocale.getVariant();	214	rtl::OUString suVariant = aLocale.getVariant();
215	t_print("Variant: %s\n", rtl::OUStringToOString(suVariant, osl_getThreadTextEncoding()).getStr());	215	t_print("Variant: %s\n", rtl::OUStringToOString(suVariant, osl_getThreadTextEncoding()).getStr());
216	CPPUNIT_ASSERT_MESSAGE("locale variant must be 'hochdeutsch'", suVariant.equals(rtl::OUString::createFromAscii("hochdeutsch")));	216	CPPUNIT_ASSERT_MESSAGE("locale variant must be 'Latn'", suVariant.equals(rtl::OUString::createFromAscii("Latn")));
217	}	217	}
218	void getVariant_002()	218	void getVariant_002()
219	{	219	{
220	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();	220	rtl::OLocale aLocale = ::rtl::OLocale::getDefault();
221	rtl::OUString suVariant = rtl_locale_getVariant(aLocale.getData());	221	rtl::OUString suVariant = rtl_locale_getVariant(aLocale.getData());
222	t_print("Variant: %s\n", rtl::OUStringToOString(suVariant, osl_getThreadTextEncoding()).getStr());	222	t_print("Variant: %s\n", rtl::OUStringToOString(suVariant, osl_getThreadTextEncoding()).getStr());
223	CPPUNIT_ASSERT_MESSAGE("locale variant must be 'hochdeutsch'", suVariant.equals(rtl::OUString::createFromAscii("hochdeutsch")));	223	CPPUNIT_ASSERT_MESSAGE("locale variant must be 'Latn'", suVariant.equals(rtl::OUString::createFromAscii("Latn")));
224	}	224	}
225		225
226	// Change the following lines only, if you add, remove or rename	226	// Change the following lines only, if you add, remove or rename

Lines 190-211 Link Here

(-)a/sc/source/core/tool/addincol.cxx (-9 / +25 lines)
190	const sheet::LocalizedName* pArray = rSequence.getConstArray();	190	const sheet::LocalizedName* pArray = rSequence.getConstArray();
191	long i;	191	long i;
192		192
193	rtl::OUString aLangStr, aCountryStr;	193	rtl::OUString aLanguageTag, aRegionTag, aOtherTags;
194	MsLangId::convertLanguageToIsoNames( eDestLang, aLangStr, aCountryStr );	194	MsLangId::convertLanguageToIsoNames( eDestLang, aLanguageTag, aRegionTag, aOtherTags);
195	rtl::OUString aUserLang = aLangStr.toAsciiLowerCase();	195	rtl::OUString aUserLang = aLanguageTag.toAsciiLowerCase();
196	rtl::OUString aUserCountry = aCountryStr.toAsciiUpperCase();	196	rtl::OUString aUserCountry = aRegionTag.toAsciiUpperCase();
		197	//Script Subtag is guaranteed to exist as first Subtag if there is any subtags
		198	//at all, it can be empty
		199	sal_Int32 nIndex = 0;
		200	rtl::OUString aUserScriptSubtag = aOtherTags.getToken(0, sal_Unicode('-'), nIndex);
197		201
198	// first check for match of both language and country	202	// first check for match of all language, country and Script tag
199		203
200	for ( i=0; i<nSeqLen; i++)	204	for ( i=0; i<nSeqLen; i++)
201	if ( pArray[i].Locale.Language == aUserLang &&	205	if ( pArray[i].Locale.Language == aUserLang &&
202	pArray[i].Locale.Country == aUserCountry )	206	pArray[i].Locale.Country == aUserCountry &&
		207	pArray[i].Locale.Variant == aUserScriptSubtag )
203	{	208	{
204	rRetExcelName = pArray[i].Name;	209	rRetExcelName = pArray[i].Name;
205	return TRUE;	210	return TRUE;
206	}	211	}
207		212
208	// second: check only language	213
		214	// second check for match of both language and country
		215
		216	for ( i=0; i<nSeqLen; i++)
		217	if ( pArray[i].Locale.Language == aUserLang &&
		218	pArray[i].Locale.Country == aUserCountry )
		219	{
		220	rRetExcelName = pArray[i].Name;
		221	return TRUE;
		222	}
		223
		224	// third: check only language
209		225
210	for ( i=0; i<nSeqLen; i++)	226	for ( i=0; i<nSeqLen; i++)
211	if ( pArray[i].Locale.Language == aUserLang )	227	if ( pArray[i].Locale.Language == aUserLang )
Lines 214-225 Link Here
214	return TRUE;	230	return TRUE;
215	}	231	}
216		232
217	// third: #i57772# fall-back to en-US	233	// fourth: #i57772# fall-back to en-US
218		234
219	if ( eDestLang != LANGUAGE_ENGLISH_US )	235	if ( eDestLang != LANGUAGE_ENGLISH_US )
220	return GetExcelName( LANGUAGE_ENGLISH_US, rRetExcelName );	236	return GetExcelName( LANGUAGE_ENGLISH_US, rRetExcelName );
221		237
222	// forth: use first (default) entry	238	// fifth: use first (default) entry
223		239
224	rRetExcelName = pArray[0].Name;	240	rRetExcelName = pArray[0].Name;
225	return TRUE;	241	return TRUE;

Lines 66-72 Link Here

(-)a/udkapi/com/sun/star/lang/Locale.idl (-8 / +16 lines)
66	// DocMerge from xml: field com::sun::star::lang::Locale::Language	66	// DocMerge from xml: field com::sun::star::lang::Locale::Language
67	/** specifies an <strong>ISO Language Code</strong>.	67	/** specifies an <strong>ISO Language Code</strong>.
68		68
69	<p>These codes are the lower-case two-letter codes as defined by	69	<p>These codes are the lower-case two or three letter codes as defined by
70	ISO-639. You can find a full list of these codes at a number of	70	ISO-639. You can find a full list of these codes at a number of
71	sites, such as: <br>	71	sites, such as: <br>
72	<a href="http://www.ics.uci.edu/pub/ietf/http/related/iso639.txt">	72	<a href="http://www.ics.uci.edu/pub/ietf/http/related/iso639.txt">
Lines 98-111 Link Here
98	//-------------------------------------------------------------------------	98	//-------------------------------------------------------------------------
99		99
100	// DocMerge from xml: field com::sun::star::lang::Locale::Variant	100	// DocMerge from xml: field com::sun::star::lang::Locale::Variant
101	/** contains a variant of the locale; codes are vendor and	101	/** contains a sequence of language tags that describe a variant of the locale.
102	browser-specific.
103		102
104	<p>For example, use WIN for Windows, MAC for Macintosh, and POSIX	103	<p>The format of the string is based on BCP-47. Each tag must
105	for POSIX. Wherever there are two variants, separate them with an	104	be seperated from the next by -</p>
106	underscore, and put the most important one first. For example, a	105
107	traditional Spanish collation might construct a locale with parameters	106	<p>If used, the first tag must either be empty or a four letter
108	for language, country and variant as: "es", "ES", "Traditional_WIN".</p>	107	script code as described by http://www.rfc-editor.org/rfc/bcp/bcp47.txt.
		108	Subsequent tags are not associated with any particular
		109	external standards.</p>
		110
		111	<p>Typical use is for a Language of sr, a Country of RS and a
		112	Variant of Latn in order to describe Serbian written as Latin in
		113	Serbia. An example of use of extra tags to describe a custom
		114	use speculative variant, might be e.g. Latn-WIN for Latin
		115	script on Windows, Cyrl-MAC for Cyrillic script on Macintosh,
		116	and -POSIX for a non-script-override specific POSIX variant</p>
109	*/	117	*/
110	string Variant;	118	string Variant;
111		119

Lines 146-148 Link Here

(-)a/xmloff/source/style/chrlohdl.cxx (+43 lines)
146		146
147	return sal_True;	147	return sal_True;
148	}	148	}
		149
		150	XMLCharLanguageTagsHdl::~XMLCharLanguageTagsHdl()
		151	{
		152	// nothing to do
		153	}
		154
		155	bool XMLCharLanguageTagsHdl::equals( const ::com::sun::star::uno::Any& r1, const ::com::sun::star::uno::Any& r2 ) const
		156	{
		157	sal_Bool bRet = sal_False;
		158	lang::Locale aLocale1, aLocale2;
		159
		160	if( ( r1 >>= aLocale1 ) && ( r2 >>= aLocale2 ) )
		161	bRet = ( aLocale1.Variant == aLocale2.Variant );
		162
		163	return bRet;
		164	}
		165
		166	sal_Bool XMLCharLanguageTagsHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
		167	{
		168	lang::Locale aLocale;
		169
		170	rValue >>= aLocale;
		171
		172	if( !IsXMLToken( rStrImpValue, XML_NONE ) )
		173	aLocale.Variant = rStrImpValue;
		174
		175	rValue <<= aLocale;
		176	return sal_True;
		177	}
		178
		179	sal_Bool XMLCharLanguageTagsHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
		180	{
		181	lang::Locale aLocale;
		182	if(!(rValue >>= aLocale))
		183	return sal_False;
		184
		185	rStrExpValue = aLocale.Variant;
		186
		187	if( !rStrExpValue.getLength() )
		188	rStrExpValue = GetXMLToken( XML_NONE );
		189
		190	return sal_True;
		191	}

Lines 55-59 Link Here

(-)a/xmloff/source/style/chrlohdl.hxx (+12 lines)
55	virtual sal_Bool exportXML( ::rtl::OUString& rStrExpValue, const ::com::sun::star::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const;	55	virtual sal_Bool exportXML( ::rtl::OUString& rStrExpValue, const ::com::sun::star::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const;
56	};	56	};
57		57
		58	class XMLCharLanguageTagsHdl : public XMLPropertyHandler
		59	{
		60	public:
		61	virtual ~XMLCharLanguageTagsHdl();
		62
		63	virtual bool equals( const ::com::sun::star::uno::Any& r1, const ::com::sun::star::uno::Any& r2 ) const;
		64
		65	virtual sal_Bool importXML( const ::rtl::OUString& rStrImpValue, ::com::sun::star::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const;
		66	virtual sal_Bool exportXML( ::rtl::OUString& rStrExpValue, const ::com::sun::star::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const;
		67	};
		68
		69
58	#endif // _XMLOFF_PROPERTYHANDLER_CHARLOCALETYPES_HXX	70	#endif // _XMLOFF_PROPERTYHANDLER_CHARLOCALETYPES_HXX
59		71

Lines 277-282 Link Here

(-)a/xmloff/source/style/xmlnumfi.cxx (-10 / +25 lines)
277	XML_TOK_STYLE_ATTR_NAME,	277	XML_TOK_STYLE_ATTR_NAME,
278	XML_TOK_STYLE_ATTR_LANGUAGE,	278	XML_TOK_STYLE_ATTR_LANGUAGE,
279	XML_TOK_STYLE_ATTR_COUNTRY,	279	XML_TOK_STYLE_ATTR_COUNTRY,
		280	XML_TOK_STYLE_ATTR_LANGUAGE_TAGS,
280	XML_TOK_STYLE_ATTR_TITLE,	281	XML_TOK_STYLE_ATTR_TITLE,
281	XML_TOK_STYLE_ATTR_AUTOMATIC_ORDER,	282	XML_TOK_STYLE_ATTR_AUTOMATIC_ORDER,
282	XML_TOK_STYLE_ATTR_FORMAT_SOURCE,	283	XML_TOK_STYLE_ATTR_FORMAT_SOURCE,
Lines 285-290 Link Here
285	XML_TOK_STYLE_ATTR_TRANSL_FORMAT,	286	XML_TOK_STYLE_ATTR_TRANSL_FORMAT,
286	XML_TOK_STYLE_ATTR_TRANSL_LANGUAGE,	287	XML_TOK_STYLE_ATTR_TRANSL_LANGUAGE,
287	XML_TOK_STYLE_ATTR_TRANSL_COUNTRY,	288	XML_TOK_STYLE_ATTR_TRANSL_COUNTRY,
		289	XML_TOK_STYLE_ATTR_TRANSL_LANGUAGE_TAGS,
288	XML_TOK_STYLE_ATTR_TRANSL_STYLE	290	XML_TOK_STYLE_ATTR_TRANSL_STYLE
289	};	291	};
290		292
Lines 300-305 Link Here
300	XML_TOK_ELEM_ATTR_MIN_DENOMINATOR_DIGITS,	302	XML_TOK_ELEM_ATTR_MIN_DENOMINATOR_DIGITS,
301	XML_TOK_ELEM_ATTR_LANGUAGE,	303	XML_TOK_ELEM_ATTR_LANGUAGE,
302	XML_TOK_ELEM_ATTR_COUNTRY,	304	XML_TOK_ELEM_ATTR_COUNTRY,
		305	XML_TOK_ELEM_ATTR_LANGUAGE_TAGS,
303	XML_TOK_ELEM_ATTR_STYLE,	306	XML_TOK_ELEM_ATTR_STYLE,
304	XML_TOK_ELEM_ATTR_TEXTUAL,	307	XML_TOK_ELEM_ATTR_TEXTUAL,
305	XML_TOK_ELEM_ATTR_CALENDAR	308	XML_TOK_ELEM_ATTR_CALENDAR
Lines 566-571 Link Here
566	{ XML_NAMESPACE_STYLE, XML_NAME, XML_TOK_STYLE_ATTR_NAME },	569	{ XML_NAMESPACE_STYLE, XML_NAME, XML_TOK_STYLE_ATTR_NAME },
567	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE, XML_TOK_STYLE_ATTR_LANGUAGE },	570	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE, XML_TOK_STYLE_ATTR_LANGUAGE },
568	{ XML_NAMESPACE_NUMBER, XML_COUNTRY, XML_TOK_STYLE_ATTR_COUNTRY },	571	{ XML_NAMESPACE_NUMBER, XML_COUNTRY, XML_TOK_STYLE_ATTR_COUNTRY },
		572	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE_TAGS, XML_TOK_STYLE_ATTR_LANGUAGE_TAGS },
569	{ XML_NAMESPACE_NUMBER, XML_TITLE, XML_TOK_STYLE_ATTR_TITLE },	573	{ XML_NAMESPACE_NUMBER, XML_TITLE, XML_TOK_STYLE_ATTR_TITLE },
570	{ XML_NAMESPACE_NUMBER, XML_AUTOMATIC_ORDER, XML_TOK_STYLE_ATTR_AUTOMATIC_ORDER },	574	{ XML_NAMESPACE_NUMBER, XML_AUTOMATIC_ORDER, XML_TOK_STYLE_ATTR_AUTOMATIC_ORDER },
571	{ XML_NAMESPACE_NUMBER, XML_FORMAT_SOURCE, XML_TOK_STYLE_ATTR_FORMAT_SOURCE },	575	{ XML_NAMESPACE_NUMBER, XML_FORMAT_SOURCE, XML_TOK_STYLE_ATTR_FORMAT_SOURCE },
Lines 574-579 Link Here
574	{ XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_FORMAT, XML_TOK_STYLE_ATTR_TRANSL_FORMAT },	578	{ XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_FORMAT, XML_TOK_STYLE_ATTR_TRANSL_FORMAT },
575	{ XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_LANGUAGE, XML_TOK_STYLE_ATTR_TRANSL_LANGUAGE },	579	{ XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_LANGUAGE, XML_TOK_STYLE_ATTR_TRANSL_LANGUAGE },
576	{ XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_COUNTRY, XML_TOK_STYLE_ATTR_TRANSL_COUNTRY },	580	{ XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_COUNTRY, XML_TOK_STYLE_ATTR_TRANSL_COUNTRY },
		581	{ XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_LANGUAGE_TAGS, XML_TOK_STYLE_ATTR_TRANSL_LANGUAGE_TAGS },
577	{ XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_STYLE, XML_TOK_STYLE_ATTR_TRANSL_STYLE },	582	{ XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_STYLE, XML_TOK_STYLE_ATTR_TRANSL_STYLE },
578	XML_TOKEN_MAP_END	583	XML_TOKEN_MAP_END
579	};	584	};
Lines 600-605 Link Here
600	{ XML_NAMESPACE_NUMBER, XML_MIN_DENOMINATOR_DIGITS, XML_TOK_ELEM_ATTR_MIN_DENOMINATOR_DIGITS },	605	{ XML_NAMESPACE_NUMBER, XML_MIN_DENOMINATOR_DIGITS, XML_TOK_ELEM_ATTR_MIN_DENOMINATOR_DIGITS },
601	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE, XML_TOK_ELEM_ATTR_LANGUAGE },	606	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE, XML_TOK_ELEM_ATTR_LANGUAGE },
602	{ XML_NAMESPACE_NUMBER, XML_COUNTRY, XML_TOK_ELEM_ATTR_COUNTRY },	607	{ XML_NAMESPACE_NUMBER, XML_COUNTRY, XML_TOK_ELEM_ATTR_COUNTRY },
		608	{ XML_NAMESPACE_NUMBER, XML_LANGUAGE_TAGS, XML_TOK_ELEM_ATTR_LANGUAGE_TAGS },
603	{ XML_NAMESPACE_NUMBER, XML_STYLE, XML_TOK_ELEM_ATTR_STYLE },	609	{ XML_NAMESPACE_NUMBER, XML_STYLE, XML_TOK_ELEM_ATTR_STYLE },
604	{ XML_NAMESPACE_NUMBER, XML_TEXTUAL, XML_TOK_ELEM_ATTR_TEXTUAL },	610	{ XML_NAMESPACE_NUMBER, XML_TEXTUAL, XML_TOK_ELEM_ATTR_TEXTUAL },
605	{ XML_NAMESPACE_NUMBER, XML_CALENDAR, XML_TOK_ELEM_ATTR_CALENDAR },	611	{ XML_NAMESPACE_NUMBER, XML_CALENDAR, XML_TOK_ELEM_ATTR_CALENDAR },
Lines 948-954 Link Here
948	bLong( FALSE ),	954	bLong( FALSE ),
949	bTextual( FALSE )	955	bTextual( FALSE )
950	{	956	{
951	OUString sLanguage, sCountry;	957	OUString sLanguageTag, sRegionTag, sOtherTags;
952	sal_Int32 nAttrVal;	958	sal_Int32 nAttrVal;
953	sal_Bool bAttrBool;	959	sal_Bool bAttrBool;
954	sal_uInt16 nAttrEnum;	960	sal_uInt16 nAttrEnum;
Lines 1002-1011 Link Here
1002	aNumInfo.nDenomDigits = nAttrVal;	1008	aNumInfo.nDenomDigits = nAttrVal;
1003	break;	1009	break;
1004	case XML_TOK_ELEM_ATTR_LANGUAGE:	1010	case XML_TOK_ELEM_ATTR_LANGUAGE:
1005	sLanguage = sValue;	1011	sLanguageTag = sValue;
1006	break;	1012	break;
1007	case XML_TOK_ELEM_ATTR_COUNTRY:	1013	case XML_TOK_ELEM_ATTR_COUNTRY:
1008	sCountry = sValue;	1014	sRegionTag = sValue;
		1015	break;
		1016	case XML_TOK_ELEM_ATTR_LANGUAGE_TAGS:
		1017	sOtherTags = sValue;
1009	break;	1018	break;
1010	case XML_TOK_ELEM_ATTR_STYLE:	1019	case XML_TOK_ELEM_ATTR_STYLE:
1011	if ( SvXMLUnitConverter::convertEnum( nAttrEnum, sValue, aStyleValueMap ) )	1020	if ( SvXMLUnitConverter::convertEnum( nAttrEnum, sValue, aStyleValueMap ) )
Lines 1021-1029 Link Here
1021	}	1030	}
1022	}	1031	}
1023		1032
1024	if ( sLanguage.getLength() \|\| sCountry.getLength() )	1033	if ( sLanguageTag.getLength() \|\| sRegionTag.getLength() \|\| sOtherTags.getLength() )
1025	{	1034	{
1026	nElementLang = MsLangId::convertIsoNamesToLanguage( sLanguage, sCountry );	1035	nElementLang = MsLangId::convertIsoNamesToLanguage( sLanguageTag, sRegionTag, sOtherTags );
1027	if ( nElementLang == LANGUAGE_DONTKNOW )	1036	if ( nElementLang == LANGUAGE_DONTKNOW )
1028	nElementLang = LANGUAGE_SYSTEM; //! error handling for invalid locales?	1037	nElementLang = LANGUAGE_SYSTEM; //! error handling for invalid locales?
1029	}	1038	}
Lines 1397-1403 Link Here
1397	eDateSecs( XML_DEA_NONE ),	1406	eDateSecs( XML_DEA_NONE ),
1398	bDateNoDefault( sal_False )	1407	bDateNoDefault( sal_False )
1399	{	1408	{
1400	OUString sLanguage, sCountry;	1409	OUString sLanguageTag, sRegionTag, sOtherTags;
1401	::com::sun::star::i18n::NativeNumberXmlAttributes aNatNumAttr;	1410	::com::sun::star::i18n::NativeNumberXmlAttributes aNatNumAttr;
1402	sal_Bool bAttrBool;	1411	sal_Bool bAttrBool;
1403	sal_uInt16 nAttrEnum;	1412	sal_uInt16 nAttrEnum;
Lines 1418-1427 Link Here
1418	// aName = sValue;	1427	// aName = sValue;
1419	break;	1428	break;
1420	case XML_TOK_STYLE_ATTR_LANGUAGE:	1429	case XML_TOK_STYLE_ATTR_LANGUAGE:
1421	sLanguage = sValue;	1430	sLanguageTag = sValue;
1422	break;	1431	break;
1423	case XML_TOK_STYLE_ATTR_COUNTRY:	1432	case XML_TOK_STYLE_ATTR_COUNTRY:
1424	sCountry = sValue;	1433	sRegionTag = sValue;
		1434	break;
		1435	case XML_TOK_STYLE_ATTR_LANGUAGE_TAGS:
		1436	sOtherTags = sValue;
1425	break;	1437	break;
1426	case XML_TOK_STYLE_ATTR_TITLE:	1438	case XML_TOK_STYLE_ATTR_TITLE:
1427	sFormatTitle = sValue;	1439	sFormatTitle = sValue;
Lines 1453-1467 Link Here
1453	case XML_TOK_STYLE_ATTR_TRANSL_COUNTRY:	1465	case XML_TOK_STYLE_ATTR_TRANSL_COUNTRY:
1454	aNatNumAttr.Locale.Country = sValue;	1466	aNatNumAttr.Locale.Country = sValue;
1455	break;	1467	break;
		1468	case XML_TOK_STYLE_ATTR_TRANSL_LANGUAGE_TAGS:
		1469	aNatNumAttr.Locale.Variant = sValue;
		1470	break;
1456	case XML_TOK_STYLE_ATTR_TRANSL_STYLE:	1471	case XML_TOK_STYLE_ATTR_TRANSL_STYLE:
1457	aNatNumAttr.Style = sValue;	1472	aNatNumAttr.Style = sValue;
1458	break;	1473	break;
1459	}	1474	}
1460	}	1475	}
1461		1476
1462	if ( sLanguage.getLength() \|\| sCountry.getLength() )	1477	if ( sLanguageTag.getLength() \|\| sRegionTag.getLength() \|\| sOtherTags.getLength() )
1463	{	1478	{
1464	nFormatLang = MsLangId::convertIsoNamesToLanguage( sLanguage, sCountry );	1479	nFormatLang = MsLangId::convertIsoNamesToLanguage( sLanguageTag, sRegionTag, sOtherTags );
1465	if ( nFormatLang == LANGUAGE_DONTKNOW )	1480	if ( nFormatLang == LANGUAGE_DONTKNOW )
1466	nFormatLang = LANGUAGE_SYSTEM; //! error handling for invalid locales?	1481	nFormatLang = LANGUAGE_SYSTEM; //! error handling for invalid locales?
1467	}	1482	}

Lines 132-137 Link Here

(-)a/xmloff/source/text/txtprmap.cxx (+6 lines)
132	// RES_CHRATR_LANGUAGE	132	// RES_CHRATR_LANGUAGE
133	MT_ED( "CharLocale", FO, LANGUAGE, XML_TYPE_CHAR_LANGUAGE\|MID_FLAG_MERGE_PROPERTY, 0 ),	133	MT_ED( "CharLocale", FO, LANGUAGE, XML_TYPE_CHAR_LANGUAGE\|MID_FLAG_MERGE_PROPERTY, 0 ),
134	MT_ED( "CharLocale", FO, COUNTRY, XML_TYPE_CHAR_COUNTRY\|MID_FLAG_MERGE_PROPERTY, 0 ),	134	MT_ED( "CharLocale", FO, COUNTRY, XML_TYPE_CHAR_COUNTRY\|MID_FLAG_MERGE_PROPERTY, 0 ),
		135	MT_ED( "CharLocale", FO, LANGUAGE_TAGS, XML_TYPE_CHAR_LANGUAGE_TAGS\|MID_FLAG_MERGE_PROPERTY, 0 ),
135	// RES_CHRATR_POSTURE	136	// RES_CHRATR_POSTURE
136	MT_E( "CharPosture", FO, FONT_STYLE, XML_TYPE_TEXT_POSTURE, 0 ),	137	MT_E( "CharPosture", FO, FONT_STYLE, XML_TYPE_TEXT_POSTURE, 0 ),
137	// RES_CHRATR_PROPORTIONALFONTSIZE	138	// RES_CHRATR_PROPORTIONALFONTSIZE
Lines 176-181 Link Here
176	// RES_CHRATR_CJK_LANGUAGE	177	// RES_CHRATR_CJK_LANGUAGE
177	MT_ED( "CharLocaleAsian", STYLE, LANGUAGE_ASIAN, XML_TYPE_CHAR_LANGUAGE\|MID_FLAG_MERGE_PROPERTY, 0 ),	178	MT_ED( "CharLocaleAsian", STYLE, LANGUAGE_ASIAN, XML_TYPE_CHAR_LANGUAGE\|MID_FLAG_MERGE_PROPERTY, 0 ),
178	MT_ED( "CharLocaleAsian", STYLE, COUNTRY_ASIAN, XML_TYPE_CHAR_COUNTRY\|MID_FLAG_MERGE_PROPERTY, 0 ),	179	MT_ED( "CharLocaleAsian", STYLE, COUNTRY_ASIAN, XML_TYPE_CHAR_COUNTRY\|MID_FLAG_MERGE_PROPERTY, 0 ),
		180	MT_ED( "CharLocaleAsian", STYLE, LANGUAGE_TAGS_ASIAN, XML_TYPE_CHAR_LANGUAGE_TAGS\|MID_FLAG_MERGE_PROPERTY, 0 ),
179	// RES_CHRATR_CJK_POSTURE	181	// RES_CHRATR_CJK_POSTURE
180	MT_E( "CharPostureAsian", STYLE, FONT_STYLE_ASIAN, XML_TYPE_TEXT_POSTURE, 0 ),	182	MT_E( "CharPostureAsian", STYLE, FONT_STYLE_ASIAN, XML_TYPE_TEXT_POSTURE, 0 ),
181	// RES_CHRATR_CJK_WEIGHT	183	// RES_CHRATR_CJK_WEIGHT
Lines 194-199 Link Here
194	// RES_CHRATR_CTL_LANGUAGE	196	// RES_CHRATR_CTL_LANGUAGE
195	MT_ED( "CharLocaleComplex", STYLE, LANGUAGE_COMPLEX, XML_TYPE_CHAR_LANGUAGE\|MID_FLAG_MERGE_PROPERTY, 0 ),	197	MT_ED( "CharLocaleComplex", STYLE, LANGUAGE_COMPLEX, XML_TYPE_CHAR_LANGUAGE\|MID_FLAG_MERGE_PROPERTY, 0 ),
196	MT_ED( "CharLocaleComplex", STYLE, COUNTRY_COMPLEX, XML_TYPE_CHAR_COUNTRY\|MID_FLAG_MERGE_PROPERTY, 0 ),	198	MT_ED( "CharLocaleComplex", STYLE, COUNTRY_COMPLEX, XML_TYPE_CHAR_COUNTRY\|MID_FLAG_MERGE_PROPERTY, 0 ),
		199	MT_ED( "CharLocaleComplex", STYLE, LANGUAGE_TAGS_COMPLEX, XML_TYPE_CHAR_LANGUAGE_TAGS\|MID_FLAG_MERGE_PROPERTY, 0 ),
197	// RES_CHRATR_CTL_POSTURE	200	// RES_CHRATR_CTL_POSTURE
198	MT_E( "CharPostureComplex", STYLE, FONT_STYLE_COMPLEX, XML_TYPE_TEXT_POSTURE, 0 ),	201	MT_E( "CharPostureComplex", STYLE, FONT_STYLE_COMPLEX, XML_TYPE_TEXT_POSTURE, 0 ),
199	// RES_CHRATR_CTL_WEIGHT	202	// RES_CHRATR_CTL_WEIGHT
Lines 426-431 Link Here
426	// RES_CHRATR_LANGUAGE	429	// RES_CHRATR_LANGUAGE
427	MT_ED( "CharLocale", FO, LANGUAGE, XML_TYPE_CHAR_LANGUAGE\|MID_FLAG_MERGE_PROPERTY, 0 ),	430	MT_ED( "CharLocale", FO, LANGUAGE, XML_TYPE_CHAR_LANGUAGE\|MID_FLAG_MERGE_PROPERTY, 0 ),
428	MT_ED( "CharLocale", FO, COUNTRY, XML_TYPE_CHAR_COUNTRY\|MID_FLAG_MERGE_PROPERTY, 0 ),	431	MT_ED( "CharLocale", FO, COUNTRY, XML_TYPE_CHAR_COUNTRY\|MID_FLAG_MERGE_PROPERTY, 0 ),
		432	MT_ED( "CharLocale", FO, LANGUAGE_TAGS, XML_TYPE_CHAR_LANGUAGE_TAGS\|MID_FLAG_MERGE_PROPERTY, 0 ),
429	// RES_CHRATR_POSTURE	433	// RES_CHRATR_POSTURE
430	MT_E( "CharPosture", FO, FONT_STYLE, XML_TYPE_TEXT_POSTURE, 0 ),	434	MT_E( "CharPosture", FO, FONT_STYLE, XML_TYPE_TEXT_POSTURE, 0 ),
431	// RES_CHRATR_PROPORTIONALFONTSIZE	435	// RES_CHRATR_PROPORTIONALFONTSIZE
Lines 471-476 Link Here
471	// RES_CHRATR_CJK_LANGUAGE	475	// RES_CHRATR_CJK_LANGUAGE
472	MT_ED( "CharLocaleAsian", STYLE, LANGUAGE_ASIAN, XML_TYPE_CHAR_LANGUAGE\|MID_FLAG_MERGE_PROPERTY, 0 ),	476	MT_ED( "CharLocaleAsian", STYLE, LANGUAGE_ASIAN, XML_TYPE_CHAR_LANGUAGE\|MID_FLAG_MERGE_PROPERTY, 0 ),
473	MT_ED( "CharLocaleAsian", STYLE, COUNTRY_ASIAN, XML_TYPE_CHAR_COUNTRY\|MID_FLAG_MERGE_PROPERTY, 0 ),	477	MT_ED( "CharLocaleAsian", STYLE, COUNTRY_ASIAN, XML_TYPE_CHAR_COUNTRY\|MID_FLAG_MERGE_PROPERTY, 0 ),
		478	MT_ED( "CharLocaleAsian", STYLE, LANGUAGE_TAGS_ASIAN, XML_TYPE_CHAR_LANGUAGE_TAGS\|MID_FLAG_MERGE_PROPERTY, 0 ),
474	// RES_CHRATR_CJK_POSTURE	479	// RES_CHRATR_CJK_POSTURE
475	MT_E( "CharPostureAsian", STYLE, FONT_STYLE_ASIAN, XML_TYPE_TEXT_POSTURE, 0 ),	480	MT_E( "CharPostureAsian", STYLE, FONT_STYLE_ASIAN, XML_TYPE_TEXT_POSTURE, 0 ),
476	// RES_CHRATR_CJK_WEIGHT	481	// RES_CHRATR_CJK_WEIGHT
Lines 489-494 Link Here
489	// RES_CHRATR_CTL_LANGUAGE	494	// RES_CHRATR_CTL_LANGUAGE
490	MT_ED( "CharLocaleComplex", STYLE, LANGUAGE_COMPLEX, XML_TYPE_CHAR_LANGUAGE\|MID_FLAG_MERGE_PROPERTY, 0 ),	495	MT_ED( "CharLocaleComplex", STYLE, LANGUAGE_COMPLEX, XML_TYPE_CHAR_LANGUAGE\|MID_FLAG_MERGE_PROPERTY, 0 ),
491	MT_ED( "CharLocaleComplex", STYLE, COUNTRY_COMPLEX, XML_TYPE_CHAR_COUNTRY\|MID_FLAG_MERGE_PROPERTY, 0 ),	496	MT_ED( "CharLocaleComplex", STYLE, COUNTRY_COMPLEX, XML_TYPE_CHAR_COUNTRY\|MID_FLAG_MERGE_PROPERTY, 0 ),
		497	MT_ED( "CharLocaleComplex", STYLE, LANGUAGE_TAGS_COMPLEX, XML_TYPE_CHAR_LANGUAGE_TAGS\|MID_FLAG_MERGE_PROPERTY, 0 ),
492	// RES_CHRATR_CTL_POSTURE	498	// RES_CHRATR_CTL_POSTURE
493	MT_E( "CharPostureComplex", STYLE, FONT_STYLE_COMPLEX, XML_TYPE_TEXT_POSTURE, 0 ),	499	MT_E( "CharPostureComplex", STYLE, FONT_STYLE_COMPLEX, XML_TYPE_TEXT_POSTURE, 0 ),
494	// RES_CHRATR_CTL_WEIGHT	500	// RES_CHRATR_CTL_WEIGHT