sc/source/core/tool/reffind.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "reffind.hxx"
  21 #include "global.hxx"
  22 #include "compiler.hxx"
  23 #include "document.hxx"
  24
  25 // STATIC DATA
  26 namespace {
  27
  28 // Include colon; addresses in range reference are handled individually.
  29 const sal_Unicode pDelimiters[] = {
  30     '=','(',')','+','-','*','/','^','&',' ','{','}','<','>',':', 0
  31 };
  32
  33 inline bool IsText( sal_Unicode c )
  34 {
  35     bool bFound = ScGlobal::UnicodeStrChr( pDelimiters, c );
  36     if (bFound)
  37         // This is one of delimiters, therefore not text.
  38         return false;
  39
  40     // argument separator is configurable.
  41     const sal_Unicode sep = ScCompiler::GetNativeSymbolChar(ocSep);
  42     return c != sep;
  43 }
  44
  45 inline bool IsText( bool& bQuote, sal_Unicode c )
  46 {
  47     if (c == '\'')
  48     {
  49         bQuote = !bQuote;
  50         return true;
  51     }
  52     if (bQuote)
  53         return true;
  54
  55     return IsText(c);
  56 }
  57
  58 /**
  59  * Find first character position that is considered text.  A character is
  60  * considered a text when it's within the ascii range and when it's not a
  61  * delimiter.
  62  */
  63 sal_Int32 FindStartPos(const sal_Unicode* p, sal_Int32 nStartPos, sal_Int32 nEndPos)
  64 {
  65     while (nStartPos <= nEndPos && !IsText(p[nStartPos]))
  66         ++nStartPos;
  67
  68     return nStartPos;
  69 }
  70
  71 sal_Int32 FindEndPosA1(const sal_Unicode* p, sal_Int32 nStartPos, sal_Int32 nEndPos)
  72 {
  73     bool bQuote = false;
  74     sal_Int32 nNewEnd = nStartPos;
  75     while (nNewEnd <= nEndPos && IsText(bQuote, p[nNewEnd]))
  76         ++nNewEnd;
  77
  78     return nNewEnd;
  79 }
  80
  81 sal_Int32 FindEndPosR1C1(const sal_Unicode* p, sal_Int32 nStartPos, sal_Int32 nEndPos)
  82 {
  83     sal_Int32 nNewEnd = nStartPos;
  84     p = &p[nStartPos];
  85     for (; nNewEnd <= nEndPos; ++p, ++nNewEnd)
  86     {
  87         if (*p == '\'')
  88         {
  89             // Skip until the closing quote.
  90             for (; nNewEnd <= nEndPos; ++p, ++nNewEnd)
  91                 if (*p == '\'')
  92                     break;
  93             if (nNewEnd > nEndPos)
  94                 break;
  95         }
  96         else if (*p == '[')
  97         {
  98             // Skip until the closing braket.
  99             for (; nNewEnd <= nEndPos; ++p, ++nNewEnd)
 100                 if (*p == ']')
 101                     break;
 102             if (nNewEnd > nEndPos)
 103                 break;
 104         }
 105         else if (!IsText(*p))
 106             break;
 107     }
 108
 109     return nNewEnd;
 110 }
 111
 112 /**
 113  * Find last character position that is considred text, from the specified
 114  * start position.
 115  */
 116 sal_Int32 FindEndPos(const sal_Unicode* p, sal_Int32 nStartPos, sal_Int32 nEndPos,
 117                      formula::FormulaGrammar::AddressConvention eConv)
 118 {
 119     switch (eConv)
 120     {
 121         case formula::FormulaGrammar::CONV_XL_R1C1:
 122             return FindEndPosR1C1(p, nStartPos, nEndPos);
 123         case formula::FormulaGrammar::CONV_OOO:
 124         case formula::FormulaGrammar::CONV_XL_A1:
 125         default:
 126             return FindEndPosA1(p, nStartPos, nEndPos);
 127     }
 128 }
 129
 130 void ExpandToTextA1(const sal_Unicode* p, sal_Int32 nLen, sal_Int32& rStartPos, sal_Int32& rEndPos)
 131 {
 132     bool bQuote = false;  // skip quoted text
 133     while (rStartPos > 0 && IsText(bQuote, p[rStartPos - 1]) )
 134         --rStartPos;
 135     if (rEndPos)
 136         --rEndPos;
 137     while (rEndPos+1 < nLen && IsText(p[rEndPos + 1]) )
 138         ++rEndPos;
 139 }
 140
 141 void ExpandToTextR1C1(const sal_Unicode* p, sal_Int32 nLen, sal_Int32& rStartPos, sal_Int32& rEndPos)
 142 {
 143     // move back the start position to the first text character.
 144     if (rStartPos > 0)
 145     {
 146         for (--rStartPos; rStartPos > 0; --rStartPos)
 147         {
 148             sal_Unicode c = p[rStartPos];
 149             if (c == '\'')
 150             {
 151                 // Skip until the opening quote.
 152                 for (--rStartPos; rStartPos > 0; --rStartPos)
 153                 {
 154                     c = p[rStartPos];
 155                     if (c == '\'')
 156                         break;
 157                 }
 158                 if (rStartPos == 0)
 159                     break;
 160             }
 161             else if (c == ']')
 162             {
 163                 // Skip until the opening braket.
 164                 for (--rStartPos; rStartPos > 0; --rStartPos)
 165                 {
 166                     c = p[rStartPos];
 167                     if (c == '[')
 168                         break;
 169                 }
 170                 if (rStartPos == 0)
 171                     break;
 172             }
 173             else if (!IsText(c))
 174             {
 175                 ++rStartPos;
 176                 break;
 177             }
 178         }
 179     }
 180
 181     // move forward the end position to the last text character.
 182     rEndPos = FindEndPosR1C1(p, rEndPos, nLen-1);
 183 }
 184
 185 void ExpandToText(const sal_Unicode* p, sal_Int32 nLen, sal_Int32& rStartPos, sal_Int32& rEndPos,
 186                   formula::FormulaGrammar::AddressConvention eConv)
 187 {
 188     switch (eConv)
 189     {
 190         case formula::FormulaGrammar::CONV_XL_R1C1:
 191             ExpandToTextR1C1(p, nLen, rStartPos, rEndPos);
 192         break;
 193         case formula::FormulaGrammar::CONV_OOO:
 194         case formula::FormulaGrammar::CONV_XL_A1:
 195         default:
 196             ExpandToTextA1(p, nLen, rStartPos, rEndPos);
 197     }
 198 }
 199
 200 }
 201
 202 ScRefFinder::ScRefFinder(
 203     const OUString& rFormula, const ScAddress& rPos,
 204     ScDocument* pDoc, formula::FormulaGrammar::AddressConvention eConvP) :
 205     maFormula(rFormula),
 206     meConv(eConvP),
 207     mpDoc(pDoc),
 208     maPos(rPos),
 209     mnFound(0),
 210     mnSelStart(0),
 211     mnSelEnd(0)
 212 {
 213 }
 214
 215 ScRefFinder::~ScRefFinder()
 216 {
 217 }
 218
 219 static sal_uInt16 lcl_NextFlags( sal_uInt16 nOld )
 220 {
 221     sal_uInt16 nNew = nOld & 7;                 // die drei Abs-Flags
 222     nNew = ( nNew - 1 ) & 7;                // weiterzaehlen
 223
 224     if (!(nOld & SCA_TAB_3D))
 225         nNew &= ~SCA_TAB_ABSOLUTE;          // not 3D -> never absolute!
 226
 227     return ( nOld & 0xfff8 ) | nNew;
 228 }
 229
 230 void ScRefFinder::ToggleRel( sal_Int32 nStartPos, sal_Int32 nEndPos )
 231 {
 232     sal_Int32 nLen = maFormula.getLength();
 233     if (nLen <= 0)
 234         return;
 235     const sal_Unicode* pSource = maFormula.getStr();      // for quick access
 236
 237     // expand selection, and instead of selection start- and end-index
 238
 239     if ( nEndPos < nStartPos )
 240         ::std::swap(nEndPos, nStartPos);
 241
 242     ExpandToText(pSource, nLen, nStartPos, nEndPos, meConv);
 243
 244     OUString aResult;
 245     OUString aExpr;
 246     OUString aSep;
 247     ScAddress aAddr;
 248     mnFound = 0;
 249
 250     sal_Int32 nLoopStart = nStartPos;
 251     while ( nLoopStart <= nEndPos )
 252     {
 253         // Determine the start and end positions of a text segment.  Note that
 254         // the end position returned from FindEndPos may be one position after
 255         // the last character position in case of the last segment.
 256         sal_Int32 nEStart = FindStartPos(pSource, nLoopStart, nEndPos);
 257         sal_Int32 nEEnd  = FindEndPos(pSource, nEStart, nEndPos, meConv);
 258
 259         aSep  = maFormula.copy(nLoopStart, nEStart-nLoopStart);
 260         if (nEEnd < maFormula.getLength())
 261             aExpr = maFormula.copy(nEStart, nEEnd-nEStart);
 262         else
 263             aExpr = maFormula.copy(nEStart);
 264
 265         // Check the validity of the expression, and toggle the relative flag.
 266         ScAddress::Details aDetails(meConv, maPos.Row(), maPos.Col());
 267         ScAddress::ExternalInfo aExtInfo;
 268         sal_uInt16 nResult = aAddr.Parse(aExpr, mpDoc, aDetails, &aExtInfo);
 269         if ( nResult & SCA_VALID )
 270         {
 271             sal_uInt16 nFlags = lcl_NextFlags( nResult );
 272             if( aExtInfo.mbExternal )
 273             {    // retain external doc name and tab name before toggle relative flag
 274                 sal_Int32 nSep;
 275                 switch(meConv)
 276                 {
 277                   case formula::FormulaGrammar::CONV_XL_A1 :
 278                   case formula::FormulaGrammar::CONV_XL_OOX :
 279                   case formula::FormulaGrammar::CONV_XL_R1C1 :
 280                          nSep = aExpr.lastIndexOf('!');
 281                          break;
 282                   case formula::FormulaGrammar::CONV_OOO :
 283                   default:
 284                          nSep = aExpr.lastIndexOf('.');
 285                          break;
 286                 }
 287                 if (nSep < 0)
 288                 {
 289                     assert(!"Invalid syntax according to address convention.");
 290                 }
 291                 else
 292                 {
 293                     OUString aRef = aExpr.copy(nSep+1);
 294                     OUString aExtDocNameTabName = aExpr.copy(0, nSep+1);
 295                     nResult = aAddr.Parse(aRef, mpDoc, aDetails);
 296                     aAddr.SetTab(0); // force to first tab to avoid error on checking
 297                     nFlags = lcl_NextFlags( nResult );
 298                     aExpr = aExtDocNameTabName + aAddr.Format(nFlags, mpDoc, aDetails);
 299                 }
 300             }
 301             else
 302             {
 303                 aExpr = aAddr.Format(nFlags, mpDoc, aDetails);
 304             }
 305
 306             sal_Int32 nAbsStart = nStartPos+aResult.getLength()+aSep.getLength();
 307
 308             if (!mnFound)                            // first reference ?
 309                 mnSelStart = nAbsStart;
 310             mnSelEnd = nAbsStart + aExpr.getLength();        // selection, no indices
 311             ++mnFound;
 312         }
 313
 314         // assemble
 315
 316         aResult += aSep;
 317         aResult += aExpr;
 318
 319         nLoopStart = nEEnd;
 320     }
 321
 322     OUString aTotal = maFormula.copy(0, nStartPos);
 323     aTotal += aResult;
 324     if (nEndPos < maFormula.getLength()-1)
 325         aTotal += maFormula.copy(nEndPos+1);
 326
 327     maFormula = aTotal;
 328 }
 329
 330 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */