basic/source/comp/codegen.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 <basic/sbx.hxx>
  22 #include "image.hxx"
  23 #include "codegen.hxx"
  24 #include "parser.hxx"
  25 #include <limits>
  26 #include <algorithm>
  27 #include <osl/diagnose.h>
  28 #include <com/sun/star/script/ModuleType.hpp>
  29
  30 // nInc is the increment size of the buffers
  31
  32 SbiCodeGen::SbiCodeGen( SbModule& r, SbiParser* p, short nInc )
  33          : rMod( r ), aCode( p, nInc )
  34 {
  35     pParser = p;
  36     bStmnt = false;
  37     nLine = 0;
  38     nCol = 0;
  39     nForLevel = 0;
  40 }
  41
  42 sal_uInt32 SbiCodeGen::GetPC()
  43 {
  44     return aCode.GetSize();
  45 }
  46
  47 // memorize the statement
  48
  49 void SbiCodeGen::Statement()
  50 {
  51     if( pParser->IsCodeCompleting() )
  52         return;
  53
  54     bStmnt = true;
  55
  56     nLine = pParser->GetLine();
  57     nCol  = pParser->GetCol1();
  58
  59     // #29955 Store the information of the for-loop-layer
  60     // in the uppper Byte of the column
  61     nCol = (nCol & 0xff) + 0x100 * nForLevel;
  62 }
  63
  64 // Mark the beginning of a statement
  65
  66 void SbiCodeGen::GenStmnt()
  67 {
  68     if( pParser->IsCodeCompleting() )
  69         return;
  70
  71     if( bStmnt )
  72     {
  73         bStmnt = false;
  74         Gen( _STMNT, nLine, nCol );
  75     }
  76 }
  77
  78 // The Gen-Routines return the offset of the 1. operand,
  79 // so that jumps can sink their backchain there.
  80
  81 sal_uInt32 SbiCodeGen::Gen( SbiOpcode eOpcode )
  82 {
  83     if( pParser->IsCodeCompleting() )
  84         return 0;
  85
  86 #ifdef DBG_UTIL
  87     if( eOpcode < SbOP0_START || eOpcode > SbOP0_END )
  88         pParser->Error( SbERR_INTERNAL_ERROR, "OPCODE1" );
  89 #endif
  90     GenStmnt();
  91     aCode += (sal_uInt8) eOpcode;
  92     return GetPC();
  93 }
  94
  95 sal_uInt32 SbiCodeGen::Gen( SbiOpcode eOpcode, sal_uInt32 nOpnd )
  96 {
  97     if( pParser->IsCodeCompleting() )
  98         return 0;
  99
 100 #ifdef DBG_UTIL
 101     if( eOpcode < SbOP1_START || eOpcode > SbOP1_END )
 102         pParser->Error( SbERR_INTERNAL_ERROR, "OPCODE2" );
 103 #endif
 104     GenStmnt();
 105     aCode += (sal_uInt8) eOpcode;
 106     sal_uInt32 n = GetPC();
 107     aCode += nOpnd;
 108     return n;
 109 }
 110
 111 sal_uInt32 SbiCodeGen::Gen( SbiOpcode eOpcode, sal_uInt32 nOpnd1, sal_uInt32 nOpnd2 )
 112 {
 113     if( pParser->IsCodeCompleting() )
 114         return 0;
 115
 116 #ifdef DBG_UTIL
 117     if( eOpcode < SbOP2_START || eOpcode > SbOP2_END )
 118         pParser->Error( SbERR_INTERNAL_ERROR, "OPCODE3" );
 119 #endif
 120     GenStmnt();
 121     aCode += (sal_uInt8) eOpcode;
 122     sal_uInt32 n = GetPC();
 123     aCode += nOpnd1;
 124     aCode += nOpnd2;
 125     return n;
 126 }
 127
 128 // Storing of the created image in the module
 129
 130 void SbiCodeGen::Save()
 131 {
 132     if( pParser->IsCodeCompleting() )
 133         return;
 134
 135     SbiImage* p = new SbiImage;
 136     rMod.StartDefinitions();
 137     // OPTION BASE-Value:
 138     p->nDimBase = pParser->nBase;
 139     // OPTION take over the EXPLICIT-Flag
 140     if( pParser->bExplicit )
 141         p->SetFlag( SbiImageFlags::EXPLICIT );
 142
 143     int nIfaceCount = 0;
 144     if( rMod.mnType == com::sun::star::script::ModuleType::CLASS )
 145     {
 146                 OSL_TRACE("COdeGen::save() classmodule processing");
 147         rMod.bIsProxyModule = true;
 148         p->SetFlag( SbiImageFlags::CLASSMODULE );
 149         GetSbData()->pClassFac->AddClassModule( &rMod );
 150
 151         nIfaceCount = pParser->aIfaceVector.size();
 152         if( !rMod.pClassData )
 153             rMod.pClassData = new SbClassData;
 154         if( nIfaceCount )
 155         {
 156             for( int i = 0 ; i < nIfaceCount ; i++ )
 157             {
 158                 const OUString& rIfaceName = pParser->aIfaceVector[i];
 159                 SbxVariable* pIfaceVar = new SbxVariable( SbxVARIANT );
 160                 pIfaceVar->SetName( rIfaceName );
 161                 SbxArray* pIfaces = rMod.pClassData->mxIfaces;
 162                 pIfaces->Insert( pIfaceVar, pIfaces->Count() );
 163             }
 164         }
 165
 166         rMod.pClassData->maRequiredTypes = pParser->aRequiredTypes;
 167     }
 168     else
 169     {
 170         GetSbData()->pClassFac->RemoveClassModule( &rMod );
 171         // Only a ClassModule can revert to Normal
 172         if ( rMod.mnType == com::sun::star::script::ModuleType::CLASS )
 173         {
 174             rMod.mnType = com::sun::star::script::ModuleType::NORMAL;
 175         }
 176         rMod.bIsProxyModule = false;
 177     }
 178
 179     // GlobalCode-Flag
 180     if( pParser->HasGlobalCode() )
 181     {
 182         p->SetFlag( SbiImageFlags::INITCODE );
 183     }
 184     // Die Entrypoints:
 185     for( SbiSymDef* pDef = pParser->aPublics.First(); pDef;
 186          pDef = pParser->aPublics.Next() )
 187     {
 188         SbiProcDef* pProc = pDef->GetProcDef();
 189         if( pProc && pProc->IsDefined() )
 190         {
 191             OUString aProcName = pProc->GetName();
 192             OUString aIfaceProcName;
 193             OUString aIfaceName;
 194             sal_uInt16 nPassCount = 1;
 195             if( nIfaceCount )
 196             {
 197                 int nPropPrefixFound = aProcName.indexOf(OUString("Property "));
 198                 OUString aPureProcName = aProcName;
 199                 OUString aPropPrefix;
 200                 if( nPropPrefixFound == 0 )
 201                 {
 202                     aPropPrefix = aProcName.copy( 0, 13 );      // 13 == Len( "Property ?et " )
 203                     aPureProcName = aProcName.copy( 13 );
 204                 }
 205                 for( int i = 0 ; i < nIfaceCount ; i++ )
 206                 {
 207                     const OUString& rIfaceName = pParser->aIfaceVector[i];
 208                     int nFound = aPureProcName.indexOf( rIfaceName );
 209                     if( nFound == 0 && '_' == aPureProcName[rIfaceName.getLength()] )
 210                     {
 211                         if( nPropPrefixFound == 0 )
 212                         {
 213                             aIfaceProcName += aPropPrefix;
 214                         }
 215                         aIfaceProcName += aPureProcName.copy( rIfaceName.getLength() + 1 );
 216                         aIfaceName = rIfaceName;
 217                         nPassCount = 2;
 218                         break;
 219                     }
 220                 }
 221             }
 222             SbMethod* pMeth = NULL;
 223             for( sal_uInt16 nPass = 0 ; nPass < nPassCount ; nPass++ )
 224             {
 225                 if( nPass == 1 )
 226                 {
 227                     aProcName = aIfaceProcName;
 228                 }
 229                 PropertyMode ePropMode = pProc->getPropertyMode();
 230                 if( ePropMode != PROPERTY_MODE_NONE )
 231                 {
 232                     SbxDataType ePropType = SbxEMPTY;
 233                     switch( ePropMode )
 234                     {
 235                     case PROPERTY_MODE_GET:
 236                         ePropType = pProc->GetType();
 237                         break;
 238                     case PROPERTY_MODE_LET:
 239                     {
 240                         // type == type of first parameter
 241                         ePropType = SbxVARIANT;     // Default
 242                         SbiSymPool* pPool = &pProc->GetParams();
 243                         if( pPool->GetSize() > 1 )
 244                         {
 245                             SbiSymDef* pPar = pPool->Get( 1 );
 246                             if( pPar )
 247                             {
 248                                 ePropType = pPar->GetType();
 249                             }
 250                         }
 251                         break;
 252                     }
 253                     case PROPERTY_MODE_SET:
 254                         ePropType = SbxOBJECT;
 255                         break;
 256                     default:
 257                         OSL_FAIL("Illegal PropertyMode");
 258                         break;
 259                     }
 260                     OUString aPropName = pProc->GetPropName();
 261                     if( nPass == 1 )
 262                     {
 263                         aPropName = aPropName.copy( aIfaceName.getLength() + 1 );
 264                     }
 265                     OSL_TRACE("*** getProcedureProperty for thing %s",
 266                               OUStringToOString( aPropName,RTL_TEXTENCODING_UTF8 ).getStr() );
 267                     rMod.GetProcedureProperty( aPropName, ePropType );
 268                 }
 269                 if( nPass == 1 )
 270                 {
 271                     rMod.GetIfaceMapperMethod( aProcName, pMeth );
 272                 }
 273                 else
 274                 {
 275                     pMeth = rMod.GetMethod( aProcName, pProc->GetType() );
 276
 277                     if( !pProc->IsPublic() )
 278                     {
 279                         pMeth->SetFlag( SBX_PRIVATE );
 280                     }
 281                     // Declare? -> Hidden
 282                     if( !pProc->GetLib().isEmpty())
 283                     {
 284                         pMeth->SetFlag( SBX_HIDDEN );
 285                     }
 286                     pMeth->nStart = pProc->GetAddr();
 287                     pMeth->nLine1 = pProc->GetLine1();
 288                     pMeth->nLine2 = pProc->GetLine2();
 289                     // The parameter:
 290                     SbxInfo* pInfo = pMeth->GetInfo();
 291                     OUString aHelpFile, aComment;
 292                     sal_uInt32 nHelpId = 0;
 293                     if( pInfo )
 294                     {
 295                         // Rescue the additional data
 296                         aHelpFile = pInfo->GetHelpFile();
 297                         aComment  = pInfo->GetComment();
 298                         nHelpId   = pInfo->GetHelpId();
 299                     }
 300                     // And reestablish the parameter list
 301                     pInfo = new SbxInfo( aHelpFile, nHelpId );
 302                     pInfo->SetComment( aComment );
 303                     SbiSymPool* pPool = &pProc->GetParams();
 304                     // The first element is always the value of the function!
 305                     for( sal_uInt16 i = 1; i < pPool->GetSize(); i++ )
 306                     {
 307                         SbiSymDef* pPar = pPool->Get( i );
 308                         SbxDataType t = pPar->GetType();
 309                         if( !pPar->IsByVal() )
 310                         {
 311                             t = (SbxDataType) ( t | SbxBYREF );
 312                         }
 313                         if( pPar->GetDims() )
 314                         {
 315                             t = (SbxDataType) ( t | SbxARRAY );
 316                         }
 317                         // #33677 hand-over an Optional-Info
 318                         SbxFlagBits nFlags = SBX_READ;
 319                         if( pPar->IsOptional() )
 320                         {
 321                             nFlags |= SBX_OPTIONAL;
 322                         }
 323                         pInfo->AddParam( pPar->GetName(), t, nFlags );
 324
 325                         sal_uInt32 nUserData = 0;
 326                         sal_uInt16 nDefaultId = pPar->GetDefaultId();
 327                         if( nDefaultId )
 328                         {
 329                             nUserData |= nDefaultId;
 330                         }
 331                         if( pPar->IsParamArray() )
 332                         {
 333                             nUserData |= PARAM_INFO_PARAMARRAY;
 334                         }
 335                         if( pPar->IsWithBrackets() )
 336                         {
 337                             nUserData |= PARAM_INFO_WITHBRACKETS;
 338                         }
 339                         SbxParamInfo* pParam = NULL;
 340                         if( nUserData )
 341                         {
 342                             pParam = const_cast<SbxParamInfo*>(pInfo->GetParam( i ));
 343                         }
 344                         if( pParam )
 345                         {
 346                             pParam->nUserData = nUserData;
 347                         }
 348                     }
 349                     pMeth->SetInfo( pInfo );
 350                 }
 351             }   // for( iPass...
 352         }
 353     }
 354     // The code
 355     p->AddCode( aCode.GetBuffer(), aCode.GetSize() );
 356
 357     // The global StringPool. 0 is not occupied.
 358     SbiStringPool* pPool = &pParser->aGblStrings;
 359     sal_uInt16 nSize = pPool->GetSize();
 360     p->MakeStrings( nSize );
 361     sal_uInt16 i;
 362     for( i = 1; i <= nSize; i++ )
 363     {
 364         p->AddString( pPool->Find( i ) );
 365     }
 366     // Insert types
 367     sal_uInt16 nCount = pParser->rTypeArray->Count();
 368     for (i = 0; i < nCount; i++)
 369     {
 370          p->AddType(static_cast<SbxObject *>(pParser->rTypeArray->Get(i)));
 371     }
 372     // Insert enum objects
 373     nCount = pParser->rEnumArray->Count();
 374     for (i = 0; i < nCount; i++)
 375     {
 376          p->AddEnum(static_cast<SbxObject *>(pParser->rEnumArray->Get(i)));
 377     }
 378     if( !p->IsError() )
 379     {
 380         rMod.pImage = p;
 381     }
 382     else
 383     {
 384         delete p;
 385     }
 386     rMod.EndDefinitions();
 387 }
 388
 389 template < class T >
 390 class PCodeVisitor
 391 {
 392 public:
 393     virtual ~PCodeVisitor();
 394
 395     virtual void start( sal_uInt8* pStart ) = 0;
 396     virtual void processOpCode0( SbiOpcode eOp ) = 0;
 397     virtual void processOpCode1( SbiOpcode eOp, T nOp1 ) = 0;
 398     virtual void processOpCode2( SbiOpcode eOp, T nOp1, T nOp2 ) = 0;
 399     virtual bool processParams() = 0;
 400     virtual void end() = 0;
 401 };
 402
 403 template <class T> PCodeVisitor< T >::~PCodeVisitor()
 404 {}
 405
 406 template <class T>
 407 class PCodeBufferWalker
 408 {
 409 private:
 410     T  m_nBytes;
 411     sal_uInt8* m_pCode;
 412     static T readParam( sal_uInt8*& pCode )
 413     {
 414         short nBytes = sizeof( T );
 415         T nOp1=0;
 416         for ( int i=0; i<nBytes; ++i )
 417             nOp1 |= *pCode++ << ( i * 8);
 418         return nOp1;
 419     }
 420 public:
 421     PCodeBufferWalker( sal_uInt8* pCode, T nBytes ): m_nBytes( nBytes ), m_pCode( pCode )
 422     {
 423     }
 424     void visitBuffer( PCodeVisitor< T >& visitor )
 425     {
 426         sal_uInt8* pCode = m_pCode;
 427         if ( !pCode )
 428             return;
 429         sal_uInt8* pEnd = pCode + m_nBytes;
 430         visitor.start( m_pCode );
 431         T nOp1 = 0, nOp2 = 0;
 432         for( ; pCode < pEnd; )
 433         {
 434             SbiOpcode eOp = (SbiOpcode)(*pCode++);
 435
 436             if ( eOp <= SbOP0_END )
 437                 visitor.processOpCode0( eOp );
 438             else if( eOp >= SbOP1_START && eOp <= SbOP1_END )
 439             {
 440                 if ( visitor.processParams() )
 441                     nOp1 = readParam( pCode );
 442                 else
 443                     pCode += sizeof( T );
 444                 visitor.processOpCode1( eOp, nOp1 );
 445             }
 446             else if( eOp >= SbOP2_START && eOp <= SbOP2_END )
 447             {
 448                 if ( visitor.processParams() )
 449                 {
 450                     nOp1 = readParam( pCode );
 451                     nOp2 = readParam( pCode );
 452                 }
 453                 else
 454                     pCode += ( sizeof( T ) * 2 );
 455                 visitor.processOpCode2( eOp, nOp1, nOp2 );
 456             }
 457         }
 458         visitor.end();
 459     }
 460 };
 461
 462 template < class T, class S >
 463 class OffSetAccumulator : public PCodeVisitor< T >
 464 {
 465     T m_nNumOp0;
 466     T m_nNumSingleParams;
 467     T m_nNumDoubleParams;
 468 public:
 469
 470     OffSetAccumulator() : m_nNumOp0(0), m_nNumSingleParams(0), m_nNumDoubleParams(0){}
 471     virtual void start( sal_uInt8* /*pStart*/ ){}
 472     virtual void processOpCode0( SbiOpcode /*eOp*/ ){ ++m_nNumOp0; }
 473     virtual void processOpCode1( SbiOpcode /*eOp*/, T /*nOp1*/ ){  ++m_nNumSingleParams; }
 474     virtual void processOpCode2( SbiOpcode /*eOp*/, T /*nOp1*/, T /*nOp2*/ ) { ++m_nNumDoubleParams; }
 475     virtual void end(){}
 476     S offset()
 477     {
 478         T result = 0 ;
 479         static const S max = std::numeric_limits< S >::max();
 480         result = m_nNumOp0 + ( ( sizeof(S) + 1 ) * m_nNumSingleParams ) + ( (( sizeof(S) * 2 )+ 1 )  * m_nNumDoubleParams );
 481         return std::min(static_cast<T>(max), result);
 482     }
 483    virtual bool processParams(){ return false; }
 484 };
 485
 486
 487
 488 template < class T, class S >
 489
 490 class BufferTransformer : public PCodeVisitor< T >
 491 {
 492     sal_uInt8* m_pStart;
 493     SbiBuffer m_ConvertedBuf;
 494 public:
 495     BufferTransformer():m_pStart(NULL), m_ConvertedBuf( NULL, 1024 ) {}
 496     virtual void start( sal_uInt8* pStart ){ m_pStart = pStart; }
 497     virtual void processOpCode0( SbiOpcode eOp )
 498     {
 499         m_ConvertedBuf += (sal_uInt8)eOp;
 500     }
 501     virtual void processOpCode1( SbiOpcode eOp, T nOp1 )
 502     {
 503         m_ConvertedBuf += (sal_uInt8)eOp;
 504         switch( eOp )
 505         {
 506             case _JUMP:
 507             case _JUMPT:
 508             case _JUMPF:
 509             case _GOSUB:
 510             case _CASEIS:
 511             case _RETURN:
 512             case _ERRHDL:
 513             case _TESTFOR:
 514                 nOp1 = static_cast<T>( convertBufferOffSet(m_pStart, nOp1) );
 515                 break;
 516             case _RESUME:
 517                 if ( nOp1 > 1 )
 518                     nOp1 = static_cast<T>( convertBufferOffSet(m_pStart, nOp1) );
 519                 break;
 520             default:
 521                 break;
 522
 523         }
 524         m_ConvertedBuf += static_cast<S>(nOp1);
 525     }
 526     virtual void processOpCode2( SbiOpcode eOp, T nOp1, T nOp2 )
 527     {
 528         m_ConvertedBuf += (sal_uInt8)eOp;
 529         if ( eOp == _CASEIS )
 530                 if ( nOp1 )
 531                     nOp1 = static_cast<T>( convertBufferOffSet(m_pStart, nOp1) );
 532         m_ConvertedBuf += static_cast<S>(nOp1);
 533         m_ConvertedBuf += static_cast<S>(nOp2);
 534
 535     }
 536     virtual bool processParams(){ return true; }
 537     virtual void end() {}
 538     // yeuch, careful here, you can only call
 539     // GetBuffer on the returned SbiBuffer once, also
 540     // you (as the caller) get to own the memory
 541     SbiBuffer& buffer()
 542     {
 543         return m_ConvertedBuf;
 544     }
 545     static S convertBufferOffSet( sal_uInt8* pStart, T nOp1 )
 546     {
 547         PCodeBufferWalker< T > aBuff( pStart, nOp1);
 548         OffSetAccumulator< T, S > aVisitor;
 549         aBuff.visitBuffer( aVisitor );
 550         return aVisitor.offset();
 551     }
 552 };
 553
 554 sal_uInt32
 555 SbiCodeGen::calcNewOffSet( sal_uInt8* pCode, sal_uInt16 nOffset )
 556 {
 557     return BufferTransformer< sal_uInt16, sal_uInt32 >::convertBufferOffSet( pCode, nOffset );
 558 }
 559
 560 sal_uInt16
 561 SbiCodeGen::calcLegacyOffSet( sal_uInt8* pCode, sal_uInt32 nOffset )
 562 {
 563     return BufferTransformer< sal_uInt32, sal_uInt16 >::convertBufferOffSet( pCode, nOffset );
 564 }
 565
 566 template <class T, class S>
 567 void
 568 PCodeBuffConvertor<T,S>::convert()
 569 {
 570     PCodeBufferWalker< T > aBuf( m_pStart, m_nSize );
 571     BufferTransformer< T, S > aTrnsfrmer;
 572     aBuf.visitBuffer( aTrnsfrmer );
 573     m_pCnvtdBuf = reinterpret_cast<sal_uInt8*>(aTrnsfrmer.buffer().GetBuffer());
 574     m_nCnvtdSize = static_cast<S>( aTrnsfrmer.buffer().GetSize() );
 575 }
 576
 577 template class PCodeBuffConvertor< sal_uInt16, sal_uInt32 >;
 578 template class PCodeBuffConvertor< sal_uInt32, sal_uInt16 >;
 579
 580 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */