Map shared formula from xls to formula groups, and share the tokens as well.

No more mapping to range names.

Change-Id: Ic43b6ef35a91fe4d6fff748ebc22969ba4e036db

16 files changed, 159 insertions, 118 deletions

diff --git a/sc/inc/column.hxx b/sc/inc/column.hxx
index 045b76a844a3..22bb9bdfa2d0 100644
--- a/sc/inc/column.hxx
+++ b/sc/inc/column.hxx
@@ -275,6 +275,7 @@ public:
      */
     ScFormulaCell* SetFormulaCell( SCROW nRow, ScFormulaCell* pCell );
     ScFormulaCell* SetFormulaCell( sc::ColumnBlockPosition& rBlockPos, SCROW nRow, ScFormulaCell* pCell );
+    bool SetGroupFormulaCell( SCROW nRow, ScFormulaCell* pCell );
 
     void SetRawString( SCROW nRow, const OUString& rStr, bool bBroadcast = true );
     void SetRawString( sc::ColumnBlockPosition& rBlockPos, SCROW nRow, const OUString& rStr, bool bBroadcast = true );
@@ -507,8 +508,8 @@ private:
 
     sc::CellStoreType::iterator GetPositionToInsert( SCROW nRow );
     sc::CellStoreType::iterator GetPositionToInsert( const sc::CellStoreType::iterator& it, SCROW nRow );
-    void ActivateNewFormulaCell( const sc::CellStoreType::iterator& itPos, SCROW nRow, ScFormulaCell& rCell );
-    void ActivateNewFormulaCell( const sc::CellStoreType::position_type& aPos, ScFormulaCell& rCell );
+    void ActivateNewFormulaCell( const sc::CellStoreType::iterator& itPos, SCROW nRow, ScFormulaCell& rCell, bool bJoin = true );
+    void ActivateNewFormulaCell( const sc::CellStoreType::position_type& aPos, ScFormulaCell& rCell, bool bJoin = true );
     void BroadcastNewCell( SCROW nRow );
     bool UpdateScriptType( sc::CellTextAttr& rAttr, SCROW nRow );
 
diff --git a/sc/inc/document.hxx b/sc/inc/document.hxx
index 90e014848444..8b82fb77aa04 100644
--- a/sc/inc/document.hxx
+++ b/sc/inc/document.hxx
@@ -804,6 +804,7 @@ public:
      *         is deleted automatically on failure to insert.
      */
     SC_DLLPUBLIC ScFormulaCell* SetFormulaCell( const ScAddress& rPos, ScFormulaCell* pCell );
