| /******************************************************************************* |
| * 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: 11 sept. 2014 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| |
| #include "TraceFactory.h" |
| |
| #include <fstream> |
| |
| #include <boost/algorithm/string.hpp> |
| |
| #include <builder/Builder.h> |
| |
| #include <computer/EvaluationEnvironment.h> |
| |
| #include <fml/expression/AvmCode.h> |
| |
| #include <fml/expression/AvmCode.h> |
| #include <fml/expression/BuiltinArray.h> |
| |
| #include <fml/executable/AvmTransition.h> |
| #include <fml/executable/ExecutableQuery.h> |
| #include <fml/executable/ExecutableSystem.h> |
| |
| #include <fml/operator/OperatorManager.h> |
| |
| #include <fml/trace/BasicTraceParser.h> |
| #include <fml/trace/TracePoint.h> |
| #include <fml/trace/TraceSequence.h> |
| |
| #include <fml/workflow/Query.h> |
| #include <fml/workflow/WObject.h> |
| |
| #include <sew/Configuration.h> |
| |
| #include <util/avm_string.h> |
| |
| |
| namespace sep |
| { |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // CONFIGURE API |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| /* |
| // Declaration part |
| section POINT |
| @assign = "sens"; |
| |
| @newfresh = "sens"; |
| |
| @signal#sens = "sens"; |
| |
| @port = "env"; |
| |
| @input = "env"; |
| @output = "env"; |
| |
| @output = "Thermostat->dt"; |
| @input = "Thermostat->equip"; |
| @output2 = "Equipment->error"; |
| endsection POINT |
| |
| section TRACE |
| @trace = ${ && "signal#sens" "output2" }; |
| @trace = [ "signal#sens" , "output2" ]; |
| @point = ( "signal#sens" || "output2" ); |
| @composite = ${ xor "signal#sens" "output2" }; |
| |
| |
| @assign = "sens"; |
| |
| @newfresh = "sens"; |
| |
| @signal = "sens"; |
| |
| @port = "env"; |
| |
| @input = "env"; |
| @output = "env"; |
| |
| @output = "Thermostat->dt"; |
| @input = "Thermostat->equip"; |
| @output = "Equipment->error"; |
| |
| @transition = "Thermostat->transition#2#MSGm1#in"; |
| @routine = "Thermostat->transition#2#MSGm1#in"; |
| |
| @machine = "Thermostat"; |
| |
| @state = "Thermostat->s4"; |
| |
| @formula = <expression>; |
| |
| |
| endsection TRACE |
| |
| */ |
| |
| static ENUM_TRACE_POINT::TRACE_NATURE to_nature(const std::string & id) |
| { |
| if( id.find("composite" ) == 0 ) return ENUM_TRACE_POINT::TRACE_COMPOSITE_NATURE; |
| if( id.find("comp" ) == 0 ) return ENUM_TRACE_POINT::TRACE_COMPOSITE_NATURE; |
| if( id.find("expression") == 0 ) return ENUM_TRACE_POINT::TRACE_COMPOSITE_NATURE; |
| if( id.find("expr" ) == 0 ) return ENUM_TRACE_POINT::TRACE_COMPOSITE_NATURE; |
| if( id.find("trace" ) == 0 ) return ENUM_TRACE_POINT::TRACE_COMPOSITE_NATURE; |
| if( id.find("point" ) == 0 ) return ENUM_TRACE_POINT::TRACE_COMPOSITE_NATURE; |
| |
| if( id.find("com" ) == 0 ) return ENUM_TRACE_POINT::TRACE_COM_NATURE; |
| if( id.find("inout" ) == 0 ) return ENUM_TRACE_POINT::TRACE_COM_NATURE; |
| |
| if( id.find("channel" ) == 0 ) return ENUM_TRACE_POINT::TRACE_CHANNEL_NATURE; |
| |
| if( id.find("message" ) == 0 ) return ENUM_TRACE_POINT::TRACE_MESSAGE_NATURE; |
| |
| if( id.find("port" ) == 0 ) return ENUM_TRACE_POINT::TRACE_PORT_NATURE; |
| |
| if( id.find("signal" ) == 0 ) return ENUM_TRACE_POINT::TRACE_SIGNAL_NATURE; |
| |
| if( id.find("time" ) == 0 ) return ENUM_TRACE_POINT::TRACE_TIME_NATURE; |
| |
| if( id.find("var" ) == 0 ) return ENUM_TRACE_POINT::TRACE_VARIABLE_NATURE; |
| if( id.find("variable" ) == 0 ) return ENUM_TRACE_POINT::TRACE_VARIABLE_NATURE; |
| // if( id.find("assign" ) == 0 ) return ENUM_TRACE_POINT::TRACE_VARIABLE_NATURE; |
| // if( id.find("newfresh" ) == 0 ) return ENUM_TRACE_POINT::TRACE_VARIABLE_NATURE; |
| |
| if( id.find("buffer" ) == 0 ) return ENUM_TRACE_POINT::TRACE_BUFFER_NATURE; |
| |
| if( id.find("formula" ) == 0 ) return ENUM_TRACE_POINT::TRACE_FORMULA_NATURE; |
| if( id.find("condition" ) == 0 ) return ENUM_TRACE_POINT::TRACE_CONDITION_NATURE; |
| if( id.find("decision" ) == 0 ) return ENUM_TRACE_POINT::TRACE_DECISION_NATURE; |
| |
| if( REGEX_MATCH(id, CONS_WID2("path", "condition")) ) { |
| return ENUM_TRACE_POINT::TRACE_PATH_CONDITION_NATURE; |
| } |
| if( REGEX_MATCH(id, CONS_WID2("node", "condition")) ) { |
| return ENUM_TRACE_POINT::TRACE_NODE_CONDITION_NATURE; |
| } |
| |
| if( REGEX_MATCH(id, CONS_WID3("path", "condition", "leaf")) ) { |
| return ENUM_TRACE_POINT::TRACE_PATH_CONDITION_NATURE_LEAF; |
| } |
| if( REGEX_MATCH(id, CONS_WID3("node", "condition", "leaf")) ) { |
| return ENUM_TRACE_POINT::TRACE_NODE_CONDITION_NATURE_LEAF; |
| } |
| |
| if( REGEX_MATCH(id, CONS_WID3("path", "timed", "condition")) ) { |
| return ENUM_TRACE_POINT::TRACE_PATH_TIMED_CONDITION_NATURE; |
| } |
| if( REGEX_MATCH(id, CONS_WID3("node", "timed", "condition")) ) { |
| return ENUM_TRACE_POINT::TRACE_NODE_TIMED_CONDITION_NATURE; |
| } |
| |
| if( REGEX_MATCH(id, CONS_WID4( |
| "path", "timed", "condition", "(leaf|end|last|tail)")) ) { |
| return ENUM_TRACE_POINT::TRACE_PATH_TIMED_CONDITION_NATURE_LEAF; |
| } |
| if( REGEX_MATCH(id, CONS_WID4( |
| "node", "timed", "condition", "(leaf|end|last|tail)")) ) { |
| return ENUM_TRACE_POINT::TRACE_NODE_TIMED_CONDITION_NATURE_LEAF; |
| } |
| |
| if( id.find("statemachine") == 0 ) return ENUM_TRACE_POINT::TRACE_STATEMACHINE_NATURE; |
| if( id.find("machine") == 0 ) return ENUM_TRACE_POINT::TRACE_MACHINE_NATURE; |
| if( id.find("state" ) == 0 ) return ENUM_TRACE_POINT::TRACE_STATE_NATURE; |
| |
| |
| if( id.find("transition") == 0 ) return ENUM_TRACE_POINT::TRACE_TRANSITION_NATURE; |
| if( id.find("routine" ) == 0 ) return ENUM_TRACE_POINT::TRACE_ROUTINE_NATURE; |
| |
| if( id.find("runnable" ) == 0 ) return ENUM_TRACE_POINT::TRACE_RUNNABLE_NATURE; |
| |
| if( REGEX_MATCH(id, CONS_WID2("step", "header")) ) { |
| return ENUM_TRACE_POINT::TRACE_STEP_HEADER_NATURE; |
| } |
| if( REGEX_MATCH(id, CONS_WID2("step", "begin" )) ) { |
| return ENUM_TRACE_POINT::TRACE_STEP_BEGIN_NATURE; |
| } |
| if( REGEX_MATCH(id, CONS_WID2("step", "end" )) ) { |
| return ENUM_TRACE_POINT::TRACE_STEP_END_NATURE; |
| } |
| |
| if( REGEX_MATCH(id, CONS_WID2("init", "header")) ) { |
| return ENUM_TRACE_POINT::TRACE_INIT_HEADER_NATURE; |
| } |
| if( REGEX_MATCH(id, CONS_WID2("init", "begin" )) ) { |
| return ENUM_TRACE_POINT::TRACE_INIT_BEGIN_NATURE; |
| } |
| if( REGEX_MATCH(id, CONS_WID2("init", "end" )) ) { |
| return ENUM_TRACE_POINT::TRACE_INIT_END_NATURE; |
| } |
| |
| if( id.find("comment" ) == 0 ) return ENUM_TRACE_POINT::TRACE_COMMENT_NATURE; |
| if( id.find("separator") == 0 ) return ENUM_TRACE_POINT::TRACE_SEPARATOR_NATURE; |
| if( id.find("newline" ) == 0 ) return ENUM_TRACE_POINT::TRACE_NEWLINE_NATURE; |
| |
| // if( not id.empty() ) return ENUM_TRACE_POINT::TRACE_COMPOSITE_NATURE; |
| |
| return ENUM_TRACE_POINT::TRACE_UNDEFINED_NATURE; |
| } |
| |
| |
| static AVM_OPCODE to_op(const std::string & id) |
| { |
| if( id.find("time" ) == 0 ) return AVM_OPCODE_TIMED_GUARD; |
| |
| if( id.find("formula" ) == 0 ) return AVM_OPCODE_GUARD; |
| if( id.find("guard" ) == 0 ) return AVM_OPCODE_GUARD; |
| |
| if( REGEX_MATCH(id,"check.sat") ) return AVM_OPCODE_CHECK_SAT; |
| |
| if( id.find("assign" ) == 0 ) return AVM_OPCODE_ASSIGN; |
| if( id.find("newfresh" ) == 0 ) return AVM_OPCODE_ASSIGN_NEWFRESH; |
| |
| if( REGEX_MATCH(id, CONS_WID2("input", "env")) ) return AVM_OPCODE_INPUT_ENV; |
| if( REGEX_MATCH(id, CONS_WID2("input", "rdv")) ) return AVM_OPCODE_INPUT_RDV; |
| |
| if( id.find("input" ) == 0 ) return AVM_OPCODE_INPUT; |
| |
| if( REGEX_MATCH(id, CONS_WID2("output", "env")) ) return AVM_OPCODE_OUTPUT_ENV; |
| if( REGEX_MATCH(id, CONS_WID2("output", "rdv")) ) return AVM_OPCODE_OUTPUT_RDV; |
| |
| if( id.find("output" ) == 0 ) return AVM_OPCODE_OUTPUT; |
| |
| return AVM_OPCODE_NULL; |
| } |
| |
| |
| bool TraceFactory::configure( |
| TraceSequence & aTraceElement, const ExecutionData * anED) |
| { |
| WObject * thePOINT = Query::getRegexWSequence( |
| mParameterWObject, OR_WID2("point", "POINT")); |
| if( (thePOINT != WObject::_NULL_) && thePOINT->hasOwnedElement() ) |
| { |
| // if( configure(thePOINT, mDeclaredPoint, anED) ) |
| // { |
| // //!! NOTHING |
| // } |
| mED = anED; |
| |
| WObject::const_iterator itWfO = thePOINT->owned_begin(); |
| WObject::const_iterator endWfO = thePOINT->owned_end(); |
| for( ; itWfO != endWfO ; ++itWfO ) |
| { |
| if( (*itWfO)->isWProperty() ) |
| { |
| if( configure(mDeclaredPoint, *itWfO) ) |
| { |
| mDeclaredPointID.append( (*itWfO)->getNameID() ); |
| |
| if( mDeclaredPoint.size() != mDeclaredPointID.size() ) |
| { |
| AVM_OS_FATAL_ERROR_EXIT |
| << "TracePoint Declaration Error !!!" |
| << SEND_EXIT; |
| } |
| } |
| } |
| } |
| } |
| |
| WObject * theTRACE = Query::getRegexWSequence( |
| mParameterWObject, OR_WID2("trace", "TRACE")); |
| if( (theTRACE != WObject::_NULL_) && theTRACE->hasOwnedElement() ) |
| { |
| if( configure(theTRACE, aTraceElement, anED) ) |
| { |
| //!! NOTHING |
| } |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configure( |
| AvmCode * aTraceExpression, const ExecutionData * anED) |
| { |
| WObject * thePOINT = Query::getRegexWSequence( |
| mParameterWObject, OR_WID2("point", "POINT")); |
| if( (thePOINT != WObject::_NULL_) && thePOINT->hasOwnedElement() ) |
| { |
| mED = anED; |
| |
| WObject::const_iterator itWfO = thePOINT->owned_begin(); |
| WObject::const_iterator endWfO = thePOINT->owned_end(); |
| for( ; itWfO != endWfO ; ++itWfO ) |
| { |
| if( (*itWfO)->isWProperty() ) |
| { |
| if( configure(mDeclaredPoint, *itWfO) ) |
| { |
| mDeclaredPointID.append( (*itWfO)->getNameID() ); |
| |
| if( mDeclaredPoint.size() != mDeclaredPointID.size() ) |
| { |
| AVM_OS_FATAL_ERROR_EXIT |
| << "TracePoint Declaration Error !!!" |
| << SEND_EXIT; |
| } |
| } |
| } |
| } |
| } |
| |
| WObject * theTRACE = Query::getRegexWSequence( |
| mParameterWObject, OR_WID2("trace", "TRACE")); |
| if( (theTRACE != WObject::_NULL_) && theTRACE->hasOwnedElement() ) |
| { |
| if( configure(theTRACE, aTraceExpression, anED) ) |
| { |
| //!! NOTHING |
| } |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configure(WObject * aTraceSequence, |
| BFCollection & tracePoints, const ExecutionData * anED) |
| { |
| if( aTraceSequence == WObject::_NULL_ ) |
| { |
| return( false ); |
| } |
| else if( aTraceSequence->hasnoOwnedElement() ) |
| { |
| return( true ); |
| } |
| |
| mED = anED; |
| |
| WObject::const_iterator itWfO = aTraceSequence->owned_begin(); |
| WObject::const_iterator endWfO = aTraceSequence->owned_end(); |
| for( ; itWfO != endWfO ; ++itWfO ) |
| { |
| if( (*itWfO)->isWProperty() ) |
| { |
| if( configure(tracePoints, *itWfO ) ) |
| { |
| //!! NOTHING |
| } |
| } |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configure(WObject * aTraceSequence, |
| TraceSequence & aTraceElement, const ExecutionData * anED) |
| { |
| if( aTraceSequence == NULL ) |
| { |
| return( false ); |
| } |
| else if( aTraceSequence->hasnoOwnedElement() ) |
| { |
| return( true ); |
| } |
| |
| mED = anED; |
| |
| WObject::const_iterator itWfO = aTraceSequence->owned_begin(); |
| WObject::const_iterator endWfO = aTraceSequence->owned_end(); |
| |
| if( (*itWfO)->isWProperty() ) |
| { |
| if( (*itWfO)->getNameID() == "combinator" ) |
| { |
| aTraceElement.combinator = OperatorManager::toOperator( |
| (*itWfO)->toStringValue(), |
| OperatorManager::OPERATOR_OR ); |
| |
| ++itWfO; |
| } |
| } |
| |
| for( ; itWfO != endWfO ; ++itWfO ) |
| { |
| if( (*itWfO)->isWProperty() ) |
| { |
| if( configure(aTraceElement.points, *itWfO ) ) |
| { |
| //!! NOTHING |
| } |
| } |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configure(WObject * aTraceSequence, |
| AvmCode * aTraceExpression, const ExecutionData * anED) |
| { |
| if( aTraceSequence == NULL ) |
| { |
| return( false ); |
| } |
| else if( aTraceSequence->hasnoOwnedElement() ) |
| { |
| return( true ); |
| } |
| |
| mED = anED; |
| |
| WObject::const_iterator itWfO = aTraceSequence->owned_begin(); |
| WObject::const_iterator endWfO = aTraceSequence->owned_end(); |
| |
| if( (*itWfO)->isWProperty() ) |
| { |
| if( (*itWfO)->getNameID() == "combinator" ) |
| { |
| // aTraceExpression->setOperator( OperatorManager::toOperator( |
| // wfProperty->toStringValue(), OperatorManager::OPERATOR_OR) ); |
| |
| AvmCode * subFTP = new AvmCode( OperatorManager::toOperator( |
| (*itWfO)->toStringValue(),OperatorManager::OPERATOR_OR) ); |
| aTraceExpression->append( BF(subFTP) ); |
| aTraceExpression = subFTP; |
| |
| ++itWfO; |
| } |
| } |
| |
| for( ; itWfO != endWfO ; ++itWfO ) |
| { |
| if( (*itWfO)->isWProperty() ) |
| { |
| if( (*itWfO)->getNameID() == "combinator" ) |
| { |
| AvmCode * subFTP = new AvmCode(OperatorManager::toOperator( |
| (*itWfO)->toStringValue(), |
| OperatorManager::OPERATOR_OR) ); |
| aTraceExpression->append( BF(subFTP) ); |
| aTraceExpression = subFTP; |
| } |
| |
| else if( configure(aTraceExpression->getArgs(), *itWfO) ) |
| { |
| //!! NOTHING |
| } |
| } |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configure( |
| BFCollection & tracePoints, WObject * wfProperty) |
| { |
| ENUM_TRACE_POINT::TRACE_NATURE nature = to_nature( wfProperty->getNameID() ); |
| |
| AVM_OPCODE opNature = to_op( wfProperty->getNameID() ); |
| |
| |
| if( (nature == ENUM_TRACE_POINT::TRACE_PATH_CONDITION_NATURE) |
| && (nature == ENUM_TRACE_POINT::TRACE_PATH_TIMED_CONDITION_NATURE) |
| && (nature == ENUM_TRACE_POINT::TRACE_NODE_CONDITION_NATURE) |
| && (nature == ENUM_TRACE_POINT::TRACE_NODE_TIMED_CONDITION_NATURE) |
| |
| && (nature == ENUM_TRACE_POINT::TRACE_PATH_CONDITION_NATURE_LEAF) |
| && (nature == ENUM_TRACE_POINT::TRACE_PATH_TIMED_CONDITION_NATURE_LEAF) |
| && (nature == ENUM_TRACE_POINT::TRACE_NODE_CONDITION_NATURE_LEAF) |
| && (nature == ENUM_TRACE_POINT::TRACE_NODE_TIMED_CONDITION_NATURE_LEAF) ) |
| { |
| bfTP = aTracePoint = new TracePoint(nature, AVM_OPCODE_SELECT); |
| |
| if( not configureNodePathCondition(tracePoints, wfProperty->getValue()) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure <Node Path Condition> with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| } |
| |
| else if( wfProperty->hasBuiltinArrayValue() ) |
| { |
| if( configureArray(tracePoints, wfProperty, |
| wfProperty->getBuiltinArrayValue(), nature, opNature) ) |
| { |
| //!! NOTHING |
| } |
| } |
| |
| else if( wfProperty->hasAvmCodeValue() ) |
| { |
| if( (nature == ENUM_TRACE_POINT::TRACE_FORMULA_NATURE) |
| || (nature == ENUM_TRACE_POINT::TRACE_CONDITION_NATURE) |
| || (nature == ENUM_TRACE_POINT::TRACE_DECISION_NATURE) ) |
| { |
| bfTP = aTracePoint = new TracePoint(nature, AVM_OPCODE_CHECK_SAT); |
| |
| if( not configureFormula(tracePoints, wfProperty->getValue()) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < Formula > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| } |
| else if( configureExpression(tracePoints, wfProperty, |
| wfProperty->getAvmCodeValue(), nature, opNature) ) |
| { |
| //!! NOTHING |
| } |
| } |
| |
| else |
| { |
| if( nature != ENUM_TRACE_POINT::TRACE_UNDEFINED_NATURE ) |
| { |
| if( configure(tracePoints, wfProperty, |
| nature, wfProperty->toStringValue()) ) |
| { |
| //!! NOTHING |
| } |
| } |
| else if( opNature != AVM_OPCODE_NULL ) |
| { |
| if( configure(tracePoints, wfProperty, |
| opNature, wfProperty->toStringValue()) ) |
| { |
| //!! NOTHING |
| } |
| } |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configure( |
| BFCollection & tracePoints, WObject * wfProperty, |
| ENUM_TRACE_POINT::TRACE_NATURE nature, const std::string & object) |
| { |
| switch( nature ) |
| { |
| case ENUM_TRACE_POINT::TRACE_COM_NATURE: |
| case ENUM_TRACE_POINT::TRACE_CHANNEL_NATURE: |
| case ENUM_TRACE_POINT::TRACE_MESSAGE_NATURE: |
| case ENUM_TRACE_POINT::TRACE_PORT_NATURE: |
| case ENUM_TRACE_POINT::TRACE_SIGNAL_NATURE: |
| { |
| bfTP = aTracePoint = new TracePoint(nature, AVM_OPCODE_NULL); |
| |
| if( not configurePort(tracePoints, object) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < Port > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| |
| break; |
| } |
| |
| case ENUM_TRACE_POINT::TRACE_TIME_NATURE: |
| { |
| bfTP = aTracePoint = new TracePoint(nature, AVM_OPCODE_ASSIGN); |
| |
| if( not configureTime(tracePoints, object) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < Time > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| |
| break; |
| } |
| |
| case ENUM_TRACE_POINT::TRACE_VARIABLE_NATURE: |
| { |
| bfTP = aTracePoint = new TracePoint(nature, AVM_OPCODE_ASSIGN); |
| |
| if( not configureVariable(tracePoints, object) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < Variable > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| |
| break; |
| } |
| |
| case ENUM_TRACE_POINT::TRACE_BUFFER_NATURE: |
| { |
| bfTP = aTracePoint = new TracePoint(nature, AVM_OPCODE_NULL); |
| |
| if( not configureBuffer(tracePoints, object) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < Buffer > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| |
| break; |
| } |
| |
| case ENUM_TRACE_POINT::TRACE_FORMULA_NATURE: |
| case ENUM_TRACE_POINT::TRACE_CONDITION_NATURE: |
| case ENUM_TRACE_POINT::TRACE_DECISION_NATURE: |
| { |
| bfTP = aTracePoint = new TracePoint(nature, AVM_OPCODE_CHECK_SAT); |
| |
| if( not configureFormula(tracePoints, wfProperty->getValue()) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < Formula > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| |
| break; |
| } |
| |
| case ENUM_TRACE_POINT::TRACE_PATH_CONDITION_NATURE: |
| case ENUM_TRACE_POINT::TRACE_NODE_CONDITION_NATURE: |
| case ENUM_TRACE_POINT::TRACE_PATH_TIMED_CONDITION_NATURE: |
| case ENUM_TRACE_POINT::TRACE_NODE_TIMED_CONDITION_NATURE: |
| |
| case ENUM_TRACE_POINT::TRACE_PATH_CONDITION_NATURE_LEAF: |
| case ENUM_TRACE_POINT::TRACE_NODE_CONDITION_NATURE_LEAF: |
| case ENUM_TRACE_POINT::TRACE_PATH_TIMED_CONDITION_NATURE_LEAF: |
| case ENUM_TRACE_POINT::TRACE_NODE_TIMED_CONDITION_NATURE_LEAF: |
| { |
| bfTP = aTracePoint = new TracePoint(nature, AVM_OPCODE_SELECT); |
| |
| if( not configureNodePathCondition(tracePoints, wfProperty->getValue()) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < Node Path Condition > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| |
| break; |
| } |
| |
| case ENUM_TRACE_POINT::TRACE_MACHINE_NATURE: |
| { |
| bfTP = aTracePoint = new TracePoint(nature, AVM_OPCODE_RUN); |
| |
| if( not configureMachine(tracePoints, object) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < Machine > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| |
| break; |
| } |
| |
| case ENUM_TRACE_POINT::TRACE_STATEMACHINE_NATURE: |
| { |
| bfTP = aTracePoint = new TracePoint(nature, AVM_OPCODE_NULL); |
| |
| if( not configureStatemachine(tracePoints, object) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < Statemachine > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| |
| break; |
| } |
| |
| case ENUM_TRACE_POINT::TRACE_STATE_NATURE: |
| { |
| bfTP = aTracePoint = new TracePoint(nature, |
| AVM_OPCODE_NULL /*AVM_OPCODE_ENABLE_SET*/); |
| |
| if( not configureState(tracePoints, object) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < State > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| |
| break; |
| } |
| |
| |
| case ENUM_TRACE_POINT::TRACE_TRANSITION_NATURE: |
| { |
| bfTP = aTracePoint = |
| new TracePoint(nature, AVM_OPCODE_INVOKE_TRANSITION); |
| |
| if( not configureTransition(tracePoints, object) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < Transition > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| |
| break; |
| } |
| |
| case ENUM_TRACE_POINT::TRACE_ROUTINE_NATURE: |
| { |
| bfTP = aTracePoint = new TracePoint(nature); |
| // new TracePoint(nature, AVM_OPCODE_INVOKE_ROUTINE); |
| |
| if( not configureRoutine(tracePoints, object) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < Routine > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| |
| break; |
| } |
| |
| case ENUM_TRACE_POINT::TRACE_RUNNABLE_NATURE: |
| { |
| bfTP = aTracePoint = new TracePoint(nature); |
| |
| if( not configureRunnable(tracePoints, object) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < Runnable > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| |
| break; |
| } |
| |
| case ENUM_TRACE_POINT::TRACE_COMPOSITE_NATURE: |
| { |
| bfTP = aTracePoint = new TracePoint(nature, AVM_OPCODE_NULL); |
| |
| if( not configureComposite(tracePoints, object) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < Composite > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| |
| break; |
| } |
| |
| default: |
| { |
| break; |
| } |
| } |
| |
| if( (mED != NULL) && (aTracePoint != NULL) ) |
| { |
| aTracePoint->updateRID( *mED ); |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configure( |
| BFCollection & tracePoints, WObject * wfProperty, |
| AVM_OPCODE opNature, const std::string & object) |
| { |
| switch( opNature ) |
| { |
| case AVM_OPCODE_INPUT: |
| case AVM_OPCODE_INPUT_ENV: |
| case AVM_OPCODE_OUTPUT: |
| case AVM_OPCODE_OUTPUT_ENV: |
| { |
| bfTP = aTracePoint = new TracePoint( |
| ENUM_TRACE_POINT::TRACE_COM_NATURE, opNature); |
| |
| if( not configurePort(tracePoints, object) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < Port > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| |
| break; |
| } |
| |
| case AVM_OPCODE_TIMED_GUARD: |
| { |
| break; |
| } |
| |
| case AVM_OPCODE_ASSIGN: |
| case AVM_OPCODE_ASSIGN_NEWFRESH: |
| { |
| bfTP = aTracePoint = new TracePoint( |
| ENUM_TRACE_POINT::TRACE_VARIABLE_NATURE, opNature); |
| |
| if( not configureVariable(tracePoints, object) ) |
| { |
| wfProperty->warningLocation(AVM_OS_WARN) |
| << "Failed to configure < Variable > with value: " |
| << wfProperty->toStringValue() << std::endl; |
| } |
| |
| break; |
| } |
| |
| default: |
| { |
| break; |
| } |
| } |
| |
| if( (mED != NULL) && (aTracePoint != NULL) ) |
| { |
| aTracePoint->updateRID( *mED ); |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configureArray(BFCollection & tracePoints, |
| WObject * wfProperty, BuiltinArray * anArray, |
| ENUM_TRACE_POINT::TRACE_NATURE nature, AVM_OPCODE opNature) |
| { |
| BFVector tpArray; |
| |
| for( avm_size_t offset = 0 ; offset < anArray->size() ; ++offset ) |
| { |
| if( nature != ENUM_TRACE_POINT::TRACE_UNDEFINED_NATURE ) |
| { |
| if( configure(tpArray, wfProperty, nature, |
| wfProperty->toStringValue(anArray, offset)) ) |
| { |
| //!! NOTHING |
| } |
| } |
| else if( opNature != AVM_OPCODE_NULL ) |
| { |
| if( configure(tpArray, wfProperty, opNature, |
| wfProperty->toStringValue(anArray, offset)) ) |
| { |
| //!! NOTHING |
| } |
| } |
| } |
| |
| if( tpArray.singleton() ) |
| { |
| tracePoints.append( tpArray[0] ); |
| } |
| else if( tpArray.populated() ) |
| { |
| bfTP = aTracePoint = new TracePoint( |
| ENUM_TRACE_POINT::TRACE_COMPOSITE_NATURE, AVM_OPCODE_AND); |
| aTracePoint->tpid = ++TP_ID; |
| aTracePoint->value = BF( new ArrayBF(tpArray) ); |
| |
| tracePoints.append( bfTP ); |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configureExpression(BFCollection & tracePoints, |
| WObject * wfProperty, AvmCode * aCode, |
| ENUM_TRACE_POINT::TRACE_NATURE nature, AVM_OPCODE opNature) |
| { |
| BFVector tpArray; |
| |
| AvmCode::const_iterator itArg = aCode->begin(); |
| AvmCode::const_iterator endArg = aCode->end(); |
| for( ; itArg != endArg ; ++itArg ) |
| { |
| if( (*itArg).is< AvmCode >() ) |
| { |
| if( configureExpression(tpArray, wfProperty, |
| (*itArg).to_ptr< AvmCode >(), nature, opNature) ) |
| { |
| //!! NOTHING |
| } |
| } |
| else if( nature != ENUM_TRACE_POINT::TRACE_UNDEFINED_NATURE ) |
| { |
| if( configure(tpArray, wfProperty, |
| nature, wfProperty->toStringValue(*itArg)) ) |
| { |
| //!! NOTHING |
| } |
| } |
| else if( opNature != AVM_OPCODE_NULL ) |
| { |
| if( configure(tpArray, wfProperty, |
| opNature, wfProperty->toStringValue(*itArg)) ) |
| { |
| //!! NOTHING |
| } |
| } |
| } |
| |
| if( tpArray.singleton() ) |
| { |
| tracePoints.append( tpArray[0] ); |
| } |
| else if( tpArray.populated() ) |
| { |
| bfTP = aTracePoint = new TracePoint( |
| ENUM_TRACE_POINT::TRACE_COMPOSITE_NATURE, |
| aCode->getAvmOpCode()); |
| aTracePoint->tpid = ++TP_ID; |
| aTracePoint->value = BF( new ArrayBF(tpArray) ); |
| |
| tracePoints.append( bfTP ); |
| } |
| |
| return( true ); |
| } |
| |
| |
| |
| bool TraceFactory::configureComposite( |
| BFCollection & tracePoints, const std::string & object) |
| { |
| for( avm_size_t offset = 0 ; offset < mDeclaredPoint.size() ; ++offset ) |
| { |
| if( mDeclaredPointID[offset] == object ) |
| { |
| tracePoints.append( mDeclaredPoint[offset] ); |
| |
| // if break: append first else: any Point with this ID |
| // break; |
| } |
| } |
| |
| return( true ); |
| } |
| |
| |
| |
| bool TraceFactory::configurePort( |
| BFCollection & tracePoints, const std::string & object) |
| { |
| otherTracePoint.clear(); |
| |
| if( aTracePoint->configurePort(mConfiguration, object, otherTracePoint) ) |
| { |
| aTracePoint->tpid = ++TP_ID; |
| |
| listOfPortTracePoint.append( aTracePoint ); |
| listOfPortTracePoint.append( otherTracePoint ); |
| |
| tracePoints.append( bfTP ); |
| while( otherTracePoint.nonempty() ) |
| { |
| otherTracePoint.front()->tpid = ++TP_ID; |
| |
| tracePoints.append( BF(otherTracePoint.front()) ); |
| otherTracePoint.pop_front(); |
| } |
| } |
| else |
| { |
| return( false ); |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configureTime( |
| BFCollection & tracePoints, const std::string & object) |
| { |
| if( NamedElement::fqnStartsWith(object, "time" ) || |
| NamedElement::fqnStartsWith(object, "$time") || |
| NamedElement::fqnStartsWith(object, "#time") ) |
| { |
| aTracePoint->tpid = ++TP_ID; |
| aTracePoint->op = AVM_OPCODE_TIMED_GUARD; |
| aTracePoint->object = mVarTime; |
| |
| tracePoints.append( bfTP ); |
| } |
| else if( aTracePoint->configureVariable(mConfiguration, object) ) |
| { |
| aTracePoint->tpid = ++TP_ID; |
| aTracePoint->op = AVM_OPCODE_TIMED_GUARD; |
| mVarTime = aTracePoint->object->to< InstanceOfData >(); |
| |
| listOfVariableTracePoint.append( aTracePoint ); |
| |
| tracePoints.append( bfTP ); |
| } |
| else |
| { |
| return( false ); |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configureVariable( |
| BFCollection & tracePoints, const std::string & object) |
| { |
| if( NamedElement::fqnStartsWith(object, "time" ) || |
| NamedElement::fqnStartsWith(object, "$time") || |
| NamedElement::fqnStartsWith(object, "#time") ) |
| { |
| aTracePoint->tpid = ++TP_ID; |
| aTracePoint->nature = ENUM_TRACE_POINT::TRACE_TIME_NATURE; |
| aTracePoint->op = AVM_OPCODE_TIMED_GUARD; |
| aTracePoint->object = mVarTime; |
| |
| tracePoints.append( bfTP ); |
| } |
| else if( aTracePoint->configureVariable(mConfiguration, object) ) |
| { |
| aTracePoint->tpid = ++TP_ID; |
| |
| listOfVariableTracePoint.append( aTracePoint ); |
| |
| tracePoints.append( bfTP ); |
| } |
| else |
| { |
| return( false ); |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configureBuffer( |
| BFCollection & tracePoints, const std::string & object) |
| { |
| if( aTracePoint->configureBuffer(mConfiguration, object) ) |
| { |
| aTracePoint->tpid = ++TP_ID; |
| tracePoints.append( bfTP ); |
| } |
| else |
| { |
| return( false ); |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configureFormula( |
| BFCollection & tracePoints, const BF & object) |
| { |
| aTracePoint->tpid = ++TP_ID; |
| |
| // aTracePoint->value = ENV.getBuilder().compileExpression( |
| // mConfiguration.getExecutableSystem() |
| // .getSystemInstance().getExecutable(), object); |
| |
| ENV.getBuilder().resetErrorWarning(); |
| |
| aTracePoint->value = ENV.getBuilder(). |
| compileExpression(mLocalExecutableForm, object); |
| |
| if( not ENV.getBuilder().hasError() ) |
| { |
| tracePoints.append( bfTP ); |
| } |
| |
| return( true ); |
| } |
| |
| |
| #define LEAF_NODE_REGEX_PATTERN "\\S?(leaf|end|last|tail)\\S?" |
| |
| #define LEAF_NODE_DEFAULT_PATTERN ":leaf:" |
| |
| bool TraceFactory::configureNodePathCondition( |
| BFCollection & tracePoints, const BF & object) |
| { |
| if( REGEX_MATCH( object.toBuiltinString() , LEAF_NODE_REGEX_PATTERN ) ) |
| { |
| switch( aTracePoint->nature ) |
| { |
| case ENUM_TRACE_POINT::TRACE_PATH_CONDITION_NATURE: |
| { |
| aTracePoint->nature = |
| ENUM_TRACE_POINT::TRACE_PATH_CONDITION_NATURE_LEAF; |
| break; |
| } |
| case ENUM_TRACE_POINT::TRACE_NODE_CONDITION_NATURE: |
| { |
| aTracePoint->nature = |
| ENUM_TRACE_POINT::TRACE_NODE_CONDITION_NATURE_LEAF; |
| break; |
| } |
| case ENUM_TRACE_POINT::TRACE_PATH_TIMED_CONDITION_NATURE: |
| { |
| aTracePoint->nature = |
| ENUM_TRACE_POINT::TRACE_PATH_TIMED_CONDITION_NATURE_LEAF; |
| break; |
| } |
| case ENUM_TRACE_POINT::TRACE_NODE_TIMED_CONDITION_NATURE: |
| { |
| aTracePoint->nature = |
| ENUM_TRACE_POINT::TRACE_NODE_TIMED_CONDITION_NATURE_LEAF; |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| aTracePoint->any_object = true; |
| } |
| |
| else if( object.toBuiltinString() == "[*]" ) |
| { |
| aTracePoint->any_object = true; |
| } |
| else |
| { |
| aTracePoint->value = object; |
| } |
| |
| aTracePoint->tpid = ++TP_ID; |
| tracePoints.append( bfTP ); |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configureMachine( |
| BFCollection & tracePoints, const std::string & object) |
| { |
| if( aTracePoint->configureMachine(mConfiguration, object) ) |
| { |
| aTracePoint->tpid = ++TP_ID; |
| tracePoints.append( bfTP ); |
| } |
| else |
| { |
| return( false ); |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configureState( |
| BFCollection & tracePoints, const std::string & object) |
| { |
| if( aTracePoint->configureMachine(mConfiguration, object) ) |
| { |
| aTracePoint->tpid = ++TP_ID; |
| tracePoints.append( bfTP ); |
| } |
| else |
| { |
| return( false ); |
| } |
| |
| return( true ); |
| } |
| |
| bool TraceFactory::configureStatemachine( |
| BFCollection & tracePoints, const std::string & object) |
| { |
| if( aTracePoint->configureMachine(mConfiguration, object) ) |
| { |
| aTracePoint->tpid = ++TP_ID; |
| tracePoints.append( bfTP ); |
| } |
| else |
| { |
| return( false ); |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configureTransition( |
| BFCollection & tracePoints, const std::string & object) |
| { |
| if( aTracePoint->configureTransition(mConfiguration, object) ) |
| { |
| aTracePoint->tpid = ++TP_ID; |
| tracePoints.append( bfTP ); |
| } |
| else |
| { |
| return( false ); |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configureRoutine( |
| BFCollection & tracePoints, const std::string & object) |
| { |
| if( aTracePoint->configureRoutine(mConfiguration, object) ) |
| { |
| aTracePoint->tpid = ++TP_ID; |
| tracePoints.append( bfTP ); |
| } |
| else |
| { |
| return( false ); |
| } |
| |
| return( true ); |
| } |
| |
| |
| bool TraceFactory::configureRunnable( |
| BFCollection & tracePoints, const std::string & object) |
| { |
| if( aTracePoint->configureRunnable(mConfiguration, object) ) |
| { |
| aTracePoint->tpid = ++TP_ID; |
| tracePoints.append( bfTP ); |
| } |
| else |
| { |
| return( false ); |
| } |
| |
| return( true ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // BASIC PARSER API |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| /* |
| * Exemple de trace basique |
| 1 |
| TSI_target?1 |
| 120 |
| RSD_ENABLED_source!1 |
| 0 |
| PSD_ENABLED_source!1 |
| 423385 |
| RSD_CMD_source!1 |
| 0 |
| PSD_STATE1_target?0 |
| 3025646 |
| DEP_AUTH1_source!1 |
| 1059822 |
| TSI1_target?0 |
| */ |
| |
| bool TraceFactory::parseBasicTrace(TraceSequence & aTraceElement, |
| std::ifstream & inFile, const BF & aVarTime) |
| { |
| |
| BasicTraceParser aParser( mConfiguration ); |
| |
| return( aParser.parseBasicTrace(aTraceElement, inFile, aVarTime) ); |
| } |
| |
| bool TraceFactory::parseBasicXliaTrace(TraceSequence & aTraceElement, |
| std::ifstream & inFile, const BF & aVarTime) |
| { |
| |
| BasicTraceParser aParser( mConfiguration ); |
| |
| return( aParser.parseBasicXliaTrace(aTraceElement, inFile, aVarTime) ); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // OTHER API |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| bool TraceFactory::appendTransitionPoint(const Configuration & aConfiguration, |
| TraceSequence & aTraceElement, const std::string & aTransitionUfid) |
| { |
| ExecutableQuery XQuery( aConfiguration ); |
| |
| const BF & foundTransition = |
| XQuery.getTransitionByQualifiedNameID(aTransitionUfid); |
| |
| if( foundTransition.valid() ) |
| { |
| BF newTransitionPoint( new TracePoint( |
| ENUM_TRACE_POINT::TRACE_TRANSITION_NATURE, |
| AVM_OPCODE_INVOKE_TRANSITION, NULL, |
| foundTransition.to_ptr< AvmTransition>()) ); |
| |
| aTraceElement.points.append( newTransitionPoint ); |
| |
| return( true ); |
| } |
| |
| return( false ); |
| } |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // SERIALIZATION API |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| void TraceFactory::toStream(OutStream & os, ListOfTracePoint & listofTracePoint) const |
| { |
| ListOfTracePoint::iterator itPoint = listofTracePoint.begin(); |
| ListOfTracePoint::iterator endPoint = listofTracePoint.end(); |
| for( ; itPoint != endPoint ; ++itPoint ) |
| { |
| (*itPoint)->toStream(os); |
| } |
| } |
| |
| |
| |
| } /* namespace sep */ |
