xref: /aoo4110/main/basic/source/comp/symtbl.cxx (revision b1cdbd2c)

/**************************************************************
 *
 * 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 "sbcomp.hxx"
#include <stdio.h>
#include <string.h>
#include <ctype.h>

SV_IMPL_PTRARR(SbiStrings,String*)
SV_IMPL_PTRARR(SbiSymbols,SbiSymDef*)

// Alle Symbolnamen werden im Stringpool des Symbol-Pools abgelegt, damit
// alle Symbole im gleichen Case verarbeitet werden. Beim Speichern des
// Code-Images wird der globale Stringpool mit den entsprechenden Sympools
// gespeichert. Der lokale Stringpool nimmt alle Symbole auf, die nicht
// ins Image wandern (Labels, Konstantennamen etc).

/***************************************************************************
|*
|*	SbiStringPool
|*
***************************************************************************/

SbiStringPool::SbiStringPool( SbiParser* p )
{
	pParser = p;
}

SbiStringPool::~SbiStringPool()
{}

// Suchen

const String& SbiStringPool::Find( sal_uInt16 n ) const
{
	if( !n || n > aData.Count() )
		return aEmpty;
	else
		return *aData.GetObject( n-1 );
}

// Hinzufuegen eines Strings. Der String wird Case-Insensitiv
// verglichen.

short SbiStringPool::Add( const String& rVal, sal_Bool bNoCase )
{
	sal_uInt16 n = aData.Count();
	for( sal_uInt16 i = 0; i < n; i++ )
	{
		String* p = aData.GetObject( i );
		if( (  bNoCase && p->Equals( rVal ) )
		 || ( !bNoCase && p->EqualsIgnoreCaseAscii( rVal ) ) )
			return i+1;
	}
	const String* pNew = new String( rVal );
	aData.Insert( pNew, n++ );
	return (short) n;
}

short SbiStringPool::Add( double n, SbxDataType t )
{
	char buf[ 40 ];
	switch( t )
	{
        case SbxINTEGER: snprintf( buf, sizeof(buf), "%d", (short) n ); break;
        case SbxLONG:    snprintf( buf, sizeof(buf), "%ld", (long) n ); break;
        case SbxSINGLE:  snprintf( buf, sizeof(buf), "%.6g", (float) n ); break;
        case SbxDOUBLE:  snprintf( buf, sizeof(buf), "%.16g", n ); break;
		default: break;
	}
	return Add( String::CreateFromAscii( buf ) );
}

/***************************************************************************
|*
|*	SbiSymPool
|*
***************************************************************************/

SbiSymPool::SbiSymPool( SbiStringPool& r, SbiSymScope s ) : rStrings( r )
{
	pParser	 = r.GetParser();
	eScope   = s;
	pParent  = NULL;
	nCur	 =
	nProcId  = 0;
}

SbiSymPool::~SbiSymPool()
{}

// Inhalt loeschen

void SbiSymPool::Clear()
{
	aData.DeleteAndDestroy( 0, aData.Count() );
}

SbiSymDef* SbiSymPool::First()
{
	nCur = (sal_uInt16) -1;
	return Next();
}

SbiSymDef* SbiSymPool::Next()
{
	if( ++nCur >= aData.Count() )
		return NULL;
	else
		return aData.GetObject( nCur );
}

// Hinzufuegen eines Symbols

SbiSymDef* SbiSymPool::AddSym( const String& rName )
{
	SbiSymDef* p = new SbiSymDef( rName );
	p->nPos    = aData.Count();
	p->nId	   = rStrings.Add( rName );
	p->nProcId = nProcId;
	p->pIn	   = this;
	const SbiSymDef* q = p;
	aData.Insert( q, q->nPos );
	return p;
}

