formula/source/ui/dlg/FormulaHelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: formula.hxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 #include "precompiled_formula.hxx"
  31
  32 #include "formula/formulahelper.hxx"
  33 #include <unotools/charclass.hxx>
  34 #include <svtools/syslocale.hxx>
  35
  36 namespace formula
  37 {
  38
  39     namespace
  40     {
  41         //============================================================================
  42         class OEmptyFunctionDescription : public IFunctionDescription
  43         {
  44         public:
  45             OEmptyFunctionDescription(){}
  46             virtual ~OEmptyFunctionDescription(){}
  47
  48             virtual ::rtl::OUString getFunctionName() const { return ::rtl::OUString(); }
  49             virtual const IFunctionCategory* getCategory() const { return NULL; }
  50             virtual ::rtl::OUString getDescription() const { return ::rtl::OUString(); }
  51             virtual xub_StrLen getSuppressedArgumentCount() const { return 0; }
  52             virtual ::rtl::OUString getFormula(const ::std::vector< ::rtl::OUString >& ) const { return ::rtl::OUString(); }
  53             virtual void fillVisibleArgumentMapping(::std::vector<USHORT>& ) const {}
  54             virtual void initArgumentInfo()  const {}
  55             virtual ::rtl::OUString getSignature() const { return ::rtl::OUString(); }
  56             virtual long getHelpId() const { return 0; }
  57             virtual sal_uInt32 getParameterCount() const { return 0; }
  58             virtual ::rtl::OUString getParameterName(sal_uInt32 ) const { return ::rtl::OUString(); }
  59             virtual ::rtl::OUString getParameterDescription(sal_uInt32 ) const { return ::rtl::OUString(); }
  60             virtual bool isParameterOptional(sal_uInt32 ) const { return sal_False; }
  61         };
  62     }
  63 //===================================================================
  64 //      class FormulaHelper - statische Methoden
  65 //===================================================================
  66
  67 #define FUNC_NOTFOUND 0xffff
  68
  69 FormulaHelper::FormulaHelper(const IFunctionManager* _pFunctionManager)
  70     :m_pSysLocale(new SvtSysLocale)
  71     ,m_pFunctionManager(_pFunctionManager)
  72     ,open(_pFunctionManager->getSingleToken(IFunctionManager::eOk))
  73     ,close(_pFunctionManager->getSingleToken(IFunctionManager::eClose))
  74     ,sep(_pFunctionManager->getSingleToken(IFunctionManager::eSep))
  75     ,arrayOpen(_pFunctionManager->getSingleToken(IFunctionManager::eArrayOpen))
  76     ,arrayClose(_pFunctionManager->getSingleToken(IFunctionManager::eArrayClose))
  77 {
  78     m_pCharClass = m_pSysLocale->GetCharClassPtr();
  79 }
  80 BOOL FormulaHelper::GetNextFunc( const String&  rFormula,
  81                                  BOOL                   bBack,
  82                                  xub_StrLen&    rFStart,   // Ein- und Ausgabe
  83                                  xub_StrLen*    pFEnd,     // = NULL
  84                                  const IFunctionDescription**   ppFDesc,   // = NULL
  85                                  ::std::vector< ::rtl::OUString>*       pArgs )  const // = NULL
  86 {
  87     BOOL                bFound = FALSE;
  88     xub_StrLen  nOldStart = rFStart;
  89     String              aFname;
  90
  91     rFStart = GetFunctionStart( rFormula, rFStart, bBack, ppFDesc ? &aFname : NULL );
  92     bFound  = ( rFStart != FUNC_NOTFOUND );
  93
  94     if ( bFound )
  95     {
  96         if ( pFEnd )
  97             *pFEnd = GetFunctionEnd( rFormula, rFStart );
  98
  99         if ( ppFDesc )
 100         {
 101             *ppFDesc = NULL;
 102             const ::rtl::OUString sTemp( aFname );
 103             const sal_uInt32 nCategoryCount = m_pFunctionManager->getCount();
 104             for(sal_uInt32 j= 0; j < nCategoryCount && !*ppFDesc; ++j)
 105             {
 106                 const IFunctionCategory* pCategory = m_pFunctionManager->getCategory(j);
 107                 const sal_uInt32 nCount = pCategory->getCount();
 108                 for(sal_uInt32 i = 0 ; i < nCount; ++i)
 109                 {
 110                     const IFunctionDescription* pCurrent = pCategory->getFunction(i);
 111                     if ( pCurrent->getFunctionName().equalsIgnoreAsciiCase(sTemp) )
 112                     {
 113                         *ppFDesc = pCurrent;
 114                         break;
 115                     }
 116                 } // for(sal_uInt32 i = 0 ; i < nCount; ++i)
 117             }
 118             if ( *ppFDesc && pArgs )
 119             {
 120                 GetArgStrings( *pArgs,rFormula, rFStart, static_cast<USHORT>((*ppFDesc)->getParameterCount() ));
 121             }
 122             else
 123             {
 124                 static OEmptyFunctionDescription s_aFunctionDescription;
 125                 *ppFDesc = &s_aFunctionDescription;
 126             }
 127         }
 128     }
 129     else
 130         rFStart = nOldStart;
 131
 132     return bFound;
 133 }
 134
 135 //------------------------------------------------------------------------
 136
 137 void FormulaHelper::FillArgStrings( const String&       rFormula,
 138                                     xub_StrLen          nFuncPos,
 139                                     USHORT                      nArgs,
 140                                     ::std::vector< ::rtl::OUString >& _rArgs ) const
 141 {
 142     xub_StrLen  nStart  = 0;
 143     xub_StrLen  nEnd    = 0;
 144     USHORT              i;
 145     BOOL                bLast   = FALSE;
 146
 147     for ( i=0; i<nArgs && !bLast; i++ )
 148     {
 149         nStart = GetArgStart( rFormula, nFuncPos, i );
 150
 151         if ( i+1<nArgs ) // letztes Argument?
 152         {
 153             nEnd = GetArgStart( rFormula, nFuncPos, i+1 );
 154
 155             if ( nEnd != nStart )
 156                 _rArgs.push_back(rFormula.Copy( nStart, nEnd-1-nStart ));
 157             else
 158                 _rArgs.push_back(String()), bLast = TRUE;
 159         }
 160         else
 161         {
 162             nEnd = GetFunctionEnd( rFormula, nFuncPos )-1;
 163             if ( nStart < nEnd )
 164                 _rArgs.push_back( rFormula.Copy( nStart, nEnd-nStart ) );
 165             else
 166                 _rArgs.push_back(String());
 167         }
 168     }
 169
 170     if ( bLast )
 171         for ( ; i<nArgs; i++ )
 172             _rArgs.push_back(String());
 173 }
 174
 175 //------------------------------------------------------------------------
 176
 177 void FormulaHelper::GetArgStrings( ::std::vector< ::rtl::OUString >& _rArgs
 178                                       ,const String& rFormula,
 179                                        xub_StrLen nFuncPos,
 180                                        USHORT nArgs ) const
 181 {
 182     if (nArgs)
 183     {
 184         FillArgStrings( rFormula, nFuncPos, nArgs, _rArgs );
 185     }
 186 }
 187
 188 //------------------------------------------------------------------------
 189
 190 inline BOOL IsFormulaText( const CharClass* _pCharClass,const String& rStr, xub_StrLen nPos )
 191 {
 192     if( _pCharClass->isLetterNumeric( rStr, nPos ) )
 193         return TRUE;
 194     else
 195     {   // In internationalized versions function names may contain a dot
 196         //  and in every version also an underscore... ;-)
 197         sal_Unicode c = rStr.GetChar(nPos);
 198         return c == '.' || c == '_';
 199     }
 200
 201 }
 202
 203 xub_StrLen FormulaHelper::GetFunctionStart( const String&       rFormula,
 204                                         xub_StrLen              nStart,
 205                                         BOOL                    bBack,
 206                                         String*                 pFuncName ) const
 207 {
 208     xub_StrLen nStrLen = rFormula.Len();
 209
 210     if ( nStrLen < nStart )
 211         return nStart;
 212
 213     xub_StrLen  nFStart = FUNC_NOTFOUND;
 214     xub_StrLen  nParPos = nStart;
 215
 216     BOOL bRepeat, bFound;
 217     do
 218     {
 219         bFound  = FALSE;
 220         bRepeat = FALSE;
 221
 222         if ( bBack )
 223         {
 224             while ( !bFound && (nParPos > 0) )
 225             {
 226                 if ( rFormula.GetChar(nParPos) == '"' )
 227                 {
 228                     nParPos--;
 229                     while ( (nParPos > 0) && rFormula.GetChar(nParPos) != '"' )
 230                         nParPos--;
 231                     if (nParPos > 0)
 232                         nParPos--;
 233                 }
 234                 else if ( (bFound = ( rFormula.GetChar(nParPos) == '(' ) ) == FALSE )
 235                     nParPos--;
 236             }
 237         }
 238         else
 239         {
 240             while ( !bFound && (nParPos < nStrLen) )
 241             {
 242                 if ( rFormula.GetChar(nParPos) == '"' )
 243                 {
 244                     nParPos++;
 245                     while ( (nParPos < nStrLen) && rFormula.GetChar(nParPos) != '"' )
 246                         nParPos++;
 247                     nParPos++;
 248                 }
 249                 else if ( (bFound = ( rFormula.GetChar(nParPos) == '(' ) ) == FALSE )
 250                     nParPos++;
 251             }
 252         }
 253
 254         if ( bFound && (nParPos > 0) )
 255         {
 256             nFStart = nParPos-1;
 257
 258             while ( (nFStart > 0) && IsFormulaText(m_pCharClass, rFormula, nFStart ))
 259                 nFStart--;
 260         }
 261
 262         nFStart++;
 263
 264         if ( bFound )
 265         {
 266             if ( IsFormulaText( m_pCharClass,rFormula, nFStart ) )
 267             {
 268                                     //  Funktion gefunden
 269                 if ( pFuncName )
 270                     *pFuncName = rFormula.Copy( nFStart, nParPos-nFStart );
 271             }
 272             else                                        // Klammern ohne Funktion -> weitersuchen
 273             {
 274                 bRepeat = TRUE;
 275                 if ( !bBack )
 276                     nParPos++;
 277                 else if (nParPos > 0)
 278                     nParPos--;
 279                 else
 280                     bRepeat = FALSE;
 281             }
 282         }
 283         else                                            // keine Klammern gefunden
 284         {
 285             nFStart = FUNC_NOTFOUND;
 286             if ( pFuncName )
 287                 pFuncName->Erase();
 288         }
 289     }
 290     while(bRepeat);
 291
 292     return nFStart;
 293 }
 294
 295 //------------------------------------------------------------------------
 296
 297 xub_StrLen      FormulaHelper::GetFunctionEnd( const String& rStr, xub_StrLen nStart ) const
 298 {
 299     xub_StrLen nStrLen = rStr.Len();
 300
 301     if ( nStrLen < nStart )
 302         return nStart;
 303
 304     short       nParCount = 0;
 305     bool    bInArray = false;
 306     BOOL        bFound = FALSE;
 307
 308     while ( !bFound && (nStart < nStrLen) )
 309     {
 310         sal_Unicode c = rStr.GetChar(nStart);
 311
 312         if ( c == '"' )
 313         {
 314             nStart++;
 315             while ( (nStart < nStrLen) && rStr.GetChar(nStart) != '"' )
 316                 nStart++;
 317         }
 318         else if ( c == open )
 319             nParCount++;
 320         else if ( c == close )
 321         {
 322             nParCount--;
 323             if ( nParCount == 0 )
 324                 bFound = TRUE;
 325             else if ( nParCount < 0 )
 326             {
 327                 bFound = TRUE;
 328                 nStart--;       // einen zu weit gelesen
 329             }
 330         }
 331         else if ( c == arrayOpen )
 332         {
 333             bInArray = true;
 334         }
 335         else if ( c == arrayClose )
 336         {
 337             bInArray = false;
 338         }
 339         else if ( c == sep )
 340         {
 341             if ( !bInArray && nParCount == 0 )
 342             {
 343                 bFound = TRUE;
 344                 nStart--;       // einen zu weit gelesen
 345             }
 346         }
 347         nStart++; // hinter gefundene Position stellen
 348     }
 349
 350     return nStart;
 351 }
 352
 353 //------------------------------------------------------------------
 354
 355 xub_StrLen FormulaHelper::GetArgStart( const String& rStr, xub_StrLen nStart, USHORT nArg ) const
 356 {
 357     xub_StrLen nStrLen = rStr.Len();
 358
 359     if ( nStrLen < nStart )
 360         return nStart;
 361
 362     short       nParCount       = 0;
 363     bool    bInArray    = false;
 364     BOOL        bFound          = FALSE;
 365
 366     while ( !bFound && (nStart < nStrLen) )
 367     {
 368         sal_Unicode c = rStr.GetChar(nStart);
 369
 370         if ( c == '"' )
 371         {
 372             nStart++;
 373             while ( (nStart < nStrLen) && rStr.GetChar(nStart) != '"' )
 374                 nStart++;
 375         }
 376         else if ( c == open )
 377         {
 378             bFound = ( nArg == 0 );
 379             nParCount++;
 380         }
 381         else if ( c == close )
 382         {
 383             nParCount--;
 384             bFound = ( nParCount == 0 );
 385         }
 386         else if ( c == arrayOpen )
 387         {
 388             bInArray = true;
 389         }
 390         else if ( c == arrayClose )
 391         {
 392             bInArray = false;
 393         }
 394         else if ( c == sep )
 395         {
 396             if ( !bInArray && nParCount == 1 )
 397             {
 398                 nArg--;
 399                 bFound = ( nArg == 0  );
 400             }
 401         }
 402         nStart++;
 403     }
 404
 405     return nStart;
 406 }
 407 // =============================================================================
 408 } // formula
 409 // =============================================================================