/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_i18npool.hxx"

#include <cclass_unicode.hxx>
#include <unicode/uchar.h>
#include <rtl/math.hxx>
#include <rtl/ustring.hxx>
#include <com/sun/star/i18n/KParseTokens.hpp>
#include <com/sun/star/i18n/KParseType.hpp>
#include <com/sun/star/i18n/UnicodeType.hpp>
#include <com/sun/star/i18n/XLocaleData.hpp>
#include <com/sun/star/i18n/NativeNumberMode.hpp>

#include <string.h>		// memcpy()

using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::rtl;

namespace com { namespace sun { namespace star { namespace i18n {

const UPT_FLAG_TYPE cclass_Unicode::TOKEN_ILLEGAL		= 0x00000000;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_CHAR			= 0x00000001;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_CHAR_BOOL	= 0x00000002;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_CHAR_WORD	= 0x00000004;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_CHAR_VALUE	= 0x00000008;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_CHAR_STRING	= 0x00000010;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_CHAR_DONTCARE= 0x00000020;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_BOOL			= 0x00000040;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_WORD			= 0x00000080;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_WORD_SEP		= 0x00000100;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_VALUE		= 0x00000200;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_VALUE_SEP	= 0x00000400;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_VALUE_EXP	= 0x00000800;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_VALUE_SIGN	= 0x00001000;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_VALUE_EXP_VALUE	= 0x00002000;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_VALUE_DIGIT	= 0x00004000;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_NAME_SEP		= 0x20000000;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_STRING_SEP	= 0x40000000;
const UPT_FLAG_TYPE cclass_Unicode::TOKEN_EXCLUDED		= 0x80000000;

#define TOKEN_DIGIT_FLAGS (TOKEN_CHAR_VALUE | TOKEN_VALUE | TOKEN_VALUE_EXP | TOKEN_VALUE_EXP_VALUE | TOKEN_VALUE_DIGIT)

// Default identifier/name specification is [A-Za-z_][A-Za-z0-9_]*

const sal_uInt8 cclass_Unicode::nDefCnt = 128;
const UPT_FLAG_TYPE cclass_Unicode::pDefaultParserTable[ nDefCnt ] =
{
// (...) == Calc formula compiler specific, commented out and modified

	/* \0 */	TOKEN_EXCLUDED,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
	/*  9 \t */	TOKEN_CHAR_DONTCARE | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,		// (TOKEN_ILLEGAL)
				TOKEN_ILLEGAL,
	/* 11 \v */	TOKEN_CHAR_DONTCARE | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,		// (TOKEN_ILLEGAL)
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
				TOKEN_ILLEGAL,
	/*  32   */	TOKEN_CHAR_DONTCARE | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
	/*  33 ! */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
	/*  34 " */	TOKEN_CHAR_STRING | TOKEN_STRING_SEP,
	/*  35 # */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_WORD_SEP)
	/*  36 $ */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_CHAR_WORD | TOKEN_WORD)
	/*  37 % */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_VALUE)
	/*  38 & */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
	/*  39 ' */	TOKEN_NAME_SEP,
	/*  40 ( */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
	/*  41 ) */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
	/*  42 * */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
	/*  43 + */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP | TOKEN_VALUE_EXP | TOKEN_VALUE_SIGN,
	/*  44 , */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_CHAR_VALUE | TOKEN_VALUE)
	/*  45 - */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP | TOKEN_VALUE_EXP | TOKEN_VALUE_SIGN,
	/*  46 . */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_WORD | TOKEN_CHAR_VALUE | TOKEN_VALUE)
	/*  47 / */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
	//for ( i = 48; i < 58; i++ )
	/*  48 0 */	TOKEN_DIGIT_FLAGS | TOKEN_WORD,
	/*  49 1 */	TOKEN_DIGIT_FLAGS | TOKEN_WORD,
	/*  50 2 */	TOKEN_DIGIT_FLAGS | TOKEN_WORD,
	/*  51 3 */	TOKEN_DIGIT_FLAGS | TOKEN_WORD,
	/*  52 4 */	TOKEN_DIGIT_FLAGS | TOKEN_WORD,
	/*  53 5 */	TOKEN_DIGIT_FLAGS | TOKEN_WORD,
	/*  54 6 */	TOKEN_DIGIT_FLAGS | TOKEN_WORD,
	/*  55 7 */	TOKEN_DIGIT_FLAGS | TOKEN_WORD,
	/*  56 8 */	TOKEN_DIGIT_FLAGS | TOKEN_WORD,
	/*  57 9 */	TOKEN_DIGIT_FLAGS | TOKEN_WORD,
	/*  58 : */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_WORD)
	/*  59 ; */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
	/*  60 < */	TOKEN_CHAR_BOOL | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
	/*  61 = */	TOKEN_CHAR | TOKEN_BOOL | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
	/*  62 > */	TOKEN_CHAR_BOOL | TOKEN_BOOL | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
	/*  63 ? */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_CHAR_WORD | TOKEN_WORD)
	/*  64 @ */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_ILLEGAL // UNUSED)
	//for ( i = 65; i < 91; i++ )
	/*  65 A */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  66 B */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  67 C */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  68 D */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  69 E */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  70 F */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  71 G */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  72 H */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  73 I */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  74 J */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  75 K */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  76 L */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  77 M */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  78 N */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  79 O */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  80 P */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  81 Q */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  82 R */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  83 S */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  84 T */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  85 U */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  86 V */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  87 W */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  88 X */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  89 Y */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  90 Z */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  91 [ */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_ILLEGAL // UNUSED)
	/*  92 \ */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_ILLEGAL // UNUSED)
	/*  93 ] */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_ILLEGAL // UNUSED)
	/*  94 ^ */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
	/*  95 _ */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  96 ` */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_ILLEGAL // UNUSED)
	//for ( i = 97; i < 123; i++ )
	/*  97 a */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  98 b */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/*  99 c */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 100 d */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 101 e */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 102 f */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 103 g */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 104 h */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 105 i */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 106 j */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 107 k */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 108 l */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 109 m */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 110 n */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 111 o */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 112 p */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 113 q */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 114 r */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 115 s */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 116 t */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 117 u */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 118 v */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 119 w */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 120 x */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 121 y */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 122 z */	TOKEN_CHAR_WORD | TOKEN_WORD,
	/* 123 { */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_ILLEGAL // UNUSED)
	/* 124 | */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_ILLEGAL // UNUSED)
	/* 125 } */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_ILLEGAL // UNUSED)
	/* 126 ~ */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,	// (TOKEN_ILLEGAL // UNUSED)
	/* 127   */	TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP	// (TOKEN_ILLEGAL // UNUSED)
};


const sal_Int32 cclass_Unicode::pParseTokensType[ nDefCnt ] =
{
	/* \0 */	KParseTokens::ASC_OTHER,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
	/*  9 \t */	KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
	/* 11 \v */	KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
				KParseTokens::ASC_CONTROL,
	/*  32   */	KParseTokens::ASC_OTHER,
	/*  33 ! */	KParseTokens::ASC_OTHER,
	/*  34 " */	KParseTokens::ASC_OTHER,
	/*  35 # */	KParseTokens::ASC_OTHER,
	/*  36 $ */	KParseTokens::ASC_DOLLAR,
	/*  37 % */	KParseTokens::ASC_OTHER,
	/*  38 & */	KParseTokens::ASC_OTHER,
	/*  39 ' */	KParseTokens::ASC_OTHER,
	/*  40 ( */	KParseTokens::ASC_OTHER,
	/*  41 ) */	KParseTokens::ASC_OTHER,
	/*  42 * */	KParseTokens::ASC_OTHER,
	/*  43 + */	KParseTokens::ASC_OTHER,
	/*  44 , */	KParseTokens::ASC_OTHER,
	/*  45 - */	KParseTokens::ASC_OTHER,
	/*  46 . */	KParseTokens::ASC_DOT,
	/*  47 / */	KParseTokens::ASC_OTHER,
	//for ( i = 48; i < 58; i++ )
	/*  48 0 */	KParseTokens::ASC_DIGIT,
	/*  49 1 */	KParseTokens::ASC_DIGIT,
	/*  50 2 */	KParseTokens::ASC_DIGIT,
	/*  51 3 */	KParseTokens::ASC_DIGIT,
	/*  52 4 */	KParseTokens::ASC_DIGIT,
	/*  53 5 */	KParseTokens::ASC_DIGIT,
	/*  54 6 */	KParseTokens::ASC_DIGIT,
	/*  55 7 */	KParseTokens::ASC_DIGIT,
	/*  56 8 */	KParseTokens::ASC_DIGIT,
	/*  57 9 */	KParseTokens::ASC_DIGIT,
	/*  58 : */	KParseTokens::ASC_COLON,
	/*  59 ; */	KParseTokens::ASC_OTHER,
	/*  60 < */	KParseTokens::ASC_OTHER,
	/*  61 = */	KParseTokens::ASC_OTHER,
	/*  62 > */	KParseTokens::ASC_OTHER,
	/*  63 ? */	KParseTokens::ASC_OTHER,
	/*  64 @ */	KParseTokens::ASC_OTHER,
	//for ( i = 65; i < 91; i++ )
	/*  65 A */	KParseTokens::ASC_UPALPHA,
	/*  66 B */	KParseTokens::ASC_UPALPHA,
	/*  67 C */	KParseTokens::ASC_UPALPHA,
	/*  68 D */	KParseTokens::ASC_UPALPHA,
	/*  69 E */	KParseTokens::ASC_UPALPHA,
	/*  70 F */	KParseTokens::ASC_UPALPHA,
	/*  71 G */	KParseTokens::ASC_UPALPHA,
	/*  72 H */	KParseTokens::ASC_UPALPHA,
	/*  73 I */	KParseTokens::ASC_UPALPHA,
	/*  74 J */	KParseTokens::ASC_UPALPHA,
	/*  75 K */	KParseTokens::ASC_UPALPHA,
	/*  76 L */	KParseTokens::ASC_UPALPHA,
	/*  77 M */	KParseTokens::ASC_UPALPHA,
	/*  78 N */	KParseTokens::ASC_UPALPHA,
	/*  79 O */	KParseTokens::ASC_UPALPHA,
	/*  80 P */	KParseTokens::ASC_UPALPHA,
	/*  81 Q */	KParseTokens::ASC_UPALPHA,
	/*  82 R */	KParseTokens::ASC_UPALPHA,
	/*  83 S */	KParseTokens::ASC_UPALPHA,
	/*  84 T */	KParseTokens::ASC_UPALPHA,
	/*  85 U */	KParseTokens::ASC_UPALPHA,
	/*  86 V */	KParseTokens::ASC_UPALPHA,
	/*  87 W */	KParseTokens::ASC_UPALPHA,
	/*  88 X */	KParseTokens::ASC_UPALPHA,
	/*  89 Y */	KParseTokens::ASC_UPALPHA,
	/*  90 Z */	KParseTokens::ASC_UPALPHA,
	/*  91 [ */	KParseTokens::ASC_OTHER,
	/*  92 \ */	KParseTokens::ASC_OTHER,
	/*  93 ] */	KParseTokens::ASC_OTHER,
	/*  94 ^ */	KParseTokens::ASC_OTHER,
	/*  95 _ */	KParseTokens::ASC_UNDERSCORE,
	/*  96 ` */	KParseTokens::ASC_OTHER,
	//for ( i = 97; i < 123; i++ )
	/*  97 a */	KParseTokens::ASC_LOALPHA,
	/*  98 b */	KParseTokens::ASC_LOALPHA,
	/*  99 c */	KParseTokens::ASC_LOALPHA,
	/* 100 d */	KParseTokens::ASC_LOALPHA,
	/* 101 e */	KParseTokens::ASC_LOALPHA,
	/* 102 f */	KParseTokens::ASC_LOALPHA,
	/* 103 g */	KParseTokens::ASC_LOALPHA,
	/* 104 h */	KParseTokens::ASC_LOALPHA,
	/* 105 i */	KParseTokens::ASC_LOALPHA,
	/* 106 j */	KParseTokens::ASC_LOALPHA,
	/* 107 k */	KParseTokens::ASC_LOALPHA,
	/* 108 l */	KParseTokens::ASC_LOALPHA,
	/* 109 m */	KParseTokens::ASC_LOALPHA,
	/* 110 n */	KParseTokens::ASC_LOALPHA,
	/* 111 o */	KParseTokens::ASC_LOALPHA,
	/* 112 p */	KParseTokens::ASC_LOALPHA,
	/* 113 q */	KParseTokens::ASC_LOALPHA,
	/* 114 r */	KParseTokens::ASC_LOALPHA,
	/* 115 s */	KParseTokens::ASC_LOALPHA,
	/* 116 t */	KParseTokens::ASC_LOALPHA,
	/* 117 u */	KParseTokens::ASC_LOALPHA,
	/* 118 v */	KParseTokens::ASC_LOALPHA,
	/* 119 w */	KParseTokens::ASC_LOALPHA,
	/* 120 x */	KParseTokens::ASC_LOALPHA,
	/* 121 y */	KParseTokens::ASC_LOALPHA,
	/* 122 z */	KParseTokens::ASC_LOALPHA,
	/* 123 { */	KParseTokens::ASC_OTHER,
	/* 124 | */	KParseTokens::ASC_OTHER,
	/* 125 } */	KParseTokens::ASC_OTHER,
	/* 126 ~ */	KParseTokens::ASC_OTHER,
	/* 127   */	KParseTokens::ASC_OTHER
};


