/**************************************************************
 * 
 * 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_scfilt.hxx"


#ifndef PCH
#include <string.h>
#endif

#include "compiler.hxx"
#include "tokstack.hxx"
#include "global.hxx"
#include "scmatrix.hxx"

#include <stdio.h> // printf

const sal_uInt16	TokenPool::nScTokenOff = 8192;


TokenStack::TokenStack( sal_uInt16 nNewSize )
{
	pStack = new TokenId[ nNewSize ];

	Reset();
	nSize = nNewSize;
}


TokenStack::~TokenStack()
{
	delete[] pStack;
}




//------------------------------------------------------------------------

// !ACHTUNG!: nach Aussen hin beginnt die Nummerierung mit 1!
// !ACHTUNG!: SC-Token werden mit einem Offset nScTokenOff abgelegt
//				-> Unterscheidung von anderen Token


TokenPool::TokenPool( void )
{
	sal_uInt16	nLauf = nScTokenOff;

	// Sammelstelle fuer Id-Folgen
	nP_Id = 256;
	pP_Id = new sal_uInt16[ nP_Id ];

	// Sammelstelle fuer Ids
	nElement = 32;
	pElement = new sal_uInt16[ nElement ];
	pType = new E_TYPE[ nElement ];
	pSize = new sal_uInt16[ nElement ];
	nP_IdLast = 0;

	// Sammelstelle fuer Strings
	nP_Str = 4;
	ppP_Str = new String *[ nP_Str ];
	for( nLauf = 0 ; nLauf < nP_Str ; nLauf++ )
		ppP_Str[ nLauf ] = NULL;

	// Sammelstelle fuer double
	nP_Dbl = 8;
	pP_Dbl = new double[ nP_Dbl ];

    // Sammelstelle fuer error codes
    nP_Err = 8;
    pP_Err = new sal_uInt16[ nP_Err ];

	// Sammelstellen fuer Referenzen
	nP_RefTr = 32;
	ppP_RefTr = new ScSingleRefData *[ nP_RefTr ];
	for( nLauf = 0 ; nLauf < nP_RefTr ; nLauf++ )
		ppP_RefTr[ nLauf ] = NULL;

	nP_Ext = 32;
	ppP_Ext = new EXTCONT*[ nP_Ext ];
	memset( ppP_Ext, 0, sizeof( EXTCONT* ) * nP_Ext );

    nP_Nlf = 16;
	ppP_Nlf = new NLFCONT*[ nP_Nlf ];
	memset( ppP_Nlf, 0, sizeof( NLFCONT* ) * nP_Nlf );

    nP_Matrix = 16;
    ppP_Matrix = new ScMatrix*[ nP_Matrix ];
    memset( ppP_Matrix, 0, sizeof( ScMatrix* ) * nP_Matrix );

	pScToken = new ScTokenArray;

	Reset();
}


TokenPool::~TokenPool()
{
    sal_uInt16	n;

    delete[] pP_Id;
    delete[] pElement;
    delete[] pType;
    delete[] pSize;
    delete[] pP_Dbl;
    delete[] pP_Err;

    for( n = 0 ; n < nP_RefTr ; n++ )
        delete ppP_RefTr[ n ];
    delete[] ppP_RefTr;

    for( n = 0 ; n < nP_Str ; n++ )
        delete ppP_Str[ n ];
    delete[] ppP_Str;

    for( n = 0 ; n < nP_Ext ; n++ )
        delete ppP_Ext[ n ];
    delete[] ppP_Ext;

    for( n = 0 ; n < nP_Nlf ; n++ )
        delete ppP_Nlf[ n ];
    delete[] ppP_Nlf;

    for( n = 0 ; n < nP_Matrix ; n++ )
    {
        if( ppP_Matrix[ n ] )
            ppP_Matrix[ n ]->DecRef( );
    }
    delete[] ppP_Matrix;

    delete pScToken;
}


/** Returns the new number of elements, or 0 if overflow. */
static sal_uInt16 lcl_canGrow( sal_uInt16 nOld, sal_uInt16 nByMin = 1 )
{
    if (!nOld)
        return nByMin ? nByMin : 1;
    if (nOld == SAL_MAX_UINT16)
        return 0;
    sal_uInt32 nNew = ::std::max( static_cast<sal_uInt32>(nOld) * 2, 
            static_cast<sal_uInt32>(nOld) + nByMin);
    if (nNew > SAL_MAX_UINT16)
        nNew = SAL_MAX_UINT16;
    if (nNew - nByMin < nOld)
        nNew = 0;
    return static_cast<sal_uInt16>(nNew);
}