+    SC_DLLPUBLIC bool SetGroupFormulaCell( const ScAddress& rPos, ScFormulaCell* pCell );
 
     SC_DLLPUBLIC void InsertMatrixFormula(SCCOL nCol1, SCROW nRow1,
                                         SCCOL nCol2, SCROW nRow2,
diff --git a/sc/inc/formulacell.hxx b/sc/inc/formulacell.hxx
index 648005692899..f857aff36410 100644
--- a/sc/inc/formulacell.hxx
+++ b/sc/inc/formulacell.hxx
@@ -27,6 +27,7 @@
 #include "types.hxx"
 
 #include <set>
+#include <boost/noncopyable.hpp>
 
 namespace sc {
 
@@ -43,7 +44,7 @@ class ScProgress;
 class ScTokenArray;
 struct ScSimilarFormulaDelta;
 
-struct SC_DLLPUBLIC ScFormulaCellGroup
+struct SC_DLLPUBLIC ScFormulaCellGroup : boost::noncopyable
 {
     mutable size_t mnRefCount;
 
@@ -55,6 +56,8 @@ struct SC_DLLPUBLIC ScFormulaCellGroup
 
     ScFormulaCellGroup();
     ~ScFormulaCellGroup();
+
+    void setCode( const ScTokenArray& rCode );
 };
 
 inline void intrusive_ptr_add_ref(const ScFormulaCellGroup *p)
diff --git a/sc/inc/table.hxx b/sc/inc/table.hxx
index 37c14301034d..a95f2bc3b66c 100644
--- a/sc/inc/table.hxx
+++ b/sc/inc/table.hxx
@@ -340,6 +340,7 @@ public:
      *         is deleted automatically on failure to insert.
      */
     ScFormulaCell* SetFormulaCell( SCCOL nCol, SCROW nRow, ScFormulaCell* pCell );
+    bool SetGroupFormulaCell( SCCOL nCol, SCROW nRow, ScFormulaCell* pCell );
 
     void        SetValue( SCCOL nCol, SCROW nRow, const double& rVal );
     void        SetError( SCCOL nCol, SCROW nRow, sal_uInt16 nError);
diff --git a/sc/inc/tokenarray.hxx b/sc/inc/tokenarray.hxx
index f9a4ff191708..09a9798a214b 100644
--- a/sc/inc/tokenarray.hxx
+++ b/sc/inc/tokenarray.hxx
@@ -62,6 +62,12 @@ public:
 
     ScFormulaVectorState GetVectorState() const;
 
+    /**
+     * If the array contains at least one relative row reference or named
+     * expression, it's variant. Otherwise invariant.
+     */
+    bool IsInvariant() const;
+
     /// Exactly and only one range (valid or deleted)
     bool IsReference( ScRange& rRange, const ScAddress& rPos ) const;
     /// Exactly and only one valid range (no #REF!s)
diff --git a/sc/qa/unit/data/xls/shared-formula.xls b/sc/qa/unit/data/xls/shared-formula.xls
index a9be6b7f1ec6..f27acb4cc649 100644
--- a/sc/qa/unit/data/xls/shared-formula.xls
+++ b/sc/qa/unit/data/xls/shared-formula.xls
diff --git a/sc/qa/unit/filters-test.cxx b/sc/qa/unit/filters-test.cxx
index 1d7eecafb217..957e0e005894 100644
--- a/sc/qa/unit/filters-test.cxx
+++ b/sc/qa/unit/filters-test.cxx
@@ -32,6 +32,8 @@
 #include "cellform.hxx"
 #include "drwlayer.hxx"
 #include "userdat.hxx"
+#include "formulacell.hxx"
+
 #include <svx/svdpage.hxx>
 
 using namespace ::com::sun::star;
@@ -344,6 +346,13 @@ void ScFiltersTest::testSharedFormulaXLS()
         double fCheck = i*10.0;
         CPPUNIT_ASSERT_EQUAL(fCheck, fVal);
     }
+
+    ScFormulaCell* pCell = pDoc->GetFormulaCell(ScAddress(1,18,0));
+    CPPUNIT_ASSERT_MESSAGE("This should be a formula cell.", pCell);
+    ScFormulaCellGroupRef xGroup = pCell->GetCellGroup();
+    CPPUNIT_ASSERT_MESSAGE("This cell should be a part of a cell group.", xGroup);
+    CPPUNIT_ASSERT_MESSAGE("Incorrect group geometry.", xGroup->mnStart == 2 && xGroup->mnLength == 17);
+
     xDocSh->DoClose();
 }
 
