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