blob: 1b7a7250ec57d6ac5656022561efb84d8174af50 [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 "Compiler.h"
#include <builder/analysis/CommunicationDependency.h>
#include <fml/expression/AvmCode.h>
#include <fml/expression/ExpressionConstant.h>
#include <fml/expression/ExpressionFactory.h>
#include <fml/builtin/Identifier.h>
#include <fml/expression/StatementTypeChecker.h>
#include <fml/expression/StatementConstructor.h>
#include <fml/expression/StatementFactory.h>
#include <fml/builtin/QualifiedIdentifier.h>
#include <fml/executable/AvmProgram.h>
#include <fml/executable/AvmTransition.h>
#include <fml/executable/BaseInstanceForm.h>
#include <fml/executable/ExecutableLib.h>
#include <fml/executable/ExecutableForm.h>
#include <fml/executable/ExecutableSystem.h>
#include <fml/executable/InstanceOfBuffer.h>
#include <fml/executable/InstanceOfData.h>
#include <fml/executable/InstanceOfMachine.h>
#include <fml/executable/InstanceOfPort.h>
#include <fml/executable/RoutingData.h>
#include <fml/operator/OperatorManager.h>
#include <fml/type/TypeManager.h>
#include <fml/infrastructure/DataType.h>
#include <fml/infrastructure/Machine.h>
#include <fml/infrastructure/System.h>
#include <fml/infrastructure/Transition.h>
#include <fml/infrastructure/BehavioralPart.h>
#include <fml/infrastructure/CompositePart.h>
#include <fml/infrastructure/PropertyPart.h>
#include <fml/workflow/UniFormIdentifier.h>
#include <fml/workflow/WObject.h>
#include <sew/Configuration.h>
namespace sep
{
/**
* CONSTRUCTOR
* Default
*/
Compiler::Compiler(Configuration & aConfiguration,
AvmcodeCompiler & anAvmcodeCompiler)
: BaseMachineCompiler( aConfiguration, anAvmcodeCompiler ),
mDataCompiler( *this ),
mProgramCompiler( *this ),
mTransitionCompiler( *this ),
mComCompiler( *this )
{
//!! NOTHING
}
/**
* CONFIGURE
*/
bool Compiler::configure()
{
if( not mAvmcodeCompiler.configure() )
{
AVM_OS_ERROR_ALERT << "Compiler::configure:> "
"the Avmcode compiler configuration failed !!!"
<< SEND_ALERT;
return( false );
}
return( true );
}
/*
******************************************************************************
* START
******************************************************************************
*/
bool Compiler::start(System & aSystem)
{
ExecutableSystem * aExecutableSystem = new ExecutableSystem( aSystem );
mConfiguration.setExecutableSystem( aExecutableSystem );
precompileSystem(aSystem);
AVM_IF_DEBUG_FLAG( COMPILING )
mConfiguration.serializeDebugExecutable( "precompiling" );
AVM_ENDIF_DEBUG_FLAG( COMPILING )
mComCompiler.updateMessageID();
compileExecutableSystem();
AVM_IF_DEBUG_FLAG( COMPILING )
mConfiguration.serializeDebugExecutable( "compiling" );
AVM_ENDIF_DEBUG_FLAG( COMPILING )
postcompileExecutableSystem();
AVM_IF_DEBUG_FLAG( COMPILING )
mConfiguration.serializeDebugExecutable( "postcompiling" );
AVM_ENDIF_DEBUG_FLAG( COMPILING )
return( hasZeroError() );
}
/**
*******************************************************************************
* PRECOMPILATION
*******************************************************************************
*/
/**
* precompile
* declaration
*/
void Compiler::precompilePropertyPart(ExecutableForm * anExecutable,
PropertyPart & theDeclaration, TableOfInstanceOfData & tableOfVariable)
{
// User Variable-Parameters
PropertyPart::const_variable_iterator itVar =
theDeclaration.var_parameter_begin();
PropertyPart::const_owned_iterator endVar =
theDeclaration.var_parameter_end();
for( ; itVar != endVar ; ++itVar )
{
AVM_OS_ASSERT_FATAL_NULL_SMART_POINTER_EXIT( (*itVar) )
<< "data or type for compiling !!!"
<< SEND_EXIT;
// Allocation for variable
mDataCompiler.precompileData(anExecutable,
(*itVar).to_ptr< Variable >(), tableOfVariable);
}
// User Variable-Returns
itVar = theDeclaration.var_return_begin();
endVar = theDeclaration.var_return_end();
for( ; itVar != endVar ; ++itVar )
{
AVM_OS_ASSERT_FATAL_NULL_SMART_POINTER_EXIT( (*itVar) )
<< "data or type for compiling !!!"
<< SEND_EXIT;
// Allocation for variable
mDataCompiler.precompileData(anExecutable,
(*itVar).to_ptr< Variable >(), tableOfVariable);
}
// Other OwnedElements
PropertyPart::const_owned_iterator itWfO = theDeclaration.owned_begin();
PropertyPart::const_owned_iterator endWfO = theDeclaration.owned_end();
for( ; itWfO != endWfO ; ++itWfO )
{
AVM_OS_ASSERT_FATAL_NULL_SMART_POINTER_EXIT( (*itWfO) )
<< "data or type for compiling !!!"
<< SEND_EXIT;
// Allocation for variable
if( (*itWfO).is< Variable >() )
{
Variable * aVariable = (*itWfO).to_ptr< Variable >();
if( aVariable->getModifier().noNatureParameter() )
{
mDataCompiler.precompileData(anExecutable,
aVariable, tableOfVariable);
}
}
// Allocation for buffer
else if( (*itWfO).is< Buffer >() )
{
mComCompiler.precompileBuffer(
anExecutable, (*itWfO).to_ptr< Buffer >());
}
// Allocation for port
else if( (*itWfO).is< Port >() )
{
// mComCompiler.precompilePort(anExecutable,
// (*it).to_ptr< Port >(), tableOfVariable);
}
else if( (*itWfO).is< Channel >() )
{
// mComCompiler.precompileChannel(
// anExecutable, (*it).to_ptr< Channel >());
}
else if( (*itWfO).is< Machine >() )
{
// precompileInstanceStatic(
// anExecutable, (*it).to_ptr< Machine >());
}
// Allocation for typedef
else if( (*itWfO).is< DataType >() )
{
precompileTypeSpecifier(anExecutable, (*itWfO));
}
}
// Allocation for ports / signals
mComCompiler.precompileComPoint(
anExecutable, theDeclaration, tableOfVariable);
// Allocation for channels
mComCompiler.precompileChannel(anExecutable,
theDeclaration, tableOfVariable);
}
void Compiler::precompileDataType(AvmProgram * aProgram,
PropertyPart & theDeclaration, TableOfInstanceOfData & tableOfVariable)
{
PropertyPart::const_owned_iterator it = theDeclaration.owned_begin();
PropertyPart::const_owned_iterator endIt = theDeclaration.owned_end();
for( ; it != endIt ; ++it )
{
AVM_OS_ASSERT_FATAL_NULL_SMART_POINTER_EXIT( (*it) )
<< "data or type for compiling !!!"
<< SEND_EXIT;
// Allocation for variable
if( (*it).is< Variable >() )
{
mDataCompiler.precompileData(aProgram,
(*it).to_ptr< Variable >(), tableOfVariable);
}
// Allocation for typedef
else
{
precompileTypeSpecifier(aProgram, (*it));
}
}
}
/**
* precompile
* specification
*/
void Compiler::precompileExecutableCompositePart(
ExecutableForm * aContainer, Machine * anExecutableSpec)
{
CompositePart * aCompositePart = anExecutableSpec->getCompositePart();
if( aCompositePart == NULL )
{
//!! NOTHING
return;
}
/*
* precompiling procedure
*/
if( aCompositePart->hasProcedure() )
{
CompositePart::const_procedure_iterator it =
aCompositePart->procedure_begin();
CompositePart::const_procedure_iterator endIt =
aCompositePart->procedure_end();
for( ; it != endIt ; ++it )
{
precompileExecutable(aContainer, (it));
}
}
/*
* precompiling executable - instance static
*/
if( aCompositePart->hasMachine() )
{
// precompiling sub-executable
anExecutableSpec->expandGroupStatemachine();
CompositePart::const_machine_iterator it =
aCompositePart->machine_begin();
CompositePart::const_machine_iterator endIt =
aCompositePart->machine_end();
for( ; it != endIt ; ++it )
{
precompileExecutable(aContainer, (it));
}
}
/*
* precompiling instance dynamic
*/
if( aCompositePart->hasInstanceDynamic() )
{
CompositePart::const_machine_iterator it =
aCompositePart->instance_dynamic_begin();
CompositePart::const_machine_iterator endIt =
aCompositePart->instance_dynamic_end();
for( ; it != endIt ; ++it )
{
// if( (it)->getSpecifier().isDesignInstanceDynamic() )
{
precompileExecutableInstanceDynamique(aContainer, (it));
}
}
}
}
void Compiler::precompileExecutable(
ExecutableForm * aContainer, Machine * anExecutableSpec)
{
if( anExecutableSpec->getSpecifier().hasGroupMask() )
{
precompileExecutableGroup(aContainer, anExecutableSpec);
}
else if( anExecutableSpec->getSpecifier().isDesignModel())
{
precompileExecutableModel(aContainer, anExecutableSpec);
}
else if( anExecutableSpec->getSpecifier().isDesignPrototypeStatic() )
{
precompileExecutablePrototype(aContainer, anExecutableSpec);
}
else if( anExecutableSpec->getSpecifier().isDesignInstanceStatic() )
{
precompileExecutableInstanceStatic(aContainer, anExecutableSpec);
}
else if( anExecutableSpec->getSpecifier().isDesignInstanceDynamic() )
{
precompileExecutableInstanceDynamique(aContainer, anExecutableSpec);
}
else
{
AVM_OS_FATAL_ERROR_EXIT
<< "Unexpected in precompiling stage the executable: "
<< std::endl << str_header( anExecutableSpec ) << std::endl
<< "==> with specifier: "
<< anExecutableSpec->getSpecifier().str() << " !!!"
<< SEND_EXIT;
}
}
ExecutableForm * Compiler::precompileExecutableModel(
ExecutableForm * aContainer, Machine * anExecutableSpec)
{
//AVM_OS_CERR << TAB << "<** begin precompiling executable model:>"
// << std::endl << str_header( anExecutableSpec ) << std::endl;
// CREATE NEW EXECUTABLE
ExecutableForm * anExec = new ExecutableForm(
mConfiguration.getExecutableSystem(),
aContainer, anExecutableSpec);
setInheritedSpecifier(aContainer, anExec);
// APPEND NEW EXECUTABLE IN THE SYSTEM
// //?? For retrocompatibity serialization order
// getSymbolTable().addMachineExecutable(
// mExecutableSystem->saveExecutable( anExec ) );
avm_size_t maximalInstanceCount = anExecutableSpec->hasInstanceSpecifier()
? anExecutableSpec->getInstanceSpecifier()->getMaximalInstanceCount()
: AVM_NUMERIC_MAX_SIZE_T;
//??? Sera fait dans precompileExecutableInstanceXXX(...) ?
// anExec->incrPossibleStaticInstanciationCount( createdInstanceCount );
if( anExecutableSpec->getSpecifier().isFamilyComponentComposite() )
{
Specifier aSpecifier( anExecutableSpec->getSpecifier() );
InstanceOfMachine * aModelInstance = new InstanceOfMachine(
aContainer, anExecutableSpec, anExec, NULL,
aContainer->getInstanceModel().size(),
aSpecifier.setDesignModel() );
//??? Sera fait dans precompileExecutableInstanceXXX(...) ?
aModelInstance->setInstanceCount(
/*createdInstanceCount*/0, maximalInstanceCount);
aContainer->saveInstanceModel( aModelInstance );
}
/*
* Allocation of declaration contents :>
* constant, variable, typedef, buffer, port
*/
TableOfInstanceOfData tableOfVariable;
if( anExecutableSpec->hasProperty() )
{
avm_offset_t parametersCount = anExecutableSpec->
getPropertyPart().getVariableParametersCount();
anExec->setParamOffsetCount( 0 , parametersCount );
anExec->setReturnOffsetCount( parametersCount, anExecutableSpec->
getPropertyPart().getVariableReturnsCount() );
precompilePropertyPart(anExec,
anExecutableSpec->getPropertyPart(), tableOfVariable);
}
/*
* Update data table
*/
anExec->setData(tableOfVariable);
/*
* precompiling executable composite part
*/
if( anExecutableSpec->hasMachine() || anExecutableSpec->hasPortSignal() )
{
Specifier aSpecifier( anExecutableSpec->getSpecifier() );
// Set the instance THIS at first position (index = 0)
InstanceOfMachine * aNewInstance =
InstanceOfMachine::newInstanceModelThis(
anExec, anExecutableSpec, anExec, NULL,
anExec->getInstanceModel().size(),
aSpecifier.setDesignModel() );
anExec->saveInstanceModel(aNewInstance);
aNewInstance = InstanceOfMachine::newThis(anExec,
aNewInstance, anExec->getInstanceStatic().size() );
// aNewInstance->setAutoStart( anExecutableSpec->hasInitialInstance() );
anExec->saveInstanceStatic(aNewInstance);
}
precompileExecutableCompositePart(anExec, anExecutableSpec);
/*
* precompiling transition
*/
if( anExecutableSpec->hasOutgoingTransition() )
{
BehavioralPart::const_transition_iterator it = anExecutableSpec->
getBehavior()->outgoing_transition_begin();
BehavioralPart::const_transition_iterator endIt = anExecutableSpec->
getBehavior()->outgoing_transition_end();
for( ; it != endIt ; ++it )
{
mTransitionCompiler.precompileTransition( anExec, (it) );
}
}
// APPEND NEW EXECUTABLE IN THE SYSTEM
//?? For retrocompatibity serialization order
getSymbolTable().addMachineExecutable( mConfiguration.
getExecutableSystem().saveExecutable( anExec ) );
//AVM_OS_TRACE << TAB << ">** end precompiling executable MODEL:>"
// << std::endl << str_header( anExecutableSpec ) << std::endl;
return( anExec );
}
void Compiler::precompileExecutablePrototype(
ExecutableForm * aContainer, Machine * anExecutableSpec)
{
//AVM_OS_TRACE << TAB << "<++ begin precompiling executable #instance model:>"
// << std::endl << str_header( anExecutableSpec ) << std::endl;
ExecutableForm * anExec =
precompileExecutableModel(aContainer, anExecutableSpec);
avm_size_t initialInstanceCount = 1;
avm_size_t maximalInstanceCount = AVM_NUMERIC_MAX_SIZE_T;
if( anExecutableSpec->hasInstanceSpecifier() )
{
initialInstanceCount = anExecutableSpec->
getInstanceSpecifier()->getInitialInstanceCount();
maximalInstanceCount = anExecutableSpec->
getInstanceSpecifier()->getMaximalInstanceCount();
}
// Instances for << MODEL >> & INSTANCE
InstanceOfMachine * aModelInstance = NULL;
if( anExecutableSpec->getSpecifier().isFamilyComponentComposite() )
{
aModelInstance = aContainer->getInstanceModel().
getByAstElement( anExec->getAstElement() ).rawMachine();
if( aModelInstance == NULL )
{
AVM_OS_FATAL_ERROR_EXIT
<< "Unfound model instance of #prototype executable !!!"
<< std::endl << str_header( anExec->getAstElement() )
<< SEND_EXIT;
}
else
{
aModelInstance->incrInstanciationCount( initialInstanceCount );
anExec->incrPossibleStaticInstanciationCount( initialInstanceCount );
}
}
if( initialInstanceCount > 0 )
{
Specifier aSpecifier( anExecutableSpec->getSpecifier() );
InstanceOfMachine * aNewInstance = new InstanceOfMachine(
aContainer, anExecutableSpec, anExec, aModelInstance,
aContainer->getInstanceStatic().size(),
aSpecifier.setDesignPrototypeStatic() );
aNewInstance->setInstanceCount(
initialInstanceCount, maximalInstanceCount);
aNewInstance->setAutoStart( true );
setInheritedSpecifier(aContainer, aNewInstance);
anExec->setPrototypeInstance( aNewInstance );
const Symbol & bfInstance =
aContainer->saveInstanceStatic(aNewInstance);
getSymbolTable().addInstanceStatic(bfInstance);
aSpecifier.setDesignInstanceStatic();
avm_size_t offset = 1;
for( ; offset < initialInstanceCount ; ++offset )
{
aNewInstance = new InstanceOfMachine(
aContainer, anExecutableSpec, anExec, aModelInstance,
aContainer->getInstanceStatic().size(), aSpecifier);
aNewInstance->setInstanceCount(1, maximalInstanceCount);
aNewInstance->updateUfid(offset);
aNewInstance->setAutoStart( true );
setInheritedSpecifier(aContainer, aNewInstance);
getSymbolTable().addInstanceStatic(
aContainer->saveInstanceStatic(aNewInstance));
}
}
else
{
//!![TRACE]: to delete
//AVM_OS_DEBUG << "precompileExecutablePrototype Initial Instanciation Count: 0"
// << std::endl << str_header( anExec ) << std::endl;
}
//AVM_OS_TRACE << TAB << ">++ end precompiling executable #instance model:>"
// << std::endl << str_header( anExecutableSpec ) << std::endl;
}
void Compiler::precompileExecutableInstanceStatic(
ExecutableForm * aContainer, Machine * anExecutableSpec)
{
//AVM_OS_TRACE << TAB << "<-- begin precompiling executable #static instance:>"
// << std::endl << str_header( anExecutableSpec ) << std::endl;
ExecutableForm * anExec =
getSymbolTable().searchExecutableModel(anExecutableSpec);
if( anExec != NULL )
{
avm_size_t initialInstanceCount = anExecutableSpec->
getInstanceSpecifier()->getInitialInstanceCount();
avm_size_t maximalInstanceCount = anExecutableSpec->
getInstanceSpecifier()->getMaximalInstanceCount();
anExec->incrPossibleStaticInstanciationCount( initialInstanceCount );
// Instances for << MODEL >> & INSTANCE
InstanceOfMachine * aModelInstance = aContainer->getInstanceModel().
getByAstElement( anExec->getAstElement() ).rawMachine();
if( aModelInstance == NULL )
{
Specifier aSpecifier(
anExec->getAstMachine()->getSpecifier() );
aModelInstance = new InstanceOfMachine( aContainer,
anExec->getAstMachine(), anExec, NULL,
aContainer->getInstanceModel().size(),
aSpecifier.setDesignModel() );
aModelInstance->setInstanceCount(
initialInstanceCount, maximalInstanceCount);
aContainer->saveInstanceModel( aModelInstance );
}
else
{
aModelInstance->incrInstanciationCount( initialInstanceCount );
}
InstanceOfMachine * aNewInstance = NULL;
avm_size_t offset = 0;
for( ; offset < initialInstanceCount ; ++offset )
{
aNewInstance = new InstanceOfMachine(
aContainer, anExecutableSpec, anExec, aModelInstance,
aContainer->getInstanceStatic().size() );
aNewInstance->setInstanceCount(
initialInstanceCount, maximalInstanceCount);
if( offset > 0 )
{
aNewInstance->updateUfid(offset);
}
aNewInstance->setAutoStart( anExecutableSpec->isAutoStart() );
// aNewInstance->setAutoStart( true );
setInheritedSpecifier(aContainer, aNewInstance);
getSymbolTable().addInstanceStatic(
aContainer->saveInstanceStatic(aNewInstance));
}
}
// ERROR REPORTING
else if( getSymbolTable().hasError() )
{
incrErrorCount();
anExecutableSpec->errorLocation(AVM_OS_WARN)
<< getSymbolTable().getErrorMessage()
<< std::endl << std::endl;
}
else
{
incrErrorCount();
anExecutableSpec->errorLocation(AVM_OS_WARN)
<< "Unfound the model << " << anExecutableSpec->strType()
<< " >> of the executable instance << "
<< str_header( anExecutableSpec ) << " >>"
<< std::endl << std::endl;
}
//AVM_OS_TRACE << TAB << ">-- end precompiling executable #dynamic instance:>"
// << std::endl << str_header( anExecutableSpec ) << std::endl;
}
void Compiler::precompileExecutableInstanceDynamique(
ExecutableForm * aContainer, Machine * anExecutableSpec)
{
//AVM_OS_WARN << TAB << "<-- begin precompiling executable #dynamic instance:>"
// << std::endl << str_header( anExecutableSpec ) << std::endl;
ExecutableForm * anExec =
getSymbolTable().searchExecutableModel(anExecutableSpec);
avm_size_t initialInstanceCount = anExecutableSpec->
getInstanceSpecifier()->getInitialInstanceCount();
avm_size_t maximalInstanceCount = anExecutableSpec->
getInstanceSpecifier()->getMaximalInstanceCount();
if( anExec != NULL )
{
// Instances for << MODEL >> & INSTANCE
CompilationEnvironment cENV(anExec);
InstanceOfMachine * aModelInstance =
getSymbolTable().searchInstanceModel(
cENV.mCTX, anExec->getAstElement()).rawMachine();
if( aModelInstance == NULL )
{
aModelInstance = aContainer->getInstanceModel().
getByAstElement( anExec->getAstElement() ).rawMachine();
}
if( aModelInstance == NULL )
{
Specifier aSpecifier(
anExec->getAstMachine()->getSpecifier() );
aModelInstance = new InstanceOfMachine( aContainer,
anExec->getAstMachine(), anExec, NULL,
aContainer->getInstanceModel().size(),
aSpecifier.setDesignModel() );
aModelInstance->setInstanceCount(
initialInstanceCount, maximalInstanceCount);
aContainer->saveInstanceModel( aModelInstance );
anExec->incrPossibleDynamicInstanciationCount(
initialInstanceCount );
}
else
{
aModelInstance->incrPossibleDynamicInstanciationCount(
initialInstanceCount );
}
InstanceOfMachine * aNewInstance = new InstanceOfMachine(
aContainer, anExecutableSpec, anExec, aModelInstance,
aContainer->getInstanceStatic().size() );
aNewInstance->setInstanceCount(
initialInstanceCount, maximalInstanceCount);
aNewInstance->setAutoStart( true );
setInheritedSpecifier(aContainer, aNewInstance);
aContainer->saveInstanceDynamic(aNewInstance);
}
// ERROR REPORTING
else if( getSymbolTable().hasError() )
{
incrErrorCount();
anExecutableSpec->errorLocation(AVM_OS_WARN)
<< getSymbolTable().getErrorMessage()
<< std::endl << std::endl;
}
else
{
incrWarningCount();
anExecutableSpec->warningLocation(AVM_OS_LOG)
<< "Unfound the executable model << "
<< anExecutableSpec->strType()
<< " >> of the #dynamic instance !!!"
<< std::endl << str_header( anExecutableSpec )
<< std::endl << std::endl;
InstanceOfMachine * aNewInstance = new InstanceOfMachine(
aContainer, anExecutableSpec, anExec, NULL,
aContainer->getInstanceStatic().size() );
aNewInstance->setInstanceCount(
initialInstanceCount, maximalInstanceCount);
aNewInstance->setAutoStart( false );
setInheritedSpecifier(aContainer, aNewInstance);
aContainer->saveInstanceDynamic(aNewInstance);
}
//AVM_OS_WARN << TAB << ">-- end precompiling executable #dynamic instance:>"
// << std::endl << str_header( anExecutableSpec ) << std::endl;
}
void Compiler::precompileExecutableGroup(
ExecutableForm * aContainer, Machine * anExecutableSpec)
{
// Machine * containerSM = anExecutableSpec->getContainerMachine();
//
// if( anExecutableSpec->getSpecifier().isGroupEvery())
// {
// containerSM->appendOutgoingTransitionToEveryState(anExecutableSpec);
// }
// else if( anExecutableSpec->getSpecifier().isGroupSome())
// {
// containerSM->appendOutgoingTransitionToSomeState(anExecutableSpec);
// }
// else if( anExecutableSpec->getSpecifier().isGroupExcept() )
// {
// containerSM->appendOutgoingTransitionToExceptState(anExecutableSpec);
// }
}
/**
* precompile
* specification
*/
void Compiler::precompileSystem(System & aSystem)
{
//AVM_OS_TRACE << TAB << "< begin precompiling specification:> "
// << aSystem.getFullyQualifiedNameID() << std::endl;
/*
* For the system executable
*/
ExecutableForm * systemExec = new ExecutableForm(
mConfiguration.getExecutableSystem(), NULL, (& aSystem));
// APPEND NEW EXECUTABLE IN THE SYSTEM
// //?? For retrocompatibity serialization order
// getSymbolTable().addMachineExecutable(
// mExecutableSystem->saveExecutable( systemExec ) );
// Structural decompositon
systemExec->setMainComponent( true );
Specifier aSpecifier( aSystem.getSpecifier() );
InstanceOfMachine * aNewInstance = new InstanceOfMachine(NULL, (& aSystem),
systemExec, NULL, 0, aSpecifier.setDesignPrototypeStatic() );
aNewInstance->setAutoStart( true );
// aSystem.getInstanceSpecifier()->hasInitialInstance() );
aNewInstance->setInstanceCount(1, 1);
systemExec->setPrototypeInstance( aNewInstance );
systemExec->incrPossibleStaticInstanciationCount(1);
getSymbolTable().addInstanceStatic( mConfiguration.
getExecutableSystem().setSystemInstance(aNewInstance) );
// Set the instance THIS in first position (index = 0)
// for << MODEL >> & INSTANCE
aNewInstance = InstanceOfMachine::newInstanceModelThis(
systemExec, (& aSystem), systemExec, NULL,
systemExec->getInstanceModel().size(),
aSpecifier.setDesignModel() );
aNewInstance->setInstanceCount(0, 1);
systemExec->saveInstanceModel( aNewInstance );
aNewInstance = InstanceOfMachine::newThis(systemExec,
aNewInstance, systemExec->getInstanceStatic().size() );
systemExec->saveInstanceStatic(aNewInstance);
/*
* Allocation of declaration contents :>
* constant, variable, typedef, buffer, port
*/
if( aSystem.hasProperty() )
{
TableOfInstanceOfData tableOfVariable;
precompilePropertyPart(systemExec,
aSystem.getPropertyPart(), tableOfVariable);
/*
* Update data table
*/
systemExec->setData(tableOfVariable);
}
/*
* precompiling executable composite part
*/
precompileExecutableCompositePart(systemExec, (& aSystem));
//AVM_OS_TRACE << TAB << "> end precompiling specification:> "
// << aSystem.getFullyQualifiedNameID() << std::endl << std::endl;
// APPEND NEW EXECUTABLE IN THE SYSTEM
//?? For retrocompatibity serialization order
getSymbolTable().addMachineExecutable( mConfiguration.
getExecutableSystem().saveExecutable( systemExec ) );
}
/**
* setInheritedSpecifier from container to owned elements
*/
void Compiler::setInheritedSpecifier(
ExecutableForm * aContainer, ExecutableForm * anExecutable)
{
if( aContainer->getSpecifier().hasFeatureInputEnabled() )
{
anExecutable->getwSpecifier().setFeatureInputEnabled();
const_cast< Machine * >(anExecutable->getAstMachine() )
->getwSpecifier().setFeatureInputEnabled();
}
}
void Compiler::setInheritedSpecifier(
ExecutableForm * aContainer, InstanceOfMachine * aMachine)
{
if( aContainer->getSpecifier().hasFeatureInputEnabled() )
{
aMachine->getwSpecifier().setFeatureInputEnabled();
}
}
/**
*******************************************************************************
* COMPILATION OF EXECUTABLE
*******************************************************************************
*/
void Compiler::compileExecutableSystem()
{
TableOfExecutableForm::const_raw_iterator itProc;
TableOfExecutableForm::const_raw_iterator endProc;
TableOfExecutableForm::const_raw_iterator itExec =
mConfiguration.getExecutableSystem().getExecutables().begin();
TableOfExecutableForm::const_raw_iterator endIt =
mConfiguration.getExecutableSystem().getExecutables().end();
for( ; itExec != endIt ; ++itExec )
{
compileExecutable( (itExec) );
if( (itExec)->hasExecutable() )
{
itProc = (itExec)->getExecutables().begin();
endProc = (itExec)->getExecutables().end();
for( ; itProc != endProc ; ++itProc )
{
compileProcedure( itProc );
}
}
}
}
void Compiler::compileExecutable(ExecutableForm * anExecutable)
{
if( anExecutable->isCompiledFlag() )
{
return;
}
else
{
anExecutable->setCompiledFlag();
}
AVM_IF_DEBUG_FLAG( COMPILING )
AVM_OS_TRACE << INCR_INDENT_TAB << "<| compiling<executable>: "
<< anExecutable->getFullyQualifiedNameID() << std::endl;
AVM_ENDIF_DEBUG_FLAG( COMPILING )
// Compile data & all machine MOE program
compileBaseMachine(anExecutable);
// Compile data & all instance MOE program
compileAllInstances( anExecutable );
if( anExecutable->getAstElement()->is< System >() )
{
compileSystem( anExecutable );
}
else if( anExecutable->getAstElement()->is_exactly< Machine >() )
{
if( anExecutable->getSpecifier().isFamilyComponentStatemachine() )
{
compileStatemachine( anExecutable );
}
else
{
compileMachine( anExecutable );
}
}
else
{
AVM_OS_EXIT( FAILED )
<< "Unexpected executable form for compiling :\n"
<< anExecutable->toString()
<< SEND_EXIT;
}
AVM_IF_DEBUG_FLAG( COMPILING )
AVM_OS_TRACE << TAB_DECR_INDENT << ">| compiling<executable>: "
<< anExecutable->getFullyQualifiedNameID() << std::endl;
AVM_ENDIF_DEBUG_FLAG( COMPILING )
}
/**
*******************************************************************************
* COMPILATION OF INSTANCE MACHINE PARAM
*******************************************************************************
*/
void Compiler::compileAllInstances(ExecutableForm * anExecutableForm)
{
if( anExecutableForm->hasInstanceStatic() )
{
// Compilation of InstanceOfMachine Parameters / Behaviors
TableOfSymbol::const_iterator itMachine =
anExecutableForm->instance_static_begin();
TableOfSymbol::const_iterator endMachine =
anExecutableForm->instance_static_end();
for( ; itMachine != endMachine ; ++itMachine )
{
compileInstance(anExecutableForm, (*itMachine).rawMachine());
if( not (*itMachine).hasExecutable() )
{
AVM_OS_FATAL_ERROR_EXIT
<< "Unexpected a #static instance "
"without executable model !!!"
<< std::endl << str_header( (*itMachine) )
<< SEND_EXIT;
}
}
}
if( anExecutableForm->hasInstanceDynamic() )
{
// Compilation of InstanceOfMachine Parameters / Behaviors
TableOfSymbol::const_iterator itMachine =
anExecutableForm->instance_dynamic_begin();
TableOfSymbol::const_iterator endMachine =
anExecutableForm->instance_dynamic_end();
for( ; itMachine != endMachine ; ++itMachine )
{
compileInstance(anExecutableForm, (*itMachine).rawMachine());
if( not (*itMachine).hasExecutable() )
{
AVM_OS_FATAL_ERROR_EXIT
<< "Unexpected a #dynamic instance "
"without executable model !!!"
<< std::endl << str_header( (*itMachine) )
<< SEND_EXIT;
}
}
}
}
void Compiler::compileInstance(
ExecutableForm * theExecutableContainer, InstanceOfMachine * anInstance)
{
const Machine * anExecutableSpec = anInstance->getAstMachine();
//AVM_OS_WARN << TAB << "<-- begin compiling executable instance:>" << std::endl
// << to_stream( anInstance )// << std::endl
// << to_stream( anExecutableSpec ) << std::endl;
ExecutableForm * anExec = anInstance->getExecutable();
if( anExec == NULL )
{
anExec = getSymbolTable().searchExecutableModel(anExecutableSpec);
if( anExec != NULL )
{
anInstance->setExecutable( anExec );
anInstance->setAutoStart( true );
// Instances for << MODEL >> & INSTANCE
CompilationEnvironment cENV(anExec);
InstanceOfMachine * aModelInstance =
getSymbolTable().searchInstanceModel(
cENV.mCTX, anExec->getAstElement()).rawMachine();
if( aModelInstance == NULL )
{
aModelInstance = theExecutableContainer->getInstanceModel().
getByAstElement( anExec->getAstElement() ).rawMachine();
}
if( aModelInstance != NULL )
{
anInstance->setInstanceModel( aModelInstance );
}
if( anInstance->getSpecifier().hasDesignInstanceDynamic() )
{
if( aModelInstance != NULL )
{
aModelInstance->incrPossibleDynamicInstanciationCount( 1 );
}
else
{
anExec->incrPossibleDynamicInstanciationCount( 1 );
}
}
else
{
anExec->incrPossibleStaticInstanciationCount( 1 );
}
}
// ERROR REPORTING
else if( getSymbolTable().hasError() )
{
incrErrorCount();
anExecutableSpec->errorLocation(AVM_OS_WARN)
<< getSymbolTable().getErrorMessage()
<< std::endl << std::endl;
}
else
{
incrErrorCount();
anExecutableSpec->errorLocation(AVM_OS_WARN)
<< "Unfound the model << "
<< anExecutableSpec->strType()
<< " >> of the statemachine instance << "
<< str_header( anExecutableSpec ) << " >>"
<< std::endl << std::endl;
}
}
if( anExec != NULL )
{
compileExecutable( anExec );
if( anExec->hasParamReturn() )
{
compileInstanceParameters(theExecutableContainer, anInstance);
}
}
else
{
AVM_OS_FATAL_ERROR_EXIT
<< "Unexpected a instance without executable model !!!"
<< std::endl << str_header( anInstance )
<< SEND_EXIT;
return;
}
BehavioralPart * theBehavior = anExecutableSpec->getBehavior();
if( theBehavior != NULL )
{
/*
* onCreate
*/
if( theBehavior->hasOnCreate()
&& StatementTypeChecker::doSomething(theBehavior->getOnCreate()) )
{
CompilationEnvironment cENV(NULL, anExec, theExecutableContainer);
BFCode onCreate = theBehavior->getOnCreate();
if( anExec->hasOnCreate()
&& anInstance->getSpecifier().hasDesignInstanceNotModel() )
{
onCreate = StatementConstructor::newCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
anExec->getOnCreate(), onCreate );
}
anInstance->setOnCreate(
mAvmcodeCompiler.compileStatement(cENV.mCTX, onCreate) );
}
/*
* onStart
*/
if( theBehavior->hasOnStart()
&& StatementTypeChecker::doSomething(theBehavior->getOnStart()) )
{
CompilationEnvironment cENV(NULL, anExec, theExecutableContainer);
BFCode onStart = theBehavior->getOnStart();
if( anExec->hasOnStart() )
{
onStart = StatementConstructor::newCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
anExec->getOnStart(), onStart );
}
if( anExec->hasOnInit() )
{
onStart = StatementConstructor::newCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
onStart, anExec->getOnInit() );
}
anInstance->setOnStart(
mAvmcodeCompiler.compileStatement(cENV.mCTX, onStart) );
}
}
//AVM_OS_WARN << TAB << ">-- end compiling executable instance:>" << std::endl
// << to_stream( anInstance )// << std::endl
// << str_header( anExecutableSpec ) << std::endl;
}
void Compiler::compileInstanceParameters(
ExecutableForm * theExecutableContainer, InstanceOfMachine * anInstance)
{
ExecutableForm * anExecutableForm = anInstance->getExecutable();
const Machine * aMachine = anInstance->getAstMachine();
if( (anExecutableForm != NULL) && anExecutableForm->hasParamReturn() )
{
APTableOfData aParamTable( new TableOfData(
anExecutableForm->getParamReturnCount() ) );
anInstance->setParamReturnTable( aParamTable );
anInstance->setReturnOffset( anExecutableForm->getParamCount() );
bool hasInitialInstance =
aMachine->getInstanceSpecifier()->hasInitialInstance();
if( anExecutableForm->hasParam() )
{
if( aMachine->hasVariableParameter() )
{
BF paramValue;
TableOfVariable::const_raw_iterator it =
aMachine->getVariableParameters().begin();
TableOfVariable::const_raw_iterator itEnd =
aMachine->getVariableParameters().end();
for( avm_offset_t offset = 0 ; it != itEnd ; ++it , ++offset )
{
if( (*it).invalid() )
{
if( hasInitialInstance )
{
incrWarningCount();
aMachine->errorLocation(AVM_OS_WARN)
<< "Compile param warning << "
<< str_header(
anExecutableForm->rawParamData(offset) )
<< " >> for the statemachine instance << "
<< str_header( aMachine ) << " >> "
<< "Unexpected non-instanciated parameters !"
<< std::endl << std::endl;
//!! Generation of symbolic parameter
//!! Generation of symbolic parameter
}
}
else if( (it)->hasValue() )
{
paramValue = mAvmcodeCompiler.decode_compileExpression(
theExecutableContainer, (it)->getValue() );
if( paramValue.valid() )
{
aParamTable->set(offset, paramValue);
}
else
{
incrErrorCount();
aMachine->errorLocation(AVM_OS_WARN)
<< "Compile param error << "
<< str_header( *it )
<< " >> for the statemachine instance << "
<< str_header( aMachine ) << " >>"
<< std::endl << std::endl;
}
}
else if( hasInitialInstance )
{
incrWarningCount();
aMachine->warningLocation(AVM_OS_WARN)
<< "Compile param warning << "
<< str_header( *it )
<< " >> for the statemachine instance << "
<< str_header( aMachine ) << " >> "
<< "Unexpected non-instanciated parameters !"
<< std::endl << std::endl;
//!! Generation of symbolic parameter
//!! Generation of symbolic parameter
}
}
}
}
if( anExecutableForm->hasReturn() )
{
if( aMachine->hasVariableReturn() )
{
BF returnValue;
TableOfVariable::const_raw_iterator it =
aMachine->getVariableReturns().begin();
TableOfVariable::const_raw_iterator itEnd =
aMachine->getVariableReturns().end();
for( avm_offset_t offset = 0 ; it != itEnd ; ++it , ++offset )
{
if( (*it).invalid() )
{
incrWarningCount();
aMachine->errorLocation(AVM_OS_WARN)
<< "Compile return warning << "
<< str_header(
anExecutableForm->rawReturnData(offset) )
<< " >> for the statemachine instance << "
<< str_header( aMachine ) << " >> "
<< "Unexpected non-instanciated parameters !"
<< std::endl << std::endl;
//!! Generation of symbolic parameter
//!! Generation of symbolic parameter
}
else if( (it)->hasValue() )
{
returnValue = mAvmcodeCompiler.decode_compileExpression(
theExecutableContainer, (it)->getValue() );
if( returnValue.valid() )
{
aParamTable->set(anExecutableForm->getReturnOffset()
+ offset, returnValue);
}
else
{
incrErrorCount();
aMachine->errorLocation(AVM_OS_WARN)
<< "Compile return error << "
<< str_header( *it )
<< " >> for the statemachine instance << "
<< str_header( aMachine ) << " >>"
<< std::endl << std::endl;
}
}
}
}
}
}
}
/**
*******************************************************************************
* COMPILATION OF AVMPROGRAM
*******************************************************************************
*/
void Compiler::compileAvmPrograms()
{
AvmProgram * aProgram;
avm_size_t offset;
TableOfExecutableForm::const_raw_iterator itExec =
mConfiguration.getExecutableSystem().getExecutables().begin();
TableOfExecutableForm::const_raw_iterator endExec =
mConfiguration.getExecutableSystem().getExecutables().end();
for( ; itExec != endExec ; ++itExec )
{
for( offset = 0 ; offset < (itExec)->getProgram().size() ; ++offset )
{
aProgram = (itExec)->getProgram().rawAt(offset);
AVM_IF_DEBUG_FLAG( COMPILING )
AVM_OS_TRACE << INCR_INDENT_TAB << "<| compiling<program>: "
<< aProgram->getFullyQualifiedNameID() << std::endl;
AVM_ENDIF_DEBUG_FLAG( COMPILING )
mProgramCompiler.compileProgram( aProgram );
AVM_IF_DEBUG_FLAG( COMPILING )
// (*itProg)->toStream(AVM_OS_TRACE);
AVM_OS_TRACE << TAB_DECR_INDENT << ">| compiling<program>: "
<< aProgram->getFullyQualifiedNameID() << std::endl;
AVM_ENDIF_DEBUG_FLAG( COMPILING )
}
}
}
/**
* compile
* Executable
*/
void Compiler::compileBaseMachine(ExecutableForm * anExecutableForm)
{
const Machine * aMachine = anExecutableForm->getAstMachine();
//AVM_OS_TRACE << TAB << "<| compiling<machine>: "
// << str_header( aMachine ) << std::endl;
// COMPILATION OF PORT
mComCompiler.compilePort(anExecutableForm);
// COMPILATION OF DATA
mDataCompiler.compileData(anExecutableForm);
if( not aMachine->hasBehavior() )
{
return;
}
BehavioralPart * theBehavior = aMachine->getBehavior();
/*
* onCreate
*/
if( theBehavior->hasOnCreate() &&
StatementTypeChecker::doSomething(theBehavior->getOnCreate()) )
{
anExecutableForm->setOnCreate(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnCreate()) );
}
/*
* onInit
*/
if( theBehavior->hasOnInit() &&
StatementTypeChecker::doSomething(theBehavior->getOnInit()) )
{
anExecutableForm->setOnInit(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnInit()) );
}
/*
* onFinal
*/
if( theBehavior->hasOnFinal() &&
StatementTypeChecker::doSomething(theBehavior->getOnFinal()) )
{
anExecutableForm->setOnFinal(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnFinal()) );
}
/*
* onReturn
*/
if( theBehavior->hasOnReturn() &&
StatementTypeChecker::doSomething(theBehavior->getOnReturn()) )
{
anExecutableForm->setOnReturn(
StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnReturn()),
StatementConstructor::newCode(
OperatorManager::OPERATOR_FINAL) ) );
}
/*
* onStart
*/
if( theBehavior->hasOnStart() &&
StatementTypeChecker::doSomething(theBehavior->getOnStart()) )
{
anExecutableForm->setOnStart(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnStart()) );
}
/*
* onStop
*/
if( theBehavior->hasOnStop() &&
StatementTypeChecker::doSomething(theBehavior->getOnStop()) )
{
anExecutableForm->setOnStop(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnStop()) );
}
/*
* onIEnable
*/
if( theBehavior->hasOnIEnable() &&
StatementTypeChecker::doSomething(theBehavior->getOnIEnable()) )
{
anExecutableForm->setOnIEnable(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnIEnable()) );
AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , COMPUTING , STATEMENT )
anExecutableForm->setOnIEnable(StatementConstructor::newCodeFlatMiddle(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
StatementConstructor::newComment( "begin<ienable> " +
anExecutableForm->getFullyQualifiedNameID() ),
anExecutableForm->getOnIEnable(),
StatementConstructor::newComment( "end<ienable> " +
anExecutableForm->getFullyQualifiedNameID() ) ) );
AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , COMPUTING , STATEMENT )
}
/*
* onEnable
*/
if( theBehavior->hasOnEnable() &&
StatementTypeChecker::doSomething(theBehavior->getOnEnable()) )
{
anExecutableForm->setOnEnable(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnEnable()) );
AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , COMPUTING , STATEMENT )
anExecutableForm->setOnEnable(StatementConstructor::newCodeFlatMiddle(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
StatementConstructor::newComment( "begin<enable> " +
anExecutableForm->getFullyQualifiedNameID() ),
anExecutableForm->getOnEnable(),
StatementConstructor::newComment( "end<enable> " +
anExecutableForm->getFullyQualifiedNameID() ) ) );
AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , COMPUTING , STATEMENT )
}
// EXPAND IENABLE / ENABLE
if( anExecutableForm->hasOnIEnable() )
{
if( anExecutableForm->hasOnEnable() )
{
if( not AvmCodeFactory::contains(anExecutableForm,
anExecutableForm->getOnEnable(), AVM_OPCODE_IENABLE_INVOKE) )
{
anExecutableForm->setOnEnable(
StatementConstructor::newCodeFlat(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
anExecutableForm->getOnIEnable(),
anExecutableForm->getOnEnable() ) );
}
else
{
// EXPAND IENABLE
}
}
else
{
// (*it)->setOnEnable( BFCode(OperatorManager::OPERATOR_IENABLE) );
//Optimization
anExecutableForm->setOnEnable( anExecutableForm->getOnIEnable() );
}
}
/*
* onIDisable
*/
if( theBehavior->hasOnIDisable() &&
StatementTypeChecker::doSomething(theBehavior->getOnIDisable()) )
{
anExecutableForm->setOnIDisable(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnIDisable()) );
AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , COMPUTING , STATEMENT )
anExecutableForm->setOnIDisable(StatementConstructor::newCodeFlatMiddle(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
StatementConstructor::newComment( "begin<idisable> " +
anExecutableForm->getFullyQualifiedNameID() ),
anExecutableForm->getOnIDisable(),
StatementConstructor::newComment( "end<idisable> " +
anExecutableForm->getFullyQualifiedNameID() ) ) );
AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , COMPUTING , STATEMENT )
}
/*
* onDisable
*/
if( theBehavior->hasOnDisable() &&
StatementTypeChecker::doSomething(theBehavior->getOnDisable()) )
{
anExecutableForm->setOnDisable(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnDisable()) );
AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , COMPUTING , STATEMENT )
anExecutableForm->setOnDisable(StatementConstructor::newCodeFlatMiddle(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
StatementConstructor::newComment( "begin<disable> " +
anExecutableForm->getFullyQualifiedNameID() ),
anExecutableForm->getOnDisable(),
StatementConstructor::newComment( "end<disable> " +
anExecutableForm->getFullyQualifiedNameID() ) ) );
AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , COMPUTING , STATEMENT )
anExecutableForm->setOnDisable( StatementConstructor::newCodeFlat(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
anExecutableForm->getOnDisable(),
StatementConstructor::newCode(
OperatorManager::OPERATOR_DISABLE_SELF) ) );
}
// EXPAND IDISABLE / DISABLE
if( anExecutableForm->hasOnIDisable() )
{
if( anExecutableForm->hasOnDisable() )
{
if( not AvmCodeFactory::contains(anExecutableForm,
anExecutableForm->getOnDisable(), AVM_OPCODE_IDISABLE_INVOKE) )
{
anExecutableForm->setOnDisable(
StatementConstructor::newCodeFlat(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
anExecutableForm->getOnIDisable(),
anExecutableForm->getOnDisable() ) );
}
else
{
// EXPAND IDISABLE
}
}
else
{
// (*it)->setOnDisable( BFCode(OperatorManager::OPERATOR_IDISABLE) );
//Optimization
anExecutableForm->setOnDisable( StatementConstructor::newCodeFlat(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
anExecutableForm->getOnIDisable(),
StatementConstructor::newCode(
OperatorManager::OPERATOR_DISABLE_SELF) ) );
}
anExecutableForm->setOnIDisable( StatementConstructor::newCodeFlat(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
anExecutableForm->getOnIDisable(),
StatementConstructor::newCode(
OperatorManager::OPERATOR_DISABLE_SELF) ) );
}
/*
* onIAbort
*/
if( theBehavior->hasOnIAbort() &&
StatementTypeChecker::doSomething(theBehavior->getOnIAbort()) )
{
anExecutableForm->setOnIAbort(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnIAbort()) );
AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , COMPUTING , STATEMENT )
anExecutableForm->setOnIAbort(StatementConstructor::newCodeFlatMiddle(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
StatementConstructor::newComment( "begin<iabort> " +
anExecutableForm->getFullyQualifiedNameID() ),
anExecutableForm->getOnIAbort(),
StatementConstructor::newComment( "end<iabort> " +
anExecutableForm->getFullyQualifiedNameID() ) ) );
AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , COMPUTING , STATEMENT )
}
/*
* onAbort
*/
if( theBehavior->hasOnAbort() &&
StatementTypeChecker::doSomething(theBehavior->getOnAbort()) )
{
anExecutableForm->setOnAbort(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnAbort()) );
AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , COMPUTING , STATEMENT )
anExecutableForm->setOnAbort(StatementConstructor::newCodeFlatMiddle(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
StatementConstructor::newComment( "begin<abort> " +
anExecutableForm->getFullyQualifiedNameID() ),
anExecutableForm->getOnAbort(),
StatementConstructor::newComment( "end<abort> " +
anExecutableForm->getFullyQualifiedNameID() ) ) );
AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , COMPUTING , STATEMENT )
anExecutableForm->setOnAbort( StatementConstructor::newCodeFlat(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
anExecutableForm->getOnAbort(),
StatementConstructor::newCode(
OperatorManager::OPERATOR_ABORT_SELF) ) );
}
// EXPAND IABORT / ABORT
if( anExecutableForm->hasOnIAbort() )
{
if( anExecutableForm->hasOnAbort() )
{
if( not AvmCodeFactory::contains(anExecutableForm,
anExecutableForm->getOnAbort(), AVM_OPCODE_IABORT_INVOKE) )
{
anExecutableForm->setOnAbort(
StatementConstructor::newCodeFlat(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
anExecutableForm->getOnIAbort(),
anExecutableForm->getOnAbort() ) );
}
else
{
// EXPAND IABORT
}
}
else
{
// (*it)->setOnAbort( BFCode(OperatorManager::OPERATOR_IABORT) );
//Optimization
anExecutableForm->setOnAbort( StatementConstructor::newCodeFlat(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
anExecutableForm->getOnIAbort(),
StatementConstructor::newCode(
OperatorManager::OPERATOR_ABORT_SELF) ) );
}
anExecutableForm->setOnIAbort( StatementConstructor::newCodeFlat(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
anExecutableForm->getOnIAbort(),
StatementConstructor::newCode(
OperatorManager::OPERATOR_ABORT_SELF) ) );
}
/*
* onIRun
*/
if( theBehavior->hasOnIRun() &&
StatementTypeChecker::doSomething(theBehavior->getOnIRun()) )
{
anExecutableForm->setOnIRun(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnIRun()) );
}
/*
* onRun
*/
if( theBehavior->hasOnRun() &&
StatementTypeChecker::doSomething(theBehavior->getOnRun()) )
{
anExecutableForm->setOnRun(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnRun()) );
}
/*
* onRtc
*/
if( theBehavior->hasOnRtc() &&
StatementTypeChecker::doSomething(theBehavior->getOnRtc()) )
{
anExecutableForm->setOnRtc(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnRtc()) );
}
/*
* onSchedule
*/
if( theBehavior->hasOnSchedule() )
{
if( StatementTypeChecker::isEmptySchedule(theBehavior->getOnSchedule()) )
{
//!! NOTHING
}
else
{
anExecutableForm->setOnSchedule(
compileSchedulerRoutine(
anExecutableForm,
theBehavior->getOnSchedule() ) );
}
}
/*
* onConcurrency
*/
if( theBehavior->hasOnConcurrency() )
{
if( StatementTypeChecker::isEmptySchedule(theBehavior->getOnConcurrency()) )
{
anExecutableForm->setOnConcurrency( theBehavior->getOnConcurrency() );
}
else
{
anExecutableForm->setOnConcurrency(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnConcurrency()) );
}
}
else if( StatementTypeChecker::isSchedule(theBehavior->getOnSchedule()) )
{
anExecutableForm->setOnConcurrency(
theBehavior->getOnSchedule().getOperator() );
}
/*
* onSynchronize
*/
if( theBehavior->hasOnSynchronize() )
{
anExecutableForm->setOnSynchronize(
mAvmcodeCompiler.compileStatement(
anExecutableForm, theBehavior->getOnSynchronize()) );
}
/*
* other user Routines
*/
BehavioralPart::const_routine_iterator it = theBehavior->routine_begin();
BehavioralPart::const_routine_iterator endIt = theBehavior->routine_end();
for( ; it != endIt ; ++it )
{
anExecutableForm->saveProgram(
mAvmcodeCompiler.compileRoutine(this, anExecutableForm, it) );
}
//AVM_OS_TRACE << TAB << ">| compiling<machine>: "
// << str_header( aMachine ) << std::endl << std::endl;
}
/**
* compile
* executable procedure
*/
void Compiler::compileProcedure(ExecutableForm * anExecutableForm)
{
// Compile data & all machine MOE program
compileBaseMachine(anExecutableForm);
const Machine * aProcedure = anExecutableForm->getAstMachine();
//AVM_OS_TRACE << TAB << "<| compiling<statemachine>: "
// << str_header( aProcedure ) << std::endl;
// PUSH MOC
WObject * moc_transition = NULL;//aProcedure::getTransitionMoc();
if( moc_transition != NULL )
{
mTransitionCompiler.pushMoc(moc_transition);
}
// Compile all specific statemachine
if( aProcedure->getSpecifier().isStateBasic() )
{
compileStatemachineBasic(anExecutableForm);
}
else if( aProcedure->getSpecifier().isMocStateTransitionStructure() )
{
compileExecutableMocStateTransitionStructure(anExecutableForm);
}
else if( aProcedure->getSpecifier().isMocCompositeStructure() )
{
compileExecutableMocCompositeStructure(anExecutableForm);
}
else
{
// MOC Attribute for mutable Schedule
anExecutableForm->setMutableSchedule(
anExecutableForm->hasOnSchedule() );
/*
* Compiling communication
*/
bool hasSynchronizeMachine = false;
bool hasUpdateBuffer = false;
mComCompiler.compileCommunication(anExecutableForm,
hasUpdateBuffer, hasSynchronizeMachine);
if( anExecutableForm->hasOnRun() )
{
//!! NOTHING
}
else if( anExecutableForm->hasOnRtc() )
{
anExecutableForm->setOnRun(StatementConstructor::newCode(
OperatorManager::OPERATOR_RTC));
}
else if( anExecutableForm->hasOnSchedule() )
{
anExecutableForm->setOnRun( StatementConstructor::newCode(
OperatorManager::OPERATOR_SCHEDULE_INVOKE));
}
}
// POP MOC
if( moc_transition != NULL )
{
mTransitionCompiler.popMoc();
}
//AVM_OS_TRACE << TAB << ">| compiling<statemachine>: "
// << str_header( aProcedure ) << std::endl;
}
/**
* compile
* executable machine
*/
void Compiler::compileMachine(ExecutableForm * anExecutableForm)
{
//AVM_OS_TRACE << TAB << "<| compiling<machine>: "
// << str_header( aMachine ) << std::endl;
// COMPILE PROGRAM
if( anExecutableForm->hasProgram() )
{
AvmProgram * aProgram;
avm_size_t offset = 0;
for( ; offset < anExecutableForm->getProgram().size() ; ++offset )
{
aProgram = anExecutableForm->getProgram().rawAt(offset);
AVM_IF_DEBUG_FLAG( COMPILING )
AVM_OS_TRACE << INCR_INDENT_TAB << "<| compiling<program>: "
<< aProgram->getFullyQualifiedNameID() << std::endl;
AVM_ENDIF_DEBUG_FLAG( COMPILING )
mProgramCompiler.compileProgram( aProgram );
AVM_IF_DEBUG_FLAG( COMPILING )
// (*itProg)->toStream(AVM_OS_TRACE);
AVM_OS_TRACE << TAB_DECR_INDENT << ">| compiling<program>: "
<< aProgram->getFullyQualifiedNameID() << std::endl;
AVM_ENDIF_DEBUG_FLAG( COMPILING )
}
}
const Machine * aMachine = anExecutableForm->getAstMachine();
// Compile all specific machine
if( aMachine->getSpecifier().isMocStateTransitionStructure() )
{
compileExecutableMocStateTransitionStructure(anExecutableForm);
}
else if( aMachine->getSpecifier().isMocCompositeStructure() )
{
compileExecutableMocCompositeStructure(anExecutableForm);
}
else
{
// MOC Attribute for mutable Schedule
anExecutableForm->setMutableSchedule(
anExecutableForm->hasOnSchedule() );
/*
* Compiling communication
*/
bool hasSynchronizeMachine = false;
bool hasUpdateBuffer = false;
mComCompiler.compileCommunication(anExecutableForm,
hasUpdateBuffer, hasSynchronizeMachine);
if( anExecutableForm->hasOnRun() )
{
//!! NOTHING
}
else if( anExecutableForm->hasOnRtc() )
{
anExecutableForm->setOnRun(StatementConstructor::newCode(
OperatorManager::OPERATOR_RTC));
}
else if( anExecutableForm->hasOnSchedule() )
{
anExecutableForm->setOnRun( StatementConstructor::newCode(
OperatorManager::OPERATOR_SCHEDULE_INVOKE));
}
}
//AVM_OS_TRACE << TAB << ">| compiling<machine>: "
// << str_header( aMachine ) << std::endl << std::endl;
}
/**
* compile
* specification
*/
void Compiler::compileSystem(ExecutableForm * anExecutableForm)
{
const System * aSystem = anExecutableForm->getAstSystem();
//AVM_OS_TRACE << TAB << "<| compiling<system>: "
// << aSystem->getFullyQualifiedNameID() << std::endl;
// Compile all specific machine
if( aSystem->getSpecifier().isMocStateTransitionStructure() )
{
compileExecutableMocStateTransitionStructure(anExecutableForm);
}
else //if( aSystem->getSpecifier().isMocCompositeStructure()
//|| (not aSystem->hasRunnableBehavior()) )
{
compileExecutableMocCompositeStructure(anExecutableForm);
}
if( not anExecutableForm->hasOnInit() )
{
anExecutableForm->setOnInit( StatementConstructor::nopCode() );
}
if( anExecutableForm->hasOnIRun() )
{
if( anExecutableForm->hasOnRun() )
{
anExecutableForm->setOnRun(
StatementConstructor::newCode(
OperatorManager::OPERATOR_SEQUENCE_SIDE,
anExecutableForm->getOnIRun(),
anExecutableForm->getOnRun()) );
}
else
{
anExecutableForm->setOnRun( anExecutableForm->getOnIRun() );
}
}
else if( (not anExecutableForm->hasOnSchedule())
&& (not anExecutableForm->hasOnRun()) )
{
anExecutableForm->setOnRun( StatementConstructor::nopCode() );
}
//AVM_OS_TRACE << TAB << ">| compiling<system>: "
// << aSystem->getFullyQualifiedNameID() << std::endl << std::endl;
}
/**
* compile
* statemachine
*/
void Compiler::compileStatemachine(ExecutableForm * anExecutableForm)
{
const Machine * aStatemachine = anExecutableForm->getAstMachine();
//AVM_OS_TRACE << TAB << "<| compiling<statemachine>: "
// << str_header( aStatemachine ) << std::endl;
// PUSH MOC
WObject * moc_transition = NULL;//aStatemachine::getTransitionMoc();
if( moc_transition != NULL )
{
mTransitionCompiler.pushMoc(moc_transition);
}
// Compile all specific statemachine
if( aStatemachine->getSpecifier().hasFamilyPseudostateEnding() )
{
compilePseudostateEnding(anExecutableForm);
}
else if( aStatemachine->getSpecifier().hasPseudostateMocHISTORY() )
{
compileStatemachineHistory(anExecutableForm);
}
else if( aStatemachine->getSpecifier().isPseudostate() )
{
compileStatemachinePseudo(anExecutableForm);
}
else if( aStatemachine->getSpecifier().isStateBasic() )
{
compileStatemachineBasic(anExecutableForm);
}
else if( aStatemachine->getSpecifier().isMocStateTransitionStructure() )
{
compileExecutableMocStateTransitionStructure(anExecutableForm);
}
else if( aStatemachine->getSpecifier().isMocCompositeStructure() )
{
compileExecutableMocCompositeStructure(anExecutableForm);
}
else if( aStatemachine->getSpecifier().isComponentProcedure() )
{
compileExecutableMocCompositeStructure(anExecutableForm);
}
else
{
incrErrorCount();
aStatemachine->errorLocation(AVM_OS_WARN)
<< "Unexpected statemachine type << "
<< str_header( aStatemachine ) << " >>"
<< std::endl << std::endl;
}
// COMPILE TRANSITION
if( anExecutableForm->hasTransition() )
{
AvmTransition * aTransition;
avm_size_t offset = 0;
for( ; offset < anExecutableForm->getTransition().size() ; ++offset )
{
aTransition = anExecutableForm->getTransition().rawAt(offset);
AVM_IF_DEBUG_FLAG( COMPILING )
AVM_OS_TRACE << INCR_INDENT_TAB << "<| compiling<transition>: "
<< aTransition->getFullyQualifiedNameID() << std::endl;
AVM_ENDIF_DEBUG_FLAG( COMPILING )
mTransitionCompiler.compileTransition( aTransition );
AVM_IF_DEBUG_FLAG( COMPILING )
// (*itProg)->toStream(AVM_OS_TRACE);
AVM_OS_TRACE << TAB_DECR_INDENT << ">| compiling<transition>: "
<< aTransition->getFullyQualifiedNameID() << std::endl;
AVM_ENDIF_DEBUG_FLAG( COMPILING )
}
if( anExecutableForm->getSpecifier().hasFeatureInputEnabled() )
{
computeInputEnabledCom( anExecutableForm );
}
}
// COMPILE PROGRAM
if( anExecutableForm->hasProgram() )
{
AvmProgram * aProgram;
avm_size_t offset = 0;
for( ; offset < anExecutableForm->getProgram().size() ; ++offset )
{
aProgram = anExecutableForm->getProgram().rawAt(offset);
AVM_IF_DEBUG_FLAG( COMPILING )
AVM_OS_TRACE << INCR_INDENT_TAB << "<| compiling<program>: "
<< aProgram->getFullyQualifiedNameID() << std::endl;
AVM_ENDIF_DEBUG_FLAG( COMPILING )
mProgramCompiler.compileProgram( aProgram );
AVM_IF_DEBUG_FLAG( COMPILING )
// (*itProg)->toStream(AVM_OS_TRACE);
AVM_OS_TRACE << TAB_DECR_INDENT << ">| compiling<program>: "
<< aProgram->getFullyQualifiedNameID() << std::endl;
AVM_ENDIF_DEBUG_FLAG( COMPILING )
}
if( anExecutableForm->getSpecifier().hasFeatureInputEnabled() )
{
computeInputEnabledCom( anExecutableForm );
}
}
// POP MOC
if( moc_transition != NULL )
{
mTransitionCompiler.popMoc();
}
//AVM_OS_TRACE << TAB << ">| compiling<statemachine>: "
// << str_header( aStatemachine ) << std::endl;
}
void Compiler::compileExecutableMocCompositeStructure(
ExecutableForm * anExecutableForm)
{
const Machine * anExecutableSpec = anExecutableForm->getAstMachine();
//AVM_OS_TRACE << TAB << "<| compiling executable< moc: and >: "
// << str_header( anExecutableSpec ) << std::endl;
bool hasInstanceStatic = anExecutableSpec->hasMachine();
bool hasSynchronizeMachine = false;
bool hasUpdateBuffer = false;
// MOC Attribute for mutable Schedule
anExecutableForm->setMutableSchedule( false );
/**
* compile all routines which defined the executable's behavior
*/
compileAllBehavioralRoutines( anExecutableForm );
/*
* Compiling communication
*/
mComCompiler.compileCommunication(anExecutableForm,
hasUpdateBuffer, hasSynchronizeMachine);
/*
* OnRun
* whith high priority order
*
* StrongAbort Transition
* OnIRun
* ( Simple Transition or submachine ) depend on MOC
* WeakAbort Transition
* NormalTerminaison Transition
*/
BFCode onRunProgram;
// Update Buffer
if( hasInstanceStatic )
{
if( hasSynchronizeMachine ) // only if has RDV protocol
{
anExecutableForm->setRdvCommunication( hasSynchronizeMachine );
setRdvScheduling( anExecutableForm );
}
if( anExecutableForm->hasOnRun() )
{
onRunProgram = anExecutableForm->getOnRun();
anExecutableForm->setOnRun( BFCode::REF_NULL );
if( not AvmCodeFactory::contains(anExecutableForm,
onRunProgram, AVM_OPCODE_SCHEDULE_INVOKE) )
{
if( (not anExecutableForm->hasOnRtc()) &&
AvmCodeFactory::contains(anExecutableForm,
onRunProgram, AVM_OPCODE_RTC) )
{
anExecutableForm->setOnRtc(
StatementConstructor::newCode(
OperatorManager::OPERATOR_SCHEDULE_INVOKE) );
}
else if( anExecutableForm->hasOnSchedule()
|| anExecutableForm->isMutableSchedule() )
{
onRunProgram = StatementConstructor::newCodeFlat(
OperatorManager::OPERATOR_SEQUENCE, onRunProgram,
StatementConstructor::newCode(
OperatorManager::OPERATOR_SCHEDULE_INVOKE) );
}
}
}
else if( anExecutableForm->hasOnSchedule()
|| anExecutableForm->isMutableSchedule() )
{
onRunProgram = StatementConstructor::newCode(
OperatorManager::OPERATOR_SCHEDULE_INVOKE);
}
if( hasUpdateBuffer ) // only if has BROADCAST protocol
{
onRunProgram = StatementConstructor::newCode(
OperatorManager::OPERATOR_UPDATE_BUFFER, onRunProgram);
}
}
if( anExecutableSpec->hasOutgoingTransition() )
{
// Compile Statemachine Transition
mTransitionCompiler.compileStatemachineTransition(
anExecutableForm, onRunProgram );
}
else if( onRunProgram.valid() )
{
anExecutableForm->setOnRun( onRunProgram );
}
else if( anExecutableForm->hasOnIRun() )
{
anExecutableForm->setOnRun( StatementConstructor::nopCode() );
}
//AVM_OS_TRACE << TAB << ">| compiling executable< moc: and >: "
// << str_header( anExecutableSpec ) << std::endl;
}
void Compiler::compileExecutableMocStateTransitionStructure(
ExecutableForm * anExecutableForm)
{
const Machine * anExecutableSpec = anExecutableForm->getAstMachine();
//AVM_OS_TRACE << TAB << "<| compiling executable< moc: and >: "
// << str_header( anExecutableSpec ) << std::endl;
bool hasSynchronizeMachine = false;
bool hasUpdateBuffer = false;
// /*
// * Compiling program
// */
//
// TableOfAvmProgram::iterator it = anExecutableForm->getProgram().begin();
// for( ; it != anExecutableForm->getProgram().end() ; ++it )
// {
// compileProgram(anExecutableForm, (*it));
// }
// MOC Attribute for mutable Schedule
anExecutableForm->setMutableSchedule( true );
if( anExecutableSpec->hasMachine() )
{
/*
* ON_INIT
* ON_ENABLE
*/
// non determinism: simulation of enabling for
// each [ start ] state or [ initial ] state ...
BFCode onInitCode( OperatorManager::OPERATOR_NONDETERMINISM );
BFCode onEnableCode( OperatorManager::OPERATOR_NONDETERMINISM );
BFCode onScheduleCode( OperatorManager::OPERATOR_NONDETERMINISM );
bool hasnotOwnedPseudostateHistory = (not anExecutableSpec->
getOwnedElementsSpecifier().hasPseudostateMocHISTORY());
bool hasnotOwnedPseudostateInitialOrStateStart =
(not anExecutableSpec->
getOwnedElementsSpecifier().hasMocINITIAL_START());
TableOfSymbol::const_iterator itMachine =
anExecutableForm->instance_static_begin();
TableOfSymbol::const_iterator endMachine =
anExecutableForm->instance_static_end();
for( ; itMachine != endMachine ; ++itMachine )
{
const Specifier & itSpecifier =
(*itMachine).getExecutable()->getSpecifier();
if( itSpecifier.isPseudostateInitialOrStateStart() )
{
onInitCode->append( StatementConstructor::newCode(
OperatorManager::OPERATOR_INIT, (*itMachine) ) );
if( hasnotOwnedPseudostateHistory )
{
onEnableCode->append( StatementConstructor::newCode(
OperatorManager::OPERATOR_ENABLE_INVOKE,
(*itMachine) ) );
}
onScheduleCode->append( StatementConstructor::newCode(
OperatorManager::OPERATOR_RUN, (*itMachine)) );
}
else if( itSpecifier.hasPseudostateHistory() )
{
onEnableCode->append( StatementConstructor::newCode(
OperatorManager::OPERATOR_ENABLE_INVOKE,
(*itMachine) ) );
}
else if( hasnotOwnedPseudostateInitialOrStateStart )
{
onInitCode->append( StatementConstructor::newCode(
OperatorManager::OPERATOR_INIT, (*itMachine) ) );
if( hasnotOwnedPseudostateHistory )
{
onEnableCode->append( StatementConstructor::newCode(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
StatementConstructor::newCode(
OperatorManager::OPERATOR_ENABLE_SET,
(*itMachine) ),
StatementConstructor::newCode(
OperatorManager::OPERATOR_ENABLE_INVOKE,
(*itMachine) ) ) );
}
onScheduleCode->append( StatementConstructor::newCode(
OperatorManager::OPERATOR_RUN, (*itMachine) ) );
}
}
// ON INIT
if( onInitCode->nonempty() )
{
anExecutableForm->setOnInit( StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
anExecutableForm->getOnInit(),
(onInitCode->singleton() ?
onInitCode->first().bfCode() : onInitCode) ) );
}
// ON ENABLE
if( onEnableCode->nonempty() )
{
anExecutableForm->setOnEnable( StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
anExecutableForm->getOnEnable(),
(onEnableCode->singleton() ?
onEnableCode->first().bfCode() : onEnableCode) ) );
}
/**
* ON SCHEDULE
*/
if( anExecutableForm->hasOnSchedule() )
{
incrErrorCount();
anExecutableSpec->errorLocation(AVM_OS_WARN)
<< "Unexpected a State-Transition-System << "
<< str_header( anExecutableSpec )
<< " >> with user schedule code: "
<< anExecutableForm->getOnSchedule() << std::endl;
}
else if( onScheduleCode->nonempty() )
{
anExecutableForm->setOnSchedule( StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
anExecutableForm->getOnSchedule(),
(onScheduleCode->singleton() ?
onScheduleCode->first().bfCode() : onScheduleCode) ) );
}
else if( anExecutableForm->hasOneInstanceStatic() )
{
anExecutableForm->setOnSchedule( StatementConstructor::newCode(
OperatorManager::OPERATOR_RUN,
anExecutableForm->firstInstanceStatic() ) );
}
/*
* ON_DISABLE
*/
if( anExecutableForm->hasOnDisable() )
{
anExecutableForm->setOnDisable(
StatementConstructor::newCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
StatementConstructor::newCode(
OperatorManager::OPERATOR_DISABLE_CHILD),
anExecutableForm->getOnDisable() ) );
}
else
{
anExecutableForm->setOnDisable( StatementConstructor::newCode(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
StatementConstructor::newCode(
OperatorManager::OPERATOR_DISABLE_CHILD),
StatementConstructor::newCode(
OperatorManager::OPERATOR_DISABLE_SELF) ) );
}
}
/*
* Compiling communication
*/
mComCompiler.compileCommunication(anExecutableForm,
hasUpdateBuffer, hasSynchronizeMachine);
/*
* OnRun
* whith high priority order
*
* StrongAbort Transition
* OnIRun
* ( Simple Transition or submachine ) depend on MOC
* WeakAbort Transition
* NormalTerminaison Transition
*/
BFCode onRunProgram;
// Update Buffer
if( anExecutableSpec->hasMachine() )
{
if( hasSynchronizeMachine ) // only if has RDV protocol
{
anExecutableForm->setRdvCommunication( hasSynchronizeMachine );
setRdvScheduling( anExecutableForm );
}
if( anExecutableForm->hasOnRun() )
{
onRunProgram = anExecutableForm->getOnRun();
if( AvmCodeFactory::contains(anExecutableForm,
onRunProgram, AVM_OPCODE_SCHEDULE_INVOKE) )
{
//!!NOTHING
}
else if( (not anExecutableForm->hasOnRtc())
&& AvmCodeFactory::contains(anExecutableForm,
onRunProgram, AVM_OPCODE_RTC) )
{
anExecutableForm->setOnRtc(
StatementConstructor::newCode(
OperatorManager::OPERATOR_SCHEDULE_INVOKE) );
}
else
{
onRunProgram = StatementConstructor::newCodeFlat(
OperatorManager::OPERATOR_SEQUENCE, onRunProgram,
StatementConstructor::newCode(
OperatorManager::OPERATOR_SCHEDULE_INVOKE) );
}
anExecutableForm->setOnRun( BFCode::REF_NULL );
}
else
{
onRunProgram = StatementConstructor::newCode(
OperatorManager::OPERATOR_SCHEDULE_INVOKE);
}
if( hasUpdateBuffer ) // only if has BROADCAST protocol
{
onRunProgram = StatementConstructor::newCode(
OperatorManager::OPERATOR_UPDATE_BUFFER, onRunProgram);
}
}
if( anExecutableSpec->hasOutgoingTransition() )
{
// Compile Statemachine Transition
mTransitionCompiler.compileStatemachineTransition(
anExecutableForm, onRunProgram);
}
else if( onRunProgram.valid() )
{
anExecutableForm->setOnRun( onRunProgram );
}
else if( anExecutableForm->hasOnIRun() )
{
anExecutableForm->setOnRun( StatementConstructor::nopCode() );
}
//AVM_OS_TRACE << TAB << ">| compiling executable< moc: and >: "
// << str_header( anExecutableSpec ) << std::endl;
}
void Compiler::compilePseudostateEnding(ExecutableForm * anExecutableForm)
{
const Machine * aStatemachine = anExecutableForm->getAstMachine();
//AVM_OS_TRACE << TAB << "<| compiling<statemachine>: "
// << str_header( aStatemachine ) << std::endl;
// MOC Attribute for mutable Schedule
anExecutableForm->setMutableSchedule( false );
/*
* ON ENABLE
*/
BFCode onTerminalCode;
if( aStatemachine->getSpecifier().isPseudostateTerminal() )
{
onTerminalCode = StatementConstructor::newCode(
OperatorManager::OPERATOR_DESTROY, ExecutableLib::MACHINE_PARENT);
}
else //if( aStatemachine->getSpecifier().isPseudostateReturn() )
{
onTerminalCode = StatementConstructor::newCode(
OperatorManager::OPERATOR_FINAL);
}
anExecutableForm->setOnEnable( StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
anExecutableForm->getOnEnable(), onTerminalCode) );
if( aStatemachine->hasOutgoingTransition() )
{
incrErrorCount();
aStatemachine->errorLocation(AVM_OS_WARN)
<< "Unexpected state< terminal > << "
<< str_header( aStatemachine )
<< " >> with outgoing transitions"
<< std::endl << std::endl;
}
//aStatemachine->toStream(AVM_OS_TRACE << TAB);
//anExecutableForm->toStream(AVM_OS_TRACE << TAB);
//AVM_OS_TRACE << TAB << ">| compiling<statemachine>: "
// << str_header( aStatemachine ) << std::endl;
}
void Compiler::compileStatemachineHistory(ExecutableForm * anExecutableForm)
{
const Machine * aStatemachine = anExecutableForm->getAstMachine();
//AVM_OS_TRACE << TAB << "<| compiling<statemachine>: "
// << str_header( aStatemachine ) << std::endl;
// MOC Attribute for mutable Schedule
anExecutableForm->setMutableSchedule( false );
if( aStatemachine->hasOutgoingTransition() )
{
// Compile Statemachine Transition
mTransitionCompiler.compileStatemachineTransition(
anExecutableForm , anExecutableForm->getOnRun());
}
BFCode onEnableCode = StatementConstructor::newCode(
OperatorManager::OPERATOR_RUN);
BFCode onHistoryCode = StatementConstructor::newCode(
aStatemachine->getSpecifier().isPseudostateDeepHistory() ?
OperatorManager::OPERATOR_DEEP_HISTORY_INVOKE :
OperatorManager::OPERATOR_SHALLOW_HISTORY_INVOKE,
ExecutableLib::MACHINE_PARENT);
if( anExecutableForm->hasOnRun() )
{
anExecutableForm->setOnRun( StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_PRIOR_GT,
anExecutableForm->getOnRun(), onHistoryCode) );
}
else if( anExecutableForm->hasOnIRun() )
{
anExecutableForm->setOnRun( onHistoryCode );
}
else
{
onEnableCode = onHistoryCode;
}
/*
* ON INIT
* ON ENABLE
*/
// this is aStatemachine->getSpecifier().isPseudostate()
// ON INIT
anExecutableForm->setOnInit( StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
anExecutableForm->getOnInit(), onEnableCode) );
// ON ENABLE
anExecutableForm->setOnEnable( StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
anExecutableForm->getOnEnable(), onEnableCode) );
//aStatemachine->toStream(AVM_OS_TRACE << TAB);
//anExecutableForm->toStream(AVM_OS_TRACE << TAB);
//AVM_OS_TRACE << TAB << ">| compiling<statemachine>: "
// << str_header( aStatemachine ) << std::endl;
}
void Compiler::compileStatemachinePseudo(ExecutableForm * anExecutableForm)
{
const Machine * aStatemachine = anExecutableForm->getAstMachine();
//AVM_OS_TRACE << TAB << "<| compiling<statemachine>: "
// << str_header( aStatemachine ) << std::endl;
// MOC Attribute for mutable Schedule
anExecutableForm->setMutableSchedule( false );
/*
* ON INIT
* ON ENABLE
*/
BFCode onEnableCode = StatementConstructor::newCode(
OperatorManager::OPERATOR_RUN);
// ON INIT
if( aStatemachine->getSpecifier().isPseudostateInitial()
&& anExecutableForm->hasOnEnable() )
{
anExecutableForm->setOnInit(
StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
anExecutableForm->getOnInit(),
anExecutableForm->getOnEnable(), onEnableCode) );
}
else
{
anExecutableForm->setOnInit( StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
anExecutableForm->getOnInit(), onEnableCode) );
}
anExecutableForm->setOnEnable(
StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
anExecutableForm->getOnEnable(), onEnableCode) );
/*
* Schedule State Transition
*/
if( aStatemachine->getSpecifier().isPseudostateFork() )
{
if( aStatemachine->hasOutgoingTransition() &&
aStatemachine->getBehavior()->
getOutgoingTransitions().populated() )
{
// Schedule State< fork > Transition
mTransitionCompiler.compileStateForkOutputTransition(
anExecutableForm, anExecutableForm->getOnRun());
}
else
{
incrErrorCount();
aStatemachine->errorLocation(AVM_OS_WARN)
<< "Unexpected pseudostate< fork > << "
<< str_header( aStatemachine )
<< " >> with less than 2 outgoing transitions"
<< std::endl << std::endl;
}
}
else if( aStatemachine->getSpecifier().isPseudostateJoin() )
{
if( aStatemachine->hasIncomingTransition()
&& aStatemachine->getBehavior()->
getIncomingTransitions().populated() )
{
// SYnchronize incoming Transition
mTransitionCompiler.compileStateJoinInputTransition(
anExecutableForm );
}
else
{
incrErrorCount();
aStatemachine->errorLocation(AVM_OS_WARN)
<< "Unexpected pseudostate< join > << "
<< str_header( aStatemachine )
<< " >> with less than 2 incoming transitions"
<< std::endl << std::endl;
}
if( aStatemachine->hasOutgoingTransition() )
{
// Compile Statemachine Transition
mTransitionCompiler.compileStatemachineTransition(
anExecutableForm , anExecutableForm->getOnRun());
}
else
{
incrErrorCount();
aStatemachine->errorLocation(AVM_OS_WARN)
<< "Unexpected pseudostate< join > << "
<< str_header( aStatemachine )
<< " >> without outgoing transitions"
<< std::endl << std::endl;
}
}
else if( aStatemachine->hasOutgoingTransition() )
{
// Compile Statemachine Transition
mTransitionCompiler.compileStatemachineTransition(
anExecutableForm , anExecutableForm->getOnRun() );
}
if( not anExecutableForm->hasOnRun() )
{
if( not aStatemachine->getSpecifier().hasFamilyPseudostateENDING() )
{
incrWarningCount();
aStatemachine->warningLocation(AVM_OS_WARN)
<< "No eval code for << " << str_header( aStatemachine )
<< " >> which is not TERMINAL or RETURN moc!" << std::endl;
}
else if( aStatemachine->getSpecifier().isPseudostateInitial() )
{
incrErrorCount();
aStatemachine->errorLocation(AVM_OS_WARN)
<< "No eval code for << " << str_header( aStatemachine )
<< " >> which is an INITIAL state!!!" << std::endl;
anExecutableForm->setOnRun( StatementConstructor::nopCode() );
}
AVM_OS_WARN << std::endl;
if( anExecutableForm->hasOnIRun() )
{
anExecutableForm->setOnRun( StatementConstructor::nopCode() );
}
}
//aStatemachine->toStream(AVM_OS_TRACE << TAB);
//anExecutableForm->toStream(AVM_OS_TRACE << TAB);
//AVM_OS_TRACE << TAB << ">| compiling<statemachine>: "
// << str_header( aStatemachine ) << std::endl;
}
void Compiler::compileStatemachineBasic(ExecutableForm * anExecutableForm)
{
const Machine * aStatemachine = anExecutableForm->getAstMachine();
//AVM_OS_TRACE << TAB << "<| compiling<statemachine>: "
// << str_header( aStatemachine ) << std::endl;
// MOC Attribute for mutable Schedule
anExecutableForm->setMutableSchedule( false );
// ON INIT
if( aStatemachine->getSpecifier().isStateStart()
&& anExecutableForm->hasOnEnable() )
{
anExecutableForm->setOnInit(
StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
anExecutableForm->getOnInit(),
anExecutableForm->getOnEnable()) );
}
/*
* Schedule State Transition
*/
if( aStatemachine->getSpecifier().isStateFinal() )
{
anExecutableForm->setOnEnable(
StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
anExecutableForm->getOnEnable(),
StatementConstructor::newCode(
OperatorManager::OPERATOR_FINAL)) );
if( aStatemachine->hasOutgoingTransition() )
{
incrErrorCount();
aStatemachine->errorLocation(AVM_OS_WARN)
<< "Unexpected state< final > << "
<< str_header( aStatemachine )
<< " >> with outgoing transitions"
<< std::endl << std::endl;
}
}
else if( aStatemachine->hasOutgoingTransition() )
{
// Compile Statemachine Transition
mTransitionCompiler.compileStatemachineTransition(
anExecutableForm , anExecutableForm->getOnRun() );
}
if( aStatemachine->getSpecifier().isStateSync() )
{
Variable * aVar = new Variable(
const_cast< Machine * >( aStatemachine ),
Modifier::PROPERTY_PUBLIC_VOLATILE_MODIFIER,
TypeManager::INTEGER,
aStatemachine->getNameID() + "#syncVar" );
const_cast< Machine * >( aStatemachine )->
getPropertyPart().saveOwnedVariable( aVar );
InstanceOfData * syncInstance = new InstanceOfData(
IPointerDataNature::POINTER_STANDARD_NATURE,
anExecutableForm, aVar, TypeManager::INTEGER,
anExecutableForm->getDataSize(),
Modifier::PROPERTY_PUBLIC_VOLATILE_MODIFIER);
//!![MIGRATION]:MODIFIER
// Modifier::PROPERTY_VOLATILE_FEATURE);
syncInstance->setValue( ExpressionConstant::INTEGER_ZERO );
const BF & syncVar = anExecutableForm->saveData(syncInstance);
BFCode incrSyncVar = StatementConstructor::newCode(
OperatorManager::OPERATOR_ASSIGN, syncVar,
StatementConstructor::newCode(
OperatorManager::OPERATOR_PLUS, syncVar,
ExpressionConstant::INTEGER_ONE) );
anExecutableForm->setOnEnable(
StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
anExecutableForm->getOnEnable(), incrSyncVar) );
BFCode decrSyncVar = StatementConstructor::newCode(
OperatorManager::OPERATOR_ASSIGN, syncVar,
StatementConstructor::newCode(
OperatorManager::OPERATOR_PLUS, syncVar,
ExpressionConstant::INTEGER_MINUS_ONE) );
anExecutableForm->setOnDisable(
StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_ATOMIC_SEQUENCE,
anExecutableForm->getOnDisable(), decrSyncVar) );
BFCode guardSyncVar = StatementConstructor::newCode(
OperatorManager::OPERATOR_GUARD,
StatementConstructor::newCode(
OperatorManager::OPERATOR_GT, syncVar,
ExpressionConstant::INTEGER_ZERO) );
anExecutableForm->setOnRun(
StatementConstructor::xnewCodeFlat(
OperatorManager::OPERATOR_SEQUENCE,
guardSyncVar, anExecutableForm->getOnRun()) );
}
if( anExecutableForm->hasOnIRun()
&& (not anExecutableForm->hasOnRun()) )
{
anExecutableForm->setOnRun( StatementConstructor::nopCode() );