blob: c0d610ef184bdaa51f8f84df420d4a5d923ad6db [file] [log] [blame]
/*******************************************************************************
* Copyright (c) 2016 CEA LIST.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
* - Initial API and implementation
******************************************************************************/
#include <builder/compiler/SymbolTable.h>
#include <builder/primitive/CompilationEnvironment.h>
#include <fml/common/ObjectElement.h>
#include <fml/common/PropertyElement.h>
#include <fml/executable/AvmProgram.h>
#include <fml/executable/AvmTransition.h>
#include <fml/executable/BaseAvmProgram.h>
#include <fml/executable/BaseInstanceForm.h>
#include <fml/executable/ExecutableForm.h>
#include <fml/executable/ExecutableLib.h>
#include <fml/executable/ExecutableSystem.h>
#include <fml/executable/InstanceOfBuffer.h>
#include <fml/executable/InstanceOfPort.h>
#include <fml/executable/RoutingData.h>
#include <fml/builtin/QualifiedIdentifier.h>
#include <fml/expression/AvmCode.h>
#include <fml/infrastructure/Channel.h>
#include <fml/infrastructure/Connector.h>
#include <fml/infrastructure/Machine.h>
#include <fml/infrastructure/Port.h>
#include <fml/symbol/Symbol.h>
#include <fml/workflow/UniFormIdentifier.h>
#include <sew/Configuration.h>
namespace sep
{
/**
*******************************************************************************
* SEARCH
*******************************************************************************
*/
/**
* SEARCH
* for Type
*/
const TypeSpecifier & SymbolTable::searchTypeSpecifier(
ExecutableSystem & anExecutableSystem,
COMPILE_CONTEXT * aCTX, const ObjectElement * astElement)
{
BaseAvmProgram * aProgram = aCTX->mCompileCtx;
for( ; aProgram != NULL ; aProgram = aProgram->getContainer() )
{
if( aProgram->is< AvmProgram >() )
{
const TypeSpecifier & foundType =
aProgram->to< AvmProgram >()->getTypeSpecifier(astElement);
if( foundType.valid() )
{
return( foundType );
}
}
}
TableOfExecutableForm::const_raw_iterator itExec =
anExecutableSystem.getExecutables().begin();
TableOfExecutableForm::const_raw_iterator itEnd =
anExecutableSystem.getExecutables().end();
for( ; itExec != itEnd ; ++itExec )
{
const TypeSpecifier & foundType =
(itExec)->getTypeSpecifier(astElement);
if( foundType.valid() )
{
return( foundType );
}
}
return( TypeSpecifier::REF_NULL );
}
const TypeSpecifier & SymbolTable::searchTypeSpecifier(
ExecutableSystem & anExecutableSystem, COMPILE_CONTEXT * aCTX,
const std::string & aFullyQualifiedNameID)
{
BaseAvmProgram * aProgram = aCTX->mCompileCtx;
for( ; aProgram != NULL ; aProgram = aProgram->getContainer() )
{
if( aProgram->is< AvmProgram >() )
{
const TypeSpecifier & foundType = aProgram->to< AvmProgram >()->
getTypeSpecifier( aFullyQualifiedNameID );
if( foundType.valid() )
{
return( foundType );
}
}
}
TableOfExecutableForm::const_raw_iterator itExec =
anExecutableSystem.getExecutables().begin();
TableOfExecutableForm::const_raw_iterator itEnd =
anExecutableSystem.getExecutables().end();
for( ; itExec != itEnd ; ++itExec )
{
const TypeSpecifier & foundType =
(itExec)->getTypeSpecifier( aFullyQualifiedNameID );
if( foundType.valid() )
{
return( foundType );
}
}
return( TypeSpecifier::REF_NULL );
}
/*
* SEARCH
* for Data Instance
*/
const BF & SymbolTable::searchDataInstance(
BaseAvmProgram * tmpProgram, const ObjectElement * astElement) const
{
for( ; tmpProgram != NULL ; tmpProgram = tmpProgram->getContainer() )
{
{
const BF & foundInstance =
tmpProgram->getAllData().getByAstElement(astElement);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
{
const BF & foundInstance =
tmpProgram->getDataAlias().getByAstElement(astElement);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
if( tmpProgram->is< AvmProgram >() )
{
{
const BF & foundInstance = tmpProgram->to< AvmProgram >()->
getConstData().getByAstElement(astElement);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
{
const BF & foundInstance = tmpProgram->to< AvmProgram >()->
getSymbolDataByAstElement(astElement);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
}
}
return( BF::REF_NULL );
}
const BF & SymbolTable::searchDataInstance(
COMPILE_CONTEXT * aCTX, const ObjectElement * objElement)
{
// RESET ERROR
resetError();
const BF & foundInstance =
searchDataInstance(aCTX->mCompileCtx, objElement);
if( foundInstance.valid() )
{
return( foundInstance );
}
else if( aCTX->isSpecificRuntimeCtx() )
{
const BF & foundInstance =
searchDataInstance(aCTX->mRuntimeCtx, objElement);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
return( searchDataInstanceAlias(aCTX, objElement) );
}
const BF & SymbolTable::searchDataInstance(BaseAvmProgram * tmpProgram,
const std::string & aFullyQualifiedNameID) const
{
for( ; tmpProgram != NULL ; tmpProgram = tmpProgram->getContainer() )
{
const BF & foundInstance = tmpProgram->getAllData().
getByFQNameID( aFullyQualifiedNameID );
if( foundInstance.valid() )
{
return( foundInstance );
}
if( tmpProgram->is< AvmProgram >() )
{
{
const BF & foundInstance = tmpProgram->to< AvmProgram >()->
getConstData().getByFQNameID( aFullyQualifiedNameID );
if( foundInstance.valid() )
{
return( foundInstance );
}
}
{
const BF & foundInstance = tmpProgram->to< AvmProgram >()->
getSymbolData( aFullyQualifiedNameID );
if( foundInstance.valid() )
{
return( foundInstance );
}
}
if( tmpProgram->is< ExecutableForm >() )
{
const BF & foundInstance = tmpProgram->to< ExecutableForm >()->
getDataAlias().getByFQNameID( aFullyQualifiedNameID );
if( foundInstance.valid() )
{
return( foundInstance );
}
}
}
}
return( BF::REF_NULL );
}
const BF & SymbolTable::searchDataInstance(COMPILE_CONTEXT * aCTX,
const std::string & aFullyQualifiedNameID)
{
// RESET ERROR
resetError();
const BF & foundInstance =
searchDataInstance(aCTX->mCompileCtx, aFullyQualifiedNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
else if( aCTX->isSpecificRuntimeCtx() )
{
const BF & foundInstance =
searchDataInstance(aCTX->mRuntimeCtx, aFullyQualifiedNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
return( searchDataInstanceAlias(aCTX, aFullyQualifiedNameID) );
}
const BF & SymbolTable::searchDataInstanceByQualifiedNameID(
BaseAvmProgram * tmpProgram, const std::string & aQualifiedNameID) const
{
for( ; tmpProgram != NULL ; tmpProgram = tmpProgram->getContainer() )
{
const BF & foundInstance = tmpProgram->
getAllData().getByQualifiedNameID(aQualifiedNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
if( tmpProgram->is< AvmProgram >() )
{
{
const BF & foundInstance = tmpProgram->to< AvmProgram >()->
getConstData().getByQualifiedNameID(aQualifiedNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
{
const BF & foundInstance = tmpProgram->to< AvmProgram >()->
getSymbolDataByQualifiedNameID(aQualifiedNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
if( tmpProgram->is< ExecutableForm >() )
{
const BF & foundInstance = tmpProgram->to< ExecutableForm >()->
getDataAlias().getByQualifiedNameID(aQualifiedNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
}
}
return( BF::REF_NULL );
}
const BF & SymbolTable::searchDataInstanceByQualifiedNameID(
COMPILE_CONTEXT * aCTX, const std::string & aQualifiedNameID)
{
// RESET ERROR
resetError();
const BF & foundInstance = searchDataInstanceByQualifiedNameID(
aCTX->mCompileCtx, aQualifiedNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
else if( aCTX->isSpecificRuntimeCtx() )
{
const BF & foundInstance = searchDataInstanceByQualifiedNameID(
aCTX->mRuntimeCtx, aQualifiedNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
return( BF::REF_NULL );
}
const BF & SymbolTable::searchDataInstanceByNameID(
BaseAvmProgram * tmpProgram, const std::string & aNameID) const
{
for( ; tmpProgram != NULL ; tmpProgram = tmpProgram->getContainer() )
{
const BF & foundInstance =
tmpProgram->getAllData().getByNameID(aNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
if( tmpProgram->is< AvmProgram >() )
{
{
const BF & foundInstance = tmpProgram->to<
AvmProgram >()->getConstData().getByNameID(aNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
{
const BF & foundInstance = tmpProgram->to<
AvmProgram >()->getSymbolDataByNameID(aNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
if( tmpProgram->is< ExecutableForm >() )
{
const BF & foundInstance = tmpProgram->to<
ExecutableForm >()->getDataAlias().getByNameID(aNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
}
}
return( BF::REF_NULL );
}
const BF & SymbolTable::searchDataInstanceAlias(
COMPILE_CONTEXT * aCTX, const ObjectElement * astElement)
{
ExecutableForm * tmpExecutable = NULL;
BF foundInstance;
InstanceOfData * foundData = NULL;
TableOfExecutableForm::const_raw_iterator itExec =
mConfiguration.getExecutableSystem().getExecutables().begin();
TableOfExecutableForm::const_raw_iterator endExec =
mConfiguration.getExecutableSystem().getExecutables().end();
for( ; itExec != endExec ; ++itExec )
{
foundInstance = (itExec)->getAllData().getByAstElement(astElement);
if( foundInstance.valid() )
{
tmpExecutable = (itExec);
break;
}
foundInstance = (itExec)->getConstData().getByAstElement(astElement);
if( foundInstance.valid() )
{
tmpExecutable = (itExec);
break;
}
foundInstance = (itExec)->getSymbolDataByAstElement(astElement);
if( foundInstance.valid() )
{
tmpExecutable = (itExec);
break;
}
}
if( foundInstance.valid() )
{
foundData = foundInstance.to_ptr< InstanceOfData >();
if( foundData->getModifier().isVisibilityPublic( aCTX->getModifier() ) )
{
return( createDataInstanceAlias(
aCTX->mCompileCtx->getExecutable(),
astElement->getFullyQualifiedNameID(),
foundData, tmpExecutable) );
}
else
{
incrErrorCount();
ERROR_OS << "Illegal acces of the NON-PUBLIC instance << &"
<< astElement->getFullyQualifiedNameID() << " >> !!!";
}
}
return( BF::REF_NULL );
}
const BF & SymbolTable::searchDataInstanceAlias(
COMPILE_CONTEXT * aCTX, const std::string & aFullyQualifiedNameID)
{
std::string fqnPrefix = aFullyQualifiedNameID.substr(0,
aFullyQualifiedNameID.find_last_of('.'));
std::string aliasFQN;
VectorOfInstanceOfMachine theInstanceOfMachinePath;
ExecutableForm * tmpExecutable = aCTX->mCompileCtx->getExecutable();
Symbol aMachine;
for( ; tmpExecutable != NULL ;
tmpExecutable = tmpExecutable->getExecutableContainer() )
{
if( ((aMachine = tmpExecutable->getInstanceStatic().
getByFQNameID(fqnPrefix)).valid() )
|| ((aMachine = tmpExecutable->getInstanceStatic().
getByQualifiedNameID(fqnPrefix)).valid()) )
{
theInstanceOfMachinePath.append( aMachine.rawMachine() );
tmpExecutable = aMachine.getExecutable();
aliasFQN = aMachine.getFullyQualifiedNameID();
break;
}
}
if( aMachine.invalid() )
{
fqnPrefix = aFullyQualifiedNameID.substr(0,
aFullyQualifiedNameID.find('.'));
tmpExecutable = NULL;
TableOfExecutableForm::const_raw_iterator itExec =
mConfiguration.getExecutableSystem().getExecutables().begin();
TableOfExecutableForm::const_raw_iterator endExec =
mConfiguration.getExecutableSystem().getExecutables().end();
for( ; itExec != endExec ; ++itExec )
{
if( (itExec)->getAstFullyQualifiedNameID() == fqnPrefix )
{
tmpExecutable = (itExec);
break;
}
else if( NamedElement::compareLocation(
(itExec)->getAstFullyQualifiedNameID(), fqnPrefix) )
{
tmpExecutable = (itExec);
break;
}
else if( (itExec)->getNameID() == fqnPrefix )
{
tmpExecutable = (itExec);
break;
}
}
}
if( tmpExecutable != NULL )
{
ListOfString strList;
NamedElement::collectNameID(strList,
aFullyQualifiedNameID, fqnPrefix.size() + 1);
if( strList.singleton() )
{
aliasFQN = aliasFQN + '.' + strList.first();
fqnPrefix = tmpExecutable->getAstFullyQualifiedNameID() +
'.' + strList.pop_first();
if( tmpExecutable->getAllData().getByFQNameID(fqnPrefix).invalid() )
{
tmpExecutable = NULL;
}
}
while( strList.populated() && (tmpExecutable != NULL) )
{
fqnPrefix = tmpExecutable->getAstFullyQualifiedNameID()
+ '.' + strList.pop_first();
aMachine = tmpExecutable->
getInstanceStatic().getByFQNameID( fqnPrefix );
if( aMachine != NULL )
{
aliasFQN = aMachine.getFullyQualifiedNameID();
theInstanceOfMachinePath.append( aMachine.rawMachine() );
tmpExecutable = aMachine.getExecutable();
}
else
{
if( tmpExecutable->getAllData().
getByFQNameID(fqnPrefix).invalid() )
{
break;
}
}
}
if( tmpExecutable != NULL )
{
while( strList.nonempty() )
{
aliasFQN = aliasFQN + '.' + strList.first();
fqnPrefix = fqnPrefix + '.' + strList.pop_first();
}
const BF & foundInstance =
tmpExecutable->getAllData().getByFQNameID(fqnPrefix);
if( foundInstance.valid() )
{
InstanceOfData * foundData =
foundInstance.to_ptr< InstanceOfData >();
if( foundData->getModifier().
isVisibilityPublic( aCTX->getModifier() ) )
{
return( createDataInstanceAlias(
aCTX->mCompileCtx->getExecutable(),
aliasFQN, foundData, theInstanceOfMachinePath) );
}
else
{
incrErrorCount();
ERROR_OS << "Illegal acces of the NON-PUBLIC instance << "
<< aFullyQualifiedNameID << " >> !!!";
}
}
}
}
return( BF::REF_NULL );
}
const BF & SymbolTable::createDataInstanceAlias(ExecutableForm * anExecutable,
const std::string & aFullyQualifiedNameID,
InstanceOfData * anInstance, ExecutableForm * instContainer)
{
const ExecutableForm * lcaExecutable = anExecutable->LCA( instContainer );
if( lcaExecutable != NULL )
{
std::string fqnPrefix = lcaExecutable->getAstFullyQualifiedNameID();
ListOfString strList;
NamedElement::collectNameID(strList, aFullyQualifiedNameID, fqnPrefix);
VectorOfInstanceOfMachine theInstanceOfMachinePath;
while( strList.populated() )
{
fqnPrefix = fqnPrefix + '.' + strList.pop_first();
const Symbol & execInstance =
lcaExecutable->getInstanceStatic().getByFQNameID( fqnPrefix );
if( execInstance.valid() )
{
theInstanceOfMachinePath.append(execInstance.rawMachine());
lcaExecutable = execInstance.getExecutable();
}
else
{
if( lcaExecutable->getAllData().
getByFQNameID( fqnPrefix ).invalid() )
{
lcaExecutable = NULL;
}
break;
}
}
if( lcaExecutable != NULL )
{
while( strList.nonempty() )
{
fqnPrefix = fqnPrefix + '.' + strList.pop_first();
}
BF foundInstance =
lcaExecutable->getAllData().getByFQNameID( fqnPrefix );
if( foundInstance.invalid() )
{
foundInstance =
lcaExecutable->getConstData().getByFQNameID( fqnPrefix );
if( foundInstance.invalid() )
{
foundInstance = lcaExecutable->getSymbolData(fqnPrefix);
}
}
if( foundInstance == anInstance )
{
InstanceOfData * aliasInstance( new InstanceOfData(
anExecutable, anInstance, theInstanceOfMachinePath) );
aliasInstance->setFullyQualifiedNameID("alias" +
aFullyQualifiedNameID.substr(
aFullyQualifiedNameID.find(':')) );
return( anExecutable->saveDataAlias(aliasInstance) );
}
else
{
incrErrorCount();
ERROR_OS << "Failed to create ALIAS for instance << "
<< aFullyQualifiedNameID << " >> !!!";
}
}
}
else
{
incrErrorCount();
ERROR_OS << "Unfound LCA executable between "
<< anExecutable->getFullyQualifiedNameID() << " & ";
ERROR_OS << instContainer->getFullyQualifiedNameID()
<< " for ALIAS creation for instance << "
<< aFullyQualifiedNameID << " >> !!!";
}
return( BF::REF_NULL );
}
const BF & SymbolTable::createDataInstanceAlias(ExecutableForm * anExecutable,
const std::string & aFullyQualifiedNameID, InstanceOfData * anInstance,
VectorOfInstanceOfMachine & theInstanceOfMachinePath)
{
const ExecutableForm * lcaExecutable = anExecutable->LCRA(
theInstanceOfMachinePath.last()->getContainer()->getExecutable() );
if( lcaExecutable != NULL )
{
if( lcaExecutable->hasContainer()
&& theInstanceOfMachinePath.populated()
&& (theInstanceOfMachinePath.first()
!= mConfiguration.getExecutableSystem().rawSystemInstance()) )
{
while( theInstanceOfMachinePath.first()->getExecutable()
!= lcaExecutable )
{
theInstanceOfMachinePath.remove_first();
}
if( lcaExecutable == anExecutable )
{
theInstanceOfMachinePath.remove_first();
}
}
else
{
//!! NOTHING
}
InstanceOfData * aliasInstance( new InstanceOfData(anExecutable,
anInstance, theInstanceOfMachinePath) );
aliasInstance->setFullyQualifiedNameID( "alias" +
aFullyQualifiedNameID.substr(aFullyQualifiedNameID.find(':')) );
return( anExecutable->saveDataAlias(aliasInstance) );
}
return( BF::REF_NULL );
}
/*
******************************************************************************
* SEARCH PORT CONNECT INSTANCE
******************************************************************************
*/
InstanceOfPort * SymbolTable::searchPortConnectorInstance(
ExecutableForm * anExecutable,
const std::string & aFullyQualifiedNameID) const
{
// SEACH FOR INTERNAL PORT CONNEXION
{
const Symbol & foundInstance =
anExecutable->getPort().getByFQNameID( aFullyQualifiedNameID );
if( foundInstance.valid() )
{
return( foundInstance.rawPort() );
}
}
// SEACH FOR MACHINE PORT CONNEXION
TableOfSymbol::const_iterator itMachine =
anExecutable->getInstanceStatic().begin();
TableOfSymbol::const_iterator endMachine =
anExecutable->getInstanceStatic().end();
for( ; itMachine != endMachine ; ++itMachine )
{
const Symbol & foundInstance = (*itMachine).getExecutable()->getPort().
getByFQNameID( aFullyQualifiedNameID );
if( foundInstance.valid() )
{
return( foundInstance.rawPort() );
}
}
return( NULL );
}
InstanceOfPort * SymbolTable::searchPortConnectorInstance(
ExecutableForm * anExecutable, const ObjectElement * aPort) const
{
// SEACH FOR INTERNAL PORT CONNEXION
{
const Symbol & foundInstance =
anExecutable->getPort().getByAstElement(aPort);
if( foundInstance.valid() )
{
return( foundInstance.rawPort() );
}
}
// SEACH FOR MACHINE PORT CONNEXION
TableOfSymbol::const_iterator itMachine =
anExecutable->getInstanceStatic().begin();
TableOfSymbol::const_iterator endMachine =
anExecutable->getInstanceStatic().end();
for( ; itMachine != endMachine ; ++itMachine )
{
const Symbol & foundInstance = (*itMachine).getExecutable()->
getPort().getByAstElement(aPort);
if( foundInstance.valid() )
{
return( foundInstance.rawPort() );
}
}
const Symbol & foundInstance = XQuery.getSemPortByAstElement(
anExecutable->getExecutableContainer(), aPort);
if( foundInstance.valid() )
{
return( foundInstance.rawPort() );
}
return( NULL );
}
/*
******************************************************************************
* SEARCH PORT SYMBOL INSTANCE
******************************************************************************
*/
const Symbol & SymbolTable::searchPortSymbolInstance(
ExecutableForm * anExec, Port * aPort) const
{
const Symbol & foundInstance = XQuery.getSemPortByAstElement(anExec, aPort);
if( foundInstance.valid() )
{
return foundInstance;
}
if( aPort->hasRoutingChannel() )
{
const Symbol & foundChannel =
XQuery.getChannel( aPort->getRoutingChannel() );
if( foundChannel.valid() )
{
return foundChannel.channel().getContents().getByAstElement(aPort);
}
}
return( Symbol::REF_NULL );
}
/*
*******************************************************************************
* SEARCH BUFFER SYMBOL INSTANCE
*******************************************************************************
*/
const Symbol & SymbolTable::searchBufferInstance(
ExecutableForm * anExecutable, const ObjectElement * objElement) const
{
// SEARCH ON CURRENT BUFFER LIST
{
const Symbol & anInstance =
anExecutable->getBuffer().getByAstElement(objElement);
if( anInstance.valid() )
{
return( anInstance );
}
}
// SEARCH ON CURRENT ALIAS BUFFER LIST
{
const Symbol & anInstance =
anExecutable->getAlias().getByAstElement(objElement);
if( anInstance.is< InstanceOfBuffer >() )
{
return( anInstance );
}
}
// SEARCH ON CURRENT MODEL CHILD BUFFER LIST & MAKE AN ALIAS
InstanceOfBuffer * aBufferInstance = NULL;
TableOfSymbol::const_iterator itMachine = anExecutable->instance_model_begin();
TableOfSymbol::const_iterator endMachine = anExecutable->instance_model_end();
for( ; itMachine != endMachine ; ++itMachine )
{
aBufferInstance = (*itMachine).getExecutable()->
getBuffer().getByAstElement(objElement).rawBuffer();
if( aBufferInstance != NULL )
{
break;
}
}
if( aBufferInstance != NULL )
{
VectorOfInstanceOfMachine theInstanceOfMachinePath;
theInstanceOfMachinePath.append( (*itMachine).rawMachine() );
InstanceOfBuffer * aliasInstance = new InstanceOfBuffer(
anExecutable, aBufferInstance, theInstanceOfMachinePath);
std::string aFullyQualifiedNameID =
aBufferInstance->getFullyQualifiedNameID();
aliasInstance->setFullyQualifiedNameID( "alias" +
aFullyQualifiedNameID.substr(aFullyQualifiedNameID.find(':')) );
return( anExecutable->saveAlias(aliasInstance) );
}
return( searchBufferInstance(objElement) );
}
const Symbol & SymbolTable::searchBufferInstance(ExecutableForm * anExecutable,
const std::string & aFullyQualifiedNameID)
{
// SEARCH ON CURRENT BUFFER LIST
{
const Symbol & anInstance =
anExecutable->getBuffer().getByFQNameID( aFullyQualifiedNameID );
if( anInstance.valid() )
{
return( anInstance );
}
}
// SEARCH ON CURRENT ALIAS BUFFER LIST
{
const Symbol & anInstance =
anExecutable->getAlias().getByFQNameID( aFullyQualifiedNameID );
if( anInstance.is< InstanceOfBuffer >() )
{
return( anInstance );
}
}
// SEARCH ON CURRENT MODEL CHILD BUFFER LIST & MAKE AN ALIAS
InstanceOfBuffer * aBufferInstance = NULL;
TableOfSymbol::const_iterator itMachine = anExecutable->instance_model_begin();
TableOfSymbol::const_iterator endMachine = anExecutable->instance_model_end();
for( ; itMachine != endMachine ; ++itMachine )
{
aBufferInstance = (*itMachine).getExecutable()->
getBuffer().getByFQNameID( aFullyQualifiedNameID ).rawBuffer();
if( aBufferInstance != NULL )
{
break;
}
}
if( aBufferInstance != NULL )
{
VectorOfInstanceOfMachine theInstanceOfMachinePath;
theInstanceOfMachinePath.append( (*itMachine).rawMachine() );
InstanceOfBuffer * aliasInstance = new InstanceOfBuffer(
anExecutable, aBufferInstance, theInstanceOfMachinePath );
std::string fqnID = aBufferInstance->getFullyQualifiedNameID();
aliasInstance->setFullyQualifiedNameID( "alias" +
fqnID.substr(fqnID.find(':')) );
return( anExecutable->saveAlias(aliasInstance) );
}
return( searchBufferInstanceAlias(anExecutable, aFullyQualifiedNameID) );
}
const Symbol & SymbolTable::searchBufferInstanceByQualifiedNameID(
ExecutableForm * anExec, const std::string & aQualifiedNameID) const
{
for( ; anExec != NULL ; anExec = anExec->getExecutableContainer() )
{
const Symbol & anInstance =
anExec->getBuffer().getByQualifiedNameID(aQualifiedNameID);
if( anInstance.valid() )
{
return( anInstance );
}
}
return( Symbol::REF_NULL );
}
const Symbol & SymbolTable::searchBufferInstanceByNameID(
ExecutableForm * anExec, const std::string & aNameID) const
{
for( ; anExec != NULL ; anExec = anExec->getExecutableContainer() )
{
const Symbol & foundInstance =
anExec->getBuffer().getByNameID(aNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
return( Symbol::REF_NULL );
}
const Symbol & SymbolTable::searchBufferInstanceAlias(
ExecutableForm * anExecutable,
const std::string & aFullyQualifiedNameID)
{
std::string fqnPrefix = aFullyQualifiedNameID.substr(0,
aFullyQualifiedNameID.find_last_of('.'));
std::string aliasFQN;
VectorOfInstanceOfMachine theInstanceOfMachinePath;
ExecutableForm * tmpExecutable = anExecutable;
Symbol aMachine;
for( ; tmpExecutable != NULL ;
tmpExecutable = tmpExecutable->getExecutableContainer() )
{
if( ((aMachine = tmpExecutable->getInstanceStatic().getByFQNameID(
fqnPrefix)).valid())
|| ((aMachine = tmpExecutable->getInstanceStatic().
getByQualifiedNameID(fqnPrefix)).valid()) )
{
theInstanceOfMachinePath.append( aMachine.rawMachine() );
tmpExecutable = aMachine.getExecutable();
aliasFQN = aMachine.getFullyQualifiedNameID();
break;
}
}
if( aMachine.invalid() )
{
fqnPrefix = aFullyQualifiedNameID.substr(0,
aFullyQualifiedNameID.find('.'));
tmpExecutable = NULL;
TableOfExecutableForm::const_raw_iterator itExec =
mConfiguration.getExecutableSystem().getExecutables().begin();
TableOfExecutableForm::const_raw_iterator endExec =
mConfiguration.getExecutableSystem().getExecutables().end();
for( ; itExec != endExec ; ++itExec )
{
if( (itExec)->getAstFullyQualifiedNameID() == fqnPrefix )
{
tmpExecutable = (itExec);
break;
}
else if( NamedElement::compareLocation(
(itExec)->getAstFullyQualifiedNameID(), fqnPrefix) )
{
tmpExecutable = (itExec);
break;
}
else if( (itExec)->getNameID() == fqnPrefix )
{
tmpExecutable = (itExec);
break;
}
}
}
if( tmpExecutable != NULL )
{
ListOfString strList;
NamedElement::collectNameID(strList,
aFullyQualifiedNameID, fqnPrefix.size() + 1);
if( strList.singleton() )
{
aliasFQN = aliasFQN + '.' + strList.first();
fqnPrefix = tmpExecutable->getAstFullyQualifiedNameID() +
'.' + strList.pop_first();
if( tmpExecutable->getBuffer().getByFQNameID(fqnPrefix).invalid() )
{
tmpExecutable = NULL;
}
}
while( strList.populated() && (tmpExecutable != NULL) )
{
fqnPrefix = tmpExecutable->getAstFullyQualifiedNameID()
+ '.' + strList.pop_first();
aMachine = tmpExecutable->getInstanceStatic().
getByFQNameID( fqnPrefix );
if( aMachine.valid() )
{
aliasFQN = aMachine.getFullyQualifiedNameID();
theInstanceOfMachinePath.append( aMachine.rawMachine() );
tmpExecutable = aMachine.getExecutable();
}
else
{
if( tmpExecutable->getBuffer().
getByFQNameID( fqnPrefix ).invalid() )
{
break;
}
}
}
if( tmpExecutable != NULL )
{
while( strList.nonempty() )
{
aliasFQN = aliasFQN + '.' + strList.first();
fqnPrefix = fqnPrefix + '.' + strList.pop_first();
}
const Symbol & foundInstance =
tmpExecutable->getBuffer().getByFQNameID( fqnPrefix );
if( foundInstance.valid() )
{
if( foundInstance.getModifier().isVisibilityPublic() )
{
return( createBufferInstanceAlias(anExecutable, aliasFQN,
foundInstance.rawBuffer(), theInstanceOfMachinePath) );
}
else
{
incrErrorCount();
ERROR_OS << "Illegal acces of the NON-PUBLIC instance << "
<< aFullyQualifiedNameID << " >> !!!";
}
}
}
}
return( Symbol::REF_NULL );
}
const Symbol & SymbolTable::createBufferInstanceAlias(ExecutableForm * anExecutable,
const std::string & aFullyQualifiedNameID, InstanceOfBuffer * anInstance,
VectorOfInstanceOfMachine & theInstanceOfMachinePath)
{
const ExecutableForm * lcaExecutable = anExecutable->LCRA(
theInstanceOfMachinePath.last()->getContainer()->getExecutable() );
if( lcaExecutable != NULL )
{
if( lcaExecutable->hasContainer()
&& (theInstanceOfMachinePath.first()
!= mConfiguration.getExecutableSystem().rawSystemInstance()) )
{
while( theInstanceOfMachinePath.first()->getExecutable()
!= lcaExecutable )
{
theInstanceOfMachinePath.remove_first();
}
if( lcaExecutable == anExecutable )
{
theInstanceOfMachinePath.remove_first();
}
}
else
{
//!! NOTHING
}
InstanceOfBuffer * aliasInstance( new InstanceOfBuffer(
anExecutable, anInstance, theInstanceOfMachinePath) );
aliasInstance->setFullyQualifiedNameID( "alias" +
aFullyQualifiedNameID.substr(aFullyQualifiedNameID.find(':')) );
return( anExecutable->saveAlias(aliasInstance) );
}
return( Symbol::REF_NULL );
}
/*
*******************************************************************************
* SEARCH CONNECT SYMBOL INSTANCE
*******************************************************************************
*/
const Symbol & SymbolTable::searchConnectorInstance(
ExecutableForm * anExecutable, const ObjectElement * objElement) const
{
// SEARCH ON CURRENT BUFFER LIST
{
const Symbol & anInstance =
anExecutable->getConnect().getByAstElement(objElement);
if( anInstance.valid() )
{
return( anInstance );
}
}
// SEARCH ON CURRENT ALIAS BUFFER LIST
{
const Symbol & anInstance =
anExecutable->getAlias().getByAstElement(objElement);
if( anInstance.is< InstanceOfConnect >() )
{
return( anInstance );
}
}
// SEARCH ON CURRENT MODEL CHILD BUFFER LIST & MAKE AN ALIAS
Symbol bfConnect;
TableOfSymbol::const_iterator itMachine = anExecutable->instance_model_begin();
TableOfSymbol::const_iterator itEnd = anExecutable->instance_model_end();
for( ; itMachine != itEnd ; ++itMachine )
{
bfConnect = (*itMachine).getExecutable()->
getConnect().getByAstElement(objElement);
if( bfConnect.valid() )
{
break;
}
}
if( bfConnect.valid() )
{
VectorOfInstanceOfMachine theInstanceOfMachinePath;
theInstanceOfMachinePath.append( (*itMachine).rawMachine() );
InstanceOfConnect * aliasInstance = new InstanceOfConnect(
anExecutable, bfConnect.rawConnect(), theInstanceOfMachinePath );
const std::string & aFullyQualifiedNameID =
bfConnect.getFullyQualifiedNameID();
aliasInstance->setFullyQualifiedNameID( "alias" +
aFullyQualifiedNameID.substr(aFullyQualifiedNameID.find(':')) );
return( anExecutable->saveAlias(aliasInstance) );
}
return( searchConnectorInstance(objElement) );
}
const Symbol & SymbolTable::searchConnectorInstance(ExecutableForm * anExecutable,
const std::string & aFullyQualifiedNameID) const
{
// SEARCH ON CURRENT BUFFER LIST
{
const Symbol & anInstance =
anExecutable->getConnect().getByFQNameID( aFullyQualifiedNameID );
if( anInstance.valid() )
{
return( anInstance );
}
}
// SEARCH ON CURRENT ALIAS BUFFER LIST
{
const Symbol & anInstance =
anExecutable->getAlias().getByFQNameID( aFullyQualifiedNameID );
if( anInstance.is< InstanceOfConnect >() )
{
return( anInstance );
}
}
// SEARCH ON CURRENT MODEL CHILD BUFFER LIST & MAKE AN ALIAS
Symbol bfConnect;
TableOfSymbol::const_iterator itMachine = anExecutable->instance_model_begin();
TableOfSymbol::const_iterator endMachine = anExecutable->instance_model_end();
for( ; itMachine != endMachine ; ++itMachine )
{
bfConnect = (*itMachine).getExecutable()->getConnect().
getByFQNameID( aFullyQualifiedNameID );
if( bfConnect.valid() )
{
break;
}
}
if( bfConnect.valid() )
{
VectorOfInstanceOfMachine theInstanceOfMachinePath;
theInstanceOfMachinePath.append( (*itMachine).rawMachine() );
InstanceOfConnect * aliasInstance = new InstanceOfConnect(
anExecutable, bfConnect.rawConnect(), theInstanceOfMachinePath );
const std::string & aFullyQualifiedNameID =
bfConnect.getFullyQualifiedNameID();
aliasInstance->setFullyQualifiedNameID( "alias" +
aFullyQualifiedNameID.substr(aFullyQualifiedNameID.find(':')) );
return( anExecutable->saveAlias(aliasInstance) );
}
return( searchConnectorInstance( aFullyQualifiedNameID ) );
}
const Symbol & SymbolTable::searchConnectorInstanceByQualifiedNameID(
ExecutableForm * anExec, const std::string & aQualifiedNameID) const
{
for( ; anExec != NULL ; anExec = anExec->getExecutableContainer() )
{
const Symbol & foundInstance =
anExec->getConnect().getByQualifiedNameID(aQualifiedNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
return( Symbol::REF_NULL );
}
const Symbol & SymbolTable::searchConnectorInstanceByNameID(
ExecutableForm * anExec, const std::string & aNameID) const
{
for( ; anExec != NULL ; anExec = anExec->getExecutableContainer() )
{
const Symbol & foundInstance =
anExec->getConnect().getByNameID(aNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
return( Symbol::REF_NULL );
}
/*
*******************************************************************************
* SEARCH MACHINE INSTANCE
*******************************************************************************
*/
const Symbol & SymbolTable::searchInstanceModelByNameID(
ExecutableForm * anExec, const std::string & aNameID) const
{
for( ; anExec != NULL ; anExec = anExec->getExecutableContainer() )
{
const Symbol & foundInstance =
anExec->getInstanceModel().getByNameID(aNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
return( Symbol::REF_NULL );
}
const Symbol & SymbolTable::searchInstanceModelByNameID(
COMPILE_CONTEXT * aCTX, const std::string & aNameID) const
{
return( searchInstanceModelByNameID(
aCTX->mCompileCtx->getExecutable(), aNameID) );
}
const Symbol & SymbolTable::searchMachineInstanceByNameID(
ExecutableForm * anExec, const std::string & aNameID) const
{
for( ; anExec != NULL ; anExec = anExec->getExecutableContainer() )
{
const Symbol & foundInstance =
anExec->getInstanceStatic().getByNameID(aNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
return( Symbol::REF_NULL );
}
const Symbol & SymbolTable::searchMachineInstanceByNameID(
COMPILE_CONTEXT * aCTX, const std::string & aNameID) const
{
return( searchMachineInstanceByNameID(
aCTX->mCompileCtx->getExecutable(), aNameID) );
}
/**
* SEARCH
* for Machine Instance
*/
const Symbol & SymbolTable::searchInstanceModel(
COMPILE_CONTEXT * aCTX, const ObjectElement * astElement) const
{
ExecutableForm * anExec = aCTX->mCompileCtx->getExecutable();
for( ; anExec != NULL ; anExec = anExec->getExecutableContainer() )
{
const Symbol & foundInstance =
anExec->getByAstInstanceModel(astElement);
if( foundInstance.valid() && foundInstance.machine().isnotThis() )
{
return( foundInstance );
}
}
return( searchInstanceStatic( astElement ) );
}
const Symbol & SymbolTable::searchInstanceStatic(
COMPILE_CONTEXT * aCTX, const ObjectElement * astElement) const
{
ExecutableForm * anExec = aCTX->mCompileCtx->getExecutable();
for( ; anExec != NULL ; anExec = anExec->getExecutableContainer() )
{
const Symbol & foundInstance =
anExec->getByAstInstanceStatic(astElement);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
return( searchInstanceStatic( astElement ) );
}
const Symbol & SymbolTable::searchInstanceDynamic(
COMPILE_CONTEXT * aCTX, const ObjectElement * astElement) const
{
ExecutableForm * anExec = aCTX->mCompileCtx->getExecutable();
for( ; anExec != NULL ; anExec = anExec->getExecutableContainer() )
{
const Symbol & foundInstance =
anExec->getByAstInstanceDynamic(astElement);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
return( searchInstanceStatic( astElement ) );
}
InstanceOfMachine * SymbolTable::searchInstanceStatic(
const ObjectElement * fromMachine, const UniFormIdentifier & anUFI)
{
// RESET ERROR
resetError();
BFList listofMachine;
searchInstanceStatic(
fromMachine->getContainerMachine(), anUFI, listofMachine);
if( listofMachine.populated() )
{
incrErrorCount();
ERROR_OS << "Too more statemachine << "
<< anUFI.str() << " >> are found !";
return( listofMachine.first().to_ptr< InstanceOfMachine >() );
}
else if( listofMachine.nonempty() )
{
return( listofMachine.first().to_ptr< InstanceOfMachine >() );
}
else
{
incrErrorCount();
ERROR_OS << "Unfound statemachine << "
<< anUFI.str() << " >> !";
return( NULL );
}
}
void SymbolTable::searchInstanceStatic(const ObjectElement * refMachine,
const UniFormIdentifier & anUFI, BFList & foundList) const
{
std::string strUFI = anUFI.str();
SymbolPredicateByCompiledFQNameID pred(strUFI);
if( not anUFI.hasLocator() )
{
std::string refUfi = refMachine->getFullyQualifiedNameID();
refUfi = refUfi.substr(
refUfi.find(FQN_ID_ROOT_SEPARATOR), refUfi.size());
pred.mQualifiedNameID = refUfi + '.' + strUFI;
searchCompiledElement(mListOfInstanceStatic, pred, foundList);
if( anUFI.populated() )
{
std::string commonAncestor = anUFI.first().str();
std::string::size_type pos;
while( (pos = refUfi.rfind(commonAncestor)) != std::string::npos )
{
refUfi = refUfi.substr(0, pos);
pred.mQualifiedNameID = refUfi + strUFI;
searchCompiledElement(mListOfInstanceStatic, pred, foundList);
}
}
}
else
{
searchCompiledElement(mListOfInstanceStatic, pred, foundList);
}
}
void SymbolTable::searchInstanceByNameID(COMPILE_CONTEXT * aCTX,
const std::string & aNameID, BFList & foundList) const
{
switch( aCTX->mType->getTypeSpecifierKind() )
{
case TYPE_MACHINE_SPECIFIER:
{
searchMachineInstanceByNameID(aNameID, foundList);
break;
}
case TYPE_PORT_SPECIFIER:
{
searchPortInstanceByNameID(aNameID, foundList);
break;
}
case TYPE_SIGNAL_SPECIFIER:
{
searchPortInstanceByNameID(aNameID, foundList);
break;
}
case TYPE_BUFFER_SPECIFIER:
{
searchBufferInstanceByNameID(aNameID, foundList);
break;
}
case TYPE_CONNECTOR_SPECIFIER:
{
searchConnectorInstanceByNameID(aNameID, foundList);
break;
}
case TYPE_BOOLEAN_SPECIFIER:
case TYPE_POS_INTEGER_SPECIFIER:
case TYPE_UINTEGER_SPECIFIER:
case TYPE_INTEGER_SPECIFIER:
case TYPE_URATIONAL_SPECIFIER:
case TYPE_RATIONAL_SPECIFIER:
case TYPE_UFLOAT_SPECIFIER:
case TYPE_FLOAT_SPECIFIER:
case TYPE_UREAL_SPECIFIER:
case TYPE_REAL_SPECIFIER:
case TYPE_ENUM_SPECIFIER:
case TYPE_CHARACTER_SPECIFIER:
case TYPE_STRING_SPECIFIER:
case TYPE_CLOCK_SPECIFIER:
case TYPE_TIME_SPECIFIER:
case TYPE_CONTINUOUS_TIME_SPECIFIER:
case TYPE_DISCRETE_TIME_SPECIFIER:
case TYPE_INTERVAL_SPECIFIER:
case TYPE_OPERATOR_SPECIFIER:
case TYPE_AVMCODE_SPECIFIER:
case TYPE_MESSAGE_SPECIFIER:
{
searchDataInstanceByNameID(aNameID, foundList);
if( foundList.empty() )
{
searchPortInstanceByNameID(aNameID, foundList);
searchMachineInstanceByNameID(aNameID, foundList);
searchBufferInstanceByNameID(aNameID, foundList);
searchConnectorInstanceByNameID(aNameID, foundList);
}
break;
}
default:
{
searchDataInstanceByNameID(aNameID, foundList);
searchPortInstanceByNameID(aNameID, foundList);
searchMachineInstanceByNameID(aNameID, foundList);
searchBufferInstanceByNameID(aNameID, foundList);
searchConnectorInstanceByNameID(aNameID, foundList);
break;
}
}
if( foundList.empty() )
{
searchDataInstanceByNameID(aNameID, foundList);
}
}
void SymbolTable::searchInstanceByQualifiedNameID(COMPILE_CONTEXT * aCTX,
const std::string & aQualifiedNameID, BFList & foundList) const
{
switch( aCTX->mType->getTypeSpecifierKind() )
{
case TYPE_MACHINE_SPECIFIER:
{
searchMachineInstanceByQualifiedNameID(aQualifiedNameID, foundList);
break;
}
case TYPE_PORT_SPECIFIER:
{
searchPortInstanceByQualifiedNameID(aQualifiedNameID, foundList);
break;
}
case TYPE_SIGNAL_SPECIFIER:
{
searchPortInstanceByQualifiedNameID(aQualifiedNameID, foundList);
break;
}
case TYPE_BUFFER_SPECIFIER:
{
searchBufferInstanceByQualifiedNameID(aQualifiedNameID, foundList);
break;
}
case TYPE_CONNECTOR_SPECIFIER:
{
searchConnectorInstanceByQualifiedNameID(aQualifiedNameID, foundList);
break;
}
case TYPE_BOOLEAN_SPECIFIER:
case TYPE_POS_INTEGER_SPECIFIER:
case TYPE_UINTEGER_SPECIFIER:
case TYPE_INTEGER_SPECIFIER:
case TYPE_URATIONAL_SPECIFIER:
case TYPE_RATIONAL_SPECIFIER:
case TYPE_UFLOAT_SPECIFIER:
case TYPE_FLOAT_SPECIFIER:
case TYPE_UREAL_SPECIFIER:
case TYPE_REAL_SPECIFIER:
case TYPE_ENUM_SPECIFIER:
case TYPE_CHARACTER_SPECIFIER:
case TYPE_STRING_SPECIFIER:
case TYPE_CLOCK_SPECIFIER:
case TYPE_TIME_SPECIFIER:
case TYPE_CONTINUOUS_TIME_SPECIFIER:
case TYPE_DISCRETE_TIME_SPECIFIER:
case TYPE_INTERVAL_SPECIFIER:
case TYPE_OPERATOR_SPECIFIER:
case TYPE_AVMCODE_SPECIFIER:
case TYPE_MESSAGE_SPECIFIER:
{
searchDataInstanceByQualifiedNameID(aQualifiedNameID, foundList);
if( foundList.empty() )
{
searchPortInstanceByQualifiedNameID(aQualifiedNameID, foundList);
searchMachineInstanceByQualifiedNameID(aQualifiedNameID, foundList);
searchBufferInstanceByQualifiedNameID(aQualifiedNameID, foundList);
searchConnectorInstanceByQualifiedNameID(aQualifiedNameID, foundList);
}
break;
}
default:
{
searchDataInstanceByQualifiedNameID(aQualifiedNameID, foundList);
searchPortInstanceByQualifiedNameID(aQualifiedNameID, foundList);
searchMachineInstanceByQualifiedNameID(aQualifiedNameID, foundList);
searchBufferInstanceByQualifiedNameID(aQualifiedNameID, foundList);
searchConnectorInstanceByQualifiedNameID(aQualifiedNameID, foundList);
break;
}
}
if( foundList.empty() )
{
searchDataInstanceByNameID(aQualifiedNameID, foundList);
}
}
/**
* SEARCH
* for DataFactory, Port or Machine
*/
const BF & SymbolTable::searchInstance(
COMPILE_CONTEXT * aCTX, const ObjectElement * objElement)
{
// CASE form is a PORT
if( objElement->is< Port >() )
{
const Symbol & foundInstance = XQuery.getSemPortByAstElement(
aCTX->mCompileCtx->getExecutable(), objElement);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
// CASE form is a [STATE]MACHINE
if( objElement->is< Machine >() )
{
{
const Symbol & foundInstance =
searchInstanceStatic(aCTX, objElement);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
{
const Symbol & foundInstance =
searchInstanceModel(aCTX, objElement);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
return( searchInstanceStatic(objElement) );
}
// CASE form is a BUFFER
if( objElement->is< Buffer >() )
{
const Symbol & foundInstance = searchBufferInstance(
aCTX->mCompileCtx->getExecutable(), objElement);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
// CASE form is a CONNECT
if( objElement->is< Connector >() )
{
const Symbol & foundInstance = searchConnectorInstance(
aCTX->mCompileCtx->getExecutable(), objElement);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
{
const BF & foundInstance = searchDataInstance(aCTX, objElement);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
// For the Case of undetected TYPE
{
const Symbol & foundInstance = searchInstanceStatic(objElement);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
return( BF::REF_NULL );
}
const BF & SymbolTable::searchInstance(COMPILE_CONTEXT * aCTX,
const std::string & aFullyQualifiedNameID)
{
// CASE element is a PORT
if( aCTX->typeMustBePortFamily() )
{
const Symbol & foundInstance = XQuery.getSemPort(
aCTX->mCompileCtx->getExecutable(), aFullyQualifiedNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
// CASE element is a [STATE]MACHINE
if( aCTX->typeMustBeMachineFamily() )
{
const Symbol & foundInstance =
searchInstanceStatic(aFullyQualifiedNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
// CASE element is a BUFFER
if( aCTX->typeMustBeBufferFamily() )
{
const Symbol & foundInstance = searchBufferInstance(
aCTX->mCompileCtx->getExecutable(), aFullyQualifiedNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
// CASE element is a CONNECT
if( aCTX->typeMustBeConnectorFamily() )
{
const Symbol & foundInstance = searchConnectorInstance(
aCTX->mCompileCtx->getExecutable(), aFullyQualifiedNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
// CASE element is anything ELSE
// UNCONDITIONAL
{
const BF & foundInstance =
searchDataInstance(aCTX, aFullyQualifiedNameID);
if( foundInstance.valid() )
{
return( foundInstance );
}
}
return( BF::REF_NULL );
}
/*
* SEARCH
* Program for a given FORM
*/
const BF & SymbolTable::searchTransition(
COMPILE_CONTEXT * aCTX, const ObjectElement * objElement) const
{
ExecutableForm * anExec = aCTX->mCompileCtx->getExecutable();
for( ; anExec != NULL ; anExec = anExec->getExecutableContainer() )
{
const BF & tmpTransition =
anExec->getTransitionByAstElement(objElement);
if( tmpTransition.valid() )
{
return( tmpTransition );
}
}
{
const BF & aTransition = searchTransition(objElement);
if( aTransition.valid() )
{
return( aTransition );
}
}
return( BF::REF_NULL );
}
const BF & SymbolTable::searchTransition(
COMPILE_CONTEXT * aCTX, const std::string & aFullyQualifiedNameID) const
{
ExecutableForm * anExec = aCTX->mCompileCtx->getExecutable();
for( ; anExec != NULL ; anExec = anExec->getExecutableContainer() )
{
const BF & tmpTransition = anExec->getTransition(aFullyQualifiedNameID);
if( tmpTransition.valid() )
{
return( tmpTransition );
}
}
{
const BF & aTransition = searchTransition(aFullyQualifiedNameID);
if( aTransition.valid() )
{
return( aTransition );
}
}
return( BF::REF_NULL );
}
const BF & SymbolTable::searchTransitionByNameID(
COMPILE_CONTEXT * aCTX, const std::string & aNameID) const
{
ExecutableForm * anExec = aCTX->mCompileCtx->getExecutable();
for( ; anExec != NULL ; anExec = anExec->getExecutableContainer() )
{
const BF & tmpTransition = anExec->getTransitionByNameID(aNameID);
if( tmpTransition.valid() )
{
return( tmpTransition );
}
}
{
const BF & aTransition = searchTransitionByNameID(aNameID);
if( aTransition.valid() )
{
return( aTransition );
}
}
return( BF::REF_NULL );
}
const BF & SymbolTable::searchProgram(
COMPILE_CONTEXT * aCTX, const ObjectElement * objElement) const
{
ExecutableForm * anExec = aCTX->mCompileCtx->getExecutable();
for( ; anExec != NULL ; anExec = anExec->getExecutableContainer() )
{
const BF & tmpProgram = anExec->getProgramByAstElement(objElement);
if( tmpProgram.valid() )
{
return( tmpProgram );
}
}
{
const BF & aProgram = searchProgram(objElement);
if( aProgram.valid() )
{
return( aProgram );
}
}
return( searchExecutable(objElement) );
}
const BF & SymbolTable::searchProgram(
COMPILE_CONTEXT * aCTX, const std::string & aFullyQualifiedNameID) const
{
ExecutableForm * anExec = aCTX->mCompileCtx->getExecutable();
for( ; anExec != NULL ; anExec = anExec->getExecutableContainer() )
{
const BF & tmpProgram = anExec->getProgram(aFullyQualifiedNameID);
if( tmpProgram.valid() )
{
return( tmpProgram );
}
}
{
const BF & aProgram = searchProgram(aFullyQualifiedNameID);
if( aProgram.valid() )
{
return( aProgram );
}
}
return( searchExecutable(aFullyQualifiedNameID) );
}
const BF & SymbolTable::searchProgramByNameID(
COMPILE_CONTEXT * aCTX, const std::string & aNameID) const
{
ExecutableForm * anExec = aCTX->mCompileCtx->getExecutable();
for( ; anExec != NULL ; anExec = anExec->getExecutableContainer() )
{
const BF & tmpProgram = anExec->getProgramByNameID(aNameID);
if( tmpProgram.valid() )
{
return( tmpProgram );
}
}
{
const BF & aProgram = searchProgramByNameID(aNameID);
if( aProgram.valid() )
{
return( aProgram );
}
}
return( searchExecutableByNameID(aNameID) );
}
/*
* SEARCH
* Executable of the MODEL for a given FORM
*/
ExecutableForm * SymbolTable::searchExecutableModel(const Machine * aMachine)
{
// RESET ERROR
resetError();
const BF & aModel = aMachine->getType();
if( aModel.is< Machine >() )
{
if( aModel.to_ptr< Machine >()->getSpecifier().hasDesignModel() )
{
return( searchExecutable(aModel.to_ptr< Machine >()).
to_ptr< ExecutableForm >() );
}
else
{
return( searchExecutableModel(aModel.to_ptr< Machine >()) );
}
}
else if( aModel.is< Identifier >() )
{
std::string aNameID = aModel.to_ptr< Identifier >()->getValue();
const BF & foundExec = searchExecutableByNameID(aNameID);
return( foundExec.valid() ?
foundExec.as_ptr< ExecutableForm >() : NULL );
}
else
{
std::string aQualifiedNameID = aModel.is< QualifiedIdentifier >()
? aModel.to_ptr< QualifiedIdentifier >()->getValue()
: ( aModel.is< UniFormIdentifier >()
? aModel.to_ptr< UniFormIdentifier >()->toStringLocation()
: aModel.str() );
const BF & foundExec =
searchExecutableByQualifiedNameID( aQualifiedNameID );
return( foundExec.valid() ?
foundExec.as_ptr< ExecutableForm >() : NULL );
}
}
/**
* SEARCH SYMBOL
* for DataFactory, Port, Machine, Executable
*/
const BF & SymbolTable::searchSymbol(COMPILE_CONTEXT * aCTX,
const ObjectElement * objElement)
{
{
const BF & theSymbol = searchInstance(aCTX, objElement);
if( theSymbol.valid() )
{
return( theSymbol );
}
}
{
const BF & theSymbol = searchTransition(aCTX, objElement);
if( theSymbol.valid() )
{
return( theSymbol );
}
}
{
const BF & theSymbol = searchProgram(aCTX, objElement);
if( theSymbol.valid() )
{
return( theSymbol );
}
}
return( BF::REF_NULL );
}
const BF & SymbolTable::searchSymbol(COMPILE_CONTEXT * aCTX,
const std::string & aFullyQualifiedNameID)
{
{
const BF & theSymbol = searchInstance(aCTX, aFullyQualifiedNameID);
if( theSymbol.valid() )
{
return( theSymbol );
}
}
{
const BF & theSymbol = searchTransition(aCTX, aFullyQualifiedNameID);
if( theSymbol.valid() )
{
return( theSymbol );
}
}
{
const BF & theSymbol = searchProgram(aCTX, aFullyQualifiedNameID);
if( theSymbol.valid() )
{
return( theSymbol );
}
}
return( BF::REF_NULL );
}
BF SymbolTable::searchSymbolByUFI(
COMPILE_CONTEXT * aCTX, const UniFormIdentifier & anUFI)
{
UniFormIdentifier::const_iterator it = anUFI.begin();
UniFormIdentifier::const_iterator itEnd = anUFI.end();
std::ostringstream ossUFI;
const ObjectElement * TheMainObjectElement = NULL;
BF bfInstance;
InstanceOfMachine * theInstanceMachine;
// CHECKING ROOT MACHINE INSTANCE
if( (*it).is< ObjectElement >() )
{
TheMainObjectElement = (*it).to_ptr< ObjectElement >();
if( (bfInstance = searchInstanceStatic(TheMainObjectElement)).valid() )
{
theInstanceMachine = bfInstance.to_ptr< InstanceOfMachine >();
}
else
{
incrErrorCount();
ERROR_OS << "Unfound the main form < "
<< TheMainObjectElement->getFullyQualifiedNameID()
<< " > of UFI < " << anUFI.str() << " > in the system << "
<< mConfiguration.getExecutableSystem().rawSystemInstance()
->getAstElement()->getFullyQualifiedNameID() << " >>"
<< std::endl;
return( BF::REF_NULL );
}
}
else
{
ossUFI << anUFI.toStringLocator()
<< FQN_ID_ROOT_SEPARATOR << (*it).str();
theInstanceMachine =
mConfiguration.getExecutableSystem().rawSystemInstance();
TheMainObjectElement = theInstanceMachine->getAstElement();
if( (TheMainObjectElement != NULL)
&& TheMainObjectElement->fqnEquals( ossUFI.str() ) )
{
if( it == itEnd )
{
return( mConfiguration.getExecutableSystem().getSystemInstance() );
}
}
else
{
incrErrorCount();
ERROR_OS << "Unfound the main form < "
<< ossUFI.str() << " > of UFI < "
<< anUFI.str() << " > in the system << "
<< mConfiguration.getExecutableSystem().rawSystemInstance()
->getAstElement()->getFullyQualifiedNameID() << " >>"
<< std::endl;
return( BF::REF_NULL );
}
}
ossUFI.str("");
ossUFI << theInstanceMachine->getFullyQualifiedNameID();
// CHECKING MAIN MACHINE INSTANCE
for( ++it ; it != itEnd ; ++it )
{
if( (*it).isIdentifier() )
{
ossUFI << '.' << (*it).str();
bfInstance = theInstanceMachine->getExecutable()->
getInstanceStatic().getByFQNameID( ossUFI.str() );
if( bfInstance.invalid() )
{
bfInstance = theInstanceMachine->getExecutable()->
getInstanceStatic().getByNameID( (*it).str() );
}
if( bfInstance.valid() )
{
theInstanceMachine = bfInstance.to_ptr< InstanceOfMachine >();
continue;
}
}
else if( (*it).is< ObjectElement >() )
{
if( (*it).to_ptr< ObjectElement >()->getContainer()
== TheMainObjectElement )
{
TheMainObjectElement = (*it).to_ptr< ObjectElement >();
if( (bfInstance = theInstanceMachine->getExecutable()->
getByAstInstanceStatic(TheMainObjectElement)).valid() )
{
theInstanceMachine = bfInstance.to_ptr< InstanceOfMachine >();
ossUFI.str("");
ossUFI << theInstanceMachine->getFullyQualifiedNameID();
continue;
}
}
else
{
incrErrorCount();
ERROR_OS << "MissFormed UFI < "
<< anUFI.str() << " > : the field < "
<< (*it).to_ptr<
ObjectElement >()->getFullyQualifiedNameID()
<< " > container is not < "
<< TheMainObjectElement->getFullyQualifiedNameID()
<< " > !!!" << std::endl;
return( BF::REF_NULL );
}
}
else
{
incrErrorCount();
ERROR_OS << "Unexpected < " << it->str()
<< " > as field of the UFI < "
<< anUFI.str() << " > !!!"
<< std::endl;
return( BF::REF_NULL );
}
break;
}
if( bfInstance.valid() )
{
if( it == itEnd )
{
return( bfInstance );
}
// CHECKING FOR MAIN MACHINE
ossUFI.str("");
ossUFI << theInstanceMachine->getFullyQualifiedNameID();
for( ; it != itEnd ; ++it )
{
if( (*it).isUfid() )
{
ossUFI << '.' << it->str();
}
else
{
incrErrorCount();
ERROR_OS << "Unexpected < " << it->str()
<< " > as field of the UFI < " << anUFI.str()
<< " > !!!" << std::endl;
return( BF::REF_NULL );
}
}
const BF & aSymbol = theInstanceMachine->getExecutable()->
getSymbol(ossUFI.str(), aCTX->getTypeFamily());
if( aSymbol.valid() )
{
return( aSymbol );
}
else
{
incrErrorCount();
ERROR_OS << "Unfound a runtime symbol for the UFI < "
<< anUFI.str() << " >" << std::endl;
}
}
return( BF::REF_NULL );
}
const BF & SymbolTable::searchSemSymbol(
COMPILE_CONTEXT * aCTX, const ObjectElement * astElement) const
{
BaseAvmProgram * aProgram = aCTX->mCompileCtx;
for( ; aProgram != NULL ; aProgram = aProgram->getContainer() )
{
const BF & theSymbol =
aProgram->getSymbolByAstElement(astElement, aCTX->getTypeFamily());
if( theSymbol.valid() )
{
return( theSymbol );
}
}
if( aCTX->mRuntimeCtx != aCTX->mCompileCtx )
{
aProgram = aCTX->mRuntimeCtx;
for( ; aProgram != NULL ; aProgram = aProgram->getContainer() )
{
const BF & theSymbol = aProgram->
getSymbolByAstElement(astElement, aCTX->getTypeFamily());
if( theSymbol.valid() )
{
return( theSymbol );
}
}
}
return( BF::REF_NULL );
}
const BF & SymbolTable::searchSemSymbolByQualifiedNameID(
COMPILE_CONTEXT * aCTX, const std::string & aQualifiedNameID) const
{
BaseAvmProgram * aProgram = aCTX->mCompileCtx;
for( ; aProgram != NULL ; aProgram = aProgram->getContainer() )
{
const BF & theSymbol = aProgram->getSymbolByQualifiedNameID(
aQualifiedNameID, aCTX->getTypeFamily());
if( theSymbol.valid() )
{
return( theSymbol );
}
}
if( aCTX->mRuntimeCtx != aCTX->mCompileCtx )
{
aProgram = aCTX->mRuntimeCtx;
for( ; aProgram != NULL ; aProgram = aProgram->getContainer() )
{
const BF & theSymbol = aProgram->getSymbolByQualifiedNameID(
aQualifiedNameID, aCTX->getTypeFamily());
if( theSymbol.valid() )
{
return( theSymbol );
}
}
}
return( BF::REF_NULL );
}
const BF & SymbolTable::searchSemSymbolByNameID(
COMPILE_CONTEXT * aCTX, const std::string & aNameID) const
{
BaseAvmProgram * aProgram = aCTX->mCompileCtx;
for( ; aProgram != NULL ; aProgram = aProgram->getContainer() )
{
const BF & theSymbol =
aProgram->getSymbolByNameID(aNameID, aCTX->getTypeFamily());
if( theSymbol.valid() )
{
return( theSymbol );
}
}
if( aCTX->mRuntimeCtx != aCTX->mCompileCtx )
{
aProgram = aCTX->mRuntimeCtx;
for( ; aProgram != NULL ; aProgram = aProgram->getContainer() )
{
const BF & theSymbol = aProgram->
getSymbolByNameID(aNameID, aCTX->getTypeFamily());
if( theSymbol.valid() )
{
return( theSymbol );
}
}
}
return( BF::REF_NULL );
}
// TODO Optimize searchSymbolByQualifiedNameID
BF SymbolTable::searchSymbolByQualifiedNameID(
COMPILE_CONTEXT * aCTX, const std::string & aQualifiedNameID)
{
{
const BF & theSymbol =
searchSemSymbolByQualifiedNameID(aCTX, aQualifiedNameID);
if( theSymbol.valid() )
{
return( theSymbol );
}
}
ListOfString listOfId;
avm_size_t idCount = NamedElement::collectNameID(listOfId, aQualifiedNameID);
if( idCount == 2 )
{
const Symbol & aMachine = aCTX->mCompileCtx->getExecutable()
->getInstanceStatic().getByNameID(listOfId.first());
if( aMachine.valid() )
{
const BF & theSymbol = aMachine.getExecutable()->
getSymbolByNameID(listOfId.second(), aCTX->getTypeFamily());
if( theSymbol.valid() )
{
if( theSymbol.is< BaseInstanceForm >() )
{
return( createAliasIfNotAccessible(
aCTX, aMachine.rawMachine(), theSymbol) );
}
return( theSymbol );
}
}
}
BFList foundList;
searchInstanceByQualifiedNameID(aCTX, aQualifiedNameID, foundList);
if( foundList.singleton() )
{
return( foundList.pop_first() );
}
else if( foundList.populated() )
{
incrErrorCount();
ERROR_OS << "Indeterminism:> found too many element < "
<< aQualifiedNameID << " > from "
<< ( aCTX->mCompileCtx->is< ExecutableForm >() ?
"executable" : "program" )
<< " < " << aCTX->mCompileCtx->getFullyQualifiedNameID()
<< " > !!!";
while( foundList.nonempty() )
{
ERROR_OS << "\n\tFound :> " << str_header( foundList.pop_first() );
}
return( BF::REF_NULL );
}
{
const BF & theSymbol = searchTransition(aCTX, aQualifiedNameID);
if( theSymbol.valid() )
{
return( theSymbol );
}
}
{
const BF & theSymbol = searchProgram(aCTX, aQualifiedNameID);
if( theSymbol.valid() )
{
return( theSymbol );
}
}
{
const BF & theSymbol = searchInstanceStatic(aQualifiedNameID);
if( theSymbol.valid() )
{
return( theSymbol );
}
}
return( BF::REF_NULL );
}
BF SymbolTable::searchSymbolByNameID(
COMPILE_CONTEXT * aCTX, const std::string & aNameID)
{
{
const BF & theSymbol = searchSemSymbolByNameID(aCTX, aNameID);
if( theSymbol.valid() )
{
return( theSymbol );
}
}
BFList foundList;
searchInstanceByNameID(aCTX, aNameID, foundList);
if( foundList.singleton() )
{
return( foundList.pop_first() );
}
else if( foundList.populated() )
{
incrErrorCount();
ERROR_OS << "Indeterminism:> found too many element < " << aNameID
<< " > from " << ( aCTX->mCompileCtx->is< ExecutableForm >() ?
"executable" : "program" )
<< " < " << aCTX->mCompileCtx->getFullyQualifiedNameID() << " > !!!";
while( foundList.nonempty() )
{
ERROR_OS << "\n\tFound :> " << str_header( foundList.pop_first() );
}
return( BF::REF_NULL );
}
{
const BF & theSymbol = searchMachineInstanceByNameID(aCTX, aNameID);
if( theSymbol.valid() )
{
return( theSymbol );
}
}
{
const BF & theSymbol = searchInstanceModelByNameID(aCTX, aNameID);
if( theSymbol.valid() )
{
return( theSymbol );
}
}
{
const BF & theSymbol = searchTransitionByNameID(aCTX, aNameID);
if( theSymbol.valid() )
{
return( theSymbol );
}
}
{
const BF & theSymbol = searchProgramByNameID(aCTX, aNameID);
if( theSymbol.valid() )
{
return( theSymbol );
}
}
return( BF::REF_NULL );
}
BF SymbolTable::createAliasIfNotAccessible(COMPILE_CONTEXT * aCTX,
InstanceOfMachine * aContainerInstance, const BF & bfInstance)
{
if( not aContainerInstance->getSpecifier().isDesignInstanceStatic() )
{
return( createAliasIfNotAccessible(aCTX, bfInstance) );
}
ExecutableForm * anExecutable = aCTX->mCompileCtx->getExecutable();
const ExecutableForm * lcaExecutable = anExecutable->LCRA(
aContainerInstance->getContainer()->getExecutable() );
if( lcaExecutable != NULL )
{
BaseInstanceForm * ptrInstance = bfInstance.to_ptr< BaseInstanceForm >();
std::string fqnPrefix = lcaExecutable->getAstFullyQualifiedNameID();
ListOfString strList;
NamedElement::collectNameID(strList,
aContainerInstance->getAstFullyQualifiedNameID() + '.' +
ptrInstance->getNameID(), fqnPrefix);
VectorOfInstanceOfMachine theInstanceOfMachinePath;
while( strList.populated() )
{
fqnPrefix = fqnPrefix + '.' + strList.pop_first();
const Symbol & execInstance = lcaExecutable->getInstanceStatic().
getByFQNameID( fqnPrefix );
if( execInstance.valid() )
{
theInstanceOfMachinePath.append(execInstance.rawMachine());
lcaExecutable = execInstance.getExecutable();
}
else
{
if( lcaExecutable->getAllData().getByFQNameID( fqnPrefix ).valid()
|| lcaExecutable->getBuffer().getByFQNameID( fqnPrefix ).valid()
|| lcaExecutable->getPort().getByFQNameID( fqnPrefix ).valid()
|| lcaExecutable->getConnect().getByFQNameID( fqnPrefix ).valid() )
{
lcaExecutable = NULL;
}
break;
}
}
if( lcaExecutable != NULL )
{
// if( theInstanceOfMachinePath.last() != aContainerInstance )
// {
// theInstanceOfMachinePath.append(aContainerInstance);
// }
Symbol newInstance;
switch ( ptrInstance->classKind() )
{
case FORM_INSTANCE_DATA_KIND:
{
if( lcaExecutable->containsAllData(
bfInstance.to_ptr< InstanceOfData >()) )
{
newInstance = new InstanceOfData(anExecutable,
ptrInstance->to< InstanceOfData >(),
theInstanceOfMachinePath);
}
break;
}
case FORM_INSTANCE_MACHINE_KIND:
{
if( lcaExecutable->getInstanceStatic().contains(bfInstance) )
{
newInstance = new InstanceOfMachine( anExecutable,
ptrInstance->to< InstanceOfMachine >(),
theInstanceOfMachinePath);
}
break;
}
case FORM_INSTANCE_PORT_KIND:
{
if( lcaExecutable->getPort().contains(bfInstance) )
{
newInstance = new InstanceOfPort(anExecutable,
ptrInstance->to< InstanceOfPort >(),
theInstanceOfMachinePath);
}
break;
}
case FORM_INSTANCE_BUFFER_KIND:
{
if( lcaExecutable->getBuffer().contains(bfInstance) )
{
newInstance = new InstanceOfBuffer(anExecutable,
ptrInstance->to< InstanceOfBuffer >(),
theInstanceOfMachinePath);
}
break;
}
case FORM_INSTANCE_CONNECTOR_KIND:
{
if( lcaExecutable->getConnect().contains(bfInstance) )
{
newInstance = new InstanceOfConnect(anExecutable,
ptrInstance->to< InstanceOfConnect >(),
theInstanceOfMachinePath);
}
break;
}
default :
{
break;
}
}
if( newInstance != NULL )
{
newInstance.setFullyQualifiedNameID( "alias"
+ aContainerInstance->getFullyQualifiedNameID().substr(
aContainerInstance->getFullyQualifiedNameID().find(':'))
+ "." + ptrInstance->getNameID() );
if( not newInstance.getModifier().
isVisibilityPublic( aCTX->getModifier() ) )
{
incrErrorCount();
ERROR_OS << "Failed to create ALIAS for a non PUBLIC instance << "
<< str_header( ptrInstance ) << " >> !!!";
}
if( newInstance.is< InstanceOfData >() )
{
aCTX->mCompileCtx->getExecutable()->appendDataAlias(newInstance);
}
else
{
aCTX->mCompileCtx->getExecutable()->appendAlias(newInstance);
}
return( newInstance );
}
else
{
incrErrorCount();
ERROR_OS << "Failed to create ALIAS for instance << "
<< str_header( ptrInstance ) << " >> !!!";
}
}
}
return( bfInstance );
}
BF SymbolTable::createAliasIfNotAccessible(
COMPILE_CONTEXT * aCTX, const BF & bfInstance)
{
BaseInstanceForm * ptrInstance = bfInstance.to_ptr< BaseInstanceForm >();
for( BaseAvmProgram * tmpProgram = aCTX->mCompileCtx ; tmpProgram != NULL ;
tmpProgram = tmpProgram->getContainer() )
{
if( tmpProgram == ptrInstance->getContainer() )
{
return( bfInstance );
}
}
ExecutableForm * anExecutable = aCTX->mCompileCtx->getExecutable();
const ExecutableForm * lcaExecutable = anExecutable->LCRA(
ptrInstance->getContainer()->getExecutable() );
if( lcaExecutable != NULL )
{
std::string fqnPrefix = lcaExecutable->getAstFullyQualifiedNameID();
ListOfString strList;
NamedElement::collectNameID(strList,
ptrInstance->getAstFullyQualifiedNameID(), fqnPrefix);
VectorOfInstanceOfMachine theInstanceOfMachinePath;
while( strList.populated() )
{
fqnPrefix = fqnPrefix + '.' + strList.pop_first();
const Symbol & execInstance =
lcaExecutable->getInstanceStatic().getByFQNameID( fqnPrefix );
if( execInstance.valid() )
{
theInstanceOfMachinePath.append(execInstance.rawMachine());
lcaExecutable = execInstance.getExecutable();
}
else
{
if( lcaExecutable->getAllData().getByFQNameID( fqnPrefix ).valid()
|| lcaExecutable->getBuffer().getByFQNameID(fqnPrefix ).valid()
|| lcaExecutable->getPort().getByFQNameID(fqnPrefix ).valid()
|| lcaExecutable->getConnect().getByFQNameID(fqnPrefix ).valid() )
{
lcaExecutable = NULL;
}
break;
}
}
if( lcaExecutable != NULL )
{
Symbol newInstance;
switch ( bfInstance.classKind() )
{
case FORM_INSTANCE_DATA_KIND:
{
if( lcaExecutable->containsAllData(
bfInstance.to_ptr< InstanceOfData >()) )
{
newInstance = new InstanceOfData(anExecutable,
ptrInstance->to< InstanceOfData >(),
theInstanceOfMachinePath);
}
break;
}
case FORM_INSTANCE_MACHINE_KIND:
{
if( lcaExecutable->getInstanceStatic().contains(bfInstance) )
{
newInstance = new InstanceOfMachine(anExecutable,
ptrInstance->to< InstanceOfMachine >(),
theInstanceOfMachinePath);
}
break;
}
case FORM_INSTANCE_PORT_KIND:
{
if( lcaExecutable->getPort().contains(bfInstance) )
{
newInstance = new InstanceOfPort(anExecutable,
ptrInstance->to< InstanceOfPort >(),
theInstanceOfMachinePath);
}
break;
}
case FORM_INSTANCE_BUFFER_KIND:
{
if( lcaExecutable->getBuffer().contains(bfInstance) )
{
newInstance = new InstanceOfBuffer(anExecutable,
ptrInstance->to< InstanceOfBuffer >(),
theInstanceOfMachinePath);
}
break;
}
case FORM_INSTANCE_CONNECTOR_KIND:
{
if( lcaExecutable->getConnect().contains(bfInstance) )
{
newInstance = new