bool TokenPool::GrowString( void )
{
    sal_uInt16 nP_StrNew = lcl_canGrow( nP_Str);
    if (!nP_StrNew)
        return false;

	sal_uInt16		nL;

	String**	ppP_StrNew = new (::std::nothrow) String *[ nP_StrNew ];
    if (!ppP_StrNew)
        return false;

	for( nL = 0 ; nL < nP_Str ; nL++ )
		ppP_StrNew[ nL ] = ppP_Str[ nL ];
	for( nL = nP_Str ; nL < nP_StrNew ; nL++ )
		ppP_StrNew[ nL ] = NULL;

	nP_Str = nP_StrNew;

	delete[]	ppP_Str;
	ppP_Str = ppP_StrNew;
    return true;
}


bool TokenPool::GrowDouble( void )
{
    sal_uInt16 nP_DblNew = lcl_canGrow( nP_Dbl);
    if (!nP_DblNew)
        return false;


	double*		pP_DblNew = new (::std::nothrow) double[ nP_DblNew ];
    if (!pP_DblNew)
        return false;

	for( sal_uInt16 nL = 0 ; nL < nP_Dbl ; nL++ )
		pP_DblNew[ nL ] = pP_Dbl[ nL ];

	nP_Dbl = nP_DblNew;

	delete[] pP_Dbl;
	pP_Dbl = pP_DblNew;
    return true;
}


/* TODO: in case we had FormulaTokenArray::AddError() */
#if 0
void TokenPool::GrowError( void )
{
    sal_uInt16 nP_ErrNew = lcl_canGrow( nP_Err);
    if (!nP_ErrNew)
        return false;


    sal_uInt16*     pP_ErrNew = new (::std::nothrow) sal_uInt16[ nP_ErrNew ];
    if (!pP_ErrNew)
        return false;

    for( sal_uInt16 nL = 0 ; nL < nP_Err ; nL++ )
        pP_ErrNew[ nL ] = pP_Err[ nL ];

    nP_Err = nP_ErrNew;

    delete[] pP_Err;
    pP_Err = pP_ErrNew;
    return true;
}
#endif


bool TokenPool::GrowTripel( sal_uInt16 nByMin )
{
    sal_uInt16 nP_RefTrNew = lcl_canGrow( nP_RefTr, nByMin);
    if (!nP_RefTrNew)
        return false;

	sal_uInt16			nL;

	ScSingleRefData**	ppP_RefTrNew = new (::std::nothrow) ScSingleRefData *[ nP_RefTrNew ];
    if (!ppP_RefTrNew)
        return false;

	for( nL = 0 ; nL < nP_RefTr ; nL++ )
		ppP_RefTrNew[ nL ] = ppP_RefTr[ nL ];
	for( nL = nP_RefTr ; nL < nP_RefTrNew ; nL++ )
		ppP_RefTrNew[ nL ] = NULL;

	nP_RefTr = nP_RefTrNew;

	delete[] ppP_RefTr;
	ppP_RefTr = ppP_RefTrNew;
    return true;
}


bool TokenPool::GrowId( void )
{
    sal_uInt16 nP_IdNew = lcl_canGrow( nP_Id);
    if (!nP_IdNew)
        return false;


	sal_uInt16*	pP_IdNew = new (::std::nothrow) sal_uInt16[ nP_IdNew ];
    if (!pP_IdNew)
        return false;

	for( sal_uInt16 nL = 0 ; nL < nP_Id ; nL++ )
		pP_IdNew[ nL ] = pP_Id[ nL ];

	nP_Id = nP_IdNew;

	delete[] pP_Id;
	pP_Id = pP_IdNew;
    return true;
}


bool TokenPool::GrowElement( void )
{
    sal_uInt16 nElementNew = lcl_canGrow( nElement);
    if (!nElementNew)
        return false;


	sal_uInt16*	pElementNew = new (::std::nothrow) sal_uInt16[ nElementNew ];
	E_TYPE*	pTypeNew = new (::std::nothrow) E_TYPE[ nElementNew ];
	sal_uInt16*	pSizeNew = new (::std::nothrow) sal_uInt16[ nElementNew ];
    if (!pElementNew || !pTypeNew || !pSizeNew)
    {
        delete [] pElementNew;
        delete [] pTypeNew;
        delete [] pSizeNew;
        return false;
    }

	for( sal_uInt16 nL = 0 ; nL < nElement ; nL++ )
	{
		pElementNew[ nL ] = pElement[ nL ];
		pTypeNew[ nL ] = pType[ nL ];
		pSizeNew[ nL ] = pSize[ nL ];
	}

	nElement = nElementNew;

	delete[] pElement;
	delete[] pType;
	delete[] pSize;
	pElement = pElementNew;
	pType = pTypeNew;
	pSize = pSizeNew;
    return true;
}


bool TokenPool::GrowExt( void )
{
    sal_uInt16 nNewSize = lcl_canGrow( nP_Ext);
    if (!nNewSize)
        return false;

	EXTCONT**	ppNew = new (::std::nothrow) EXTCONT*[ nNewSize ];
    if (!ppNew)
        return false;

    memset( ppNew, 0, sizeof( EXTCONT* ) * nNewSize );
	memcpy( ppNew, ppP_Ext, sizeof( EXTCONT* ) * nP_Ext );

	delete[] ppP_Ext;
	ppP_Ext = ppNew;
	nP_Ext = nNewSize;
    return true;
}


bool TokenPool::GrowNlf( void )
{
    sal_uInt16 nNewSize = lcl_canGrow( nP_Nlf);
    if (!nNewSize)
        return false;

	NLFCONT**	ppNew = new (::std::nothrow) NLFCONT*[ nNewSize ];
    if (!ppNew)
        return false;

    memset( ppNew, 0, sizeof( NLFCONT* ) * nNewSize );
	memcpy( ppNew, ppP_Nlf, sizeof( NLFCONT* ) * nP_Nlf );

	delete[] ppP_Nlf;
    ppP_Nlf = ppNew;
	nP_Nlf = nNewSize;
    return true;
}


bool TokenPool::GrowMatrix( void )
{
    sal_uInt16 nNewSize = lcl_canGrow( nP_Matrix);
    if (!nNewSize)
        return false;

    ScMatrix**  ppNew = new (::std::nothrow) ScMatrix*[ nNewSize ];
    if (!ppNew)
        return false;

    memset( ppNew, 0, sizeof( ScMatrix* ) * nNewSize );
    memcpy( ppNew, ppP_Matrix, sizeof( ScMatrix* ) * nP_Matrix );

    delete[] ppP_Matrix;
    ppP_Matrix = ppNew;
    nP_Matrix = nNewSize;
    return true;
}