SbiProcDef* SbiSymPool::AddProc( const String& rName )
{
	SbiProcDef* p = new SbiProcDef( pParser, rName );
	p->nPos    = aData.Count();
	p->nId	   = rStrings.Add( rName );
	// Procs sind immer global
	p->nProcId = 0;
	p->pIn	   = this;
	const SbiSymDef* q = p;
	aData.Insert( q, q->nPos );
	return p;
}

// Hinzufuegen einer extern aufgebauten Symboldefinition

void SbiSymPool::Add( SbiSymDef* pDef )
{
	if( pDef && pDef->pIn != this )
	{
		if( pDef->pIn )
		{
#ifdef DBG_UTIL
			// schon in einem anderen Pool drin!
			pParser->Error( SbERR_INTERNAL_ERROR, "Dbl Pool" );
#endif
			return;
		}

		pDef->nPos = aData.Count();
		if( !pDef->nId )
		{
			// Bei statischen Variablen muss ein eindeutiger Name
			// im Stringpool erzeugt werden (Form ProcName:VarName)
			String aName( pDef->aName );
			if( pDef->IsStatic() )
			{
				aName = pParser->aGblStrings.Find( nProcId );
				aName += ':';
				aName += pDef->aName;
			}
			pDef->nId = rStrings.Add( aName );
		}
		// Procs sind immer global
		if( !pDef->GetProcDef() )
			pDef->nProcId = nProcId;
		pDef->pIn = this;
		const SbiSymDef* q = pDef;
		aData.Insert( q, q->nPos );
	}
}

// Suchen eines Eintrags ueber den Namen. Es wird auch im Parent gesucht.

SbiSymDef* SbiSymPool::Find( const String& rName ) const
{
	sal_uInt16 nCount = aData.Count();
	for( sal_uInt16 i = 0; i < nCount; i++ )
	{
		SbiSymDef* p = aData.GetObject( nCount - i - 1 );
		if( ( !p->nProcId || ( p->nProcId == nProcId ) )
		 && ( p->aName.EqualsIgnoreCaseAscii( rName ) ) )
			return p;
	}
	if( pParent )
		return pParent->Find( rName );
	else
		return NULL;
}

// Suchen ueber ID-Nummer

SbiSymDef* SbiSymPool::FindId( sal_uInt16 n ) const
{
	for( sal_uInt16 i = 0; i < aData.Count(); i++ )
	{
		SbiSymDef* p = aData.GetObject( i );
		if( p->nId == n && ( !p->nProcId || ( p->nProcId == nProcId ) ) )
			return p;
	}
	if( pParent )
		return pParent->FindId( n );
	else
		return NULL;
}

// Suchen ueber Position (ab 0)

SbiSymDef* SbiSymPool::Get( sal_uInt16 n ) const
{
	if( n >= aData.Count() )
		return NULL;
	else
		return aData.GetObject( n );
}

sal_uInt32 SbiSymPool::Define( const String& rName )
{
	SbiSymDef* p = Find( rName );
	if( p )
	{	if( p->IsDefined() )
			pParser->Error( SbERR_LABEL_DEFINED, rName );
	}
	else
		p = AddSym( rName );
	return p->Define();
}

sal_uInt32 SbiSymPool::Reference( const String& rName )
{
	SbiSymDef* p = Find( rName );
	if( !p )
		p = AddSym( rName );
	//Sicherheitshalber
	pParser->aGen.GenStmnt();
	return p->Reference();
}

// Alle offenen Referenzen anmaulen

void SbiSymPool::CheckRefs()
{
	for( sal_uInt16 i = 0; i < aData.Count(); i++ )
	{
		SbiSymDef* p = aData.GetObject( i );
		if( !p->IsDefined() )
			pParser->Error( SbERR_UNDEF_LABEL, p->GetName() );
	}
}

/***************************************************************************
|*
|*	Symbol-Definitionen
|*
***************************************************************************/