// static
const sal_Unicode* cclass_Unicode::StrChr( const sal_Unicode* pStr, sal_Unicode c )
{
	if ( !pStr )
		return NULL;
	while ( *pStr )
	{
		if ( *pStr == c )
			return pStr;
		pStr++;
	}
	return NULL;
}


sal_Int32 cclass_Unicode::getParseTokensType( const sal_Unicode* aStr, sal_Int32 nPos )
{
	sal_Unicode c = aStr[nPos];
	if ( c < nDefCnt )
		return pParseTokensType[ sal_uInt8(c) ];
	else
	{

		//! all KParseTokens::UNI_... must be matched
        switch ( u_charType( (sal_uInt32) c ) )
		{
			case U_UPPERCASE_LETTER :
				return KParseTokens::UNI_UPALPHA;
			case U_LOWERCASE_LETTER :
				return KParseTokens::UNI_LOALPHA;
			case U_TITLECASE_LETTER :
				return KParseTokens::UNI_TITLE_ALPHA;
			case U_MODIFIER_LETTER :
				return KParseTokens::UNI_MODIFIER_LETTER;
			case U_OTHER_LETTER :
				// Non_Spacing_Mark could not be as leading character
				if (nPos == 0) break;
				// fall through, treat it as Other_Letter.
			case U_NON_SPACING_MARK :
				return KParseTokens::UNI_OTHER_LETTER;
			case U_DECIMAL_DIGIT_NUMBER :
				return KParseTokens::UNI_DIGIT;
			case U_LETTER_NUMBER :
				return KParseTokens::UNI_LETTER_NUMBER;
			case U_OTHER_NUMBER :
				return KParseTokens::UNI_OTHER_NUMBER;
		}

		return KParseTokens::UNI_OTHER;
	}
}