bool TokenPool::GetElement( const sal_uInt16 nId )
{
	DBG_ASSERT( nId < nElementAkt, "*TokenPool::GetElement(): Id too large!?" );
    if (nId >= nElementAkt)
        return false;

    bool bRet = true;
	if( pType[ nId ] == T_Id )
		bRet = GetElementRek( nId );
	else
	{
		switch( pType[ nId ] )
		{
			case T_Str:
                {
                    sal_uInt16 n = pElement[ nId ];
                    String* p = ( n < nP_Str )? ppP_Str[ n ] : NULL;
                    if (p)
                        pScToken->AddString( *p );
                    else
                        bRet = false;
                }
				break;
			case T_D:
                {
                    sal_uInt16 n = pElement[ nId ];
                    if (n < nP_Dbl)
                        pScToken->AddDouble( pP_Dbl[ n ] );
                    else
                        bRet = false;
                }
				break;
            case T_Err:
/* TODO: in case we had FormulaTokenArray::AddError() */
#if 0
                {
                    sal_uInt16 n = pElement[ nId ];
                    if (n < nP_Err)
                        pScToken->AddError( pP_Err[ n ] );
                    else
                        bRet = false;
                }
#endif
                break;
			case T_RefC:
                {
                    sal_uInt16 n = pElement[ nId ];
                    ScSingleRefData* p = ( n < nP_RefTr )? ppP_RefTr[ n ] : NULL;
                    if (p)
                        pScToken->AddSingleReference( *p );
                    else
                        bRet = false;
                }
				break;
			case T_RefA:
				{
                    sal_uInt16 n = pElement[ nId ];
                    if (n < nP_RefTr && ppP_RefTr[ n ] && n+1 < nP_RefTr && ppP_RefTr[ n + 1 ])
                    {
                        ScComplexRefData	aScComplexRefData;
                        aScComplexRefData.Ref1 = *ppP_RefTr[ n ];
                        aScComplexRefData.Ref2 = *ppP_RefTr[ n + 1 ];
                        pScToken->AddDoubleReference( aScComplexRefData );
                    }
                    else
                        bRet = false;
				}
				break;
			case T_RN:
				pScToken->AddName( pElement[ nId ] );
				break;
			case T_Ext:
                {
                    sal_uInt16			n = pElement[ nId ];
                    EXTCONT*		p = ( n < nP_Ext )? ppP_Ext[ n ] : NULL;

                    if( p )
                    {
                        if( p->eId == ocEuroConvert )
                            pScToken->AddOpCode( p->eId );
                        else
                            pScToken->AddExternal( p->aText, p->eId );
                    }
                    else
                        bRet = false;
                }
				break;
			case T_Nlf:
                {
                    sal_uInt16			n = pElement[ nId ];
                    NLFCONT*		p = ( n < nP_Nlf )? ppP_Nlf[ n ] : NULL;

                    if( p )
                        pScToken->AddColRowName( p->aRef );
                    else
                        bRet = false;
                }
				break;
            case T_Matrix:
                {
                    sal_uInt16          n = pElement[ nId ];
                    ScMatrix*       p = ( n < nP_Matrix )? ppP_Matrix[ n ] : NULL;

                    if( p )
                        pScToken->AddMatrix( p );
                    else
                        bRet = false;
                }
                break;
            case T_ExtName:
                {
                    sal_uInt16 n = pElement[nId];
                    if (n < maExtNames.size())
                    {
                        const ExtName& r = maExtNames[n];
                        pScToken->AddExternalName(r.mnFileId, r.maName);
                    }
                    else
                        bRet = false;
                }
                break;
            case T_ExtRefC:
                {
                    sal_uInt16 n = pElement[nId];
                    if (n < maExtCellRefs.size())
                    {
                        const ExtCellRef& r = maExtCellRefs[n];
                        pScToken->AddExternalSingleReference(r.mnFileId, r.maTabName, r.maRef);
                    }
                    else
                        bRet = false;
                }
                break;
            case T_ExtRefA:
                {
                    sal_uInt16 n = pElement[nId];
                    if (n < maExtAreaRefs.size())
                    {
                        const ExtAreaRef& r = maExtAreaRefs[n];
                        pScToken->AddExternalDoubleReference(r.mnFileId, r.maTabName, r.maRef);
                    }
                    else
                        bRet = false;
                }
                break;
			default:
				DBG_ERROR("-TokenPool::GetElement(): undefined state!?");
                bRet = false;
		}
	}
    return bRet;
}


bool TokenPool::GetElementRek( const sal_uInt16 nId )
{
#ifdef DBG_UTIL
	nRek++;
	DBG_ASSERT( nRek <= nP_Id, "*TokenPool::GetElement(): recursion loops" );
#endif

    if (nId >= nElementAkt)
    {
        DBG_ERRORFILE( "*TokenPool::GetElementRek(): nId >= nElementAkt" );
#ifdef DBG_UTIL
        nRek--;
#endif
        return false;
    }

    if (pType[ nId ] != T_Id)
    {
        DBG_ERRORFILE( "-TokenPool::GetElementRek(): pType[ nId ] != T_Id" );
#ifdef DBG_UTIL
        nRek--;
#endif
        return false;
    }


    bool bRet = true;
	sal_uInt16 nAnz = pSize[ nId ];
    sal_uInt16 nFirstId = pElement[ nId ];
    if (nFirstId >= nP_Id)
    {
        DBG_ERRORFILE( "TokenPool::GetElementRek: nFirstId >= nP_Id");
        nAnz = 0;
        bRet = false;
    }
	sal_uInt16* pAkt = nAnz ? &pP_Id[ nFirstId ] : NULL;
    if (nAnz > nP_Id - nFirstId)
    {
        DBG_ERRORFILE( "TokenPool::GetElementRek: nAnz > nP_Id - nFirstId");
        nAnz = nP_Id - nFirstId;
        bRet = false;
    }
	for( ; nAnz > 0 ; nAnz--, pAkt++ )
	{
		if( *pAkt < nScTokenOff )
		{// Rekursion oder nicht?
            if (*pAkt >= nElementAkt)
            {
                DBG_ERRORFILE( "TokenPool::GetElementRek: *pAkt >= nElementAkt");
                bRet = false;
            }
            else
            {
                if (pType[ *pAkt ] == T_Id)
                    bRet = GetElementRek( *pAkt );
                else
                    bRet = GetElement( *pAkt );
            }
		}
		else	// elementarer SC_Token
			pScToken->AddOpCode( ( DefTokenId ) ( *pAkt - nScTokenOff ) );
	}

#ifdef DBG_UTIL
	nRek--;
#endif
    return bRet;
}