SbiSymDef::SbiSymDef( const String& rName ) : aName( rName )
{
	eType	 = SbxEMPTY;
	nDims	 = 0;
	nTypeId  = 0;
	nProcId  = 0;
	nId 	 = 0;
	nPos	 = 0;
	nLen	 = 0;
	nChain	 = 0;
	bAs		 =
	bNew	 =
	bStatic	 =
	bOpt	 =
	bParamArray =
	bWithEvents =
	bWithBrackets =
	bByVal	 =
	bChained =
    bGlobal  = sal_False;
	pIn		 =
	pPool	 = NULL;
	nDefaultId = 0;
	nFixedStringLength = -1;
}

SbiSymDef::~SbiSymDef()
{
	delete pPool;
}

SbiProcDef* SbiSymDef::GetProcDef()
{
	return NULL;
}

SbiConstDef* SbiSymDef::GetConstDef()
{
	return NULL;
}

// Wenn der Name benoetigt wird, den aktuellen Namen
// aus dem Stringpool nehmen

const String& SbiSymDef::GetName()
{
	if( pIn )
		aName = pIn->rStrings.Find( nId );
	return aName;
}

// Eintragen eines Datentyps

void SbiSymDef::SetType( SbxDataType t )
{
	if( t == SbxVARIANT && pIn )
	{
		sal_Unicode cu = aName.GetBuffer()[0];
		if( cu < 256 )
		{
			char ch = (char)aName.GetBuffer()[0];
			if( ch == '_' ) ch = 'Z';
			int ch2 = toupper( ch );
			unsigned char c = (unsigned char)ch2;
			if( c > 0 && c < 128 )
				t = pIn->pParser->eDefTypes[ ch2 - 'A' ];
		}
	}
	eType = t;
}

// Aufbau einer Backchain, falls noch nicht definiert
// Es wird der Wert zurueckgeliefert, der als Operand gespeichert
// werden soll.

sal_uInt32 SbiSymDef::Reference()
{
	if( !bChained )
	{
		sal_uInt32 n = nChain;
		nChain = pIn->pParser->aGen.GetOffset();
		return n;
	}
	else return nChain;
}

// Definition eines Symbols.
// Hier wird der Backchain aufgeloest, falls vorhanden

sal_uInt32 SbiSymDef::Define()
{
	sal_uInt32 n = pIn->pParser->aGen.GetPC();
	pIn->pParser->aGen.GenStmnt();
	if( nChain ) pIn->pParser->aGen.BackChain( nChain );
	nChain = n;
	bChained = sal_True;
	return nChain;
}

// Eine Symboldefinition kann einen eigenen Pool haben. Dies ist
// der Fall bei Objekten und Prozeduren (lokale Variable)

SbiSymPool& SbiSymDef::GetPool()
{
	if( !pPool )
		pPool = new SbiSymPool( pIn->pParser->aGblStrings, SbLOCAL );	// wird gedumpt
	return *pPool;
}

SbiSymScope SbiSymDef::GetScope() const
{
	return pIn ? pIn->GetScope() : SbLOCAL;
}

////////////////////////////////////////////////////////////////////////////

// Die Prozedur-Definition hat drei Pools:
// 1) aParams: wird durch die Definition gefuellt. Enthaelt die Namen
//	  der Parameter, wie sie innerhalb des Rumpfes verwendet werden.
//	  Das erste Element ist der Returnwert.
// 2) pPool: saemtliche lokale Variable
// 3) aLabels: Labels

SbiProcDef::SbiProcDef( SbiParser* pParser, const String& rName,
					    sal_Bool bProcDecl )
		 : SbiSymDef( rName )
		 , aParams( pParser->aGblStrings, SbPARAM )  // wird gedumpt
		 , aLabels( pParser->aLclStrings, SbLOCAL )	 // wird nicht gedumpt
		 , mbProcDecl( bProcDecl )
{
	aParams.SetParent( &pParser->aPublics );
	pPool = new SbiSymPool( pParser->aGblStrings, SbLOCAL ); // Locals
	pPool->SetParent( &aParams );
	nLine1	=
	nLine2	= 0;
	mePropMode = PROPERTY_MODE_NONE;
	bPublic = sal_True;
	bCdecl	= sal_False;
	bStatic = sal_False;
	// Fuer Returnwerte ist das erste Element der Parameterliste
	// immer mit dem Namen und dem Typ der Proc definiert
	aParams.AddSym( aName );
}

