xename.cxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   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 .
 */
 
#include <xename.hxx>
 
#include <map>
 
#include <document.hxx>
#include <rangenam.hxx>
#include <tokenarray.hxx>
#include <xehelper.hxx>
#include <xelink.hxx>
#include <excrecds.hxx>
#include <xlname.hxx>
#include <xeformula.hxx>
#include <xestring.hxx>
#include <xltools.hxx>
 
#include <formula/grammar.hxx>
#include <oox/export/utils.hxx>
#include <oox/token/tokens.hxx>
 
using namespace ::oox;
 
// *** Helper classes ***
 
namespace {
 
class XclExpName : public XclExpRecord, protected XclExpRoot
{
public:
    explicit            XclExpName( const XclExpRoot& rRoot, const OUString& rName );
    explicit            XclExpName( const XclExpRoot& rRoot, sal_Unicode cBuiltIn );
 
    void                SetTokenArray( const XclTokenArrayRef& xTokArr );
    void                SetLocalTab( SCTAB nScTab );
    void                SetHidden( bool bHidden = true );
    void                SetMacroCall( bool bVBasic, bool bFunc );
 
    void                SetSymbol( const OUString& rValue );
 
    const OUString& GetOrigName() const { return maOrigName; }
    sal_Unicode  GetBuiltInName() const { return mcBuiltIn; }
 
    const OUString& GetSymbol() const { return msSymbol; }
 
    bool         IsGlobal() const { return mnXclTab == EXC_NAME_GLOBAL; }
    SCTAB        GetScTab() const { return mnScTab; }
 
    bool                IsVolatile() const;
    bool                IsMacroCall( bool bVBasic, bool bFunc ) const;
 
    virtual void        Save( XclExpStream& rStrm ) override;
 
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
    OUString            GetWithDefaultRangeSeparator( const OUString& rSymbol ) const;
 
private:
    OUString            maOrigName;     
    OUString            msSymbol;       
    XclExpStringRef     mxName;         
    XclTokenArrayRef    mxTokArr;       
    sal_Unicode         mcBuiltIn;      
    SCTAB               mnScTab;        
    sal_uInt16          mnFlags;        
    sal_uInt16          mnExtSheet;     
    sal_uInt16          mnXclTab;       
};
 
}
 
class XclExpNameManagerImpl : protected XclExpRoot
{
public:
    explicit            XclExpNameManagerImpl( const XclExpRoot& rRoot );
 
    void                Initialize();
 
    sal_uInt16          InsertName( SCTAB nTab, sal_uInt16 nScNameIdx, SCTAB nCurrTab );
 
    sal_uInt16          InsertBuiltInName( sal_Unicode cBuiltIn, const XclTokenArrayRef& xTokArr, SCTAB nScTab, const ScRangeList& aRangeList );
    sal_uInt16          InsertBuiltInName( sal_Unicode cBuiltIn, const XclTokenArrayRef& xTokArr, const ScRange& aRange );
    sal_uInt16          InsertUniqueName( const OUString& rName, const XclTokenArrayRef& xTokArr, SCTAB nScTab );
    sal_uInt16          InsertRawName( const OUString& rName );
    sal_uInt16          InsertMacroCall( const OUString& rMacroName, bool bVBasic, bool bFunc, bool bHidden );
 
    const XclExpName*   GetName( sal_uInt16 nNameIdx ) const;
 
    void                Save( XclExpStream& rStrm );
 
    void                SaveXml( XclExpXmlStream& rStrm );
 
private:
    typedef XclExpRecordList< XclExpName >      XclExpNameList;
    typedef XclExpNameList::RecordRefType       XclExpNameRef;
 
    typedef ::std::map< ::std::pair<SCTAB, OUString>, sal_uInt16> NamedExpMap;
 
private:
    sal_uInt16          FindNamedExp( SCTAB nTab, OUString sName );
 
    sal_uInt16          FindBuiltInNameIdx( const OUString& rName,
                            const OUString& sSymbol ) const;
    OUString            GetUnusedName( const OUString& rName ) const;
 
    sal_uInt16          Append( XclExpName* pName );
    sal_uInt16          Append( XclExpNameRef const & rxName ) { return Append(rxName.get()); }
    sal_uInt16          CreateName( SCTAB nTab, const ScRangeData& rRangeData );
 