void TokenPool::operator >>( TokenId& rId )
{
	rId = ( TokenId ) ( nElementAkt + 1 );

	if( nElementAkt >= nElement )
		if (!GrowElement())
            return;

	pElement[ nElementAkt ] = nP_IdLast;	// Start der Token-Folge
	pType[ nElementAkt ] = T_Id;			// Typinfo eintragen
	pSize[ nElementAkt ] = nP_IdAkt - nP_IdLast;
		// von nP_IdLast bis nP_IdAkt-1 geschrieben -> Laenge der Folge

	nElementAkt++;			// Startwerte fuer naechste Folge
	nP_IdLast = nP_IdAkt;
}


const TokenId TokenPool::Store( const double& rDouble )
{
	if( nElementAkt >= nElement )
		if (!GrowElement())
            return (const TokenId) nElementAkt+1;

	if( nP_DblAkt >= nP_Dbl )
		if (!GrowDouble())
            return (const TokenId) nElementAkt+1;

	pElement[ nElementAkt ] = nP_DblAkt;	// Index in Double-Array
	pType[ nElementAkt ] = T_D;				// Typinfo Double eintragen

	pP_Dbl[ nP_DblAkt ] = rDouble;

	pSize[ nElementAkt ] = 1;			// eigentlich Banane

	nElementAkt++;
	nP_DblAkt++;

	return ( const TokenId ) nElementAkt; // Ausgabe von altem Wert + 1!
}


const TokenId TokenPool::Store( const sal_uInt16 nIndex )
{
	if( nElementAkt >= nElement )
		if (!GrowElement())
            return (const TokenId) nElementAkt+1;

	pElement[ nElementAkt ] = nIndex;			// Daten direkt im Index!
	pType[ nElementAkt ] = T_RN;				// Typinfo Range Name eintragen

	nElementAkt++;
	return ( const TokenId ) nElementAkt;				// Ausgabe von altem Wert + 1!
}


const TokenId TokenPool::Store( const String& rString )
{
	// weitgehend nach Store( const sal_Char* ) kopiert, zur Vermeidung
	//  eines temporaeren Strings in "
	if( nElementAkt >= nElement )
		if (!GrowElement())
            return (const TokenId) nElementAkt+1;

	if( nP_StrAkt >= nP_Str )
		if (!GrowString())
            return (const TokenId) nElementAkt+1;

	pElement[ nElementAkt ] = nP_StrAkt;	// Index in String-Array
	pType[ nElementAkt ] = T_Str;			// Typinfo String eintragen

	// String anlegen
	if( !ppP_Str[ nP_StrAkt ] )
		//...aber nur, wenn noch nicht vorhanden
		ppP_Str[ nP_StrAkt ] = new (::std::nothrow) String( rString );
	else
		//...ansonsten nur kopieren
		*ppP_Str[ nP_StrAkt ] = rString;

    if (ppP_Str[ nP_StrAkt ])
    {
        DBG_ASSERT( sizeof( xub_StrLen ) <= 2, "*TokenPool::Store(): StrLen doesn't match!" );
        pSize[ nElementAkt ] = ( sal_uInt16 ) ppP_Str[ nP_StrAkt ]->Len();
    }

	nElementAkt++;
	nP_StrAkt++;

	return ( const TokenId ) nElementAkt; // Ausgabe von altem Wert + 1!
}