SbiProcDef::~SbiProcDef()
{}

SbiProcDef* SbiProcDef::GetProcDef()
{
	return this;
}

void SbiProcDef::SetType( SbxDataType t )
{
	SbiSymDef::SetType( t );
	aParams.Get( 0 )->SetType( eType );
}

// Match mit einer Forward-Deklaration
// Falls der Match OK ist, wird pOld durch this im Pool ersetzt
// pOld wird immer geloescht!

void SbiProcDef::Match( SbiProcDef* pOld )
{
	SbiSymDef* po, *pn=NULL;
	// Parameter 0 ist der Funktionsname
	sal_uInt16 i;
	for( i = 1; i < aParams.GetSize(); i++ )
	{
		po = pOld->aParams.Get( i );
		pn = aParams.Get( i );
		// Kein Typabgleich; das wird beim Laufen erledigt
		// aber ist sie evtl. mit zu wenigen Parametern aufgerufen
		// worden?
		if( !po && !pn->IsOptional() && !pn->IsParamArray() )
			break;
		po = pOld->aParams.Next();
	}
	// Wurden zu viele Parameter angegeben?
	if( pn && i < aParams.GetSize() && pOld->pIn )
	{
		// Die ganze Zeile markieren
		pOld->pIn->GetParser()->SetCol1( 0 );
		pOld->pIn->GetParser()->Error( SbERR_BAD_DECLARATION, aName );
	}
	if( !pIn && pOld->pIn )
	{
		// Alten Eintrag durch neuen ersetzen
		SbiSymDef** pData = (SbiSymDef**) pOld->pIn->aData.GetData();
		pData[ pOld->nPos ] = this;
		nPos = pOld->nPos;
		nId  = pOld->nId;
		pIn  = pOld->pIn;
	}
	delete pOld;
}

void SbiProcDef::setPropertyMode( PropertyMode ePropMode )
{
	mePropMode = ePropMode;
	if( mePropMode != PROPERTY_MODE_NONE )
	{
		// Prop name = original scanned procedure name
		maPropName = aName;

		// CompleteProcName includes "Property xxx "
		// to avoid conflicts with other symbols
		String aCompleteProcName;
		aCompleteProcName.AppendAscii( "Property " );
		switch( mePropMode )
		{
			case PROPERTY_MODE_GET:		aCompleteProcName.AppendAscii( "Get " ); break;
			case PROPERTY_MODE_LET:		aCompleteProcName.AppendAscii( "Let " ); break;
			case PROPERTY_MODE_SET:		aCompleteProcName.AppendAscii( "Set " ); break;
			case PROPERTY_MODE_NONE:
				DBG_ERROR( "Illegal PropertyMode PROPERTY_MODE_NONE" );
				break;
		}
		aCompleteProcName += aName;
		aName = aCompleteProcName;
	}
}


//////////////////////////////////////////////////////////////////////////

SbiConstDef::SbiConstDef( const String& rName )
		   : SbiSymDef( rName )
{
	nVal = 0; eType = SbxINTEGER;
}

void SbiConstDef::Set( double n, SbxDataType t )
{
	aVal.Erase(); nVal = n; eType = t;
}

void SbiConstDef::Set( const String& n )
{
	aVal = n; nVal = 0; eType = SbxSTRING;
}

SbiConstDef::~SbiConstDef()
{}

SbiConstDef* SbiConstDef::GetConstDef()
{
	return this;
}