| /******************************************************************************* |
| * 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: 9 juil. 2009 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| |
| #include "SolverFactory.h" |
| |
| #include <common/BF.h> |
| |
| #include <computer/EvaluationEnvironment.h> |
| |
| #include <fml/executable/ExecutableLib.h> |
| |
| #include <fml/expression/ExpressionFactory.h> |
| #include <fml/expression/ExpressionConstant.h> |
| #include <fml/expression/ExpressionConstructor.h> |
| |
| #include <fml/runtime/ExecutionContext.h> |
| #include <fml/runtime/ExecutionData.h> |
| #include <fml/runtime/RuntimeLib.h> |
| |
| #include <fml/type/EnumTypeSpecifier.h> |
| #include <fml/type/IntervalTypeSpecifier.h> |
| |
| |
| #include <solver/api/SatSolver.h> |
| #include <solver/api/SolverDef.h> |
| |
| #include <solver/CVC4Solver.h> |
| #include <solver/Z3Solver.h> |
| |
| #if defined( _AVM_SOLVER_YICES_V2_ ) |
| #include <compat/solver/Yices2Solver.h> |
| #endif /* _AVM_SOLVER_YICES_V2_ */ |
| |
| // Mandatory after other Solver for compilation FIX |
| #include <solver/OmegaSolver.h> |
| |
| |
| namespace sep |
| { |
| |
| |
| SatSolver * SolverFactory::theDefaultSolver4CheckSatisfiability = NULL; |
| SatSolver * SolverFactory::theDefaultSolver4ModelsProduction = NULL; |
| |
| BFVector SolverFactory::thePCParameters; |
| BFVector SolverFactory::thePCParameterValues; |
| |
| APExecutionData SolverFactory::theSymbolicED; |
| |
| |
| /** |
| * LOADER |
| */ |
| void SolverFactory::load() |
| { |
| switch( SolverDef::DEFAULT_SOLVER_KIND ) |
| { |
| #if defined( _AVM_SOLVER_CVC4_ ) |
| case SolverDef::SOLVER_CVC4_KIND: |
| { |
| theDefaultSolver4CheckSatisfiability = new CVC4Solver(); |
| |
| theDefaultSolver4ModelsProduction = |
| new CVC4Solver(true /*to set option << produce-models >>*/); |
| break; |
| } |
| #endif /* _AVM_SOLVER_CVC4_ */ |
| |
| |
| #if defined( _AVM_SOLVER_Z3_ ) |
| case SolverDef::SOLVER_Z3_KIND: |
| { |
| theDefaultSolver4CheckSatisfiability = new Z3Solver(); |
| theDefaultSolver4ModelsProduction = new Z3Solver(); |
| break; |
| } |
| #endif /* _AVM_SOLVER_Z3_ */ |
| |
| |
| #if defined( _AVM_SOLVER_YICES_V2_ ) |
| case SolverDef::SOLVER_YICES2_KIND: |
| { |
| theDefaultSolver4CheckSatisfiability = new Yices2Solver(); |
| theDefaultSolver4ModelsProduction = new Yices2Solver(); |
| break; |
| } |
| #endif /* _AVM_SOLVER_YICES_V2_ */ |
| |
| |
| #if defined( _AVM_SOLVER_OMEGA_ ) |
| case SolverDef::SOLVER_OMEGA_KIND: |
| { |
| theDefaultSolver4CheckSatisfiability = new OmegaSolver(); |
| theDefaultSolver4ModelsProduction = new OmegaSolver(); |
| break; |
| } |
| #endif /* _AVM_SOLVER_OMEGA_ */ |
| |
| |
| case SolverDef::SOLVER_UNDEFINED_KIND: |
| default: |
| { |
| #if defined( _AVM_SOLVER_CVC4_ ) |
| |
| theDefaultSolver4CheckSatisfiability = new CVC4Solver(); |
| |
| theDefaultSolver4ModelsProduction = |
| new CVC4Solver(true /*to set option << produce-models >>*/); |
| |
| #else |
| |
| theDefaultSolver4CheckSatisfiability = NULL; |
| theDefaultSolver4ModelsProduction = NULL; |
| |
| #endif /* _AVM_SOLVER_CVCx_ */ |
| |
| break; |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // CACHE FOR MEMORY ALLOCATION OPTIMIZATION FOR SOLVER CALCULUS |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| #if defined( _AVM_SOLVER_CVC4_ ) |
| |
| CVC4Solver::initCache(); |
| |
| #endif /* _AVM_SOLVER_CVC4_ */ |
| |
| |
| #if defined( _AVM_SOLVER_Z3_ ) |
| |
| Z3Solver::initCache(); |
| |
| #endif /* _AVM_SOLVER_Z3_ */ |
| |
| |
| #if defined( _AVM_SOLVER_YICES_V2_ ) |
| |
| Yices2Solver::initCache(); |
| |
| #endif /* _AVM_SOLVER_YICES_V2_ */ |
| } |
| |
| |
| /** |
| * DISPOSER |
| */ |
| void SolverFactory::dispose() |
| { |
| delete( theDefaultSolver4CheckSatisfiability ); |
| delete( theDefaultSolver4ModelsProduction ); |
| |
| #if defined( _AVM_SOLVER_CVC4_ ) |
| |
| CVC4Solver::finalizeCache(); |
| |
| #endif /* _AVM_SOLVER_CVC4_ */ |
| |
| |
| #if defined( _AVM_SOLVER_Z3_ ) |
| |
| Z3Solver::finalizeCache(); |
| |
| #endif /* _AVM_SOLVER_Z3_ */ |
| |
| |
| #if defined( _AVM_SOLVER_YICES_V2_ ) |
| |
| Yices2Solver::finalizeCache(); |
| |
| #endif /* _AVM_SOLVER_YICES_V2_ */ |
| } |
| |
| |
| SolverDef::SATISFIABILITY_RING SolverFactory::isSatisfiable( |
| SolverDef::SOLVER_KIND aSolverKind, const BF & aCondition) |
| { |
| if( aCondition.isEqualTrue() ) |
| { |
| return( SolverDef::SATISFIABLE ); |
| } |
| else if( aCondition.isEqualFalse() ) |
| { |
| return( SolverDef::UNSATISFIABLE ); |
| } |
| |
| switch( aSolverKind ) |
| { |
| #if defined( _AVM_SOLVER_CVC4_ ) |
| case SolverDef::SOLVER_CVC4_KIND: |
| case SolverDef::SOLVER_CVC4_BV32_KIND: |
| case SolverDef::SOLVER_CVC_KIND: |
| { |
| CVC4Solver solver; |
| |
| return( solver.isSatisfiable( aCondition ) ); |
| } |
| #endif /* _AVM_SOLVER_CVC4_ */ |
| |
| |
| #if defined( _AVM_SOLVER_Z3_ ) |
| case SolverDef::SOLVER_Z3_KIND: |
| { |
| Z3Solver solver; |
| |
| return( solver.isSatisfiable( aCondition ) ); |
| } |
| #endif /* _AVM_SOLVER_Z3_ */ |
| |
| |
| #if defined( _AVM_SOLVER_YICES_V2_ ) |
| case SolverDef::SOLVER_YICES2_KIND: |
| case SolverDef::SOLVER_YICES_KIND: |
| { |
| Yices2Solver solver; |
| |
| return( solver.isSatisfiable( aCondition ) ); |
| } |
| #endif /* _AVM_SOLVER_YICES_V2_ */ |
| |
| |
| #if defined( _AVM_SOLVER_OMEGA_ ) |
| case SolverDef::SOLVER_OMEGA_KIND: |
| { |
| OmegaSolver solver; |
| |
| return( solver.isSatisfiable( aCondition ) ); |
| } |
| #endif /* _AVM_SOLVER_OMEGA_ */ |
| |
| default: |
| { |
| AVM_OS_WARNING_ALERT |
| << "SolverFactory::isSatisfiable:> Unknown solver << " |
| << SolverDef::strSolver( aSolverKind ) |
| << " >> in this executable !!!" |
| << SEND_ALERT; |
| |
| return( SolverDef::UNKNOWN_SAT ); |
| } |
| } |
| |
| return( SolverDef::UNKNOWN_SAT ); |
| } |
| |
| |
| /** |
| * DESTROY |
| */ |
| void SolverFactory::destroy(SatSolver * aSolver) |
| { |
| if( (aSolver != NULL) |
| && (aSolver != SolverFactory::theDefaultSolver4CheckSatisfiability) |
| && (aSolver != SolverFactory::theDefaultSolver4ModelsProduction) ) |
| { |
| delete( aSolver ); |
| } |
| } |
| |
| SolverDef::SATISFIABILITY_RING SolverFactory::isSatisfiable( |
| const BF & aCondition, bool useDefaultSolver) |
| { |
| if( aCondition.isEqualTrue() ) |
| { |
| return( SolverDef::SATISFIABLE ); |
| } |
| else if( aCondition.isEqualFalse() ) |
| { |
| return( SolverDef::UNSATISFIABLE ); |
| } |
| else if( useDefaultSolver ) |
| { |
| return( SolverFactory::isSatisfiable( |
| SolverDef::DEFAULT_SOLVER_KIND, aCondition) ); |
| } |
| |
| return( SolverDef::UNKNOWN_SAT ); |
| } |
| |
| |
| |
| /** |
| * USED BY FAM LtlProverFilter |
| */ |
| bool SolverFactory::isEmptyIntersection(ListOfInstanceOfData aListOfVarParam, |
| const ExecutionContext & aMainEC, const ExecutionContext & aComparEC) |
| { |
| #if defined( _AVM_SOLVER_OMEGA_ ) |
| |
| OmegaSolver theSolver; |
| |
| theSolver.setSelectedVariable(aMainEC.refExecutionData(), aListOfVarParam); |
| |
| return( theSolver.isEmptyIntersection( aMainEC , aComparEC ) ); |
| |
| #else |
| |
| return( false ); |
| |
| #endif /* _AVM_SOLVER_OMEGA_ */ |
| } |
| |
| bool SolverFactory::isSubSet( |
| const ExecutionContext & aMainEC, const ExecutionContext & aComparEC) |
| { |
| #if defined( _AVM_SOLVER_OMEGA_ ) |
| |
| OmegaSolver theSolver; |
| |
| theSolver.setSelectedVariable( aMainEC.refExecutionData() ); |
| |
| return( theSolver.isSubSet( aMainEC , aComparEC) ); |
| |
| #else |
| |
| return( false ); |
| |
| #endif /* _AVM_SOLVER_OMEGA_ */ |
| } |
| |
| |
| /** |
| * SOLVER |
| */ |
| |
| SatSolver * SolverFactory::newSolver4CheckSatisfiability( |
| SolverDef::SOLVER_KIND aSolverKind) |
| { |
| switch( aSolverKind ) |
| { |
| #if defined( _AVM_SOLVER_CVC4_ ) |
| case SolverDef::SOLVER_CVC4_KIND: |
| case SolverDef::SOLVER_CVC_KIND: |
| { |
| return( new CVC4Solver() ); |
| } |
| #endif /* _AVM_SOLVER_CVC4_ */ |
| |
| |
| #if defined( _AVM_SOLVER_Z3_ ) |
| case SolverDef::SOLVER_Z3_KIND: |
| { |
| return( new Z3Solver() ); |
| } |
| #endif /* _AVM_SOLVER_Z3_ */ |
| |
| |
| #if defined( _AVM_SOLVER_YICES_V2_ ) |
| case SolverDef::SOLVER_YICES2_KIND: |
| case SolverDef::SOLVER_YICES_KIND: |
| { |
| return( new Yices2Solver() ); |
| } |
| #endif /* _AVM_SOLVER_YICES_V2_ */ |
| |
| |
| #if defined( _AVM_SOLVER_OMEGA_ ) |
| case SolverDef::SOLVER_OMEGA_KIND: |
| { |
| return( new OmegaSolver() ); |
| } |
| #endif /* _AVM_SOLVER_OMEGA_ */ |
| |
| default: |
| { |
| AVM_OS_ASSERT_FATAL_ERROR_EXIT( theDefaultSolver4CheckSatisfiability == NULL ) |
| << "SolverFactory::newSolver4CheckSatisfiability:> Unknown solver << " |
| << SolverDef::strSolver( aSolverKind ) |
| << " >> in this executable and there are no default alternative solver!!!" |
| << SEND_ALERT; |
| |
| SolverDef::toStreamSolverList(AVM_OS_COUT, "Available solver"); |
| |
| return( theDefaultSolver4CheckSatisfiability ); |
| } |
| } |
| } |
| |
| |
| SatSolver * SolverFactory::newSolver4ModelsProduction( |
| SolverDef::SOLVER_KIND aSolverKind) |
| { |
| switch( aSolverKind ) |
| { |
| #if defined( _AVM_SOLVER_CVC4_ ) |
| case SolverDef::SOLVER_CVC4_KIND: |
| case SolverDef::SOLVER_CVC_KIND: |
| { |
| return( new CVC4Solver(true/*produce-models*/) ); |
| } |
| #endif /* _AVM_SOLVER_CVC4_ */ |
| |
| |
| #if defined( _AVM_SOLVER_Z3_ ) |
| case SolverDef::SOLVER_Z3_KIND: |
| { |
| return( new Z3Solver() ); |
| } |
| #endif /* _AVM_SOLVER_Z3_ */ |
| |
| |
| #if defined( _AVM_SOLVER_YICES_V2_ ) |
| case SolverDef::SOLVER_YICES2_KIND: |
| case SolverDef::SOLVER_YICES_KIND: |
| { |
| return( new Yices2Solver() ); |
| } |
| #endif /* _AVM_SOLVER_YICES_V2_ */ |
| |
| |
| #if defined( _AVM_SOLVER_OMEGA_ ) |
| case SolverDef::SOLVER_OMEGA_KIND: |
| { |
| return( new OmegaSolver() ); |
| } |
| #endif /* _AVM_SOLVER_OMEGA_ */ |
| |
| default: |
| { |
| AVM_OS_ASSERT_FATAL_ERROR_EXIT( theDefaultSolver4ModelsProduction == NULL ) |
| << "SolverFactory::newSolver4ModelsProduction:> Unknown solver << " |
| << SolverDef::strSolver( aSolverKind ) |
| << " >> in this executable and and there are no default alternative solver !" |
| << SEND_ALERT; |
| |
| return( theDefaultSolver4ModelsProduction ); |
| } |
| } |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // CONDITION PARAMETER SOLVING |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| bool SolverFactory::solve(SolverDef::SOLVER_KIND aSolverKind, |
| const BF & aCondition, BFVector & dataVector, BFVector & valuesVector) |
| { |
| switch( aSolverKind ) |
| { |
| #if defined( _AVM_SOLVER_CVC4_ ) |
| case SolverDef::SOLVER_CVC4_KIND: |
| case SolverDef::SOLVER_CVC_KIND: |
| { |
| CVC4Solver solver(true /*to set option << produce-models >>*/); |
| |
| return( solver.solve( aCondition, dataVector, valuesVector ) ); |
| } |
| #endif /* _AVM_SOLVER_CVC4_ */ |
| |
| |
| #if defined( _AVM_SOLVER_Z3_ ) |
| case SolverDef::SOLVER_Z3_KIND: |
| { |
| Z3Solver solver; |
| return( solver.solve( aCondition, dataVector, valuesVector ) ); |
| } |
| #endif /* _AVM_SOLVER_Z3_ */ |
| |
| |
| #if defined( _AVM_SOLVER_YICES_V2_ ) |
| case SolverDef::SOLVER_YICES2_KIND: |
| case SolverDef::SOLVER_YICES_KIND: |
| { |
| Yices2Solver solver; |
| |
| return( solver.solve( aCondition, dataVector, valuesVector ) ); |
| } |
| #endif /* _AVM_SOLVER_YICES_V2_ */ |
| |
| |
| #if defined( _AVM_SOLVER_OMEGA_ ) |
| case SolverDef::SOLVER_OMEGA_KIND: |
| { |
| OmegaSolver solver; |
| |
| return( solver.solve( aCondition, dataVector, valuesVector ) ); |
| } |
| #endif /* _AVM_SOLVER_OMEGA_ */ |
| |
| default: |
| { |
| AVM_OS_WARNING_ALERT |
| << "SolverFactory::solve:> Unknown solver << " |
| << SolverDef::strSolver( aSolverKind ) |
| << " >> in this executable !!!" |
| << SEND_ALERT; |
| |
| return( false ); |
| } |
| } |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // EXECUTION CONTEXT SOLVING |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| APExecutionData SolverFactory::solve(SolverDef::SOLVER_KIND aSolverKind, |
| EvaluationEnvironment & ENV, const ExecutionContext & anEC, |
| const BF & aCondition) |
| { |
| switch( aSolverKind ) |
| { |
| #if defined( _AVM_SOLVER_CVC4_ ) |
| case SolverDef::SOLVER_CVC4_KIND: |
| case SolverDef::SOLVER_CVC_KIND: |
| { |
| CVC4Solver aSolver(true /*to set option << produce-models >>*/); |
| |
| return( SolverFactory::solve(aSolver, ENV, anEC, aCondition) ); |
| } |
| #endif /* _AVM_SOLVER_CVC4_ */ |
| |
| |
| #if defined( _AVM_SOLVER_Z3_ ) |
| case SolverDef::SOLVER_Z3_KIND: |
| { |
| Z3Solver aSolver; |
| |
| return( SolverFactory::solve(aSolver, ENV, anEC, aCondition) ); |
| } |
| #endif /* _AVM_SOLVER_Z3_ */ |
| |
| |
| #if defined( _AVM_SOLVER_YICES_V2_ ) |
| case SolverDef::SOLVER_YICES2_KIND: |
| case SolverDef::SOLVER_YICES_KIND: |
| { |
| Yices2Solver aSolver; |
| |
| return( SolverFactory::solve(aSolver, ENV, anEC, aCondition) ); |
| } |
| #endif /* _AVM_SOLVER_YICES_V2_ */ |
| |
| |
| #if defined( _AVM_SOLVER_OMEGA_ ) |
| case SolverDef::SOLVER_OMEGA_KIND: |
| { |
| OmegaSolver aSolver; |
| |
| return( SolverFactory::solve(aSolver, ENV, anEC, aCondition) ); |
| } |
| #endif /* _AVM_SOLVER_OMEGA_ */ |
| |
| |
| default: |
| { |
| AVM_OS_ASSERT_FATAL_ERROR_EXIT( theDefaultSolver4ModelsProduction == NULL ) |
| << "SolverFactory::solve:> Unknown solver << " |
| << SolverDef::strSolver( aSolverKind ) |
| << " >> in this executable and and there are no default alternative solver !" |
| << SEND_ALERT; |
| |
| return( SolverFactory::solve( |
| (*theDefaultSolver4ModelsProduction), ENV, anEC, aCondition) ); |
| } |
| } |
| } |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // EXECUTION DATA SOLVING |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| bool SolverFactory::solve(SatSolver & aSolver, EvaluationEnvironment & ENV, |
| APExecutionData & anED, const BF & aCondition) |
| { |
| thePCParameters.clear(); |
| thePCParameterValues.clear(); |
| |
| // On numérise le PC |
| |
| // On crée un ED avec des valeurs numériques |
| if( aSolver.solve( aCondition, thePCParameters, thePCParameterValues ) ) |
| { |
| if( thePCParameterValues.nonempty() ) |
| { |
| setRuntimeParametersSolvingValues(anED); |
| |
| ExecutableForm * exec = NULL; |
| TableOfInstanceOfData::const_raw_iterator itData; |
| TableOfInstanceOfData::const_raw_iterator endData; |
| |
| TableOfRuntimeT:: |
| const_iterator itRF = anED->getTableOfRuntime().begin(); |
| TableOfRuntimeT:: |
| const_iterator endRF = anED->getTableOfRuntime().end(); |
| for( RuntimeID itRID ; itRF != endRF ; ++itRF) |
| { |
| itRID = (*itRF)->getRID(); |
| |
| exec = itRID.getExecutable(); |
| if( exec->hasBasicData() ) |
| { |
| itData = exec->getBasicData().begin(); |
| endData = exec->getBasicData().end(); |
| for( ; itData != endData ; ++itData) |
| { |
| const BF & rvalue = ENV.getRvalue(anED, itRID, (itData)); |
| |
| updateRuntimeParametersValues(rvalue); |
| |
| if( ENV.eval(theSymbolicED, |
| theSymbolicED->getParametersRID(), rvalue) ) |
| { |
| ENV.setRvalue(anED, itRID, (itData), ENV.outVAL); |
| } |
| else |
| { |
| finalizeRuntimeParameters(); |
| return( false ); |
| } |
| } |
| } |
| } |
| |
| finalizeRuntimeParameters(); |
| } |
| thePCParameters.clear(); |
| thePCParameterValues.clear(); |
| |
| return( true ); |
| } |
| else |
| { |
| thePCParameters.clear(); |
| thePCParameterValues.clear(); |
| |
| return( false ); |
| } |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // EXECUTION CONTEXT PARAMETERS NUMERIZATION |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| bool SolverFactory::solveParameters(APExecutionData & anED, const BF & aCondition) |
| { |
| if( aCondition.isEqualTrue() ) |
| { |
| return( false ); |
| } |
| |
| thePCParameters.clear(); |
| thePCParameterValues.clear(); |
| |
| if( theDefaultSolver4ModelsProduction->solve( |
| aCondition, thePCParameters, thePCParameterValues) ) |
| { |
| ParametersRuntimeForm & paramsRF = anED.getWritableParametersRuntimeForm(); |
| APTableOfData & aDataTable = paramsRF.getWritableDataTable(); |
| |
| BFVector::raw_iterator< InstanceOfData > itParam = thePCParameters.begin(); |
| BFVector::raw_iterator< InstanceOfData > endParam = thePCParameters.end(); |
| for( std::size_t offset = 0 ; itParam != endParam ; ++itParam , ++offset ) |
| { |
| aDataTable->set( (itParam), thePCParameterValues[offset] ); |
| } |
| |
| return( true ); |
| } |
| |
| return( false ); |
| } |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Pour pouvoir reutiliser tout l'outillage de Diverity |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| void SolverFactory::setModel(EvaluationEnvironment & ENV, APExecutionData & anED) |
| { |
| ParametersRuntimeForm & paramsRF = anED.getWritableParametersRuntimeForm(); |
| |
| BaseTypeSpecifier * paramType = NULL; |
| BF value; |
| TableOfInstanceOfData::const_raw_iterator itParam = |
| paramsRF.getParameters().begin(); |
| TableOfInstanceOfData::const_raw_iterator endParam = |
| paramsRF.getParameters().end(); |
| TableOfData::const_iterator itValue = paramsRF.getDataTable()->begin(); |
| for( ; itParam != endParam ; ++itParam, ++itValue ) |
| { |
| value = (*itValue); |
| |
| (itParam)->getwModifier().setFeatureFinal( false ); |
| |
| if( value.isBuiltinValue() ) |
| { |
| /* OK:> value is numeric */ |
| } |
| else if( value != (itParam) ) |
| { |
| if( ENV.eval(anED, anED->getSystemRID(), value) ) |
| { |
| paramsRF.setData((itParam)->getOffset(), ENV.outVAL); |
| } |
| } |
| else if( (itParam)->hasValue() ) |
| { |
| paramsRF.setData((itParam)->getOffset(), (itParam)->getValue()); |
| } |
| else if( (itParam)->hasTypeSpecifier() && |
| (itParam)->getTypeSpecifier()->hasDefaultValue() ) |
| { |
| paramsRF.setData((itParam)->getOffset(), |
| (itParam)->getTypeSpecifier()->getDefaultValue()); |
| } |
| else |
| { |
| paramType = (itParam)->referedTypeSpecifier(); |
| |
| /* OK:> NO value */ |
| if( paramType->isTypedNumeric() ) |
| { |
| if( paramType->isTypedInterval() ) |
| { |
| IntervalTypeSpecifier * intervalTS = (itParam)-> |
| getTypeSpecifier()->as< IntervalTypeSpecifier >(); |
| |
| if( intervalTS->getInfimum().isNumeric() && |
| intervalTS->getSupremum().isNumeric() ) |
| { |
| // Calcul aléatoire d'un nombre entier |
| paramsRF.setData( (itParam)->getOffset(), |
| ExpressionConstructor::newInteger( |
| RANDOM::gen_int( |
| intervalTS->getInfimum().toInteger(), |
| intervalTS->getSupremum().toInteger())) ); |
| } |
| else if( intervalTS->isLClosed() ) |
| { |
| // Calcul aléatoire d'un nombre entier |
| paramsRF.setData( (itParam)->getOffset(), |
| intervalTS->getInfimum() ); |
| } |
| else if( intervalTS->isRClosed() ) |
| { |
| // Calcul aléatoire d'un nombre entier |
| paramsRF.setData( (itParam)->getOffset(), |
| intervalTS->getSupremum() ); |
| } |
| else |
| { |
| // Calcul aléatoire d'un nombre entier |
| paramsRF.setData( (itParam)->getOffset(), |
| ExpressionConstructor::divExpr( |
| ExpressionConstructor::addExpr( |
| intervalTS->getInfimum(), |
| intervalTS->getSupremum()), |
| ExpressionConstant::INTEGER_TWO) ); |
| } |
| } |
| else |
| { |
| // Calcul aléatoire d'un nombre entier |
| paramsRF.setData((itParam)->getOffset(), |
| ExpressionConstructor::newInteger( |
| RANDOM::gen_uint(0, AVM_NUMERIC_MAX_INT8)) ); |
| } |
| } |
| |
| else if( paramType->isTypedBoolean() ) |
| { |
| // Calcul aléatoire d'un nombre compris entre 0 et 1 |
| paramsRF.setData((itParam)->getOffset(), |
| ExpressionConstructor::newBoolean( |
| RANDOM::gen_uint(0, 1) != 0)); |
| } |
| else if( paramType->isTypedEnum() ) |
| { |
| // Choix aléatoire d'un symbol du type Enum |
| paramsRF.setData((itParam)->getOffset(), |
| paramType->as< EnumTypeSpecifier |
| >()->getRandomSymbolData()); |
| } |
| |
| else if( paramType->isTypedString() ) |
| { |
| // Calcul aléatoire d'une chaine de charactère |
| |
| paramsRF.setData((itParam)->getOffset(), |
| ExpressionConstructor::newString("<< random string >>")); |
| |
| // AVM_OS_FATAL_ERROR_EXIT |
| // << "SolverFactory::setModel:> " |
| // "Unexpected symbolic value for << " |
| // << str_header( *itParam ) << " >> !!!" |
| // << SEND_EXIT; |
| |
| } |
| else if( paramType->isTypedCharacter() ) |
| { |
| // Choix aléatoire d'un charactère |
| |
| paramsRF.setData((itParam)->getOffset(), |
| ExpressionConstructor::newChar(RANDOM::gen_char())); |
| |
| // AVM_OS_FATAL_ERROR_EXIT |
| // << "SolverFactory::setModel:> " |
| // "Unexpected symbolic value for << " |
| // << str_header( *itParam ) << " >> !!!" |
| // << SEND_EXIT; |
| } |
| |
| else if( paramType->isTypedMachine() ) |
| { |
| paramsRF.setData((itParam)->getOffset(), |
| RuntimeLib::RID_ENVIRONMENT); |
| |
| // AVM_OS_FATAL_ERROR_EXIT |
| // << "SolverFactory::setModel:> " |
| // "Unexpected symbolic value for << " |
| // << str_header( *itParam ) << " >> !!!" |
| // << SEND_EXIT; |
| } |
| |
| else |
| { |
| AVM_OS_FATAL_ERROR_EXIT |
| << "SolverFactory::setModel:> " |
| "Unexpected symbolic parameter type << " |
| << str_header( *itParam ) << " >> !!!" |
| << SEND_EXIT; |
| } |
| } |
| } |
| } |
| |
| |
| void SolverFactory::resetModel(APExecutionData & anED) |
| { |
| ParametersRuntimeForm & paramsRF = anED.getWritableParametersRuntimeForm(); |
| |
| TableOfInstanceOfData::const_raw_iterator itParam = |
| paramsRF.getParameters().begin(); |
| TableOfInstanceOfData::const_raw_iterator endParam = |
| paramsRF.getParameters().end(); |
| for( ; itParam != endParam ; ++itParam ) |
| { |
| (itParam)->getwModifier().setFeatureFinal( true ); |
| } |
| } |
| |
| |
| |
| void SolverFactory::setRuntimeParametersSolvingValues(APExecutionData & anED) |
| { |
| theSymbolicED = anED; |
| |
| ParametersRuntimeForm & paramsRF = |
| theSymbolicED.getWritableParametersRuntimeForm(); |
| |
| paramsRF.resetOffset(); |
| |
| BFVector::raw_iterator< InstanceOfData > itVar = thePCParameters.begin(); |
| BFVector::raw_iterator< InstanceOfData > endVar = thePCParameters.end(); |
| for( avm_offset_t offset = 0 ; itVar != endVar ; ++itVar, ++offset ) |
| { |
| (itVar)->getwModifier().setFeatureFinal( false ); |
| |
| // if( (itVar) != paramsRF.rawVariable((itVar)->getOffset()) ) |
| // { |
| // AVM_OS_COUT << ":?!?> " << (itVar)->getFullyQualifiedNameID() |
| // << " (param: " << paramsRF.rawVariable( |
| // (itVar)->getOffset())->getFullyQualifiedNameID() << ")" |
| // << " = " << paramsRF.getData((itVar)->getOffset()).str() |
| // << " <- " << thePCParameterValues[offset].str() |
| // << std::endl; |
| // } |
| |
| paramsRF.setData((itVar)->getOffset(), thePCParameterValues[offset]); |
| } |
| } |
| |
| |
| void SolverFactory::updateRuntimeParametersValues(const BF & aValue) |
| { |
| BFVector exprVariableVector; |
| ExpressionFactory::collectVariable(aValue, exprVariableVector); |
| |
| const ParametersRuntimeForm & paramsRF = |
| theSymbolicED->getParametersRuntimeForm(); |
| |
| BFVector::raw_iterator< InstanceOfData > itVar = exprVariableVector.begin(); |
| BFVector::raw_iterator< InstanceOfData > endVar = exprVariableVector.end(); |
| for( ; itVar != endVar ; ++itVar ) |
| { |
| if( not thePCParameters.contains(*itVar) ) |
| { |
| (itVar)->getwModifier().setFeatureFinal( false ); |
| |
| if( (itVar)->hasValue() ) |
| { |
| paramsRF.setData((itVar)->getOffset(), (itVar)->getValue()); |
| } |
| else |
| { |
| paramsRF.setData((itVar)->getOffset(), (*itVar)); |
| } |
| } |
| } |
| } |
| |
| |
| |
| void SolverFactory::finalizeRuntimeParameters() |
| { |
| TableOfInstanceOfData::const_raw_iterator itVar = |
| theSymbolicED->getParametersRuntimeForm().getVariables().begin(); |
| TableOfInstanceOfData::const_raw_iterator endVar = |
| theSymbolicED->getParametersRuntimeForm().getVariables().end(); |
| for( ; itVar != endVar ; ++itVar ) |
| { |
| (itVar)->getwModifier().setFeatureFinal( true ); |
| } |
| |
| theSymbolicED.destroy(); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // EXECUTION DATA NEWFRESH |
| //////////////////////////////////////////////////////////////////////////// |
| |
| APExecutionData SolverFactory::solveNewfresh(SolverDef::SOLVER_KIND aSolverKind, |
| EvaluationEnvironment & ENV, const ExecutionContext & anEC, |
| const BF & aCondition) |
| { |
| APExecutionData anED = anEC.getAPExecutionData(); |
| |
| ParametersRuntimeForm & paramsRF = anED.getWritableParametersRuntimeForm(); |
| |
| BF value; |
| TableOfInstanceOfData::const_raw_iterator itParam = |
| paramsRF.getParameters().begin(); |
| TableOfInstanceOfData::const_raw_iterator endParam = |
| paramsRF.getParameters().end(); |
| TableOfData::const_iterator itValue = paramsRF.getDataTable()->begin(); |
| for( ; itParam != endParam ; ++itParam, ++itValue ) |
| { |
| value = (*itValue); |
| |
| (itParam)->getwModifier().setFeatureFinal( false ); |
| |
| if( value.isBuiltinValue() ) |
| { |
| /* OK:> value is numeric */ |
| } |
| else if( value != (itParam) ) |
| { |
| if( ENV.eval(anED, anED->getSystemRID(), value) ) |
| { |
| paramsRF.setData((itParam)->getOffset(), ENV.outVAL); |
| } |
| } |
| else if( (itParam)->hasValue() ) |
| { |
| paramsRF.setData((itParam)->getOffset(), (itParam)->getValue()); |
| } |
| else |
| { |
| BFList paramList; |
| |
| value = ENV.createNewFreshParam( |
| paramsRF.getRID(), (itParam), paramList ); |
| |
| paramsRF.setData( (itParam)->getOffset(), value ); |
| } |
| } |
| |
| return( anED ); |
| } |
| |
| |
| } |