    void                CreateBuiltInNames();
    void                CreateUserNames();
 
private:
    NamedExpMap         maNamedExpMap;
    XclExpNameList      maNameList;         
    size_t              mnFirstUserIdx;     
};
 
// *** Implementation ***
 
XclExpName::XclExpName( const XclExpRoot& rRoot, const OUString& rName ) :
    XclExpRecord( EXC_ID_NAME ),
    XclExpRoot( rRoot ),
    maOrigName( rName ),
    mxName( XclExpStringHelper::CreateString( rRoot, rName, XclStrFlags::EightBitLength ) ),
    mcBuiltIn( EXC_BUILTIN_UNKNOWN ),
    mnScTab( SCTAB_GLOBAL ),
    mnFlags( EXC_NAME_DEFAULT ),
    mnExtSheet( EXC_NAME_GLOBAL ),
    mnXclTab( EXC_NAME_GLOBAL )
{
}
 
XclExpName::XclExpName( const XclExpRoot& rRoot, sal_Unicode cBuiltIn ) :
    XclExpRecord( EXC_ID_NAME ),
    XclExpRoot( rRoot ),
    mcBuiltIn( cBuiltIn ),
    mnScTab( SCTAB_GLOBAL ),
    mnFlags( EXC_NAME_DEFAULT ),
    mnExtSheet( EXC_NAME_GLOBAL ),
    mnXclTab( EXC_NAME_GLOBAL )
{
    // filter source range is hidden in Excel
    if( cBuiltIn == EXC_BUILTIN_FILTERDATABASE )
        SetHidden();
 
    // special case for BIFF5/7 filter source range - name appears as plain text without built-in flag
    if( (GetBiff() <= EXC_BIFF5) && (cBuiltIn == EXC_BUILTIN_FILTERDATABASE) )
    {
        OUString aName( XclTools::GetXclBuiltInDefName( EXC_BUILTIN_FILTERDATABASE ) );
        mxName = XclExpStringHelper::CreateString( rRoot, aName, XclStrFlags::EightBitLength );
        maOrigName = XclTools::GetXclBuiltInDefName( cBuiltIn );
    }
    else
    {
        maOrigName =  XclTools::GetBuiltInDefNameXml( cBuiltIn ) ;
        mxName = XclExpStringHelper::CreateString( rRoot, cBuiltIn, XclStrFlags::EightBitLength );
        ::set_flag( mnFlags, EXC_NAME_BUILTIN );
    }
}
 
void XclExpName::SetTokenArray( const XclTokenArrayRef& xTokArr )
{
    mxTokArr = xTokArr;
}
 
void XclExpName::SetLocalTab( SCTAB nScTab )
{
    OSL_ENSURE( GetTabInfo().IsExportTab( nScTab ), "XclExpName::SetLocalTab - invalid sheet index" );
    if( !GetTabInfo().IsExportTab( nScTab ) )
        return;
 
    mnScTab = nScTab;
    GetGlobalLinkManager().FindExtSheet( mnExtSheet, mnXclTab, nScTab );
 
    // special handling for NAME record
    switch( GetBiff() )
    {
        case EXC_BIFF5: // EXTERNSHEET index is positive in NAME record
            mnExtSheet = ~mnExtSheet + 1;
        break;
        case EXC_BIFF8: // EXTERNSHEET index not used, but must be created in link table
            mnExtSheet = 0;
        break;
        default:    DBG_ERROR_BIFF();
    }
 
    // Excel sheet index is 1-based
    ++mnXclTab;
}
 
void XclExpName::SetHidden( bool bHidden )
{
    ::set_flag( mnFlags, EXC_NAME_HIDDEN, bHidden );
}
 
void XclExpName::SetMacroCall( bool bVBasic, bool bFunc )
{
    ::set_flag( mnFlags, EXC_NAME_PROC );
    ::set_flag( mnFlags, EXC_NAME_VB, bVBasic );
    ::set_flag( mnFlags, EXC_NAME_FUNC, bFunc );
}
 
void XclExpName::SetSymbol( const OUString& rSymbol )
{
    msSymbol = rSymbol;
}
 
bool XclExpName::IsVolatile() const
{
    return mxTokArr && mxTokArr->IsVolatile();
}
 
bool XclExpName::IsMacroCall( bool bVBasic, bool bFunc ) const
{
    return
        (::get_flag( mnFlags, EXC_NAME_VB ) == bVBasic) &&
        (::get_flag( mnFlags, EXC_NAME_FUNC ) == bFunc);
}
 
