LCOV - code coverage report
Current view: top level - basic/source/comp - symtbl.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 243 0.0 %
Date: 2014-04-14 Functions: 0 43 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : 
      21             : #include "sbcomp.hxx"
      22             : #include <stdio.h>
      23             : #include <string.h>
      24             : #include <ctype.h>
      25             : 
      26             : // All symbol names are laid down int the symbol-pool's stringpool, so that
      27             : // all symbols are handled in the same case. On saving the code-image, the
      28             : // global stringpool with the respective symbols is also saved.
      29             : // The local stringpool holds all the symbols that don't move to the image
      30             : // (labels, constant names etc.).
      31             : 
      32             : /***************************************************************************
      33             : |*
      34             : |*  SbiStringPool
      35             : |*
      36             : ***************************************************************************/
      37             : 
      38           0 : SbiStringPool::SbiStringPool( SbiParser* p )
      39             : {
      40           0 :     pParser = p;
      41           0 : }
      42             : 
      43           0 : SbiStringPool::~SbiStringPool()
      44           0 : {}
      45             : 
      46           0 : const OUString& SbiStringPool::Find( sal_uInt32 n ) const
      47             : {
      48           0 :     if( n == 0 || n > aData.size() )
      49           0 :         return aEmpty; //hack, returning a reference to a simulation of null
      50             :     else
      51           0 :         return aData[n - 1];
      52             : }
      53             : 
      54           0 : short SbiStringPool::Add( const OUString& rVal, bool bNoCase )
      55             : {
      56           0 :     sal_uInt32 n = aData.size();
      57           0 :     for( sal_uInt32 i = 0; i < n; ++i )
      58             :     {
      59           0 :         OUString& p = aData[i];
      60           0 :         if( (  bNoCase && p == rVal )
      61           0 :             || ( !bNoCase && p.equalsIgnoreAsciiCase( rVal ) ) )
      62           0 :             return i+1;
      63             :     }
      64             : 
      65           0 :     aData.push_back(rVal);
      66           0 :     return (short) ++n;
      67             : }
      68             : 
      69           0 : short SbiStringPool::Add( double n, SbxDataType t )
      70             : {
      71             :     char buf[ 40 ];
      72           0 :     switch( t )
      73             :     {
      74           0 :         case SbxINTEGER: snprintf( buf, sizeof(buf), "%d", (short) n ); break;
      75           0 :         case SbxLONG:    snprintf( buf, sizeof(buf), "%ld", (long) n ); break;
      76           0 :         case SbxSINGLE:  snprintf( buf, sizeof(buf), "%.6g", (float) n ); break;
      77           0 :         case SbxDOUBLE:  snprintf( buf, sizeof(buf), "%.16g", n ); break;
      78           0 :         default: break;
      79             :     }
      80           0 :     return Add( OUString::createFromAscii( buf ) );
      81             : }
      82             : 
      83             : /***************************************************************************
      84             : |*
      85             : |*  SbiSymPool
      86             : |*
      87             : ***************************************************************************/
      88             : 
      89           0 : SbiSymPool::SbiSymPool( SbiStringPool& r, SbiSymScope s ) : rStrings( r )
      90             : {
      91           0 :     pParser  = r.GetParser();
      92           0 :     eScope   = s;
      93           0 :     pParent  = NULL;
      94             :     nCur     =
      95           0 :     nProcId  = 0;
      96           0 : }
      97             : 
      98           0 : SbiSymPool::~SbiSymPool()
      99           0 : {}
     100             : 
     101             : 
     102           0 : SbiSymDef* SbiSymPool::First()
     103             : {
     104           0 :     nCur = (sal_uInt16) -1;
     105           0 :     return Next();
     106             : }
     107             : 
     108           0 : SbiSymDef* SbiSymPool::Next()
     109             : {
     110           0 :     if( ++nCur >= aData.size() )
     111           0 :         return NULL;
     112             :     else
     113           0 :         return aData[ nCur ];
     114             : }
     115             : 
     116             : 
     117           0 : SbiSymDef* SbiSymPool::AddSym( const OUString& rName )
     118             : {
     119           0 :     SbiSymDef* p = new SbiSymDef( rName );
     120           0 :     p->nPos    = aData.size();
     121           0 :     p->nId     = rStrings.Add( rName );
     122           0 :     p->nProcId = nProcId;
     123           0 :     p->pIn     = this;
     124           0 :     aData.insert( aData.begin() + p->nPos, p );
     125           0 :     return p;
     126             : }
     127             : 
     128           0 : SbiProcDef* SbiSymPool::AddProc( const OUString& rName )
     129             : {
     130           0 :     SbiProcDef* p = new SbiProcDef( pParser, rName );
     131           0 :     p->nPos    = aData.size();
     132           0 :     p->nId     = rStrings.Add( rName );
     133             :     // procs are always local
     134           0 :     p->nProcId = 0;
     135           0 :     p->pIn     = this;
     136           0 :     aData.insert( aData.begin() + p->nPos, p );
     137           0 :     return p;
     138             : }
     139             : 
     140             : // adding an externally constructed symbol definition
     141             : 
     142           0 : void SbiSymPool::Add( SbiSymDef* pDef )
     143             : {
     144           0 :     if( pDef && pDef->pIn != this )
     145             :     {
     146           0 :         if( pDef->pIn )
     147             :         {
     148             : #ifdef DBG_UTIL
     149             : 
     150             :             pParser->Error( SbERR_INTERNAL_ERROR, "Dbl Pool" );
     151             : #endif
     152           0 :             return;
     153             :         }
     154             : 
     155           0 :         pDef->nPos = aData.size();
     156           0 :         if( !pDef->nId )
     157             :         {
     158             :             // A unique name must be created in the string pool
     159             :             // for static variables (Form ProcName:VarName)
     160           0 :             OUString aName( pDef->aName );
     161           0 :             if( pDef->IsStatic() )
     162             :             {
     163           0 :                 aName = pParser->aGblStrings.Find( nProcId );
     164           0 :                 aName += ":";
     165           0 :                 aName += pDef->aName;
     166             :             }
     167           0 :             pDef->nId = rStrings.Add( aName );
     168             :         }
     169             : 
     170           0 :         if( !pDef->GetProcDef() )
     171             :         {
     172           0 :             pDef->nProcId = nProcId;
     173             :         }
     174           0 :         pDef->pIn = this;
     175           0 :         aData.insert( aData.begin() + pDef->nPos, pDef );
     176             :     }
     177             : }
     178             : 
     179             : 
     180           0 : SbiSymDef* SbiSymPool::Find( const OUString& rName ) const
     181             : {
     182           0 :     sal_uInt16 nCount = aData.size();
     183           0 :     for( sal_uInt16 i = 0; i < nCount; i++ )
     184             :     {
     185           0 :         SbiSymDef* p = aData[ nCount - i - 1 ];
     186           0 :         if( ( !p->nProcId || ( p->nProcId == nProcId)) &&
     187           0 :             ( p->aName.equalsIgnoreAsciiCase(rName)))
     188             :         {
     189           0 :             return p;
     190             :         }
     191             :     }
     192           0 :     if( pParent )
     193             :     {
     194           0 :         return pParent->Find( rName );
     195             :     }
     196             :     else
     197             :     {
     198           0 :         return NULL;
     199             :     }
     200             : }
     201             : 
     202             : 
     203           0 : SbiSymDef* SbiSymPool::FindId( sal_uInt16 n ) const
     204             : {
     205           0 :     for( sal_uInt16 i = 0; i < aData.size(); i++ )
     206             :     {
     207           0 :         SbiSymDef* p = aData[ i ];
     208           0 :         if( p->nId == n && ( !p->nProcId || ( p->nProcId == nProcId ) ) )
     209             :         {
     210           0 :             return p;
     211             :         }
     212             :     }
     213           0 :     if( pParent )
     214             :     {
     215           0 :         return pParent->FindId( n );
     216             :     }
     217             :     else
     218             :     {
     219           0 :         return NULL;
     220             :     }
     221             : }
     222             : 
     223             : // find via position (from 0)
     224             : 
     225           0 : SbiSymDef* SbiSymPool::Get( sal_uInt16 n ) const
     226             : {
     227           0 :     if( n >= aData.size() )
     228             :     {
     229           0 :         return NULL;
     230             :     }
     231             :     else
     232             :     {
     233           0 :         return aData[ n ];
     234             :     }
     235             : }
     236             : 
     237           0 : sal_uInt32 SbiSymPool::Define( const OUString& rName )
     238             : {
     239           0 :     SbiSymDef* p = Find( rName );
     240           0 :     if( p )
     241             :     {
     242           0 :         if( p->IsDefined() )
     243             :         {
     244           0 :             pParser->Error( SbERR_LABEL_DEFINED, rName );
     245             :         }
     246             :     }
     247             :     else
     248             :     {
     249           0 :         p = AddSym( rName );
     250             :     }
     251           0 :     return p->Define();
     252             : }
     253             : 
     254           0 : sal_uInt32 SbiSymPool::Reference( const OUString& rName )
     255             : {
     256           0 :     SbiSymDef* p = Find( rName );
     257           0 :     if( !p )
     258             :     {
     259           0 :         p = AddSym( rName );
     260             :     }
     261             :     // to be sure
     262           0 :     pParser->aGen.GenStmnt();
     263           0 :     return p->Reference();
     264             : }
     265             : 
     266             : 
     267           0 : void SbiSymPool::CheckRefs()
     268             : {
     269           0 :     for( sal_uInt16 i = 0; i < aData.size(); i++ )
     270             :     {
     271           0 :         SbiSymDef* p = aData[ i ];
     272           0 :         if( !p->IsDefined() )
     273             :         {
     274           0 :             pParser->Error( SbERR_UNDEF_LABEL, p->GetName() );
     275             :         }
     276             :     }
     277           0 : }
     278             : 
     279             : /***************************************************************************
     280             : |*
     281             : |*  symbol definitions
     282             : |*
     283             : ***************************************************************************/
     284             : 
     285           0 : SbiSymDef::SbiSymDef( const OUString& rName ) : aName( rName )
     286             : {
     287           0 :     eType    = SbxEMPTY;
     288           0 :     nDims    = 0;
     289           0 :     nTypeId  = 0;
     290           0 :     nProcId  = 0;
     291           0 :     nId      = 0;
     292           0 :     nPos     = 0;
     293           0 :     nLen     = 0;
     294           0 :     nChain   = 0;
     295             :     bAs      =
     296             :     bNew     =
     297             :     bStatic  =
     298             :     bOpt     =
     299             :     bParamArray =
     300             :     bWithEvents =
     301             :     bWithBrackets =
     302             :     bByVal   =
     303             :     bChained =
     304           0 :     bGlobal  = false;
     305             :     pIn      =
     306           0 :     pPool    = NULL;
     307           0 :     nDefaultId = 0;
     308           0 :     nFixedStringLength = -1;
     309           0 : }
     310             : 
     311           0 : SbiSymDef::~SbiSymDef()
     312             : {
     313           0 :     delete pPool;
     314           0 : }
     315             : 
     316           0 : SbiProcDef* SbiSymDef::GetProcDef()
     317             : {
     318           0 :     return NULL;
     319             : }
     320             : 
     321           0 : SbiConstDef* SbiSymDef::GetConstDef()
     322             : {
     323           0 :     return NULL;
     324             : }
     325             : 
     326             : 
     327           0 : const OUString& SbiSymDef::GetName()
     328             : {
     329           0 :     if( pIn )
     330             :     {
     331           0 :         aName = pIn->rStrings.Find( nId );
     332             :     }
     333           0 :     return aName;
     334             : }
     335             : 
     336             : 
     337           0 : void SbiSymDef::SetType( SbxDataType t )
     338             : {
     339           0 :     if( t == SbxVARIANT && pIn )
     340             :     {
     341           0 :         sal_Unicode cu = aName[0];
     342           0 :         if( cu < 256 )
     343             :         {
     344           0 :             char ch = (char)cu;
     345           0 :             if( ch == '_' )
     346             :             {
     347           0 :                 ch = 'Z';
     348             :             }
     349           0 :             int ch2 = toupper( ch );
     350           0 :             unsigned char c = (unsigned char)ch2;
     351           0 :             if( c > 0 && c < 128 )
     352             :             {
     353           0 :                 int nIndex = ch2 - 'A';
     354             :                 assert(nIndex >= 0 && nIndex < N_DEF_TYPES);
     355           0 :                 if (nIndex >= 0 && nIndex < N_DEF_TYPES)
     356           0 :                     t = pIn->pParser->eDefTypes[nIndex];
     357             :             }
     358             :         }
     359             :     }
     360           0 :     eType = t;
     361           0 : }
     362             : 
     363             : // construct a backchain, if not yet defined
     364             : // the value that shall be stored as an operand is returned
     365             : 
     366           0 : sal_uInt32 SbiSymDef::Reference()
     367             : {
     368           0 :     if( !bChained )
     369             :     {
     370           0 :         sal_uInt32 n = nChain;
     371           0 :         nChain = pIn->pParser->aGen.GetOffset();
     372           0 :         return n;
     373             :     }
     374           0 :     else return nChain;
     375             : }
     376             : 
     377             : 
     378           0 : sal_uInt32 SbiSymDef::Define()
     379             : {
     380           0 :     sal_uInt32 n = pIn->pParser->aGen.GetPC();
     381           0 :     pIn->pParser->aGen.GenStmnt();
     382           0 :     if( nChain )
     383             :     {
     384           0 :         pIn->pParser->aGen.BackChain( nChain );
     385             :     }
     386           0 :     nChain = n;
     387           0 :     bChained = true;
     388           0 :     return nChain;
     389             : }
     390             : 
     391             : // A symbol definition may have its own pool. This is the case
     392             : // for objects and procedures (local variable)
     393             : 
     394           0 : SbiSymPool& SbiSymDef::GetPool()
     395             : {
     396           0 :     if( !pPool )
     397             :     {
     398           0 :         pPool = new SbiSymPool( pIn->pParser->aGblStrings, SbLOCAL );   // is dumped
     399             :     }
     400           0 :     return *pPool;
     401             : }
     402             : 
     403           0 : SbiSymScope SbiSymDef::GetScope() const
     404             : {
     405           0 :     return pIn ? pIn->GetScope() : SbLOCAL;
     406             : }
     407             : 
     408             : 
     409             : // The procedure definition has three pools:
     410             : // 1) aParams: is filled by the definition. Contains the
     411             : //    parameters' names, like they're used inside the body.
     412             : //    The first element is the return value.
     413             : // 2) pPool: all local variables
     414             : // 3) aLabels: labels
     415             : 
     416           0 : SbiProcDef::SbiProcDef( SbiParser* pParser, const OUString& rName,
     417             :                         bool bProcDecl )
     418             :          : SbiSymDef( rName )
     419             :          , aParams( pParser->aGblStrings, SbPARAM )  // is dumped
     420             :          , aLabels( pParser->aLclStrings, SbLOCAL )  // is not dumped
     421           0 :          , mbProcDecl( bProcDecl )
     422             : {
     423           0 :     aParams.SetParent( &pParser->aPublics );
     424           0 :     pPool = new SbiSymPool( pParser->aGblStrings, SbLOCAL );
     425           0 :     pPool->SetParent( &aParams );
     426             :     nLine1  =
     427           0 :     nLine2  = 0;
     428           0 :     mePropMode = PROPERTY_MODE_NONE;
     429           0 :     bPublic = true;
     430           0 :     bCdecl  = false;
     431           0 :     bStatic = false;
     432             :     // For return values the first element of the parameter
     433             :     // list is always defined with name and type of the proc
     434           0 :     aParams.AddSym( aName );
     435           0 : }
     436             : 
     437           0 : SbiProcDef::~SbiProcDef()
     438           0 : {}
     439             : 
     440           0 : SbiProcDef* SbiProcDef::GetProcDef()
     441             : {
     442           0 :     return this;
     443             : }
     444             : 
     445           0 : void SbiProcDef::SetType( SbxDataType t )
     446             : {
     447           0 :     SbiSymDef::SetType( t );
     448           0 :     aParams.Get( 0 )->SetType( eType );
     449           0 : }
     450             : 
     451             : // match with a forward-declaration
     452             : // if the match is OK, pOld is replaced by this in the pool
     453             : // pOld is deleted in any case!
     454             : 
     455           0 : void SbiProcDef::Match( SbiProcDef* pOld )
     456             : {
     457           0 :     SbiSymDef *pn=NULL;
     458             :     // parameter 0 is the function name
     459             :     sal_uInt16 i;
     460           0 :     for( i = 1; i < aParams.GetSize(); i++ )
     461             :     {
     462           0 :         SbiSymDef* po = pOld->aParams.Get( i );
     463           0 :         pn = aParams.Get( i );
     464             :         // no type matching - that is done during running
     465             :         // but is it maybe called with too little parameters?
     466           0 :         if( !po && !pn->IsOptional() && !pn->IsParamArray() )
     467             :         {
     468           0 :             break;
     469             :         }
     470           0 :         pOld->aParams.Next();
     471             :     }
     472             : 
     473           0 :     if( pn && i < aParams.GetSize() && pOld->pIn )
     474             :     {
     475             :         // mark the whole line
     476           0 :         pOld->pIn->GetParser()->SetCol1( 0 );
     477           0 :         pOld->pIn->GetParser()->Error( SbERR_BAD_DECLARATION, aName );
     478             :     }
     479           0 :     if( !pIn && pOld->pIn )
     480             :     {
     481             :         // Replace old entry with the new one
     482           0 :         pOld->pIn->aData[ pOld->nPos ] = this;
     483           0 :         nPos = pOld->nPos;
     484           0 :         nId  = pOld->nId;
     485           0 :         pIn  = pOld->pIn;
     486             :     }
     487           0 :     delete pOld;
     488           0 : }
     489             : 
     490           0 : void SbiProcDef::setPropertyMode( PropertyMode ePropMode )
     491             : {
     492           0 :     mePropMode = ePropMode;
     493           0 :     if( mePropMode != PROPERTY_MODE_NONE )
     494             :     {
     495             :         // Prop name = original scanned procedure name
     496           0 :         maPropName = aName;
     497             : 
     498             :         // CompleteProcName includes "Property xxx "
     499             :         // to avoid conflicts with other symbols
     500           0 :         OUString aCompleteProcName = "Property ";
     501           0 :         switch( mePropMode )
     502             :         {
     503           0 :         case PROPERTY_MODE_GET:  aCompleteProcName += "Get "; break;
     504           0 :         case PROPERTY_MODE_LET:  aCompleteProcName += "Let "; break;
     505           0 :         case PROPERTY_MODE_SET:  aCompleteProcName += "Set "; break;
     506           0 :         case PROPERTY_MODE_NONE: OSL_FAIL( "Illegal PropertyMode PROPERTY_MODE_NONE" ); break;
     507             :         }
     508           0 :         aCompleteProcName += aName;
     509           0 :         aName = aCompleteProcName;
     510             :     }
     511           0 : }
     512             : 
     513             : 
     514             : 
     515           0 : SbiConstDef::SbiConstDef( const OUString& rName )
     516           0 :            : SbiSymDef( rName )
     517             : {
     518           0 :     nVal = 0; eType = SbxINTEGER;
     519           0 : }
     520             : 
     521           0 : void SbiConstDef::Set( double n, SbxDataType t )
     522             : {
     523           0 :     aVal = ""; nVal = n; eType = t;
     524           0 : }
     525             : 
     526           0 : void SbiConstDef::Set( const OUString& n )
     527             : {
     528           0 :     aVal = n; nVal = 0; eType = SbxSTRING;
     529           0 : }
     530             : 
     531           0 : SbiConstDef::~SbiConstDef()
     532           0 : {}
     533             : 
     534           0 : SbiConstDef* SbiConstDef::GetConstDef()
     535             : {
     536           0 :     return this;
     537             : }
     538             : 
     539           0 : SbiSymbols::~SbiSymbols()
     540             : {
     541           0 :     for( const_iterator it = begin(); it != end(); ++it )
     542             :     {
     543           0 :         delete *it;
     544             :     }
     545           0 : };
     546             : 
     547             : 
     548             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10