const TokenId TokenPool::Store( const ScSingleRefData& rTr )
{
	if( nElementAkt >= nElement )
		if (!GrowElement())
            return (const TokenId) nElementAkt+1;

	if( nP_RefTrAkt >= nP_RefTr )
		if (!GrowTripel())
            return (const TokenId) nElementAkt+1;

	pElement[ nElementAkt ] = nP_RefTrAkt;
	pType[ nElementAkt ] = T_RefC;			// Typinfo Cell-Reff eintragen

	if( !ppP_RefTr[ nP_RefTrAkt ] )
		ppP_RefTr[ nP_RefTrAkt ] = new ScSingleRefData( rTr );
	else
		*ppP_RefTr[ nP_RefTrAkt ] = rTr;

	nElementAkt++;
	nP_RefTrAkt++;

	return ( const TokenId ) nElementAkt; // Ausgabe von altem Wert + 1!
}


const TokenId TokenPool::Store( const ScComplexRefData& rTr )
{
	if( nElementAkt >= nElement )
		if (!GrowElement())
            return (const TokenId) nElementAkt+1;

	if( nP_RefTrAkt + 1 >= nP_RefTr )
		if (!GrowTripel( 2))
            return (const TokenId) nElementAkt+1;

	pElement[ nElementAkt ] = nP_RefTrAkt;
	pType[ nElementAkt ] = T_RefA;			// Typinfo Area-Reff eintragen

	if( !ppP_RefTr[ nP_RefTrAkt ] )
		ppP_RefTr[ nP_RefTrAkt ] = new ScSingleRefData( rTr.Ref1 );
	else
		*ppP_RefTr[ nP_RefTrAkt ] = rTr.Ref1;
	nP_RefTrAkt++;

	if( !ppP_RefTr[ nP_RefTrAkt ] )
		ppP_RefTr[ nP_RefTrAkt ] = new ScSingleRefData( rTr.Ref2 );
	else
		*ppP_RefTr[ nP_RefTrAkt ] = rTr.Ref2;
	nP_RefTrAkt++;

	nElementAkt++;

	return ( const TokenId ) nElementAkt; // Ausgabe von altem Wert + 1!
}


const TokenId TokenPool::Store( const DefTokenId e, const String& r )
{
	if( nElementAkt >= nElement )
		if (!GrowElement())
            return (const TokenId) nElementAkt+1;

	if( nP_ExtAkt >= nP_Ext )
        if (!GrowExt())
            return (const TokenId) nElementAkt+1;

	pElement[ nElementAkt ] = nP_ExtAkt;
	pType[ nElementAkt ] = T_Ext;			// Typinfo String eintragen

	if( ppP_Ext[ nP_ExtAkt ] )
	{
		ppP_Ext[ nP_ExtAkt ]->eId = e;
		ppP_Ext[ nP_ExtAkt ]->aText = r;
	}
	else
		ppP_Ext[ nP_ExtAkt ] = new EXTCONT( e, r );

	nElementAkt++;
	nP_ExtAkt++;

	return ( const TokenId ) nElementAkt; // Ausgabe von altem Wert + 1!
}


const TokenId TokenPool::StoreNlf( const ScSingleRefData& rTr )
{
	if( nElementAkt >= nElement )
		if (!GrowElement())
            return (const TokenId) nElementAkt+1;

	if( nP_NlfAkt >= nP_Nlf )
		if (!GrowNlf())
            return (const TokenId) nElementAkt+1;

	pElement[ nElementAkt ] = nP_NlfAkt;
	pType[ nElementAkt ] = T_Nlf;

	if( ppP_Nlf[ nP_NlfAkt ] )
	{
		ppP_Nlf[ nP_NlfAkt ]->aRef = rTr;
	}
	else
		ppP_Nlf[ nP_NlfAkt ] = new NLFCONT( rTr );

	nElementAkt++;
	nP_NlfAkt++;

	return ( const TokenId ) nElementAkt;
}

const TokenId TokenPool::StoreMatrix()
{
    ScMatrix* pM;

    if( nElementAkt >= nElement )
		if (!GrowElement())
            return (const TokenId) nElementAkt+1;

    if( nP_MatrixAkt >= nP_Matrix )
        if (!GrowMatrix())
            return (const TokenId) nElementAkt+1;

    pElement[ nElementAkt ] = nP_MatrixAkt;
    pType[ nElementAkt ] = T_Matrix;

    pM = new ScMatrix( 0, 0 );
    pM->IncRef( );
    ppP_Matrix[ nP_MatrixAkt ] = pM;

    nElementAkt++;
    nP_MatrixAkt++;

    return ( const TokenId ) nElementAkt;
}