void XclExpName::Save( XclExpStream& rStrm )
{
    OSL_ENSURE( mxName && (mxName->Len() > 0), "XclExpName::Save - missing name" );
    OSL_ENSURE( !(IsGlobal() && ::get_flag( mnFlags, EXC_NAME_BUILTIN )), "XclExpName::Save - global built-in name" );
    SetRecSize( 11 + mxName->GetSize() + (mxTokArr ? mxTokArr->GetSize() : 2) );
    XclExpRecord::Save( rStrm );
}
 
OUString XclExpName::GetWithDefaultRangeSeparator( const OUString& rSymbol ) const
{
    sal_Int32 nPos = rSymbol.indexOf(';');
    if ( nPos > -1 )
    {
        // convert with validation
        ScRange aRange;
        ScAddress::Details detailsXL( ::formula::FormulaGrammar::CONV_XL_A1 );
        ScRefFlags nRes = aRange.Parse( rSymbol.copy(0, nPos), GetDoc(), detailsXL );
        if ( nRes & ScRefFlags::VALID )
        {
            nRes = aRange.Parse( rSymbol.copy(nPos+1), GetDoc(), detailsXL );
            if ( nRes & ScRefFlags::VALID )
            {
                return rSymbol.replaceFirst(";", ",");
            }
        }
    }
    return rSymbol;
}
 
void XclExpName::SaveXml( XclExpXmlStream& rStrm )
{
    // tdf#100034: Don't save print range if the built-in index is unknown
    // and sheet index is valid (this is a deleted range)
    if (mcBuiltIn == EXC_BUILTIN_UNKNOWN && mnScTab != SCTAB_GLOBAL)
        return;
 
    sax_fastparser::FSHelperPtr& rWorkbook = rStrm.GetCurrentStream();
    rWorkbook->startElement( XML_definedName,
            // OOXTODO: XML_comment, "",
            // OOXTODO: XML_customMenu, "",
            // OOXTODO: XML_description, "",
            XML_function, ToPsz( ::get_flag( mnFlags, EXC_NAME_VB ) ),
            // OOXTODO: XML_functionGroupId, "",
            // OOXTODO: XML_help, "",
            XML_hidden, ToPsz( ::get_flag( mnFlags, EXC_NAME_HIDDEN ) ),
            XML_localSheetId, sax_fastparser::UseIf(OString::number( mnScTab ), mnScTab != SCTAB_GLOBAL),
            XML_name, maOrigName.toUtf8(),
            // OOXTODO: XML_publishToServer, "",
            // OOXTODO: XML_shortcutKey, "",
            // OOXTODO: XML_statusBar, "",
            XML_vbProcedure, ToPsz( ::get_flag( mnFlags, EXC_NAME_VB ) )
            // OOXTODO: XML_workbookParameter, "",
            // OOXTODO: XML_xlm, ""
    );
    rWorkbook->writeEscaped( GetWithDefaultRangeSeparator( msSymbol ) );
    rWorkbook->endElement( XML_definedName );
}
 
void XclExpName::WriteBody( XclExpStream& rStrm )
{
    sal_uInt16 nFmlaSize = mxTokArr ? mxTokArr->GetSize() : 0;
 
    rStrm   << mnFlags                  // flags
            << sal_uInt8( 0 );          // keyboard shortcut
    mxName->WriteLenField( rStrm );     // length of name
    rStrm   << nFmlaSize                // size of token array
            << mnExtSheet               // BIFF5/7: EXTSHEET index, BIFF8: not used
            << mnXclTab                 // 1-based sheet index for local names
            << sal_uInt32( 0 );         // length of menu/descr/help/status text
    mxName->WriteFlagField( rStrm );    // BIFF8 flag field (no-op in <=BIFF7)
    mxName->WriteBuffer( rStrm );       // character array of the name
    if( mxTokArr )
        mxTokArr->WriteArray( rStrm );  // token array without size
}
 
static bool lcl_EnsureAbs3DToken( const SCTAB nTab, formula::FormulaToken* pTok, const bool bFix = true )
{
    bool bFixRequired = false;
    if ( !pTok || ( pTok->GetType() != formula::svSingleRef && pTok->GetType() != formula::svDoubleRef ) )
        return bFixRequired;
 
    ScSingleRefData* pRef1 = pTok->GetSingleRef();
    if ( !pRef1 )
        return bFixRequired;
 
    ScSingleRefData* pRef2 = nullptr;
    if ( pTok->GetType() == formula::svDoubleRef )
        pRef2 = pTok->GetSingleRef2();
 
    if ( pRef1->IsTabRel() || !pRef1->IsFlag3D() )
    {
        bFixRequired = true;
        if ( bFix )
        {
            if ( pRef1->IsTabRel() && nTab != SCTAB_GLOBAL )
                pRef1->SetAbsTab( nTab + pRef1->Tab() );  //XLS requirement
            if ( !pRef1->IsTabRel() )
            {
                pRef1->SetFlag3D( true );  //XLSX requirement
                if ( pRef2 && !pRef2->IsTabRel() )
                    pRef2->SetFlag3D( pRef2->Tab() != pRef1->Tab() );
            }
        }
    }
 
    if ( pRef2 && pRef2->IsTabRel() && !pRef1->IsTabRel() )
    {
        bFixRequired = true;
        if ( bFix && nTab != SCTAB_GLOBAL )
        {
            pRef2->SetAbsTab( nTab + pRef2->Tab() );
            pRef2->SetFlag3D( pRef2->Tab() != pRef1->Tab() );
        }
    }
    return bFixRequired;
}
 
XclExpNameManagerImpl::XclExpNameManagerImpl( const XclExpRoot& rRoot ) :
    XclExpRoot( rRoot ),
    mnFirstUserIdx( 0 )
{
}
 
void XclExpNameManagerImpl::Initialize()
{
    CreateBuiltInNames();
    mnFirstUserIdx = maNameList.GetSize();
    CreateUserNames();
}
 
sal_uInt16 XclExpNameManagerImpl::InsertName( SCTAB nTab, sal_uInt16 nScNameIdx, SCTAB nCurrTab )
{
    sal_uInt16 nNameIdx = 0;
    const ScRangeData* pData = nullptr;
    ScRangeName* pRN = (nTab == SCTAB_GLOBAL) ? GetDoc().GetRangeName() : GetDoc().GetRangeName(nTab);
    if (pRN)
        pData = pRN->findByIndex(nScNameIdx);
 
    if (pData)
    {
        bool bEmulateGlobalRelativeTable = false;
        const ScTokenArray* pCode = pData->GetCode();
        if ( pCode
            && nTab == SCTAB_GLOBAL
            && (pData->HasType( ScRangeData::Type::AbsPos ) || pData->HasType( ScRangeData::Type::AbsArea )) )
        {
            bEmulateGlobalRelativeTable = lcl_EnsureAbs3DToken( nTab, pCode->FirstToken(), /*bFix=*/false );
        }
        nNameIdx = FindNamedExp( bEmulateGlobalRelativeTable ? nCurrTab : nTab, pData->GetName() );
        if (!nNameIdx)
            nNameIdx = CreateName(nTab, *pData);
    }
 
    return nNameIdx;
}
 
sal_uInt16 XclExpNameManagerImpl::InsertBuiltInName( sal_Unicode cBuiltIn, const XclTokenArrayRef& xTokArr, const ScRange& aRange )
{
    XclExpNameRef xName = new XclExpName( GetRoot(), cBuiltIn );
    xName->SetTokenArray( xTokArr );
    xName->SetLocalTab( aRange.aStart.Tab() );
    OUString sSymbol(aRange.Format(GetDoc(), ScRefFlags::RANGE_ABS_3D, ScAddress::Details( ::formula::FormulaGrammar::CONV_XL_A1)));
    xName->SetSymbol( sSymbol );
    return Append( xName );
}
 
sal_uInt16 XclExpNameManagerImpl::InsertBuiltInName( sal_Unicode cBuiltIn, const XclTokenArrayRef& xTokArr, SCTAB nScTab, const ScRangeList& rRangeList )
{
    XclExpNameRef xName = new XclExpName( GetRoot(), cBuiltIn );
    xName->SetTokenArray( xTokArr );
    xName->SetLocalTab( nScTab );
    OUString sSymbol;
    rRangeList.Format( sSymbol, ScRefFlags::RANGE_ABS_3D, GetDoc(), ::formula::FormulaGrammar::CONV_XL_A1 );
    xName->SetSymbol( sSymbol );
    return Append( xName );
}
 
