| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_basic.hxx" | |
| #include <basic/sbx.hxx> | |
| #include "sbcomp.hxx" | |
| #include "image.hxx" | |
| #include <limits> | |
| #include <com/sun/star/script/ModuleType.hpp> | |
| // nInc ist die Inkrementgroesse der Puffer | |
| SbiCodeGen::SbiCodeGen( SbModule& r, SbiParser* p, short nInc ) | |
| : rMod( r ), aCode( p, nInc ) | |
| { | |
| pParser = p; | |
| bStmnt = sal_False; | |
| nLine = 0; | |
| nCol = 0; | |
| nForLevel = 0; | |
| } | |
| sal_uInt32 SbiCodeGen::GetPC() | |
| { | |
| return aCode.GetSize(); | |
| } | |
| // Statement merken | |
| void SbiCodeGen::Statement() | |
| { | |
| bStmnt = sal_True; | |
| nLine = pParser->GetLine(); | |
| nCol = pParser->GetCol1(); | |
| // #29955 Information der for-Schleifen-Ebene | |
| // in oberen Byte der Spalte speichern | |
| nCol = (nCol & 0xff) + 0x100 * nForLevel; | |
| } | |
| // Anfang eines Statements markieren | |
| void SbiCodeGen::GenStmnt() | |
| { | |
| if( bStmnt ) | |
| { | |
| bStmnt = sal_False; | |
| Gen( _STMNT, nLine, nCol ); | |
| } | |
| } | |
| // Die Gen-Routinen returnen den Offset des 1. Operanden, | |
| // damit Jumps dort ihr Backchain versenken koennen | |
| sal_uInt32 SbiCodeGen::Gen( SbiOpcode eOpcode ) | |
| { | |
| #ifdef DBG_UTIL | |
| if( eOpcode < SbOP0_START || eOpcode > SbOP0_END ) | |
| pParser->Error( SbERR_INTERNAL_ERROR, "OPCODE1" ); | |
| #endif | |
| GenStmnt(); | |
| aCode += (sal_uInt8) eOpcode; | |
| return GetPC(); | |
| } | |
| sal_uInt32 SbiCodeGen::Gen( SbiOpcode eOpcode, sal_uInt32 nOpnd ) | |
| { | |
| #ifdef DBG_UTIL | |
| if( eOpcode < SbOP1_START || eOpcode > SbOP1_END ) | |
| pParser->Error( SbERR_INTERNAL_ERROR, "OPCODE2" ); | |
| #endif | |
| GenStmnt(); | |
| aCode += (sal_uInt8) eOpcode; | |
| sal_uInt32 n = GetPC(); | |
| aCode += nOpnd; | |
| return n; | |
| } | |
| sal_uInt32 SbiCodeGen::Gen( SbiOpcode eOpcode, sal_uInt32 nOpnd1, sal_uInt32 nOpnd2 ) | |
| { | |
| #ifdef DBG_UTIL | |
| if( eOpcode < SbOP2_START || eOpcode > SbOP2_END ) | |
| pParser->Error( SbERR_INTERNAL_ERROR, "OPCODE3" ); | |
| #endif | |
| GenStmnt(); | |
| aCode += (sal_uInt8) eOpcode; | |
| sal_uInt32 n = GetPC(); | |
| aCode += nOpnd1; | |
| aCode += nOpnd2; | |
| return n; | |
| } | |
| // Abspeichern des erzeugten Images im Modul | |
| void SbiCodeGen::Save() | |
| { | |
| SbiImage* p = new SbiImage; | |
| rMod.StartDefinitions(); | |
| // OPTION BASE-Wert: | |
| p->nDimBase = pParser->nBase; | |
| // OPTION EXPLICIT-Flag uebernehmen | |
| if( pParser->bExplicit ) | |
| p->SetFlag( SBIMG_EXPLICIT ); | |
| int nIfaceCount = 0; | |
| if( rMod.mnType == com::sun::star::script::ModuleType::CLASS ) | |
| { | |
| OSL_TRACE("COdeGen::save() classmodule processing"); | |
| rMod.bIsProxyModule = true; | |
| p->SetFlag( SBIMG_CLASSMODULE ); | |
| pCLASSFAC->AddClassModule( &rMod ); | |
| nIfaceCount = pParser->aIfaceVector.size(); | |
| if( !rMod.pClassData ) | |
| rMod.pClassData = new SbClassData; | |
| if( nIfaceCount ) | |
| { | |
| for( int i = 0 ; i < nIfaceCount ; i++ ) | |
| { | |
| const String& rIfaceName = pParser->aIfaceVector[i]; | |
| SbxVariable* pIfaceVar = new SbxVariable( SbxVARIANT ); | |
| pIfaceVar->SetName( rIfaceName ); | |
| SbxArray* pIfaces = rMod.pClassData->mxIfaces; | |
| pIfaces->Insert( pIfaceVar, pIfaces->Count() ); | |
| } | |
| } | |
| rMod.pClassData->maRequiredTypes = pParser->aRequiredTypes; | |
| } | |
| else | |
| { | |
| pCLASSFAC->RemoveClassModule( &rMod ); | |
| // Only a ClassModule can revert to Normal | |
| if ( rMod.mnType == com::sun::star::script::ModuleType::CLASS ) | |
| rMod.mnType = com::sun::star::script::ModuleType::NORMAL; | |
| rMod.bIsProxyModule = false; | |
| } | |
| if( pParser->bText ) | |
| p->SetFlag( SBIMG_COMPARETEXT ); | |
| // GlobalCode-Flag | |
| if( pParser->HasGlobalCode() ) | |
| p->SetFlag( SBIMG_INITCODE ); | |
| // Die Entrypoints: | |
| for( SbiSymDef* pDef = pParser->aPublics.First(); pDef; | |
| pDef = pParser->aPublics.Next() ) | |
| { | |
| SbiProcDef* pProc = pDef->GetProcDef(); | |
| if( pProc && pProc->IsDefined() ) | |
| { | |
| String aProcName = pProc->GetName(); | |
| String aIfaceProcName; | |
| String aIfaceName; | |
| sal_uInt16 nPassCount = 1; | |
| if( nIfaceCount ) | |
| { | |
| int nPropPrefixFound = | |
| aProcName.Search( String( RTL_CONSTASCII_USTRINGPARAM("Property ") ) ); | |
| String aPureProcName = aProcName; | |
| String aPropPrefix; | |
| if( nPropPrefixFound == 0 ) | |
| { | |
| aPropPrefix = aProcName.Copy( 0, 13 ); // 13 == Len( "Property ?et " ) | |
| aPureProcName = aProcName.Copy( 13 ); | |
| } | |
| for( int i = 0 ; i < nIfaceCount ; i++ ) | |
| { | |
| const String& rIfaceName = pParser->aIfaceVector[i]; | |
| int nFound = aPureProcName.Search( rIfaceName ); | |
| if( nFound == 0 && '_' == aPureProcName.GetChar( rIfaceName.Len() ) ) | |
| { | |
| if( nPropPrefixFound == 0 ) | |
| aIfaceProcName += aPropPrefix; | |
| aIfaceProcName += aPureProcName.Copy( rIfaceName.Len() + 1 ); | |
| aIfaceName = rIfaceName; | |
| nPassCount = 2; | |
| break; | |
| } | |
| } | |
| } | |
| SbMethod* pMeth = NULL; | |
| for( sal_uInt16 nPass = 0 ; nPass < nPassCount ; nPass++ ) | |
| { | |
| if( nPass == 1 ) | |
| aProcName = aIfaceProcName; | |
| PropertyMode ePropMode = pProc->getPropertyMode(); | |
| if( ePropMode != PROPERTY_MODE_NONE ) | |
| { | |
| SbxDataType ePropType = SbxEMPTY; | |
| switch( ePropMode ) | |
| { | |
| case PROPERTY_MODE_GET: | |
| ePropType = pProc->GetType(); | |
| break; | |
| case PROPERTY_MODE_LET: | |
| { | |
| // type == type of first parameter | |
| ePropType = SbxVARIANT; // Default | |
| SbiSymPool* pPool = &pProc->GetParams(); | |
| if( pPool->GetSize() > 1 ) | |
| { | |
| SbiSymDef* pPar = pPool->Get( 1 ); | |
| if( pPar ) | |
| ePropType = pPar->GetType(); | |
| } | |
| break; | |
| } | |
| case PROPERTY_MODE_SET: | |
| ePropType = SbxOBJECT; | |
| break; | |
| case PROPERTY_MODE_NONE: | |
| DBG_ERROR( "Illegal PropertyMode PROPERTY_MODE_NONE" ); | |
| break; | |
| } | |
| String aPropName = pProc->GetPropName(); | |
| if( nPass == 1 ) | |
| aPropName = aPropName.Copy( aIfaceName.Len() + 1 ); | |
| SbProcedureProperty* pProcedureProperty = NULL; | |
| pProcedureProperty = rMod.GetProcedureProperty( aPropName, ePropType ); | |
| } | |
| if( nPass == 1 ) | |
| { | |
| SbIfaceMapperMethod* pMapperMeth = NULL; | |
| pMapperMeth = rMod.GetIfaceMapperMethod( aProcName, pMeth ); | |
| } | |
| else | |
| { | |
| pMeth = rMod.GetMethod( aProcName, pProc->GetType() ); | |
| // #110004 | |
| if( !pProc->IsPublic() ) | |
| pMeth->SetFlag( SBX_PRIVATE ); | |
| // Declare? -> Hidden | |
| if( pProc->GetLib().Len() > 0 ) | |
| pMeth->SetFlag( SBX_HIDDEN ); | |
| pMeth->nStart = pProc->GetAddr(); | |
| pMeth->nLine1 = pProc->GetLine1(); | |
| pMeth->nLine2 = pProc->GetLine2(); | |
| // Die Parameter: | |
| SbxInfo* pInfo = pMeth->GetInfo(); | |
| String aHelpFile, aComment; | |
| sal_uIntPtr nHelpId = 0; | |
| if( pInfo ) | |
| { | |
| // Die Zusatzdaten retten | |
| aHelpFile = pInfo->GetHelpFile(); | |
| aComment = pInfo->GetComment(); | |
| nHelpId = pInfo->GetHelpId(); | |
| } | |
| // Und die Parameterliste neu aufbauen | |
| pInfo = new SbxInfo( aHelpFile, nHelpId ); | |
| pInfo->SetComment( aComment ); | |
| SbiSymPool* pPool = &pProc->GetParams(); | |
| // Das erste Element ist immer der Funktionswert! | |
| for( sal_uInt16 i = 1; i < pPool->GetSize(); i++ ) | |
| { | |
| SbiSymDef* pPar = pPool->Get( i ); | |
| SbxDataType t = pPar->GetType(); | |
| if( !pPar->IsByVal() ) | |
| t = (SbxDataType) ( t | SbxBYREF ); | |
| if( pPar->GetDims() ) | |
| t = (SbxDataType) ( t | SbxARRAY ); | |
| // #33677 Optional-Info durchreichen | |
| sal_uInt16 nFlags = SBX_READ; | |
| if( pPar->IsOptional() ) | |
| nFlags |= SBX_OPTIONAL; | |
| pInfo->AddParam( pPar->GetName(), t, nFlags ); | |
| sal_uInt32 nUserData = 0; | |
| sal_uInt16 nDefaultId = pPar->GetDefaultId(); | |
| if( nDefaultId ) | |
| nUserData |= nDefaultId; | |
| if( pPar->IsParamArray() ) | |
| nUserData |= PARAM_INFO_PARAMARRAY; | |
| if( pPar->IsWithBrackets() ) | |
| nUserData |= PARAM_INFO_WITHBRACKETS; | |
| if( nUserData ) | |
| { | |
| SbxParamInfo* pParam = (SbxParamInfo*)pInfo->GetParam( i ); | |
| pParam->nUserData = nUserData; | |
| } | |
| } | |
| pMeth->SetInfo( pInfo ); | |
| } | |
| } // for( iPass... | |
| } | |
| } | |
| // Der Code | |
| p->AddCode( aCode.GetBuffer(), aCode.GetSize() ); | |
| // Der globale StringPool. 0 ist nicht belegt. | |
| SbiStringPool* pPool = &pParser->aGblStrings; | |
| sal_uInt16 nSize = pPool->GetSize(); | |
| p->MakeStrings( nSize ); | |
| sal_uInt16 i; | |
| for( i = 1; i <= nSize; i++ ) | |
| p->AddString( pPool->Find( i ) ); | |
| // Typen einfuegen | |
| sal_uInt16 nCount = pParser->rTypeArray->Count(); | |
| for (i = 0; i < nCount; i++) | |
| p->AddType((SbxObject *)pParser->rTypeArray->Get(i)); | |
| // Insert enum objects | |
| nCount = pParser->rEnumArray->Count(); | |
| for (i = 0; i < nCount; i++) | |
| p->AddEnum((SbxObject *)pParser->rEnumArray->Get(i)); | |
| if( !p->IsError() ) | |
| rMod.pImage = p; | |
| else | |
| delete p; | |
| rMod.EndDefinitions(); | |
| } | |
| template < class T > | |
| class PCodeVisitor | |
| { | |
| public: | |
| virtual ~PCodeVisitor(); | |
| virtual void start( sal_uInt8* pStart ) = 0; | |
| virtual void processOpCode0( SbiOpcode eOp ) = 0; | |
| virtual void processOpCode1( SbiOpcode eOp, T nOp1 ) = 0; | |
| virtual void processOpCode2( SbiOpcode eOp, T nOp1, T nOp2 ) = 0; | |
| virtual bool processParams() = 0; | |
| virtual void end() = 0; | |
| }; | |
| template <class T> PCodeVisitor< T >::~PCodeVisitor() | |
| {} | |
| template <class T> | |
| class PCodeBufferWalker | |
| { | |
| private: | |
| T m_nBytes; | |
| sal_uInt8* m_pCode; | |
| T readParam( sal_uInt8*& pCode ) | |
| { | |
| short nBytes = sizeof( T ); | |
| T nOp1=0; | |
| for ( int i=0; i<nBytes; ++i ) | |
| nOp1 |= *pCode++ << ( i * 8); | |
| return nOp1; | |
| } | |
| public: | |
| PCodeBufferWalker( sal_uInt8* pCode, T nBytes ): m_nBytes( nBytes ), m_pCode( pCode ) | |
| { | |
| } | |
| void visitBuffer( PCodeVisitor< T >& visitor ) | |
| { | |
| sal_uInt8* pCode = m_pCode; | |
| if ( !pCode ) | |
| return; | |
| sal_uInt8* pEnd = pCode + m_nBytes; | |
| visitor.start( m_pCode ); | |
| T nOp1 = 0, nOp2 = 0; | |
| for( ; pCode < pEnd; ) | |
| { | |
| SbiOpcode eOp = (SbiOpcode)(*pCode++); | |
| if ( eOp <= SbOP0_END ) | |
| visitor.processOpCode0( eOp ); | |
| else if( eOp >= SbOP1_START && eOp <= SbOP1_END ) | |
| { | |
| if ( visitor.processParams() ) | |
| nOp1 = readParam( pCode ); | |
| else | |
| pCode += sizeof( T ); | |
| visitor.processOpCode1( eOp, nOp1 ); | |
| } | |
| else if( eOp >= SbOP2_START && eOp <= SbOP2_END ) | |
| { | |
| if ( visitor.processParams() ) | |
| { | |
| nOp1 = readParam( pCode ); | |
| nOp2 = readParam( pCode ); | |
| } | |
| else | |
| pCode += ( sizeof( T ) * 2 ); | |
| visitor.processOpCode2( eOp, nOp1, nOp2 ); | |
| } | |
| } | |
| visitor.end(); | |
| } | |
| }; | |
| template < class T, class S > | |
| class OffSetAccumulator : public PCodeVisitor< T > | |
| { | |
| T m_nNumOp0; | |
| T m_nNumSingleParams; | |
| T m_nNumDoubleParams; | |
| public: | |
| OffSetAccumulator() : m_nNumOp0(0), m_nNumSingleParams(0), m_nNumDoubleParams(0){} | |
| virtual void start( sal_uInt8* /*pStart*/ ){} | |
| virtual void processOpCode0( SbiOpcode /*eOp*/ ){ ++m_nNumOp0; } | |
| virtual void processOpCode1( SbiOpcode /*eOp*/, T /*nOp1*/ ){ ++m_nNumSingleParams; } | |
| virtual void processOpCode2( SbiOpcode /*eOp*/, T /*nOp1*/, T /*nOp2*/ ) { ++m_nNumDoubleParams; } | |
| virtual void end(){} | |
| S offset() | |
| { | |
| T result = 0 ; | |
| static const S max = std::numeric_limits< S >::max(); | |
| result = m_nNumOp0 + ( ( sizeof(S) + 1 ) * m_nNumSingleParams ) + ( (( sizeof(S) * 2 )+ 1 ) * m_nNumDoubleParams ); | |
| if ( result > max ) | |
| return max; | |
| return static_cast<S>(result); | |
| } | |
| virtual bool processParams(){ return false; } | |
| }; | |
| template < class T, class S > | |
| class BufferTransformer : public PCodeVisitor< T > | |
| { | |
| sal_uInt8* m_pStart; | |
| SbiBuffer m_ConvertedBuf; | |
| public: | |
| BufferTransformer():m_pStart(NULL), m_ConvertedBuf( NULL, 1024 ) {} | |
| virtual void start( sal_uInt8* pStart ){ m_pStart = pStart; } | |
| virtual void processOpCode0( SbiOpcode eOp ) | |
| { | |
| m_ConvertedBuf += (sal_uInt8)eOp; | |
| } | |
| virtual void processOpCode1( SbiOpcode eOp, T nOp1 ) | |
| { | |
| m_ConvertedBuf += (sal_uInt8)eOp; | |
| switch( eOp ) | |
| { | |
| case _JUMP: | |
| case _JUMPT: | |
| case _JUMPF: | |
| case _GOSUB: | |
| case _CASEIS: | |
| case _RETURN: | |
| case _ERRHDL: | |
| case _TESTFOR: | |
| nOp1 = static_cast<T>( convertBufferOffSet(m_pStart, nOp1) ); | |
| break; | |
| case _RESUME: | |
| if ( nOp1 > 1 ) | |
| nOp1 = static_cast<T>( convertBufferOffSet(m_pStart, nOp1) ); | |
| break; | |
| default: | |
| break; // | |
| } | |
| m_ConvertedBuf += (S)nOp1; | |
| } | |
| virtual void processOpCode2( SbiOpcode eOp, T nOp1, T nOp2 ) | |
| { | |
| m_ConvertedBuf += (sal_uInt8)eOp; | |
| if ( eOp == _CASEIS ) | |
| if ( nOp1 ) | |
| nOp1 = static_cast<T>( convertBufferOffSet(m_pStart, nOp1) ); | |
| m_ConvertedBuf += (S)nOp1; | |
| m_ConvertedBuf += (S)nOp2; | |
| } | |
| virtual bool processParams(){ return true; } | |
| virtual void end() {} | |
| // yeuch, careful here, you can only call | |
| // GetBuffer on the returned SbiBuffer once, also | |
| // you (as the caller) get to own the memory | |
| SbiBuffer& buffer() | |
| { | |
| return m_ConvertedBuf; | |
| } | |
| static S convertBufferOffSet( sal_uInt8* pStart, T nOp1 ) | |
| { | |
| PCodeBufferWalker< T > aBuff( pStart, nOp1); | |
| OffSetAccumulator< T, S > aVisitor; | |
| aBuff.visitBuffer( aVisitor ); | |
| return aVisitor.offset(); | |
| } | |
| }; | |
| sal_uInt32 | |
| SbiCodeGen::calcNewOffSet( sal_uInt8* pCode, sal_uInt16 nOffset ) | |
| { | |
| return BufferTransformer< sal_uInt16, sal_uInt32 >::convertBufferOffSet( pCode, nOffset ); | |
| } | |
| sal_uInt16 | |
| SbiCodeGen::calcLegacyOffSet( sal_uInt8* pCode, sal_uInt32 nOffset ) | |
| { | |
| return BufferTransformer< sal_uInt32, sal_uInt16 >::convertBufferOffSet( pCode, nOffset ); | |
| } | |
| template <class T, class S> | |
| void | |
| PCodeBuffConvertor<T,S>::convert() | |
| { | |
| PCodeBufferWalker< T > aBuf( m_pStart, m_nSize ); | |
| BufferTransformer< T, S > aTrnsfrmer; | |
| aBuf.visitBuffer( aTrnsfrmer ); | |
| m_pCnvtdBuf = (sal_uInt8*)aTrnsfrmer.buffer().GetBuffer(); | |
| m_nCnvtdSize = static_cast<S>( aTrnsfrmer.buffer().GetSize() ); | |
| } | |
| template class PCodeBuffConvertor< sal_uInt16, sal_uInt32 >; | |
| template class PCodeBuffConvertor< sal_uInt32, sal_uInt16 >; |