diff --git a/sc/source/core/data/column3.cxx b/sc/source/core/data/column3.cxx
index 4474aecebd39..461193c77267 100644
--- a/sc/source/core/data/column3.cxx
+++ b/sc/source/core/data/column3.cxx
@@ -381,16 +381,17 @@ sc::CellStoreType::iterator ScColumn::GetPositionToInsert( const sc::CellStoreTy
 }
 
 void ScColumn::ActivateNewFormulaCell(
-    const sc::CellStoreType::iterator& itPos, SCROW nRow, ScFormulaCell& rCell )
+    const sc::CellStoreType::iterator& itPos, SCROW nRow, ScFormulaCell& rCell, bool bJoin )
 {
-    ActivateNewFormulaCell(maCells.position(itPos, nRow), rCell);
+    ActivateNewFormulaCell(maCells.position(itPos, nRow), rCell, bJoin);
 }
 
 void ScColumn::ActivateNewFormulaCell(
-    const sc::CellStoreType::position_type& aPos, ScFormulaCell& rCell )
+    const sc::CellStoreType::position_type& aPos, ScFormulaCell& rCell, bool bJoin )
 {
-    // See if this new formula cell can join an existing shared formula group.
-    JoinNewFormulaCell(aPos, rCell);
+    if (bJoin)
+        // See if this new formula cell can join an existing shared formula group.
+        JoinNewFormulaCell(aPos, rCell);
 
     // When we insert from the Clipboard we still have wrong (old) References!
     // First they are rewired in CopyBlockFromClip via UpdateReference and the
@@ -1729,6 +1730,20 @@ ScFormulaCell* ScColumn::SetFormulaCell( sc::ColumnBlockPosition& rBlockPos, SCR
     return pCell;
 }
 
+bool ScColumn::SetGroupFormulaCell( SCROW nRow, ScFormulaCell* pCell )
+{
+    sc::CellStoreType::iterator it = GetPositionToInsert(nRow);
+    sal_uInt32 nCellFormat = GetNumberFormat(nRow);
+    if( (nCellFormat % SV_COUNTRY_LANGUAGE_OFFSET) == 0)
+        pCell->SetNeedNumberFormat(true);
+    it = maCells.set(it, nRow, pCell);
+    maCellTextAttrs.set(nRow, sc::CellTextAttr());
+    CellStorageModified();
+
+    ActivateNewFormulaCell(it, nRow, *pCell, false);
+    return true;
+}
+
 namespace {
 
 class FilterEntriesHandler
diff --git a/sc/source/core/data/documen2.cxx b/sc/source/core/data/documen2.cxx
index 7a9e9d6106ae..720b504b6e61 100644
--- a/sc/source/core/data/documen2.cxx
+++ b/sc/source/core/data/documen2.cxx
@@ -1075,6 +1075,14 @@ ScFormulaCell* ScDocument::SetFormulaCell( const ScAddress& rPos, ScFormulaCell*
     return maTabs[rPos.Tab()]->SetFormulaCell(rPos.Col(), rPos.Row(), pCell);
 }
 
+bool ScDocument::SetGroupFormulaCell( const ScAddress& rPos, ScFormulaCell* pCell )
+{
+    if (!TableExists(rPos.Tab()))
+        return false;
+
+    return maTabs[rPos.Tab()]->SetGroupFormulaCell(rPos.Col(), rPos.Row(), pCell);
+}
+
 void ScDocument::SetConsolidateDlgData( const ScConsolidateParam* pData )
 {
     delete pConsolidateDlgData;
diff --git a/sc/source/core/data/formulacell.cxx b/sc/source/core/data/formulacell.cxx
index cdedb660bc9f..b9db55ab74ee 100644
--- a/sc/source/core/data/formulacell.cxx
+++ b/sc/source/core/data/formulacell.cxx
@@ -397,6 +397,14 @@ ScFormulaCellGroup::~ScFormulaCellGroup()
     delete mpCode;
 }
 
+void ScFormulaCellGroup::setCode( const ScTokenArray& rCode )
+{
+    delete mpCode;
+    mpCode = rCode.Clone();
+    mbInvariant = mpCode->IsInvariant();
+    mpCode->GenHash();
+}
+
 // ============================================================================
 
 ScFormulaCell::ScFormulaCell( ScDocument* pDoc, const ScAddress& rPos,
@@ -522,8 +530,6 @@ ScFormulaCell::ScFormulaCell(
 
     if (bSubTotal)
         pDocument->AddSubTotalCell(this);
-
-    pCode->GenHash();
 }
 
 ScFormulaCell::ScFormulaCell( const ScFormulaCell& rCell, ScDocument& rDoc, const ScAddress& rPos, int nCloneFlags ) :
@@ -3358,7 +3364,7 @@ bool ScFormulaCell::InterpretFormulaGroup()
 
     // Re-build formulae groups if necessary - ideally this is done at
     // import / insert / delete etc. and is integral to the data structures
-    pDocument->RebuildFormulaGroups();
+//  pDocument->RebuildFormulaGroups();
 
     if (!mxGroup || !pCode)
         return false;
diff --git a/sc/source/core/data/table2.cxx b/sc/source/core/data/table2.cxx
index 278096ebf259..537f85654082 100644
--- a/sc/source/core/data/table2.cxx
+++ b/sc/source/core/data/table2.cxx
@@ -1453,6 +1453,14 @@ ScFormulaCell* ScTable::SetFormulaCell( SCCOL nCol, SCROW nRow, ScFormulaCell* p
     return aCol[nCol].SetFormulaCell(nRow, pCell);
 }
 
+bool ScTable::SetGroupFormulaCell( SCCOL nCol, SCROW nRow, ScFormulaCell* pCell )
+{
+    if (!ValidColRow(nCol, nRow))
+        return false;
+
+    return aCol[nCol].SetGroupFormulaCell(nRow, pCell);
+}
+
 void ScTable::SetValue( SCCOL nCol, SCROW nRow, const double& rVal )
 {
     if (ValidColRow(nCol, nRow))
diff --git a/sc/source/core/tool/token.cxx b/sc/source/core/tool/token.cxx
index 4703cde90d42..d74182d9a065 100644
--- a/sc/source/core/tool/token.cxx
+++ b/sc/source/core/tool/token.cxx
@@ -1474,6 +1474,42 @@ ScFormulaVectorState ScTokenArray::GetVectorState() const
     return meVectorState;
 }
 
+bool ScTokenArray::IsInvariant() const
+{
+    FormulaToken** p = pCode;
+    FormulaToken** pEnd = p + static_cast<size_t>(nLen);
+    for (; p != pEnd; ++p)
+    {
+        switch ((*p)->GetType())
+        {
+            case svSingleRef:
+            case svExternalSingleRef:
+            {
+                const ScToken* pT = static_cast<const ScToken*>(*p);
+                const ScSingleRefData& rRef = pT->GetSingleRef();
+                if (rRef.IsRowRel())
+                    return false;
+            }
+            break;
+            case svDoubleRef:
+            case svExternalDoubleRef:
+            {
+                const ScToken* pT = static_cast<const ScToken*>(*p);
+                const ScComplexRefData& rRef = pT->GetDoubleRef();
+                if (rRef.Ref1.IsRowRel() || rRef.Ref2.IsRowRel())
+                    return false;
+            }
+            break;
+            case svIndex:
+                return false;
+            default:
+                ;
+        }
+    }
+
+    return true;
+}
+
 bool ScTokenArray::IsReference( ScRange& rRange, const ScAddress& rPos ) const
 {
     return ImplGetReference(rRange, rPos, false);
diff --git a/sc/source/filter/excel/excform.cxx b/sc/source/filter/excel/excform.cxx
index 4f60d7ec56bb..e236dad91077 100644
--- a/sc/source/filter/excel/excform.cxx
+++ b/sc/source/filter/excel/excform.cxx
@@ -101,7 +101,6 @@ void ImportExcel::Formula4()
 void ImportExcel::Formula(
     const XclAddress& rXclPos, sal_uInt16 nXF, sal_uInt16 nFormLen, double fCurVal, bool bShrFmla)
 {
-
     ScAddress aScPos( ScAddress::UNINITIALIZED );
     if (!GetAddressConverter().ConvertAddress(aScPos, rXclPos, GetCurrScTab(), true))
         // Conversion failed.
@@ -115,13 +114,18 @@ void ImportExcel::Formula(
     if (bShrFmla)
     {
         // This is a shared formula. Get the token array from the shared formula pool.
-        pResult = pFormConv->GetShrFmla(maStrm, nFormLen);
-        if (!pResult)
+        ScFormulaCellGroupRef xGroup = pFormConv->GetSharedFormula(maStrm, aScPos.Col(), nFormLen);
+        if (!xGroup)
             return;
 
-        ScFormulaCell* pCell = new ScFormulaCell( pD, aScPos, pResult );
+        ScFormulaCell* pCell = new ScFormulaCell(pD, aScPos, xGroup);
         pD->EnsureTable(aScPos.Tab());
-        pCell = pD->SetFormulaCell(aScPos, pCell);
+        bool bInserted = pD->SetGroupFormulaCell(aScPos, pCell);
+        if (!bInserted)
+        {
+            delete pCell;
+            return;
+        }
         pCell->SetNeedNumberFormat(false);
         if (!rtl::math::isNan(fCurVal))
             pCell->SetResultDouble(fCurVal);
@@ -1673,38 +1677,33 @@ const ScTokenArray* ExcelToSc::GetBoolErr( XclBoolError eType )
     return pErgebnis;
 }
 
-
-// if a shared formula was found, stream seeks to first byte after <nFormulaLen>,
-// else stream pointer stays unchanged
-const ScTokenArray* ExcelToSc::GetShrFmla( XclImpStream& aIn, sal_Size nFormulaLen )
+ScFormulaCellGroupRef ExcelToSc::GetSharedFormula( XclImpStream& aIn, SCCOL nCol, sal_Size nFormulaLen )
 {
     if (!nFormulaLen)
-        return NULL;
+        return ScFormulaCellGroupRef();
 
     aIn.PushPosition();
 
     sal_uInt8 nOp;
     aIn >> nOp;
 
-    if (nOp != 0x01)   // Shared Formula       [    277]
+    if (nOp != 0x01)   // must be PtgExp token.
     {
         aIn.PopPosition();
-        return NULL;
+        return ScFormulaCellGroupRef();
     }
 
-    sal_uInt16 nCol, nRow;
-    aIn >> nRow >> nCol;
+    sal_uInt16 nLeftCol, nRow;
+    aIn >> nRow >> nLeftCol;
 
-    aStack << aPool.StoreName( GetOldRoot().pShrfmlaBuff->Find(
-        ScAddress(static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), GetCurrScTab())), true);
+    ScAddress aRefPos(nCol, nRow, GetCurrScTab());
+    ScFormulaCellGroupRef xGroup = GetOldRoot().pShrfmlaBuff->Find(aRefPos);
 
     aIn.PopPosition();
-
     aIn.Ignore(nFormulaLen);
-    return aPool[aStack.Get()];
+    return xGroup;
 }
 
-
 void ExcelToSc::SetError( ScFormulaCell &rCell, const ConvErr eErr )
 {
     sal_uInt16  nInd;
diff --git a/sc/source/filter/excel/namebuff.cxx b/sc/source/filter/excel/namebuff.cxx
index 6279c87758be..ac609a462ace 100644
--- a/sc/source/filter/excel/namebuff.cxx
+++ b/sc/source/filter/excel/namebuff.cxx
@@ -20,9 +20,6 @@
 
 #include "namebuff.hxx"
 
-#include <string.h>
-
-#include "rangenam.hxx"
 #include "document.hxx"
 #include "compiler.hxx"
 #include "scextopt.hxx"
@@ -32,6 +29,7 @@
 #include "xltools.hxx"
 #include "xiroot.hxx"
 
+#include <string.h>
 
 sal_uInt32 StringHashEntry::MakeHashCode( const String& r )
 {
@@ -70,84 +68,41 @@ void NameBuffer::operator <<( const String &rNewString )
     maHashes.push_back( new StringHashEntry( rNewString ) );
 }
 
+SharedFormulaBuffer::SharedFormulaBuffer( RootData* pRD ) : ExcRoot(pRD) {}
 
-#if OSL_DEBUG_LEVEL > 0
-sal_uInt16  nShrCnt;
-#endif
-
-
-size_t SharedFormulaBuffer::ScAddressHashFunc::operator() (const ScAddress &addr) const
-{
-    // Use something simple, it is just a hash.
-    return static_cast< sal_uInt16 >( addr.Row() ) | (static_cast< sal_uInt8 >( addr.Col() ) << 16);
-}
-
-const size_t nBase = 16384; // Range~ und Shared~ Dingens mit jeweils der Haelfte Ids
-SharedFormulaBuffer::SharedFormulaBuffer( RootData* pRD ) :
-    ExcRoot( pRD ),
-    mnCurrIdx (nBase)
-{
-#if OSL_DEBUG_LEVEL > 0
-    nShrCnt = 0;
-#endif
-}
-
-SharedFormulaBuffer::~SharedFormulaBuffer()
-{
-}
+SharedFormulaBuffer::~SharedFormulaBuffer() {}
 
 void SharedFormulaBuffer::Clear()
 {
-    index_hash.clear();
-    // do not clear index_list, index calculation depends on complete list size...
-    // do not change mnCurrIdx
+    maFormulaGroups.clear();
 }
 
-void SharedFormulaBuffer::Store( const ScRange& rRange, const ScTokenArray& rToken )
+void SharedFormulaBuffer::Store( const ScRange& rRange, const ScTokenArray& rArray )
 {
-    String          aName( CreateName( rRange.aStart ) );
-
-    OSL_ENSURE( mnCurrIdx <= 0xFFFF, "*ShrfmlaBuffer::Store(): I'm getting sick...!" );
-
-    ScRangeData* pData = new ScRangeData( pExcRoot->pIR->GetDocPtr(), aName, rToken, rRange.aStart, RT_SHARED );
-    const ScAddress& rMaxPos = pExcRoot->pIR->GetMaxPos();
-    pData->SetMaxCol(rMaxPos.Col());
-    pData->SetMaxRow(rMaxPos.Row());
-    pData->SetIndex( static_cast< sal_uInt16 >( mnCurrIdx ) );
-    pExcRoot->pIR->GetNamedRanges().insert( pData );
-    index_hash[rRange.aStart] = static_cast< sal_uInt16 >( mnCurrIdx );
-    index_list.push_front (rRange);
-    ++mnCurrIdx;
+    SCROW nGroupLen = rRange.aEnd.Row() - rRange.aStart.Row() + 1;
+    for (SCCOL i = rRange.aStart.Col(); i <= rRange.aEnd.Col(); ++i)
+    {
+        // Create one group per column.
+        ScAddress aPos = rRange.aStart;
+        aPos.SetCol(i);
+
+        ScFormulaCellGroupRef xNewGroup(new ScFormulaCellGroup);
+        xNewGroup->mnStart = rRange.aStart.Row();
+        xNewGroup->mnLength = nGroupLen;
+        xNewGroup->mpCode = rArray.Clone();
+        xNewGroup->mbInvariant = rArray.IsInvariant();
+        xNewGroup->setCode(rArray);
+        maFormulaGroups.insert(FormulaGroupsType::value_type(aPos, xNewGroup));
+    }
 }
 
-
-sal_uInt16 SharedFormulaBuffer::Find( const ScAddress & aAddr ) const
+ScFormulaCellGroupRef SharedFormulaBuffer::Find( const ScAddress& rRefPos ) const
 {
-    ShrfmlaHash::const_iterator hash = index_hash.find (aAddr);
-    if (hash != index_hash.end())
-        return hash->second;
-
-    // It was not hashed on the top left corner ?  do a brute force search
-    unsigned int ind = nBase;
-    for (ShrfmlaList::const_iterator ptr = index_list.end(); ptr != index_list.begin() ; ind++)
-        if ((--ptr)->In (aAddr))
-            return static_cast< sal_uInt16 >( ind );
-    return static_cast< sal_uInt16 >( mnCurrIdx );
-}
-
+    FormulaGroupsType::const_iterator it = maFormulaGroups.find(rRefPos);
+    if (it == maFormulaGroups.end())
+        return ScFormulaCellGroupRef();
 
-#define SHRFMLA_BASENAME    "SHARED_FORMULA_"
-
-String SharedFormulaBuffer::CreateName( const ScRange& r )
-{
-    OUString aName = SHRFMLA_BASENAME +
-                     OUString::number( r.aStart.Col() ) + "_" +
-                     OUString::number( r.aStart.Row() ) + "_" +
-                     OUString::number( r.aEnd.Col() )   + "_" +
-                     OUString::number( r.aEnd.Row() )   + "_" +
-                     OUString::number( r.aStart.Tab() );
-
-    return aName;
+    return it->second;
 }
 
 sal_Int16 ExtSheetBuffer::Add( const String& rFPAN, const String& rTN, const sal_Bool bSWB )
diff --git a/sc/source/filter/inc/excform.hxx b/sc/source/filter/inc/excform.hxx
index fb866fe812e8..0e2004c9d9e3 100644
--- a/sc/source/filter/inc/excform.hxx
+++ b/sc/source/filter/inc/excform.hxx
@@ -63,7 +63,7 @@ public:
 
     void                GetDummy( const ScTokenArray*& );
     const ScTokenArray* GetBoolErr( XclBoolError );
-    const ScTokenArray* GetShrFmla( XclImpStream& rStrm, sal_Size nFormulaLen );
+    ScFormulaCellGroupRef GetSharedFormula( XclImpStream& rStrm, SCCOL nCol, sal_Size nFormulaLen );
 
     static void         SetError( ScFormulaCell& rCell, const ConvErr eErr );
 
diff --git a/sc/source/filter/inc/namebuff.hxx b/sc/source/filter/inc/namebuff.hxx
index 6f5aa2827b90..97aebc1ba086 100644
--- a/sc/source/filter/inc/namebuff.hxx
+++ b/sc/source/filter/inc/namebuff.hxx
@@ -26,6 +26,8 @@
 #include "xiroot.hxx"
 
 #include "rangenam.hxx"
+#include "formulacell.hxx"
+
 #include <boost/unordered_map.hpp>
 #include <list>
 
@@ -146,30 +148,21 @@ inline void NameBuffer::SetBase( sal_uInt16 nNewBase )
     nBase = nNewBase;
 }
 
-
-
-
+/**
+ * Store and manage shared formula tokens.
+ */
 class SharedFormulaBuffer : public ExcRoot
 {
-    struct ScAddressHashFunc : public std::unary_function< const ScAddress &, size_t >
-    {
-        size_t operator() (const ScAddress &addr) const;
-    };
-    typedef boost::unordered_map <ScAddress, sal_uInt16, ScAddressHashFunc> ShrfmlaHash;
-    typedef std::list <ScRange>                                  ShrfmlaList;
+    typedef boost::unordered_map<ScAddress, ScFormulaCellGroupRef, ScAddressHashFunctor> FormulaGroupsType;
 
-    ShrfmlaHash  index_hash;
-    ShrfmlaList  index_list;
-    size_t                  mnCurrIdx;
+    FormulaGroupsType maFormulaGroups;
 
 public:
     SharedFormulaBuffer( RootData* pRD );
     virtual ~SharedFormulaBuffer();
-    void                    Clear();
-    void                    Store( const ScRange& rRange, const ScTokenArray& );
-    sal_uInt16                  Find (const ScAddress & rAddress ) const;
-
-    static String           CreateName( const ScRange& );
+    void Clear();
+    void Store( const ScRange& rRange, const ScTokenArray& rArray );
+    ScFormulaCellGroupRef Find( const ScAddress& rRefPos ) const;
 };