sal_uInt16 XclExpNameManagerImpl::InsertUniqueName(
        const OUString& rName, const XclTokenArrayRef& xTokArr, SCTAB nScTab )
{
    OSL_ENSURE( !rName.isEmpty(), "XclExpNameManagerImpl::InsertUniqueName - empty name" );
    XclExpNameRef xName = new XclExpName( GetRoot(), GetUnusedName( rName ) );
    xName->SetTokenArray( xTokArr );
    xName->SetLocalTab( nScTab );
    return Append( xName );
}
 
sal_uInt16 XclExpNameManagerImpl::InsertRawName( const OUString& rName )
{
    // empty name? may occur in broken external Calc tokens
    if( rName.isEmpty() )
        return 0;
 
    // try to find an existing NAME record, regardless of its type
    for( size_t nListIdx = mnFirstUserIdx, nListSize = maNameList.GetSize(); nListIdx < nListSize; ++nListIdx )
    {
        XclExpNameRef xName = maNameList.GetRecord( nListIdx );
        if( xName->IsGlobal() && (xName->GetOrigName() == rName) )
            return static_cast< sal_uInt16 >( nListIdx + 1 );
    }
 
    // create a new NAME record
    XclExpNameRef xName = new XclExpName( GetRoot(), rName );
    return Append( xName );
}
 
sal_uInt16 XclExpNameManagerImpl::InsertMacroCall( const OUString& rMacroName, bool bVBasic, bool bFunc, bool bHidden )
{
    // empty name? may occur in broken external Calc tokens
    if( rMacroName.isEmpty() )
        return 0;
 
    // try to find an existing NAME record
    for( size_t nListIdx = mnFirstUserIdx, nListSize = maNameList.GetSize(); nListIdx < nListSize; ++nListIdx )
    {
        XclExpNameRef xName = maNameList.GetRecord( nListIdx );
        if( xName->IsMacroCall( bVBasic, bFunc ) && (xName->GetOrigName() == rMacroName) )
            return static_cast< sal_uInt16 >( nListIdx + 1 );
    }
 
    // create a new NAME record
    XclExpNameRef xName = new XclExpName( GetRoot(), rMacroName );
    xName->SetMacroCall( bVBasic, bFunc );
    xName->SetHidden( bHidden );
 
    // for sheet macros, add a #NAME! error
    if( !bVBasic )
        xName->SetTokenArray( GetFormulaCompiler().CreateErrorFormula( EXC_ERR_NAME ) );
 
    return Append( xName );
}
 
const XclExpName* XclExpNameManagerImpl::GetName( sal_uInt16 nNameIdx ) const
{
    OSL_ENSURE( maNameList.HasRecord( nNameIdx - 1 ), "XclExpNameManagerImpl::GetName - wrong record index" );
    return maNameList.GetRecord( nNameIdx - 1 );
}
 
void XclExpNameManagerImpl::Save( XclExpStream& rStrm )
{
    maNameList.Save( rStrm );
}
 
void XclExpNameManagerImpl::SaveXml( XclExpXmlStream& rStrm )
{
    if( maNameList.IsEmpty() )
        return;
    sax_fastparser::FSHelperPtr& rWorkbook = rStrm.GetCurrentStream();
    rWorkbook->startElement(XML_definedNames);
    maNameList.SaveXml( rStrm );
    rWorkbook->endElement( XML_definedNames );
}
 
// private --------------------------------------------------------------------
 
sal_uInt16 XclExpNameManagerImpl::FindNamedExp( SCTAB nTab, OUString sName )
{
    NamedExpMap::key_type key(nTab, sName);
    NamedExpMap::const_iterator itr = maNamedExpMap.find(key);
    return (itr == maNamedExpMap.end()) ? 0 : itr->second;
}
 
sal_uInt16 XclExpNameManagerImpl::FindBuiltInNameIdx(
        const OUString& rName, const OUString& sSymbol ) const
{
    /*  Get built-in index from the name. Special case: the database range
        'unnamed' will be mapped to Excel's built-in '_FilterDatabase' name. */
    sal_Unicode cBuiltIn = XclTools::GetBuiltInDefNameIndex( rName );
 
    if( cBuiltIn < EXC_BUILTIN_UNKNOWN )
    {
        // try to find the record in existing built-in NAME record list
        for( size_t nPos = 0; nPos < mnFirstUserIdx; ++nPos )
        {
            XclExpNameRef xName = maNameList.GetRecord( nPos );
            if( xName->GetBuiltInName() == cBuiltIn && xName->GetSymbol().replace(';', ',') == sSymbol.replace(';', ',') )
            {
                // tdf#112567 restore the original built-in names with non-localized separators
                // TODO: support more localizations, if needed
                if ( xName->GetSymbol() != sSymbol )
                {
                    xName->SetSymbol(xName->GetSymbol().replace(';', ','));
                }
                return static_cast< sal_uInt16 >( nPos + 1 );
            }
        }
    }
    return 0;
}
 