sal_Bool cclass_Unicode::setupInternational( const Locale& rLocale )
{
	sal_Bool bChanged = (aParserLocale.Language != rLocale.Language
		|| aParserLocale.Country != rLocale.Country
		|| aParserLocale.Variant != rLocale.Variant);
	if ( bChanged )
	{
		aParserLocale.Language = rLocale.Language;
		aParserLocale.Country = rLocale.Country;
		aParserLocale.Variant = rLocale.Variant;
	}
	if ( !xLocaleData.is() && xMSF.is() )
	{
		Reference <
			XInterface > xI =
			xMSF->createInstance( OUString(
			RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.i18n.LocaleData" ) ) );
		if ( xI.is() )
		{
			Any x = xI->queryInterface( getCppuType((const Reference< XLocaleData>*)0) );
			x >>= xLocaleData;
		}
	}
	return bChanged;
}


void cclass_Unicode::setupParserTable( const Locale& rLocale, sal_Int32 startCharTokenType,
            const OUString& userDefinedCharactersStart, sal_Int32 contCharTokenType,
            const OUString& userDefinedCharactersCont )
{
	bool bIntlEqual = (rLocale.Language == aParserLocale.Language &&
		rLocale.Country == aParserLocale.Country &&
		rLocale.Variant == aParserLocale.Variant);
	if ( !pTable || !bIntlEqual ||
			startCharTokenType != nStartTypes ||
			contCharTokenType != nContTypes ||
			userDefinedCharactersStart != aStartChars ||
			userDefinedCharactersCont != aContChars )
		initParserTable( rLocale, startCharTokenType, userDefinedCharactersStart,
			contCharTokenType, userDefinedCharactersCont );
}


void cclass_Unicode::initParserTable( const Locale& rLocale, sal_Int32 startCharTokenType,
            const OUString& userDefinedCharactersStart, sal_Int32 contCharTokenType,
            const OUString& userDefinedCharactersCont )
{
	// (Re)Init
	setupInternational( rLocale );
	// Memory of pTable is reused.
	if ( !pTable )
		pTable = new UPT_FLAG_TYPE[nDefCnt];
	memcpy( pTable, pDefaultParserTable, sizeof(UPT_FLAG_TYPE) * nDefCnt );
	// Start and cont tables only need reallocation if different length.
    if ( pStart && userDefinedCharactersStart.getLength() != aStartChars.getLength() )
	{
		delete [] pStart;
		pStart = NULL;
	}
    if ( pCont && userDefinedCharactersCont.getLength() != aContChars.getLength() )
	{
		delete [] pCont;
		pCont = NULL;
	}
	nStartTypes = startCharTokenType;
	nContTypes = contCharTokenType;
	aStartChars = userDefinedCharactersStart;
	aContChars = userDefinedCharactersCont;

	// specials
	if( xLocaleData.is() )
	{
		LocaleDataItem aItem =
			xLocaleData->getLocaleItem( aParserLocale );
//!TODO: theoretically separators may be a string, adjustment would have to be
//! done here and in parsing and in ::rtl::math::stringToDouble()
		cGroupSep = aItem.thousandSeparator.getStr()[0];
        cDecimalSep = aItem.decimalSeparator.getStr()[0];
	}

	if ( cGroupSep < nDefCnt )
		pTable[cGroupSep] |= TOKEN_VALUE;
	if ( cDecimalSep < nDefCnt )
		pTable[cDecimalSep] |= TOKEN_CHAR_VALUE | TOKEN_VALUE;

	// Modify characters according to KParseTokens definitions.
	{
		using namespace KParseTokens;
		sal_uInt8 i;

		if ( !(nStartTypes & ASC_UPALPHA) )
			for ( i = 65; i < 91; i++ )
				pTable[i] &= ~TOKEN_CHAR_WORD;	// not allowed as start character
		if ( !(nContTypes & ASC_UPALPHA) )
			for ( i = 65; i < 91; i++ )
				pTable[i] &= ~TOKEN_WORD;		// not allowed as cont character

		if ( !(nStartTypes & ASC_LOALPHA) )
			for ( i = 97; i < 123; i++ )
				pTable[i] &= ~TOKEN_CHAR_WORD;	// not allowed as start character
		if ( !(nContTypes & ASC_LOALPHA) )
			for ( i = 97; i < 123; i++ )
				pTable[i] &= ~TOKEN_WORD;		// not allowed as cont character

		if ( nStartTypes & ASC_DIGIT )
			for ( i = 48; i < 58; i++ )
				pTable[i] |= TOKEN_CHAR_WORD;	// allowed as start character
		if ( !(nContTypes & ASC_DIGIT) )
			for ( i = 48; i < 58; i++ )
				pTable[i] &= ~TOKEN_WORD;		// not allowed as cont character

		if ( !(nStartTypes & ASC_UNDERSCORE) )
			pTable[95] &= ~TOKEN_CHAR_WORD;		// not allowed as start character
		if ( !(nContTypes & ASC_UNDERSCORE) )
			pTable[95] &= ~TOKEN_WORD;			// not allowed as cont character

		if ( nStartTypes & ASC_DOLLAR )
			pTable[36] |= TOKEN_CHAR_WORD;		// allowed as start character
		if ( nContTypes & ASC_DOLLAR )
			pTable[36] |= TOKEN_WORD;			// allowed as cont character

		if ( nStartTypes & ASC_DOT )
			pTable[46] |= TOKEN_CHAR_WORD;		// allowed as start character
		if ( nContTypes & ASC_DOT )
			pTable[46] |= TOKEN_WORD;			// allowed as cont character

		if ( nStartTypes & ASC_COLON )
			pTable[58] |= TOKEN_CHAR_WORD;		// allowed as start character
		if ( nContTypes & ASC_COLON )
			pTable[58] |= TOKEN_WORD;			// allowed as cont character

		if ( nStartTypes & ASC_CONTROL )
			for ( i = 1; i < 32; i++ )
				pTable[i] |= TOKEN_CHAR_WORD;	// allowed as start character
		if ( nContTypes & ASC_CONTROL )
			for ( i = 1; i < 32; i++ )
				pTable[i] |= TOKEN_WORD;		// allowed as cont character

		if ( nStartTypes & ASC_ANY_BUT_CONTROL )
			for ( i = 32; i < nDefCnt; i++ )
				pTable[i] |= TOKEN_CHAR_WORD;	// allowed as start character
		if ( nContTypes & ASC_ANY_BUT_CONTROL )
			for ( i = 32; i < nDefCnt; i++ )
				pTable[i] |= TOKEN_WORD;		// allowed as cont character

	}

	// Merge in (positively override with) user defined characters.
	// StartChars
    sal_Int32 nLen = aStartChars.getLength();
	if ( nLen )
	{
		if ( !pStart )
			pStart = new UPT_FLAG_TYPE[ nLen ];
        const sal_Unicode* p = aStartChars.getStr();
        for ( sal_Int32 j=0; j<nLen; j++, p++ )
		{
			pStart[j] = TOKEN_CHAR_WORD;
            if ( *p < nDefCnt )
                pTable[*p] |= TOKEN_CHAR_WORD;
		}
	}
	// ContChars
    nLen = aContChars.getLength();
	if ( nLen )
	{
		if ( !pCont )
			pCont = new UPT_FLAG_TYPE[ nLen ];
        const sal_Unicode* p = aContChars.getStr();
        for ( sal_Int32 j=0; j<nLen; j++ )
		{
			pCont[j] = TOKEN_WORD;
            if ( *p < nDefCnt )
                pTable[*p] |= TOKEN_WORD;
		}
	}
}


void cclass_Unicode::destroyParserTable()
{
	if ( pCont )
		delete [] pCont;
	if ( pStart )
		delete [] pStart;
	if ( pTable )
		delete [] pTable;
}


UPT_FLAG_TYPE cclass_Unicode::getFlags( const sal_Unicode* aStr, sal_Int32 nPos )
{
	UPT_FLAG_TYPE nMask;
	sal_Unicode c = aStr[nPos];
	if ( c < nDefCnt )
		nMask = pTable[ sal_uInt8(c) ];
	else
		nMask = getFlagsExtended( aStr, nPos );
	switch ( eState )
	{
		case ssGetChar :
        case ssRewindFromValue :
        case ssIgnoreLeadingInRewind :
		case ssGetWordFirstChar :
			if ( !(nMask & TOKEN_CHAR_WORD) )
			{
				nMask |= getStartCharsFlags( c );
				if ( nMask & TOKEN_CHAR_WORD )
					nMask &= ~TOKEN_EXCLUDED;
			}
		break;
		case ssGetValue :
		case ssGetWord :
			if ( !(nMask & TOKEN_WORD) )
			{
				nMask |= getContCharsFlags( c );
				if ( nMask & TOKEN_WORD )
					nMask &= ~TOKEN_EXCLUDED;
			}
		break;
        default:
            ;   // other cases aren't needed, no compiler warning
	}
	return nMask;
}


UPT_FLAG_TYPE cclass_Unicode::getFlagsExtended( const sal_Unicode* aStr, sal_Int32 nPos )
{
	sal_Unicode c = aStr[nPos];
	if ( c == cGroupSep )
		return TOKEN_VALUE;
	else if ( c == cDecimalSep )
		return TOKEN_CHAR_VALUE | TOKEN_VALUE;
	using namespace i18n;
    bool bStart = (eState == ssGetChar || eState == ssGetWordFirstChar ||
            eState == ssRewindFromValue || eState == ssIgnoreLeadingInRewind);
	sal_Int32 nTypes = (bStart ? nStartTypes : nContTypes);

	//! all KParseTokens::UNI_... must be matched
    switch ( u_charType( (sal_uInt32) c ) )
	{
		case U_UPPERCASE_LETTER :
			return (nTypes & KParseTokens::UNI_UPALPHA) ?
				(bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
				TOKEN_ILLEGAL;
		case U_LOWERCASE_LETTER :
			return (nTypes & KParseTokens::UNI_LOALPHA) ?
				(bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
				TOKEN_ILLEGAL;
		case U_TITLECASE_LETTER :
			return (nTypes & KParseTokens::UNI_TITLE_ALPHA) ?
				(bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
				TOKEN_ILLEGAL;
		case U_MODIFIER_LETTER :
			return (nTypes & KParseTokens::UNI_MODIFIER_LETTER) ?
				(bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
				TOKEN_ILLEGAL;
		case U_NON_SPACING_MARK :
        case U_COMBINING_SPACING_MARK :
            // Non_Spacing_Mark can't be a leading character,
            // nor can a spacing combining mark.
            if (bStart)
                return TOKEN_ILLEGAL;
			// fall through, treat it as Other_Letter.
		case U_OTHER_LETTER :
			return (nTypes & KParseTokens::UNI_OTHER_LETTER) ?
				(bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
				TOKEN_ILLEGAL;
		case U_DECIMAL_DIGIT_NUMBER :
			return ((nTypes & KParseTokens::UNI_DIGIT) ?
				(bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
				TOKEN_ILLEGAL) | TOKEN_DIGIT_FLAGS;
		case U_LETTER_NUMBER :
			return ((nTypes & KParseTokens::UNI_LETTER_NUMBER) ?
				(bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
				TOKEN_ILLEGAL) | TOKEN_DIGIT_FLAGS;
		case U_OTHER_NUMBER :
			return ((nTypes & KParseTokens::UNI_OTHER_NUMBER) ?
				(bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
				TOKEN_ILLEGAL) | TOKEN_DIGIT_FLAGS;
		case U_SPACE_SEPARATOR :
			return ((nTypes & KParseTokens::IGNORE_LEADING_WS) ?
				TOKEN_CHAR_DONTCARE : (bStart ? TOKEN_CHAR_WORD : (TOKEN_CHAR_DONTCARE | TOKEN_WORD_SEP | TOKEN_VALUE_SEP) ));
	}

	return TOKEN_ILLEGAL;
}


UPT_FLAG_TYPE cclass_Unicode::getStartCharsFlags( sal_Unicode c )
{
	if ( pStart )
	{
        const sal_Unicode* pStr = aStartChars.getStr();
		const sal_Unicode* p = StrChr( pStr, c );
		if ( p )
			return pStart[ p - pStr ];
	}
	return TOKEN_ILLEGAL;
}


UPT_FLAG_TYPE cclass_Unicode::getContCharsFlags( sal_Unicode c )
{
	if ( pCont )
	{
        const sal_Unicode* pStr = aContChars.getStr();
		const sal_Unicode* p = StrChr( pStr, c );
		if ( p )
			return pCont[ p - pStr ];
	}
	return TOKEN_ILLEGAL;
}


void cclass_Unicode::parseText( ParseResult& r, const OUString& rText, sal_Int32 nPos, sal_Int32 nTokenType )
{
	using namespace i18n;
	const sal_Unicode* const pTextStart = rText.getStr() + nPos;
	eState = ssGetChar;

    //! All the variables below (plus ParseResult) have to be resetted on ssRewindFromValue!
	const sal_Unicode* pSym = pTextStart;
	const sal_Unicode* pSrc = pSym;
	OUString aSymbol;
	sal_Unicode c = *pSrc;
	sal_Unicode cLast = 0;
    int nDecSeps = 0;
	bool bQuote = false;
	bool bMightBeWord = true;
	bool bMightBeWordLast = true;
    //! All the variables above (plus ParseResult) have to be resetted on ssRewindFromValue!

	while ( (c != 0) && (eState != ssStop) )
	{
		UPT_FLAG_TYPE nMask = getFlags( pTextStart, pSrc - pTextStart );
		if ( nMask & TOKEN_EXCLUDED )
			eState = ssBounce;
		if ( bMightBeWord )
		{	// only relevant for ssGetValue fall back
			if ( eState == ssGetChar || eState == ssRewindFromValue ||
                    eState == ssIgnoreLeadingInRewind )
				bMightBeWord = ((nMask & TOKEN_CHAR_WORD) != 0);
			else
				bMightBeWord = ((nMask & TOKEN_WORD) != 0);
		}
		sal_Int32 nParseTokensType = getParseTokensType( pTextStart, pSrc - pTextStart );
		pSrc++;
		switch (eState)
		{
			case ssGetChar :
            case ssRewindFromValue :
            case ssIgnoreLeadingInRewind :
			{
                if ( (nMask & TOKEN_CHAR_VALUE) && eState != ssRewindFromValue
                        && eState != ssIgnoreLeadingInRewind )
				{	//! must be first, may fall back to ssGetWord via bMightBeWord
					eState = ssGetValue;
					if ( nMask & TOKEN_VALUE_DIGIT )
                    {
                        if ( 128 <= c )
                            r.TokenType = KParseType::UNI_NUMBER;
                        else
                            r.TokenType = KParseType::ASC_NUMBER;
                    }
                    else if ( c == cDecimalSep )
                    {
                        if ( *pSrc )
                            ++nDecSeps;
                        else
                            eState = ssRewindFromValue;
                            // retry for ONE_SINGLE_CHAR or others
                    }
				}
				else if ( nMask & TOKEN_CHAR_WORD )
				{
					eState = ssGetWord;
					r.TokenType = KParseType::IDENTNAME;
				}
				else if ( nMask & TOKEN_NAME_SEP )
				{
					eState = ssGetWordFirstChar;
					bQuote = true;
					pSym++;
					nParseTokensType = 0;	// will be taken of first real character
					r.TokenType = KParseType::SINGLE_QUOTE_NAME;
				}
				else if ( nMask & TOKEN_CHAR_STRING )
				{
					eState = ssGetString;
					pSym++;
					nParseTokensType = 0;	// will be taken of first real character
					r.TokenType = KParseType::DOUBLE_QUOTE_STRING;
				}
				else if ( nMask & TOKEN_CHAR_DONTCARE )
				{
					if ( nStartTypes & KParseTokens::IGNORE_LEADING_WS )
					{
                        if (eState == ssRewindFromValue)
                            eState = ssIgnoreLeadingInRewind;
						r.LeadingWhiteSpace++;
						pSym++;
						nParseTokensType = 0;	// wait until real character
						bMightBeWord = true;
					}
					else
						eState = ssBounce;
				}
				else if ( nMask & TOKEN_CHAR_BOOL )
				{
					eState = ssGetBool;
					r.TokenType = KParseType::BOOLEAN;
				}
				else if ( nMask & TOKEN_CHAR )
				{	//! must be last
					eState = ssStop;
					r.TokenType = KParseType::ONE_SINGLE_CHAR;
				}
				else
					eState = ssBounce;		// not known
			}
			break;
			case ssGetValue :
			{
                if ( nMask & TOKEN_VALUE_DIGIT )
                {
                    if ( 128 <= c )
                        r.TokenType = KParseType::UNI_NUMBER;
                    else if ( r.TokenType != KParseType::UNI_NUMBER )
                        r.TokenType = KParseType::ASC_NUMBER;
                }
                if ( nMask & TOKEN_VALUE )
                {
                    if ( c == cDecimalSep && ++nDecSeps > 1 )
                    {
                        if ( pSrc - pTextStart == 2 )
                            eState = ssRewindFromValue;
                            // consecutive separators
                        else
                            eState = ssStopBack;
                    }
                    // else keep it going
                }
				else if ( c == 'E' || c == 'e' )
				{
					UPT_FLAG_TYPE nNext = getFlags( pTextStart, pSrc - pTextStart );
					if ( nNext & TOKEN_VALUE_EXP )
						;	// keep it going
					else if ( bMightBeWord && ((nNext & TOKEN_WORD) || !*pSrc) )
					{	// might be a numerical name (1.2efg)
						eState = ssGetWord;
						r.TokenType = KParseType::IDENTNAME;
					}
					else
						eState = ssStopBack;
				}
				else if ( nMask & TOKEN_VALUE_SIGN )
				{
					if ( (cLast == 'E') || (cLast == 'e') )
					{
						UPT_FLAG_TYPE nNext = getFlags( pTextStart, pSrc - pTextStart );
						if ( nNext & TOKEN_VALUE_EXP_VALUE )
							;	// keep it going
						else if ( bMightBeWord && ((nNext & TOKEN_WORD) || !*pSrc) )
						{	// might be a numerical name (1.2e+fg)
							eState = ssGetWord;
							r.TokenType = KParseType::IDENTNAME;
						}
						else
							eState = ssStopBack;
					}
					else if ( bMightBeWord )
					{	// might be a numerical name (1.2+fg)
						eState = ssGetWord;
						r.TokenType = KParseType::IDENTNAME;
					}
					else
						eState = ssStopBack;
				}
				else if ( bMightBeWord && (nMask & TOKEN_WORD) )
				{	// might be a numerical name (1995.A1)
					eState = ssGetWord;
					r.TokenType = KParseType::IDENTNAME;
				}
				else
					eState = ssStopBack;
			}
			break;
			case ssGetWordFirstChar :
				eState = ssGetWord;
				// fall thru
			case ssGetWord :
			{
				if ( nMask & TOKEN_WORD )
					;	// keep it going
				else if ( nMask & TOKEN_NAME_SEP )
				{
					if ( bQuote )
					{
						if ( cLast == '\\' )
						{	// escaped
							aSymbol += OUString( pSym, pSrc - pSym - 2 );
							aSymbol += OUString( &c, 1);
						}
						else
						{
							eState = ssStop;
							aSymbol += OUString( pSym, pSrc - pSym - 1 );
						}
						pSym = pSrc;
					}
					else
						eState = ssStopBack;
				}
				else if ( bQuote )
					;	// keep it going
				else
					eState = ssStopBack;
			}
			break;
			case ssGetString :
			{
				if ( nMask & TOKEN_STRING_SEP )
				{
					if ( cLast == '\\' )
					{	// escaped
						aSymbol += OUString( pSym, pSrc - pSym - 2 );
						aSymbol += OUString( &c, 1);
					}
                    else if ( c == *pSrc &&
                            !(nContTypes & KParseTokens::TWO_DOUBLE_QUOTES_BREAK_STRING) )
					{	// "" => literal " escaped
						aSymbol += OUString( pSym, pSrc - pSym );
						pSrc++;
					}
					else
					{
						eState = ssStop;
						aSymbol += OUString( pSym, pSrc - pSym - 1 );
					}
					pSym = pSrc;
				}
			}
			break;
			case ssGetBool :
			{
				if ( (nMask & TOKEN_BOOL) )
					eState = ssStop;	// maximum 2: <, >, <>, <=, >=
				else
					eState = ssStopBack;
			}
			break;
            case ssStopBack :
            case ssBounce :
            case ssStop :
                ;   // nothing, no compiler warning
            break;
		}
        if ( eState == ssRewindFromValue )
        {
            r = ParseResult();
            pSym = pTextStart;
            pSrc = pSym;
            aSymbol = OUString();
            c = *pSrc;
            cLast = 0;
            nDecSeps = 0;
            bQuote = false;
            bMightBeWord = true;
            bMightBeWordLast = true;
        }
        else
        {
            if ( !(r.TokenType & nTokenType) )
            {
                if ( (r.TokenType & (KParseType::ASC_NUMBER | KParseType::UNI_NUMBER))
                        && (nTokenType & KParseType::IDENTNAME) && bMightBeWord )
                    ;	// keep a number that might be a word
                else if ( r.LeadingWhiteSpace == (pSrc - pTextStart) )
                    ;	// keep ignored white space
                else if ( !r.TokenType && eState == ssGetValue && (nMask & TOKEN_VALUE_SEP) )
                    ;   // keep uncertain value
                else
                    eState = ssBounce;
            }
            if ( eState == ssBounce )
            {
                r.TokenType = 0;
                eState = ssStopBack;
            }
            if ( eState == ssStopBack )
            {	// put back
                pSrc--;
                bMightBeWord = bMightBeWordLast;
                eState = ssStop;
            }
            if ( eState != ssStop )
            {
                if ( !r.StartFlags )
                    r.StartFlags |= nParseTokensType;
                else
                    r.ContFlags |= nParseTokensType;
            }
            bMightBeWordLast = bMightBeWord;
            cLast = c;
            c = *pSrc;
        }
	}
	// r.CharLen is the length in characters (not code points) of the parsed
	// token not including any leading white space, change this calculation if
	// multi-code-point Unicode characters are to be supported.
	r.CharLen = pSrc - pTextStart - r.LeadingWhiteSpace;
	r.EndPos = nPos + (pSrc - pTextStart);
	if ( r.TokenType & KParseType::ASC_NUMBER )
	{
        r.Value = rtl_math_uStringToDouble( pTextStart + r.LeadingWhiteSpace,
                pTextStart + r.EndPos, cDecimalSep, cGroupSep, NULL, NULL );
		if ( bMightBeWord )
			r.TokenType |= KParseType::IDENTNAME;
	}
	else if ( r.TokenType & KParseType::UNI_NUMBER )
	{
        if ( !xNatNumSup.is() )
        {
#define NATIVENUMBERSUPPLIER_SERVICENAME "com.sun.star.i18n.NativeNumberSupplier"
            if ( xMSF.is() )
            {
                xNatNumSup = Reference< XNativeNumberSupplier > (
                        xMSF->createInstance( OUString(
                                RTL_CONSTASCII_USTRINGPARAM(
                                    NATIVENUMBERSUPPLIER_SERVICENAME ) ) ),
                        UNO_QUERY );
            }
            if ( !xNatNumSup.is() )
            {
                throw RuntimeException( OUString(
#ifdef DBG_UTIL
                    RTL_CONSTASCII_USTRINGPARAM(
                        "cclass_Unicode::parseText: can't instanciate "
                        NATIVENUMBERSUPPLIER_SERVICENAME )
#endif
                    ), *this );
            }
#undef NATIVENUMBERSUPPLIER_SERVICENAME
        }
        OUString aTmp( pTextStart + r.LeadingWhiteSpace, r.EndPos - nPos +
                r.LeadingWhiteSpace );
        // transliterate to ASCII
        aTmp = xNatNumSup->getNativeNumberString( aTmp, aParserLocale,
                NativeNumberMode::NATNUM0 );
        r.Value = ::rtl::math::stringToDouble( aTmp, cDecimalSep, cGroupSep, NULL, NULL );
		if ( bMightBeWord )
			r.TokenType |= KParseType::IDENTNAME;
	}
	else if ( r.TokenType & (KParseType::SINGLE_QUOTE_NAME | KParseType::DOUBLE_QUOTE_STRING) )
	{
		if ( pSym < pSrc )
		{	//! open quote
			aSymbol += OUString( pSym, pSrc - pSym );
			r.TokenType |= KParseType::MISSING_QUOTE;
		}
		r.DequotedNameOrString = aSymbol;
	}
}

} } } }