/******************************************************************************* | |
* 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 | |
* | |
* Created on: 14 déc. 2016 | |
* | |
* Contributors: | |
* Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr | |
* - Initial API and Implementation | |
******************************************************************************/ | |
#include "Configuration.h" | |
#include <fam/serializer/GraphVizExecutionGraphSerializer.h> | |
#include <fam/serializer/GraphVizStatemachineSerializer.h> | |
#include <fml/executable/ExecutableSystem.h> | |
#include <fml/workflow/Query.h> | |
#include <sew/SymbexEngine.h> | |
#include <sew/Workflow.h> | |
#include <util/avm_vfs.h> | |
#include <boost/format.hpp> | |
namespace sep | |
{ | |
/** | |
* ATTRIBUTES | |
* GLOBAL | |
*/ | |
const std::string Configuration::SPECIFICATION_FILE_EXTENSION = ".xlia"; | |
const std::string Configuration::EXECUTABLE_FILE_EXTENSION = ".fexe"; | |
const std::string Configuration::SYMBEX_GRAPH_FILE_EXTENSION = ".fet"; | |
const std::string Configuration::SYMBEX_SCENARII_FILE_EXTENSION = ".fscn"; | |
const std::string Configuration::GRAPHVIZ_FILE_EXTENSION = ".gv"; | |
/** | |
* CONSTRUCTOR | |
* Default | |
*/ | |
Configuration::Configuration(SymbexEngine & aSymbexEngine, Workflow & aWorkflow) | |
: NamedElement( CLASS_KIND_T( Configuration ) , aSymbexEngine ), | |
mSymbexEngine( aSymbexEngine ), | |
mWorkflow( aWorkflow ), | |
mWObjectManager( WObject::FML_FQN_ROOT ), | |
mProjectSourceLocation( ), | |
mSpecificationFileLocation( ), | |
mOwnedSpecificationFlag( false ), | |
mOutputFilenamePattern( "output_%1%" ), | |
mDebugFilenamePattern ( "debug_%1%" ), | |
mOutputExecutableEnabledGenerationFlag( false ), | |
mOutputExecutableFileLocation( ), | |
mOutputSymbexGraphEnabledGenerationFlag( false ), | |
mOutputSymbexGraphFileLocation( ), | |
mOutputSymbexScenariiEnabledGenerationFlag( false ), | |
mOutputSymbexScenariiFileLocation( ), | |
mDebugStageEnabledFlag( false ), | |
mDebugParsingStageEnabledFlag( false ), | |
mDebugCompilingStageEnabledFlag( false ), | |
mDebugLoadingStageEnabledFlag( false ), | |
mDebugComputingEnabledFlag( false ), | |
// Symbex Threading config | |
mMultitaskingFlag( false ), | |
mThreadCount( 1 ), | |
// Shell config | |
mInconditionalStopMarkerLocation( ), | |
mSpecification( NULL ), | |
mExecutableSystem( NULL ), | |
mTableOfRID( ), | |
mMainExecutionContext( ), | |
mInputContext( ), | |
mTrace( ) | |
{ | |
//!! NOTHING | |
} | |
/** | |
* DESTRUCTOR | |
*/ | |
Configuration::~Configuration() | |
{ | |
destroy(); | |
} | |
void Configuration::destroy() | |
{ | |
if( mOwnedSpecificationFlag ) | |
{ | |
avm_report(AVM_OS_LOG, "Configuration::destroy"); | |
if( mTrace.populated() ) | |
{ | |
ExecutionContext * itEC; | |
while( mTrace.nonempty() ) | |
{ | |
mTrace.pop_last_to( itEC ); | |
mTrace.remove( itEC ); | |
sep::destroyElement( itEC ); | |
} | |
} | |
else if( mTrace.nonempty() ) | |
{ | |
sep::destroyElement( mTrace.pop_last() ); | |
} | |
mMainExecutionContext.destroy(); | |
// Attention:> Necessaire pour briser des references circulaires !!!! | |
destroyRIDRunningCode(); | |
mExecutableSystem.destroy(); | |
avm_report(AVM_OS_LOG, "~Configuration::destroy:> " | |
"after destruction of executable & execution context"); | |
mSpecification.destroy(); | |
avm_report(AVM_OS_LOG, "~Configuration::destroy:> " | |
"after destruction of specification"); | |
} | |
} | |
// Attention:> Necessaire pour briser des references circulaires !!!! | |
void Configuration::destroyRIDRunningCode() | |
{ | |
TableOfRuntimeID_T::iterator it = mTableOfRID.begin(); | |
TableOfRuntimeID_T::iterator itEnd = mTableOfRID.end(); | |
for( ; it != itEnd ; ++it ) | |
{ | |
(*it).finalize(); | |
} | |
// mTableOfRID.clear(); | |
} | |
/** | |
* CONFIGURE | |
*/ | |
/* | |
section project / SPECIFICATION | |
src = <source-folder-path> | |
file = "additional_file.xlia"; | |
main = "ascenseur.xlia"; | |
endsection | |
*/ | |
bool Configuration::configure( | |
WObject * wfConfiguration, Configuration * prevConfiguration) | |
{ | |
WObject * aSECTION = Query::getWSequenceOrElse( | |
wfConfiguration, "project", "SPECIFICATION"); | |
if( aSECTION != WObject::_NULL_ ) | |
{ | |
mProjectSourceLocation = | |
Query::getWPropertyStringOrElse(aSECTION, | |
"source", "src", VFS::WorkspaceSourcePath); | |
mProjectSourceLocation = VFS::native_path( | |
mProjectSourceLocation, VFS::WorkspaceRootPath); | |
mSpecificationFileLocation = | |
Query::getWPropertyStringOrElse( | |
aSECTION, "model", "main", ""); | |
mOwnedSpecificationFlag = (mSpecificationFileLocation.size() > 0); | |
if( mOwnedSpecificationFlag ) | |
{ | |
mOutputFilenamePattern = mDebugFilenamePattern = | |
(VFS::basename(mSpecificationFileLocation) + "_%1%"); | |
mSpecificationFileLocation = VFS::native_path( | |
mSpecificationFileLocation, mProjectSourceLocation); | |
OS_VERBOSITY_MINIMUM_OR_DEBUG( AVM_OS_COUT ) | |
<< _SEW_ << "Checking the specification file: \"" | |
<< VFS::relativeWorkspacePath( mSpecificationFileLocation ) | |
<< "\" ..."; | |
AVM_OS_LOG << _SEW_ << "Checking the specification ..." | |
<< std::endl | |
<< _SEW_ << "File location:> " | |
<< VFS::relativeWorkspacePath( mSpecificationFileLocation ); | |
if( VFS::checkReadingFile(mSpecificationFileLocation) ) | |
{ | |
OS_VERBOSITY_MINIMUM_OR_DEBUG( AVM_OS_COUT ) | |
<< " ==> DONE" << std::endl; | |
AVM_OS_LOG << " ==> DONE" << std::endl; | |
} | |
else | |
{ | |
mOwnedSpecificationFlag = false; | |
AVM_OS_COUT << EOL_TAB << " ==> FAILED :> " | |
<< "This file doesn't exist or is not readable !!!" | |
<< std::endl; | |
return( false ); | |
} | |
} | |
} | |
else if( prevConfiguration != NULL ) | |
{ | |
mProjectSourceLocation = prevConfiguration->mProjectSourceLocation; | |
mSpecificationFileLocation = prevConfiguration->mSpecificationFileLocation; | |
mOutputFilenamePattern = prevConfiguration->mOutputFilenamePattern; | |
mDebugFilenamePattern = prevConfiguration->mDebugFilenamePattern; | |
} | |
aSECTION = Query::getRegexWSequence( | |
wfConfiguration, OR_WID2("output", "OUTPUT")); | |
if( aSECTION != WObject::_NULL_ ) | |
{ | |
if( configureFormatter(aSECTION, mOutputFilenamePattern, "filename" ) ) | |
{ | |
mOutputFilenamePattern = VFS::native_path( | |
mOutputFilenamePattern, VFS::WorkspaceOutputPath); | |
// Output Executable | |
mOutputExecutableFileLocation = | |
Query::getWPropertyString(aSECTION, "executable", ""); | |
mOutputExecutableEnabledGenerationFlag = | |
(mOutputExecutableFileLocation.size() > 0); | |
if( mOutputExecutableEnabledGenerationFlag ) | |
{ | |
mOutputExecutableFileLocation = VFS::native_path( | |
mOutputExecutableFileLocation, VFS::WorkspaceOutputPath); | |
} | |
else | |
{ | |
mOutputExecutableFileLocation = | |
mOutputFilenamePattern + EXECUTABLE_FILE_EXTENSION; | |
} | |
// Output SymbexGraph | |
mOutputSymbexGraphFileLocation = | |
Query::getRegexWPropertyString(aSECTION, "graph(viz)?", ""); | |
mOutputSymbexGraphEnabledGenerationFlag = | |
(mOutputSymbexGraphFileLocation.size() > 0); | |
if( mOutputSymbexGraphEnabledGenerationFlag ) | |
{ | |
mOutputSymbexGraphFileLocation = VFS::native_path( | |
mOutputSymbexGraphFileLocation, VFS::WorkspaceOutputPath); | |
} | |
else | |
{ | |
mOutputSymbexGraphFileLocation = | |
mOutputFilenamePattern + SYMBEX_GRAPH_FILE_EXTENSION; | |
} | |
// Output Symbex Scenaii | |
mOutputSymbexScenariiFileLocation = | |
Query::getWPropertyString(aSECTION, "scenarii", ""); | |
mOutputSymbexScenariiEnabledGenerationFlag = | |
(mOutputSymbexScenariiFileLocation.size() > 0); | |
if( mOutputSymbexScenariiEnabledGenerationFlag ) | |
{ | |
mOutputSymbexScenariiFileLocation = VFS::native_path( | |
mOutputSymbexScenariiFileLocation, VFS::WorkspaceOutputPath); | |
} | |
else | |
{ | |
mOutputSymbexScenariiFileLocation = | |
mOutputFilenamePattern + SYMBEX_SCENARII_FILE_EXTENSION; | |
} | |
} | |
else | |
{ | |
AVM_OS_WARN << "Configuration::configureWObject:> " | |
"Failed to configure Output Filename Pattern < " | |
<< mOutputFilenamePattern << " > !" << std::endl; | |
return( false ); | |
} | |
} | |
aSECTION = Query::getRegexWSequence(wfConfiguration, | |
OR_WID2("debug", "DEBUG"), aSECTION); | |
if( aSECTION != WObject::_NULL_ ) | |
{ | |
mDebugStageEnabledFlag = true; | |
if( configureFormatter(aSECTION, mDebugFilenamePattern, "filename" ) ) | |
{ | |
mDebugFilenamePattern = VFS::native_path( | |
mDebugFilenamePattern, VFS::WorkspaceDebugPath); | |
} | |
else | |
{ | |
AVM_OS_WARN << "Configuration::configureWObject:> " | |
"Failed to configure Debug Filename Pattern < " | |
<< mDebugFilenamePattern << " > !" << std::endl; | |
return( false ); | |
} | |
mDebugParsingStageEnabledFlag = mDebugStageEnabledFlag | |
&& Query::hasWPropertyString(aSECTION, "parsing"); | |
mDebugCompilingStageEnabledFlag = mDebugStageEnabledFlag | |
&& Query::hasWPropertyString(aSECTION, "executable"); | |
mDebugLoadingStageEnabledFlag = mDebugStageEnabledFlag | |
&& Query::hasWPropertyString(aSECTION, "loading"); | |
mDebugComputingEnabledFlag = mDebugStageEnabledFlag | |
&& Query::hasWPropertyString(aSECTION, "execution"); | |
} | |
bool isOK = configure_shell_symbex(wfConfiguration); | |
return( isOK ); | |
} | |
bool Configuration::configure_shell_symbex(WObject * wfConfiguration) | |
{ | |
// Symbex config | |
WObject * configSYMBEX = Query::getRegexWSequence( | |
wfConfiguration, Workflow::SECTION_SYMBEX_REGEX_ID); | |
mMultitaskingFlag = Query::getWPropertyBoolean( | |
configSYMBEX, "multitasking", mWorkflow.isMultitasking()); | |
mThreadCount = Query::getWPropertyInt( | |
configSYMBEX, "thread", mWorkflow.getThreadCount()); | |
// Shell config | |
WObject * configSHELL = Query::getRegexWSequence( | |
wfConfiguration, Workflow::SECTION_SHELL_REGEX_ID); | |
mInconditionalStopMarkerLocation = | |
Query::getWPropertyString(configSHELL, "stop", ""); | |
if( mInconditionalStopMarkerLocation.empty() ) | |
{ | |
mInconditionalStopMarkerLocation = | |
mWorkflow.getInconditionalStopMarkerLocation(); | |
} | |
else | |
{ | |
mInconditionalStopMarkerLocation = | |
VFS::native_path(mInconditionalStopMarkerLocation); | |
mInconditionalStopMarkerLocation = VFS::native_path( | |
mInconditionalStopMarkerLocation, VFS::WorkspaceLogPath); | |
} | |
return( true ); | |
} | |
bool Configuration::configureFormatter(WObject * FORMAT, | |
std::string & formatPattern, const std::string & id) | |
{ | |
formatPattern = Query::getWPropertyString(FORMAT, id, formatPattern); | |
try | |
{ | |
boost::format formatter(formatPattern); | |
} | |
catch(const boost::io::bad_format_string & bfs) | |
{ | |
Query::reportErrorAttribute(FORMAT, id, bfs.what()); | |
return( false ); | |
} | |
return( true ); | |
} | |
/** | |
* GETTER | |
* OUTPUT / DEBUG FILE LOCATION | |
*/ | |
std::string Configuration::formatFileLocation( | |
const std::string & aFilenamePattern, | |
const std::string & strID, const std::string & strExtension) const | |
{ | |
boost::format locationFormatter(aFilenamePattern); | |
locationFormatter.exceptions( boost::io::no_error_bits ); | |
if( strExtension.empty() ) | |
{ | |
return( ( locationFormatter % strID ).str() ); | |
} | |
else | |
{ | |
return( (OSS() << (locationFormatter % strID) << strExtension).str() ); | |
} | |
} | |
/** | |
* SAVING | |
*/ | |
void Configuration::saveSpecification(bool isDebug, const std::string & strID) | |
{ | |
std::string saveFileLocation = formatFileLocation( | |
isDebug, strID, SPECIFICATION_FILE_EXTENSION); | |
if( isDebug ) | |
{ | |
AVM_OS_CLOG << _DBG_ | |
<< "Saving of the Specification in text format --> " | |
<< strID << std::endl; | |
} | |
else | |
{ | |
AVM_OS_LOG << _SEW_ | |
<< "Saving of the Specification in text format --> " | |
<< strID << std::endl; | |
} | |
Configuration::saveElementTextualView(AVM_OS_LOG, | |
getSpecification(), saveFileLocation); | |
} | |
void Configuration::saveSymbexGraph(bool isDebug, const std::string & strID) | |
{ | |
std::string saveFileLocation = formatFileLocation( | |
isDebug, strID, SYMBEX_GRAPH_FILE_EXTENSION); | |
} | |
void Configuration::saveSymbexScenarii(bool isDebug, const std::string & strID) | |
{ | |
std::string saveFileLocation = formatFileLocation( | |
isDebug, strID, SYMBEX_GRAPH_FILE_EXTENSION); | |
} | |
/** | |
* Jose Projection | |
*/ | |
//void Configuration::saveProjection(const std::string & strPrefixName) | |
//{ | |
// if( mOutputSymbexProjectionGraphEnabledGenerationFlag ) | |
// { | |
// ScopeNewIndent scope( AVM_OS_LOG , AVM_TAB1_INDENT ); | |
// | |
// AVM_OS_LOG << _SEW_ << "Saving of projection (2)" << std::endl | |
// << TAB << "path: " << VFS::relativeWorkspacePath( | |
// mOutputSymbexProjectionGraphFileLocation ) | |
// << "... " << std::flush; | |
// | |
// std::ofstream resultStream; | |
// resultStream.open(mOutputSymbexProjectionGraphFileLocation.c_str(), | |
// std::ios_base::out); | |
// if( resultStream.good() ) | |
// { | |
// OutStream os(resultStream, AVM_OUTPUT_INDENT); | |
// | |
// ListOfExecutionContext::iterator it = getTrace().begin(); | |
// ListOfExecutionContext::iterator itEnd = getTrace().end(); | |
// for( ; it != itEnd ; ++it ) | |
// { | |
// // Suppression de l'indentation dans le fichier de sortie | |
// (*it)->toFscn(os, NULL); | |
// } | |
// | |
// resultStream.close(); | |
// | |
// AVM_OS_LOG << "OK" << std::endl ; | |
// } | |
// else | |
// { | |
// AVM_OS_LOG << std::endl << TAB | |
// << " KO : Failed to open this file in write mode" | |
// << std::endl; | |
// } | |
// } | |
//} | |
// | |
// | |
//void Configuration::saveProjectionScenarii(const std::string & strPrefixName) | |
//{ | |
// if( mOutputSymbexProjectionScenariiEnabledGenerationFlag ) | |
// { | |
// ScopeNewIndent scope( AVM_OS_LOG , AVM_TAB1_INDENT ); | |
// | |
// AVM_OS_LOG << _SEW_ << "Saving of projection FSCN " << std::endl | |
// << TAB << "path: " << VFS::relativeWorkspacePath( | |
// mOutputSymbexProjectionScenariiFileLocation ) | |
// << "... " << std::flush; | |
// | |
// std::ofstream resultStream; | |
// resultStream.open(mOutputSymbexProjectionScenariiFileLocation.c_str(), | |
// std::ios_base::out); | |
// if( resultStream.good() ) | |
// { | |
// OutStream os(resultStream, AVM_OUTPUT_INDENT); | |
// | |
// ListOfExecutionContext::iterator it = getTrace().begin(); | |
// ListOfExecutionContext::iterator itEnd = getTrace().end(); | |
// for( ; it != itEnd ; ++it ) | |
// { | |
// // Suppression de l'indentation dans le fichier de sortie | |
// (*it)->toFscn(os, NULL); | |
// } | |
// | |
// resultStream.close(); | |
// | |
// AVM_OS_LOG << "OK" << std::endl ; | |
// } | |
// else | |
// { | |
// AVM_OS_LOG << std::endl << TAB | |
// << " KO : Failed to open this file in write mode" | |
// << std::endl; | |
// } | |
// } | |
//} | |
// end Jose Projection | |
///** | |
// * Configuration::saveSpecification | |
// * | |
// */ | |
//void Configuration::saveSpecificationAfterCompilationStep( | |
// const std::string & strPrefixName) | |
//{ | |
// MainDataConfiguration * aMDC = aMDC->getInstance(); | |
// ParameterManager * aPM = aMDC->getParameterManager(); | |
// | |
// std::string saveFileLocation = | |
// aPM->getEngineDebugParsingLocation(strPrefixName); | |
// | |
// if( aMDC->hasSpecification() && (not saveFileLocation.empty()) ) | |
// { | |
// AVM_OS_LOG << _SEW_ | |
// << "Saving of the internal specification " | |
// "representation in textual format " | |
// << std::endl; | |
// | |
// saveElementTextualView(aMDC->getSpecification(), saveFileLocation); | |
// } | |
//} | |
// | |
// | |
///** | |
// * Configuration::saveExecutableSpecification | |
// * | |
// */ | |
//void Configuration::saveExecutableSpecification( | |
// const std::string & strPrefixName) | |
//{ | |
// MainDataConfiguration * aMDC = MainDataConfiguration::getInstance(); | |
// ParameterManager * aPM = aMDC->getParameterManager(); | |
// | |
// std::string saveFileLocation = | |
// aPM->getEngineOutputExecutableLocation(strPrefixName); | |
// | |
// if( not saveFileLocation.empty() ) | |
// { | |
// AVM_OS_LOG << _SEW_ << "Saving of the compiled " | |
// "specification representation in textual format " | |
// << std::endl; | |
// | |
// saveFormTextualViews(aMDC->getExecutableSystem(), saveFileLocation); | |
// | |
// saveFileLocation = aPM->getEngineOutputGraphLocation("fec_"); | |
// if( aMDC->hasMainExecutionContext() && (! saveFileLocation.empty()) ) | |
// { | |
// saveElementTextualView( | |
// aMDC->getMainExecutionContext(), saveFileLocation); | |
// } | |
// } | |
//} | |
/** | |
* save Element as textual view | |
* | |
*/ | |
void Configuration::saveElementTextualView(OutStream & logger, | |
const Element & anElement, const std::string & saveFileLocation) | |
{ | |
ScopeNewIndent scope( logger , AVM_TAB1_INDENT ); | |
logger << TAB << "path: " | |
<< VFS::relativeWorkspacePath( saveFileLocation ) | |
<< "... " << std::flush; | |
std::ofstream resultStream; | |
resultStream.open(saveFileLocation.c_str(), std::ios_base::out); | |
if( resultStream.good() ) | |
{ | |
OutStream os(resultStream); | |
anElement.serialize(os); | |
resultStream.close(); | |
logger << "OK" << std::endl ; | |
} | |
else | |
{ | |
logger << std::endl << TAB | |
<< " KO : Failed to open this file in write mode" | |
<< std::endl; | |
} | |
} | |
//////////////////////////////////////////////////////////////////////////// | |
// SERIALIZATION API | |
//////////////////////////////////////////////////////////////////////////// | |
void Configuration::serializeDebugExecutable(const std::string & strID) | |
{ | |
std::string saveFileLocation = formatFileLocation( | |
true, strID, EXECUTABLE_FILE_EXTENSION); | |
AVM_OS_CLOG << _DBG_ | |
<< "Saving of the Executable in text format --> " | |
<< strID << std::endl; | |
Configuration::saveElementTextualView(AVM_OS_LOG, | |
mExecutableSystem, saveFileLocation); | |
} | |
void Configuration::serializeTextualExecutable() | |
{ | |
AVM_OS_LOG << _SEW_ | |
<< "Saving of the Executable in text format" << std::endl; | |
Configuration::saveElementTextualView(AVM_OS_LOG, | |
mExecutableSystem, mOutputExecutableFileLocation); | |
} | |
void Configuration::serializeGraphizExecutable() | |
{ | |
ScopeNewIndent scope( AVM_OS_LOG , AVM_TAB1_INDENT ); | |
std::string saveFileLocation = VFS::replace_extension( | |
mOutputExecutableFileLocation, GRAPHVIZ_FILE_EXTENSION); | |
AVM_OS_LOG << _SEW_ | |
<< "Saving of the specification representation " | |
"in GraphViz format " << std::endl; | |
AVM_OS_LOG << TAB << "path: " | |
<< VFS::relativeWorkspacePath( saveFileLocation ) | |
<< "... " << std::flush; | |
std::ofstream resultStream; | |
resultStream.open(saveFileLocation.c_str(), std::ios_base::out); | |
if( resultStream.good() ) | |
{ | |
OutStream os(resultStream, AVM_SPC_INDENT); | |
GraphVizStatemachineSerializer::format( | |
mSymbexEngine.getControllerUnitManager(), os, getSpecification()); | |
resultStream.close(); | |
AVM_OS_LOG << "OK" << std::endl ; | |
} | |
else | |
{ | |
AVM_OS_LOG << std::endl << TAB | |
<< " KO : Failed to open this file in write mode" | |
<< std::endl; | |
} | |
} | |
/** | |
* serialize Textual SymbexGraph | |
*/ | |
void Configuration::serializeTextualSymbexGraph() | |
{ | |
ScopeNewIndent scope( AVM_OS_LOG , AVM_TAB1_INDENT ); | |
AVM_OS_LOG << _SEW_ | |
<< "Saving of the trace of the execution specification " | |
"representation in textual format " << std::endl; | |
AVM_OS_LOG << TAB << "path: " | |
<< VFS::relativeWorkspacePath( mOutputSymbexGraphFileLocation ) | |
<< "... " << std::flush; | |
std::ofstream resultStream; | |
resultStream.open(mOutputSymbexGraphFileLocation.c_str(), | |
std::ios_base::out); | |
if( resultStream.good() ) | |
{ | |
OutStream os(resultStream, AVM_SPC_INDENT); | |
ListOfExecutionContext::const_iterator it = getTrace().begin(); | |
ListOfExecutionContext::const_iterator itEnd = getTrace().end(); | |
for( ; it != itEnd ; ++it ) | |
{ | |
(*it)->serialize(os); | |
} | |
resultStream.close(); | |
AVM_OS_LOG << "OK" << std::endl; | |
} | |
else | |
{ | |
AVM_OS_LOG << std::endl << TAB | |
<< " KO : Failed to open this file in write mode" | |
<< std::endl; | |
} | |
if( hasMainExecutionContext() ) | |
{ | |
std::string saveFileLocation = formatFileLocation( | |
true, "tec", SYMBEX_GRAPH_FILE_EXTENSION); | |
saveElementTextualView(AVM_OS_LOG, | |
getMainExecutionContext(), saveFileLocation); | |
} | |
} | |
/** | |
* serialize Graphiz SymbexGraph | |
*/ | |
void Configuration::serializeGraphizSymbexGraph() | |
{ | |
std::string saveFileLocation = VFS::replace_extension( | |
mOutputSymbexGraphFileLocation, GRAPHVIZ_FILE_EXTENSION); | |
ScopeNewIndent scope( AVM_OS_LOG , AVM_TAB1_INDENT ); | |
AVM_OS_LOG << _SEW_ | |
<< "Saving of the symbex trace of the execution specification " | |
"representation in GraphViz format " << std::endl; | |
AVM_OS_LOG << TAB << "path: " | |
<< VFS::relativeWorkspacePath( saveFileLocation ) | |
<< "... " << std::flush; | |
std::ofstream resultStream; | |
resultStream.open(saveFileLocation.c_str(), std::ios_base::out); | |
if( resultStream.good() ) | |
{ | |
OutStream os(resultStream, AVM_SPC_INDENT); | |
ListOfExecutionContext::const_iterator it = getTrace().begin(); | |
ListOfExecutionContext::const_iterator itEnd = getTrace().end(); | |
for( ; it != itEnd ; ++it ) | |
{ | |
GraphVizExecutionGraphSerializer::format( | |
mSymbexEngine.getControllerUnitManager(), os, *(*it)); | |
} | |
resultStream.close(); | |
AVM_OS_LOG << "OK" << std::endl ; | |
} | |
else | |
{ | |
AVM_OS_LOG << std::endl << TAB | |
<< " KO : Failed to open this file in write mode" | |
<< std::endl; | |
} | |
} | |
void Configuration::serializeScenarii() | |
{ | |
ScopeNewIndent scope( AVM_OS_LOG , AVM_TAB1_INDENT ); | |
AVM_OS_LOG << _SEW_ | |
<< "Saving of the trace of the execution specification " | |
"representation in textual format " << std::endl; | |
AVM_OS_LOG << TAB << "path: " | |
<< VFS::relativeWorkspacePath(mOutputSymbexScenariiFileLocation) | |
<< "... " << std::flush; | |
std::ofstream resultStream; | |
resultStream.open(mOutputSymbexScenariiFileLocation.c_str(), | |
std::ios_base::out); | |
if( resultStream.good() ) | |
{ | |
OutStream os(resultStream, AVM_FSCN_INDENT); | |
ListOfExecutionContext::const_iterator it = getTrace().begin(); | |
ListOfExecutionContext::const_iterator itEnd = getTrace().end(); | |
for( ; it != itEnd ; ++it ) | |
{ | |
(*it)->toFscn(os, NULL); | |
} | |
resultStream.close(); | |
AVM_OS_LOG << "OK" << std::endl ; | |
} | |
else | |
{ | |
AVM_OS_LOG << std::endl << TAB | |
<< " KO : Failed to open this file in write mode" | |
<< std::endl; | |
} | |
} | |
/** | |
* Serialization building stage | |
*/ | |
void Configuration::serializeBuildingResult() | |
{ | |
if( mOutputExecutableEnabledGenerationFlag ) | |
{ | |
serializeTextualExecutable(); | |
serializeGraphizExecutable(); | |
} | |
} | |
/** | |
* Serialization computing stage | |
*/ | |
void Configuration::serializeComputingResult() | |
{ | |
AVM_IF_DEBUG_FLAG_AND( COMPUTING , isDebugLoadingStageEnabled() ) | |
serializeDebugExecutable( "jit" ); | |
AVM_ENDIF_DEBUG_FLAG_AND( COMPUTING ) | |
if( mOutputSymbexScenariiEnabledGenerationFlag ) | |
{ | |
serializeScenarii(); | |
} | |
if( mOutputSymbexGraphEnabledGenerationFlag ) | |
{ | |
AVM_IF_DEBUG_ENABLED | |
serializeTextualSymbexGraph(); | |
AVM_ENDIF_DEBUG_ENABLED | |
serializeGraphizSymbexGraph(); | |
} | |
// saveProjection(); | |
// saveProjectionScenarii(mParameterWObject); | |
} | |
/** | |
* Serialization | |
*/ | |
void Configuration::toStream(OutStream & os) const | |
{ | |
os << TAB << "configuration " << getNameID() << " {" << EOL; | |
os << TAB2 << "WorkspaceRootPath = " << VFS::WorkspaceRootPath << EOL; | |
os << TAB2 << "mProjectSourceLocation = " | |
<< VFS::relativeWorkspacePath( mProjectSourceLocation ) | |
<< EOL; | |
os << TAB2 << "mSpecificationFileLocation = " | |
<< VFS::relativeWorkspacePath( mSpecificationFileLocation ) | |
<< EOL; | |
os << TAB2 << "mOwnedSpecificationFlag = " | |
<< ( mOwnedSpecificationFlag ? "true" : "false" ) | |
<< EOL; | |
os << TAB2 << "mOutputFilenamePattern = " | |
<< VFS::relativeWorkspacePath( mOutputFilenamePattern ) | |
<< EOL; | |
os << TAB2 << "mDebugFilenamePattern = " | |
<< VFS::relativeWorkspacePath( mDebugFilenamePattern ) | |
<< EOL; | |
os << TAB2 << "mOutputExecutableEnabledGenerationFlag = " | |
<< ( mOutputExecutableEnabledGenerationFlag ? "true" : "false" ) | |
<< EOL; | |
os << TAB2 << "mOutputExecutableFileLocation = " | |
<< VFS::relativeWorkspacePath( mOutputExecutableFileLocation ) | |
<< EOL; | |
os << TAB2 << "mOutputSymbexGraphEnabledGenerationFlag = " | |
<< ( mOutputSymbexGraphEnabledGenerationFlag ? "true" : "false" ) | |
<< EOL; | |
os << TAB2 << "mOutputSymbexGraphFileLocation = " | |
<< VFS::relativeWorkspacePath( mOutputSymbexGraphFileLocation ) | |
<< EOL; | |
os << TAB2 << "mOutputSymbexScenariiEnabledGenerationFlag = " | |
<< ( mOutputSymbexScenariiEnabledGenerationFlag ? "true" : "false" ) | |
<< EOL; | |
os << TAB2 << "mOutputSymbexScenariiFileLocation = " | |
<< VFS::relativeWorkspacePath( mOutputSymbexScenariiFileLocation ) | |
<< EOL; | |
os << TAB2 << "mDebugStageEnabledFlag = " | |
<< ( mDebugStageEnabledFlag ? "true" : "false" ) << EOL; | |
os << TAB2 << "mDebugParsingStageEnabledFlag = " | |
<< ( mDebugParsingStageEnabledFlag ? "true" : "false" ) << EOL; | |
os << TAB2 << "mDebugCompilingStageEnabledFlag = " | |
<< ( mDebugCompilingStageEnabledFlag ? "true" : "false" ) << EOL; | |
os << TAB2 << "mDebugLoadingStageEnabledFlag = " | |
<< ( mDebugLoadingStageEnabledFlag ? "true" : "false" ) << EOL; | |
os << TAB2 << "mDebugComputingEnabledFlag = " | |
<< ( mDebugComputingEnabledFlag ? "true" : "false" ) << EOL; | |
os << TAB2 << "mInconditionalStopMarkerLocation = " | |
<< VFS::relativeWorkspacePath( mInconditionalStopMarkerLocation ) | |
<< EOL; | |
os << TAB << "}" << EOL_FLUSH; | |
} | |
} /* namespace sep */ |