OUString XclExpNameManagerImpl::GetUnusedName( const OUString& rName ) const
{
    OUString aNewName( rName );
    sal_Int32 nAppIdx = 0;
    bool bExist = true;
    while( bExist )
    {
        // search the list of user-defined names
        bExist = false;
        for( size_t nPos = mnFirstUserIdx, nSize = maNameList.GetSize(); !bExist && (nPos < nSize); ++nPos )
        {
            XclExpNameRef xName = maNameList.GetRecord( nPos );
            bExist = xName->GetOrigName() == aNewName;
            // name exists -> create a new name "<originalname>_<counter>"
            if( bExist )
                aNewName = rName + "_" + OUString::number( ++nAppIdx );
        }
    }
    return aNewName;
}
 
sal_uInt16 XclExpNameManagerImpl::Append( XclExpName* pName )
{
    if( maNameList.GetSize() == 0xFFFF )
        return 0;
    maNameList.AppendRecord( pName );
    return static_cast< sal_uInt16 >( maNameList.GetSize() );  // 1-based
}
 
sal_uInt16 XclExpNameManagerImpl::CreateName( SCTAB nTab, const ScRangeData& rRangeData )
{
    const OUString& rName = rRangeData.GetName();
 
    /*  #i38821# recursive names: first insert the (empty) name object,
        otherwise a recursive call of this function from the formula compiler
        with the same defined name will not find it and will create it again. */
    size_t nOldListSize = maNameList.GetSize();
    XclExpNameRef xName = new XclExpName( GetRoot(), rName );
    if (nTab != SCTAB_GLOBAL)
        xName->SetLocalTab(nTab);
    sal_uInt16 nNameIdx = Append( xName );
    // store the index of the NAME record in the lookup map
    NamedExpMap::key_type key(nTab, rRangeData.GetName());
    maNamedExpMap[key] = nNameIdx;
 
    /*  Create the definition formula.
        This may cause recursive creation of other defined names. */
    if( const ScTokenArray* pScTokArr = const_cast< ScRangeData& >( rRangeData ).GetCode() )
    {
        XclTokenArrayRef xTokArr;
        OUString sSymbol;
        // MSO requires named ranges to have absolute sheet references
        if ( rRangeData.HasType( ScRangeData::Type::AbsPos ) || rRangeData.HasType( ScRangeData::Type::AbsArea ) )
        {
            // Don't modify the actual document; use a temporary copy to create the export formulas.
            ScTokenArray aTokenCopy( pScTokArr->CloneValue() );
            lcl_EnsureAbs3DToken(nTab, aTokenCopy.FirstToken());
 
            xTokArr = GetFormulaCompiler().CreateFormula(EXC_FMLATYPE_NAME, aTokenCopy);
            if ( GetOutput() != EXC_OUTPUT_BINARY )
            {
                ScCompiler aComp(GetDoc(), rRangeData.GetPos(), aTokenCopy,
                                 formula::FormulaGrammar::GRAM_OOXML);
                aComp.CreateStringFromTokenArray( sSymbol );
            }
        }
        else
        {
            bool bOOXML = GetOutput() == EXC_OUTPUT_XML_2007;
            xTokArr = GetFormulaCompiler().CreateFormula( EXC_FMLATYPE_NAME, *pScTokArr, bOOXML ?
                     &rRangeData.GetPos() : nullptr );
            sSymbol = rRangeData.GetSymbol( (GetOutput() == EXC_OUTPUT_BINARY) ?
                     formula::FormulaGrammar::GRAM_ENGLISH_XL_A1 : formula::FormulaGrammar::GRAM_OOXML);
        }
        xName->SetTokenArray( xTokArr );
        xName->SetSymbol( sSymbol );
 
        /*  Try to replace by existing built-in name - complete token array is
            needed for comparison, and due to the recursion problem above this
            cannot be done earlier. If a built-in name is found, the created NAME
            record for this name and all following records in the list must be
            deleted, otherwise they may contain wrong name list indexes. */
        sal_uInt16 nBuiltInIdx = FindBuiltInNameIdx( rName, sSymbol );
        if( nBuiltInIdx != 0 )
        {
            // delete the new NAME records
            while( maNameList.GetSize() > nOldListSize )
                maNameList.RemoveRecord( maNameList.GetSize() - 1 );
            // use index of the found built-in NAME record
            key = NamedExpMap::key_type(nTab, rRangeData.GetName());
            maNamedExpMap[key] = nNameIdx = nBuiltInIdx;
        }
    }
 
    return nNameIdx;
}
 