const TokenId TokenPool::StoreExtName( sal_uInt16 nFileId, const String& rName )
{
    if ( nElementAkt >= nElement )
		if (!GrowElement())
            return (const TokenId) nElementAkt+1;

    pElement[nElementAkt] = static_cast<sal_uInt16>(maExtNames.size());
    pType[nElementAkt] = T_ExtName;
    
    maExtNames.push_back(ExtName());
    ExtName& r = maExtNames.back();
    r.mnFileId = nFileId;
    r.maName = rName;

    ++nElementAkt;

    return static_cast<const TokenId>(nElementAkt);
}

const TokenId TokenPool::StoreExtRef( sal_uInt16 nFileId, const String& rTabName, const ScSingleRefData& rRef )
{
    if ( nElementAkt >= nElement )
		if (!GrowElement())
            return (const TokenId) nElementAkt+1;

    pElement[nElementAkt] = static_cast<sal_uInt16>(maExtCellRefs.size());
    pType[nElementAkt] = T_ExtRefC;
    
    maExtCellRefs.push_back(ExtCellRef());
    ExtCellRef& r = maExtCellRefs.back();
    r.mnFileId = nFileId;
    r.maTabName = rTabName;
    r.maRef = rRef;

    ++nElementAkt;

    return static_cast<const TokenId>(nElementAkt);
}

const TokenId TokenPool::StoreExtRef( sal_uInt16 nFileId, const String& rTabName, const ScComplexRefData& rRef )
{
    if ( nElementAkt >= nElement )
		if (!GrowElement())
            return (const TokenId) nElementAkt+1;

    pElement[nElementAkt] = static_cast<sal_uInt16>(maExtAreaRefs.size());
    pType[nElementAkt] = T_ExtRefA;
    
    maExtAreaRefs.push_back(ExtAreaRef());
    ExtAreaRef& r = maExtAreaRefs.back();
    r.mnFileId = nFileId;
    r.maTabName = rTabName;
    r.maRef = rRef;

    ++nElementAkt;

    return static_cast<const TokenId>(nElementAkt);
}

void TokenPool::Reset( void )
{
    nP_IdAkt = nP_IdLast = nElementAkt = nP_StrAkt = nP_DblAkt = nP_ErrAkt = nP_RefTrAkt = nP_ExtAkt = nP_NlfAkt = nP_MatrixAkt = 0;
    maExtNames.clear();
    maExtCellRefs.clear();
    maExtAreaRefs.clear();
}


sal_Bool TokenPool::IsSingleOp( const TokenId& rId, const DefTokenId eId ) const
{
    sal_uInt16 nId = (sal_uInt16) rId;
	if( nId && nId <= nElementAkt )
	{// existent?
		nId--;
		if( T_Id == pType[ nId ] )
		{// Tokenfolge?
			if( pSize[ nId ] == 1 )
			{// GENAU 1 Token
                sal_uInt16 nPid = pElement[ nId ];
                if (nPid < nP_Id)
                {
                    sal_uInt16	nSecId = pP_Id[ nPid ];
                    if( nSecId >= nScTokenOff )
                    {// Default-Token?
                        return ( DefTokenId ) ( nSecId - nScTokenOff ) == eId;	// Gesuchter?
                    }
                }
			}
		}
	}

	return sal_False;
}


const String* TokenPool::GetExternal( const TokenId& rId ) const
{
    const String*   p = NULL;
    sal_uInt16 n = (sal_uInt16) rId;
	if( n && n <= nElementAkt )
	{
		n--;
        if( pType[ n ] == T_Ext )
        {
            sal_uInt16 nExt = pElement[ n ];
            if ( nExt < nP_Ext && ppP_Ext[ nExt ] )
                p = &ppP_Ext[ nExt ]->aText;
        }
	}

    return p;
}

ScMatrix* TokenPool::GetMatrix( unsigned int n ) const
{
    if( n < nP_MatrixAkt )
        return ppP_Matrix[ n ];
    else
        printf ("GETMATRIX %d >= %d\n", n, nP_MatrixAkt);
    return NULL;
}