void XclExpNameManagerImpl::CreateBuiltInNames()
{
    ScDocument& rDoc = GetDoc();
    XclExpTabInfo& rTabInfo = GetTabInfo();
 
    /*  #i2394# built-in defined names must be sorted by the name of the
        containing sheet. Example: SheetA!Print_Range must be stored *before*
        SheetB!Print_Range, regardless of the position of SheetA in the document! */
    for( SCTAB nScTabIdx = 0, nScTabCount = rTabInfo.GetScTabCount(); nScTabIdx < nScTabCount; ++nScTabIdx )
    {
        // find real sheet index from the nScTabIdx counter
        SCTAB nScTab = rTabInfo.GetRealScTab( nScTabIdx );
        // create NAME records for all built-in names of this sheet
        if( rTabInfo.IsExportTab( nScTab ) )
        {
            // *** 1) print ranges *** ----------------------------------------
 
            if( rDoc.HasPrintRange() )
            {
                ScRangeList aRangeList;
                for( sal_uInt16 nIdx = 0, nCount = rDoc.GetPrintRangeCount( nScTab ); nIdx < nCount; ++nIdx )
                {
                    const ScRange* pPrintRange = rDoc.GetPrintRange( nScTab, nIdx );
                    if (!pPrintRange)
                        continue;
                    ScRange aRange( *pPrintRange );
                    // Calc document does not care about sheet index in print ranges
                    aRange.aStart.SetTab( nScTab );
                    aRange.aEnd.SetTab( nScTab );
                    aRange.PutInOrder();
                    aRangeList.push_back( aRange );
                }
                // create the NAME record (do not warn if ranges are shrunken)
                GetAddressConverter().ValidateRangeList( aRangeList, false );
                if( !aRangeList.empty() )
                    GetNameManager().InsertBuiltInName( EXC_BUILTIN_PRINTAREA, aRangeList );
            }
 
            // *** 2) print titles *** ----------------------------------------
 
            ScRangeList aTitleList;
            // repeated columns
            if( std::optional<ScRange> oColRange = rDoc.GetRepeatColRange( nScTab ) )
                aTitleList.push_back( ScRange(
                    oColRange->aStart.Col(), 0, nScTab,
                    oColRange->aEnd.Col(), GetXclMaxPos().Row(), nScTab ) );
            // repeated rows
            if( std::optional<ScRange> oRowRange = rDoc.GetRepeatRowRange( nScTab ) )
                aTitleList.push_back( ScRange(
                    0, oRowRange->aStart.Row(), nScTab,
                    GetXclMaxPos().Col(), oRowRange->aEnd.Row(), nScTab ) );
            // create the NAME record
            GetAddressConverter().ValidateRangeList( aTitleList, false );
            if( !aTitleList.empty() )
                GetNameManager().InsertBuiltInName( EXC_BUILTIN_PRINTTITLES, aTitleList );
 
            // *** 3) filter ranges *** ---------------------------------------
 
            if( GetBiff() == EXC_BIFF8 )
                GetFilterManager().InitTabFilter( nScTab );
        }
    }
}
 
void XclExpNameManagerImpl::CreateUserNames()
{
    std::vector<ScRangeData*> vEmulateAsLocalRange;
    const ScRangeName& rNamedRanges = GetNamedRanges();
    for (const auto& rEntry : rNamedRanges)
    {
        // skip definitions of shared formulas
        if (!FindNamedExp(SCTAB_GLOBAL, rEntry.second->GetName()))
        {
            const ScTokenArray* pCode = rEntry.second->GetCode();
            if ( pCode
                && (rEntry.second->HasType( ScRangeData::Type::AbsPos ) || rEntry.second->HasType( ScRangeData::Type::AbsArea ))
                && lcl_EnsureAbs3DToken( SCTAB_GLOBAL, pCode->FirstToken(), /*bFix=*/false ) )
            {
                vEmulateAsLocalRange.emplace_back(rEntry.second.get());
            }
            else
                CreateName(SCTAB_GLOBAL, *rEntry.second);
        }
    }
    //look at sheets containing local range names
    ScRangeName::TabNameCopyMap rLocalNames;
    GetDoc().GetAllTabRangeNames(rLocalNames);
    for (const auto& [rTab, pRangeName] : rLocalNames)
    {
        for (const auto& rEntry : *pRangeName)
        {
            // skip definitions of shared formulas
            if (!FindNamedExp(rTab, rEntry.second->GetName()))
                CreateName(rTab, *rEntry.second);
        }
    }
 
    // Emulate relative global variables by creating a copy in each local range.
    // Creating AFTER true local range names so that conflicting global names will be ignored.
    for ( SCTAB nTab = 0; nTab < GetDoc().GetTableCount(); ++nTab )
    {
        for ( auto rangeDataItr : vEmulateAsLocalRange )
        {
            if ( !FindNamedExp(nTab, rangeDataItr->GetName()) )
                CreateName(nTab, *rangeDataItr );
        }
    }
}
 
XclExpNameManager::XclExpNameManager( const XclExpRoot& rRoot ) :
    XclExpRoot( rRoot ),
    mxImpl( std::make_shared<XclExpNameManagerImpl>( rRoot ) )
{
}
 
XclExpNameManager::~XclExpNameManager()
{
}
 
void XclExpNameManager::Initialize()
{
    mxImpl->Initialize();
}
 
sal_uInt16 XclExpNameManager::InsertName( SCTAB nTab, sal_uInt16 nScNameIdx, SCTAB nCurrTab )
{
    return mxImpl->InsertName( nTab, nScNameIdx, nCurrTab );
}
 
sal_uInt16 XclExpNameManager::InsertBuiltInName( sal_Unicode cBuiltIn, const ScRange& rRange )
{
    XclTokenArrayRef xTokArr = GetFormulaCompiler().CreateFormula( EXC_FMLATYPE_NAME, rRange );
    return mxImpl->InsertBuiltInName( cBuiltIn, xTokArr, rRange );
}
 
sal_uInt16 XclExpNameManager::InsertBuiltInName( sal_Unicode cBuiltIn, const ScRangeList& rRangeList )
{
    sal_uInt16 nNameIdx = 0;
    if( !rRangeList.empty() )
    {
        XclTokenArrayRef xTokArr = GetFormulaCompiler().CreateFormula( EXC_FMLATYPE_NAME, rRangeList );
        nNameIdx = mxImpl->InsertBuiltInName( cBuiltIn, xTokArr, rRangeList.front().aStart.Tab(), rRangeList );
    }
    return nNameIdx;
}
 
sal_uInt16 XclExpNameManager::InsertUniqueName(
        const OUString& rName, const XclTokenArrayRef& xTokArr, SCTAB nScTab )
{
    return mxImpl->InsertUniqueName( rName, xTokArr, nScTab );
}
 
sal_uInt16 XclExpNameManager::InsertRawName( const OUString& rName )
{
    return mxImpl->InsertRawName( rName );
}
 
sal_uInt16 XclExpNameManager::InsertMacroCall( const OUString& rMacroName, bool bVBasic, bool bFunc, bool bHidden )
{
    return mxImpl->InsertMacroCall( rMacroName, bVBasic, bFunc, bHidden );
}
 
OUString XclExpNameManager::GetOrigName( sal_uInt16 nNameIdx ) const
{
    const XclExpName* pName = mxImpl->GetName( nNameIdx );
    return pName ? pName->GetOrigName() : OUString();
}
 
SCTAB XclExpNameManager::GetScTab( sal_uInt16 nNameIdx ) const
{
    const XclExpName* pName = mxImpl->GetName( nNameIdx );
    return pName ? pName->GetScTab() : SCTAB_GLOBAL;
}
 
bool XclExpNameManager::IsVolatile( sal_uInt16 nNameIdx ) const
{
    const XclExpName* pName = mxImpl->GetName( nNameIdx );
    return pName && pName->IsVolatile();
}
 
void XclExpNameManager::Save( XclExpStream& rStrm )
{
    mxImpl->Save( rStrm );
}
 
void XclExpNameManager::SaveXml( XclExpXmlStream& rStrm )
{
    mxImpl->SaveXml( rStrm );
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */