static node_ptr
Be2bexpDfsData_head(
Be2bexpDfsData* data
)
- Be2bexpDfsData_head
- Side Effects None
- Defined in
bmcConv.c
static node_ptr
Be2bexpDfsData_pop(
Be2bexpDfsData* data
)
- Be2bexpDfsData_pop
- Side Effects None
- Defined in
bmcConv.c
static void
Be2bexpDfsData_push(
Be2bexpDfsData* data,
node_ptr value
)
- Sets a node into the stack
- Side Effects None
- Defined in
bmcConv.c
static void
Be2bexp_Back(
be_ptr be,
char* Be2bexpData,
int sign
)
- Be2bexp_Back
- Side Effects None
- Defined in
bmcConv.c
static void
Be2bexp_First(
be_ptr be,
char* Be2bexpData,
int sign
)
- Be2bexpFirst
- Side Effects None
- Defined in
bmcConv.c
static void
Be2bexp_Last(
be_ptr be,
char* Be2bexpData,
int sign
)
- Be2bexp_Last
- Side Effects None
- Defined in
bmcConv.c
static int
Be2bexp_Set(
be_ptr be,
char* Be2bexpData,
int sign
)
- Be2bexpSet
- Side Effects None
- Defined in
bmcConv.c
be_ptr
BmcInt_Tableau_GetAtTime(
const VarsMgr_ptr vars_mgr,
const node_ptr ltl_wff,
const int time,
const int k,
const int l
)
- This function is the entry point of a mutual recursive
calling stack. All logical connectives are resolved, excepted for NOT, which
closes the recursive calling stack. Also variables and falsity/truth
constants close the recursion.
- See Also
bmc_tableauGetNextAtTime
bmc_tableauGetGloballyAtTime
bmc_tableauGetEventuallyAtTime
bmc_tableauGetUntilAtTime
bmc_tableauGetReleasesAtTime
- Defined in
bmcTableauLTLformula.c
void
Bmc_AddCmd(
)
- Adds all bmc-related commands to the interactive shell
- See Also
SmInit
- Defined in
bmcPkg.c
node_ptr
Bmc_CheckFairnessListForPropositionalFormulae(
node_ptr wffList
)
- Helper function to simplify calling to
'bmc_check_wff_list' for searching of propositional wff only.
Returns a new list of wffs which contains legal wffs only
- See Also
bmc_check_wff_list
- Defined in
bmcCheck.c
int
Bmc_CommandBmcSetup(
const int argc,
const char** argv
)
- Initializes the bmc sub-system, and builds the model in
a Boolean Expression format
- Side Effects Overall the bmc system
- Defined in
bmcCmd.c
int
Bmc_CommandBmcSimulate(
const int argc,
const char** argv
)
- Bmc_CommandBmcSimulate does not require a specification
to build the problem, because only the model is used to build it.
- Side Effects None
- Defined in
bmcCmd.c
int
Bmc_CommandCheckInvarBmc(
const int argc,
const char** argv
)
- After command line processing calls Bmc_GenSolveInvar
to solve and eventually dump the generated invariant problem. If you specify
the -o "filename" option a dimacs file will be generated, otherwise
no dimacs dump will be performed
- Side Effects Property database may change
- See Also
Bmc_GenSolveInvar
- Defined in
bmcCmd.c
int
Bmc_CommandCheckLtlSpecBmcOnePb(
const int argc,
const char** argv
)
- After command line processing this function calls
the Bmc_GenSolveLtl which generates and solve the singleton
problem with bound k and loopback l.
- Side Effects Property database may change
- See Also
Bmc_CommandCheckLtlSpecBmc
Bmc_GenSolveLtl
- Defined in
bmcCmd.c
int
Bmc_CommandCheckLtlSpecBmc(
const int argc,
const char** argv
)
- After command line processing this function calls
the Bmc_GenSolveLtl to generate and solve all problems from 0 to k.
Parameters are the maximum length and the loopback values.
- Side Effects Properties database may change
- See Also
Bmc_CommandCheckLtlSpecBmcOnePb
Bmc_GenSolveLtl
- Defined in
bmcCmd.c
int
Bmc_CommandGenInvarBmc(
const int argc,
const char** argv
)
- After command line processing calls Bmc_GenSolveInvar
to dump the generated invariant problem.
If you specify the -o "filename" option a dimacs file named
"filename" will be created, otherwise the environment variable
bmc_invar_dimacs_filename value will be considered.
- Side Effects Property database may change
- See Also
Bmc_GenSolveInvar
- Defined in
bmcCmd.c
int
Bmc_CommandGenLtlSpecBmcOnePb(
const int argc,
const char** argv
)
- After command line processing it calls
the function Bmc_GenSolveLtl to generate and dump the single problem.
- Side Effects Property database may change
- See Also
Bmc_CommandGenLtlSpecBmc
Bmc_GenSolveLtl
- Defined in
bmcCmd.c
int
Bmc_CommandGenLtlSpecBmc(
const int argc,
const char** argv
)
- Each problem is dumped for the given LTL specification,
or for all LTL specifications if no formula is given.
Generation parameters are the maximum bound and the loopback values.
After command line processing it calls the function Bmc_GenSolveLtl
to generate and dump all problems from zero to k.
- Side Effects Property database may change
- See Also
Bmc_CommandGenLtlSpecBmcOnePb
Bmc_GenSolveLtl
- Defined in
bmcCmd.c
node_ptr
Bmc_Conv_Be2Bexp(
VarsMgr_ptr vars_mgr,
be_ptr be
)
- Descends the structure of the BE with dag-level
primitives. Uses the vars manager to perform all time-related operations.
- Defined in
bmcConv.c
be_ptr
Bmc_Conv_Bexp2Be(
VarsMgr_ptr vars_mgr,
node_ptr bexp
)
- Uses the vars manager to perform all
time-related operations.
- Side Effects be hash may change
- Defined in
bmcConv.c
node_ptr
Bmc_Conv_BexpList2BeList(
VarsMgr_ptr vars_mgr,
node_ptr bexp_list
)
- Converts given boolean expressions list
into correspondent reduced boolean circuits list
- Side Effects be hash may change
- Defined in
bmcConv.c
Bmc_Fsm_ptr
Bmc_Fsm_CreateFromSexprFSM(
VarsMgr_ptr vars_manager,
const Fsm_SexpPtr bfsm
)
- Creates a new instance of the Bmc_Fsm class, getting
information from an instance of Fsm_Sexp type.
- See Also
Bmc_Fsm_Create
Bmc_Fsm_Delete
- Defined in
bmcFsm.c
Bmc_Fsm_ptr
Bmc_Fsm_Create(
VarsMgr_ptr vars_manager,
const be_ptr init,
const be_ptr invar,
const be_ptr trans,
const node_ptr list_of_be_fairness
)
- It gets init, invar, transition relation and the list
of fairness in Boolean Expression format.
- See Also
Bmc_Fsm_Delete
- Defined in
bmcFsm.c
void
Bmc_Fsm_Delete(
Bmc_Fsm_ptr* self_ref
)
- Class Bmc_Fsm destructor
- Side Effects self will be invalidated
- See Also
Bmc_Fsm_Create
Bmc_Fsm_CreateFromSexprFSM
- Defined in
bmcFsm.c
Bmc_Fsm_ptr
Bmc_Fsm_Dup(
Bmc_Fsm_ptr fsm
)
- Creates a new independent copy of the given fsm instance.
You must destroy the returned class instance by invoking the class
destructor when you no longer need it.
- See Also
Bmc_Fsm_Delete
- Defined in
bmcFsm.c
be_ptr
Bmc_Fsm_GetInit(
const Bmc_Fsm_ptr self
)
- Returns the initial states stored in BE format into the
given fsm instance
- Defined in
bmcFsm.c
be_ptr
Bmc_Fsm_GetInvar(
const Bmc_Fsm_ptr self
)
- Returns the invariants stored in BE format into the
given fsm instance
- Defined in
bmcFsm.c
node_ptr
Bmc_Fsm_GetListOfFairness(
const Bmc_Fsm_ptr self
)
- Returns the list of fairness stored in BE format
into the given fsm instance
- Defined in
bmcFsm.c
be_ptr
Bmc_Fsm_GetTrans(
const Bmc_Fsm_ptr self
)
- Returns the transition relation stored in BE format
into the given fsm instance
- Defined in
bmcFsm.c
VarsMgr_ptr
Bmc_Fsm_GetVarsManager(
const Bmc_Fsm_ptr self
)
- Returns the variables manager associated with the
given fsm instance
- See Also
Vars_Mgr
- Defined in
bmcFsm.c
void
Bmc_Fsm_SetFairness(
Bmc_Fsm_ptr self,
node_ptr fair
)
- Private service to set the list of fairness into
the given fsm
- Side Effects self will change
- Defined in
bmcFsm.c
void
Bmc_Fsm_SetInit(
Bmc_Fsm_ptr self,
be_ptr init
)
- Private service to set init states into the given fsm
- Side Effects fsm will change
- Defined in
bmcFsm.c
void
Bmc_Fsm_SetInvar(
Bmc_Fsm_ptr self,
be_ptr invar
)
- Private service to set invar states into the given fsm
- Side Effects self will change
- Defined in
bmcFsm.c
void
Bmc_Fsm_SetTrans(
Bmc_Fsm_ptr self,
be_ptr trans
)
- Private service to set the transition relation
into the given fsm
- Side Effects self will change
- Defined in
bmcFsm.c
be_ptr
Bmc_Gen_InvarBaseStep(
const Bmc_Fsm_ptr be_fsm,
const node_ptr wff
)
- Returns I0 -> P0, where I0 is the init and
invar at time 0, and P0 is the given formula at time 0
- See Also
Bmc_Gen_InvarInductStep
- Defined in
bmcGen.c
be_ptr
Bmc_Gen_InvarInductStep(
const Bmc_Fsm_ptr be_fsm,
const node_ptr wff
)
- Returns (P0 and R01) -> P1, where P0 is the formula
at time 0, R01 is the transition (without init) from time 0 to 1,
and P1 is the formula at time 1
- See Also
Bmc_Gen_InvarBaseStep
- Defined in
bmcGen.c
be_ptr
Bmc_Gen_InvarProblem(
const Bmc_Fsm_ptr be_fsm,
const node_ptr wff
)
- Builds the negation of
(I0 imp P0) and ((P0 and R01) imp P1)
that must be unsatisfiable.
- See Also
Bmc_Gen_InvarBaseStep
Bmc_Gen_InvarInductStep
- Defined in
bmcGen.c
be_ptr
Bmc_Gen_LtlProblem(
const Bmc_Fsm_ptr be_fsm,
const node_ptr ltl_wff,
const int k,
const int l
)
- Returns the LTL problem at length k with loopback l
(single loop, no loop and all loopbacks are allowed)
- Defined in
bmcGen.c
be_ptr
Bmc_GetTestTableau(
const VarsMgr_ptr vars_mgr,
const node_ptr ltl_wff,
const int k,
const int l
)
-
- Defined in
bmcInt.c
void
Bmc_Init(
)
- It builds the vars manager, and then creates the BE fsm
from the Sexpr FSM. Currently the vars manager is a singleton global private variable
which is shared between all the BE FSMs.
- Defined in
bmcPkg.c
boolean
Bmc_IsPropositionalFormula(
node_ptr wff
)
- Given a wff returns 1 if wff is a propositional formula,
zero (0) otherwise.
- Defined in
bmcCheck.c
be_ptr
Bmc_Model_GetFairness(
const Bmc_Fsm_ptr be_fsm,
const int k,
const int l
)
- Uses bmc_model_getFairness_aux which recursively calls
itself to conjuctive all fairnesses by constructing a top-level 'and'
operation.
Moreover bmc_model_getFairness_aux calls the recursive function
bmc_model_getSingleFairness, which resolves a single fairness as
a disjunctioned expression in which each ORed element is a shifting of
the single fairness across [l, k] if a loop exists.
If no loop exists, nothing can be issued, so a falsity value is returned
- See Also
bmc_model_getFairness_aux
bmc_model_getSingleFairness
- Defined in
bmcModel.c
be_ptr
Bmc_Model_GetInit0(
const Bmc_Fsm_ptr be_fsm
)
- Use this function instead of explicitly get the init
from the fsm and shift them at time 0 using the vars manager layer.
- See Also
Bmc_Model_GetInvarAtTime
- Defined in
bmcModel.c
be_ptr
Bmc_Model_GetInvarAtTime(
const Bmc_Fsm_ptr be_fsm,
const int time
)
- Use this function instead of explicitly get the invar
from the fsm and shift them at the requested time using the vars
manager layer.
- See Also
Bmc_Model_GetInit0
- Defined in
bmcModel.c
be_ptr
Bmc_Model_GetPathNoInit(
const Bmc_Fsm_ptr be_fsm,
const int k
)
- Returns the path for the model from 0 to k,
taking into account the invariants (and no init)
- See Also
Bmc_Model_GetPathWithInit
- Defined in
bmcModel.c
be_ptr
Bmc_Model_GetPathWithInit(
const Bmc_Fsm_ptr be_fsm,
const int k
)
- Returns the path for the model from 0 to k,
taking into account initial conditions and invariants
- See Also
Bmc_Model_GetPathNoInit
- Defined in
bmcModel.c
be_ptr
Bmc_Model_GetUnrolling(
const Bmc_Fsm_ptr be_fsm,
const int j,
const int k
)
- Using of invars over next variables instead of the
previuos variables is a specific implementation aspect
- See Also
Bmc_Model_GetPathWithInit
Bmc_Model_GetPathNoInit
- Defined in
bmcModel.c
Bmc_Problem_ptr
Bmc_Problem_Create(
const VarsMgr_ptr vars_mgr,
const be_ptr prob
)
- Class Bmc_Problem constructor
- See Also
Bmc_Problem_Delete
- Defined in
bmcSat.c
void
Bmc_Problem_Delete(
Bmc_Problem_ptr self
)
- Call when you no longer need the Bmc_Problem instance.
- See Also
Bmc_Problem_Create
- Defined in
bmcSat.c
be_ptr
Bmc_Problem_GetBeProblem(
const Bmc_Problem_ptr self
)
- The returned be is the same you used during instance
construction, by passing it to Bmc_Problem_Create
- Defined in
bmcSat.c
Be_Cnf_ptr
Bmc_Problem_GetCnf(
const Bmc_Problem_ptr self
)
- You do not need to delete the returned
Be_Cnf instance. If you delete the Bmc_Problem instance had returned
a Be_Cnf instance by calling this method, also the returned Be_Cnf instance
will become invalid.
- Defined in
bmcSat.c
void
Bmc_Quit(
)
- Frees all resources allocated for the BMC model manager
- Defined in
bmcPkg.c
Bmc_SatTrace_ptr
Bmc_SatTrace_Create(
Bmc_Problem_ptr bmcProb,
Sat_SatResult_ptr satResult
)
- The method gets a satisfiable Sat_SatResult instance.
The ownership of both arguments bmcProb and satResult remanins to the
caller (i.e. the Bmc_SatTrace destroyer does not delete also these
instances.)
- See Also
Bmc_SatTrace_Delete
- Defined in
bmcSat.c
void
Bmc_SatTrace_Delete(
Bmc_SatTrace_ptr* self_ref
)
- Call when you no longer need the given instance
- Side Effects self will be invalidated
- Defined in
bmcSat.c
node_ptr
Bmc_SatTrace_GetSymbModelInvar(
const Bmc_SatTrace_ptr self,
const VarsMgr_ptr vars_mgr
)
- As Bmc_SatTrace_GetSymbModel, but for invariants
- Defined in
bmcSat.c
node_ptr
Bmc_SatTrace_GetSymbModel(
const Bmc_SatTrace_ptr self,
const VarsMgr_ptr vars_mgr,
const int k
)
- Returns the symbolic counterexample with max length k.
The VarMgr instance is required by the conversion routine.
Conversion is performed with memoizing, so you can call efficiently call
this method more than one time.
- Side Effects self's internal state can change
- Defined in
bmcSat.c
Sat_SatResult_ptr
Bmc_Sat_SolveInvarProblem(
const VarsMgr_ptr vars_mgr,
Sat_SatSolver_ptr solver,
const Bmc_Problem_ptr bmcProb
)
- Calls the specified solver with the given invar problem,
and returns a sat result if there is any
- Side Effects result will change
- Defined in
bmcSat.c
Sat_SatResult_ptr
Bmc_Sat_SolveProblem(
const VarsMgr_ptr vars_mgr,
Sat_SatSolver_ptr solver,
const Bmc_Problem_ptr bmcProb,
const int k
)
- The returned result MUST be deleted by the
calling function.
- Side Effects A Sat_SatResult_ptr will be created,
and the calling function must delete it.
- See Also
Sat_SatSolver
Sat_SatResult_ptr
- Defined in
bmcSat.c
be_ptr
Bmc_TableauLTL_GetAllLoopsDepth1(
const Bmc_Fsm_ptr be_fsm,
const node_ptr ltl_wff,
const int k
)
- Builds the tableau in the case depth==1 as suggested
by R. Sebastiani
- Defined in
bmcTableau.c
be_ptr
Bmc_TableauLTL_GetAllLoops(
const Bmc_Fsm_ptr be_fsm,
const node_ptr ltl_wff,
const int k,
const int l
)
- Each tableau takes into account of fairnesses relative
to its step. All tableau are collected together into a disjunctive form.
- Defined in
bmcTableau.c
be_ptr
Bmc_TableauLTL_GetNoLoop(
const Bmc_Fsm_ptr be_fsm,
const node_ptr ltl_wff,
const int k
)
- Fairness evaluate to true if there are not fairness
in the model, otherwise them evaluate to false because of no loop
- Defined in
bmcTableau.c
be_ptr
Bmc_TableauLTL_GetSingleLoopWithFairness(
const Bmc_Fsm_ptr be_fsm,
const node_ptr ltl_wff,
const int k,
const int l
)
- Builds the tableau at time zero. Loop is allowed,
fairness are taken into account
- See Also
BmcInt_Tableau_GetAtTime
- Defined in
bmcTableau.c
be_ptr
Bmc_TableauLTL_GetSingleLoop(
const Bmc_Fsm_ptr be_fsm,
const node_ptr ltl_wff,
const int k,
const int l
)
- Builds the tableau at time zero. Loop is allowed,
fairness are taken into account
- See Also
BmcInt_Tableau_GetAtTime
- Defined in
bmcTableau.c
be_ptr
Bmc_TableauPLTL_GetAllLoopsDepth1(
const Bmc_Fsm_ptr be_fsm,
const node_ptr pltl_wff,
const int k
)
- Builds the tableau in the case depth==1 as suggested
by R. Sebastiani.
- Defined in
bmcTableau.c
be_ptr
Bmc_TableauPLTL_GetAllLoops(
const Bmc_Fsm_ptr be_fsm,
const node_ptr ltl_wff,
const int k,
const int startFromL
)
- Returns the conjunction of the single-loop tableaux for
all possible (k,l)-loops for a fixed k. Each single-loop
tableau takes into account of both fairness constraints
and loop condition.
- Defined in
bmcTableau.c
be_ptr
Bmc_TableauPLTL_GetAllTimeTableau(
const VarsMgr_ptr vars_mgr,
const node_ptr pltl_wff,
const int k
)
- This function is a special case of "evaluateOn", thus it
computes its answer by calling "evaluateOn" with some specifc
arguments. The only use of this function is in constructing
optimized tableaux for those depth-one formulas where
"RELEASES" is the unique operator.
- See Also
evaluateOn
- Defined in
bmcTableauPLTLformula.c
be_ptr
Bmc_TableauPLTL_GetNoLoop(
const Bmc_Fsm_ptr be_fsm,
const node_ptr ltl_wff,
const int k
)
- Returns the tableau for a PLTL formula on a bounded path
of length k, reasoning on fairness conditions as well.
- Defined in
bmcTableau.c
be_ptr
Bmc_TableauPLTL_GetSingleLoop(
const Bmc_Fsm_ptr be_fsm,
const node_ptr ltl_wff,
const int k,
const int l
)
- Returns the tableau for a PLTL formula on a (k,l)-loop,
conjuncted with both fairness conditions and the loop
condition on time steps k and l.
- Defined in
bmcTableau.c
be_ptr
Bmc_TableauPLTL_GetTableau(
const VarsMgr_ptr vars_mgr,
const node_ptr pltl_wff,
const int k,
const int l
)
- Builds both the bounded-tableau and the loop-tableau for a PLTL
formula "pltl_wff" (depending on the value of l). The time
the tableau refers to is (implicitly) time zero.
- See Also
getTableauAtTime
- Defined in
bmcTableauPLTLformula.c
be_ptr
Bmc_Tableau_GetAllLoopsDepth1(
const Bmc_Fsm_ptr be_fsm,
const node_ptr ltl_wff,
const int k
)
- Builds the tableau in the case depth==1 as suggested
by R. Sebastiani
- Defined in
bmcTableau.c
be_ptr
Bmc_Tableau_GetAllLoopsDisjunction(
const VarsMgr_ptr vars_mgr,
const int k
)
- Builds a formula which is a disjunction over all the
loop conditions on k-loops, with l=0,1,...,k-1.
- See Also
Bmc_Tableau_GetLoopCondition
- Defined in
bmcTableau.c
be_ptr
Bmc_Tableau_GetAllLoops(
const Bmc_Fsm_ptr be_fsm,
const node_ptr ltl_wff,
const int k,
const int l
)
- Each tableau takes into account of fairnesses relative
to its step. All tableau are collected together into a disjunctive form.
- Defined in
bmcTableau.c
be_ptr
Bmc_Tableau_GetLoopCondition(
const VarsMgr_ptr vars_mgr,
const int k,
const int l
)
- State l and state k are forced to represent the same
state by conjuncting the if-and-only-if conditions
{Vil<->Vik} between Vil (variable i at time l) and Vik
(variable i at time k) for each variable Vi.
- See Also
Bmc_Tableau_GetAllLoopsDisjunction
- Defined in
bmcTableau.c
be_ptr
Bmc_Tableau_GetNoLoop(
const Bmc_Fsm_ptr be_fsm,
const node_ptr ltl_wff,
const int k
)
- Fairness evaluate to true if there are not fairness
in the model, otherwise them evaluate to false because of no loop
- Defined in
bmcTableau.c
be_ptr
Bmc_Tableau_GetSingleLoop(
const Bmc_Fsm_ptr be_fsm,
const node_ptr ltl_wff,
const int k,
const int l
)
- Builds the tableau in the case depth==1 as suggested
by R. Sebastiani
- Defined in
bmcTableau.c
void
Bmc_TestReset(
)
- Call this function to reset the test sub-package (into
the reset command for example)
- Defined in
bmcTest.c
int
Bmc_TestTableau(
int argc,
char ** argv
)
- If you call this command with a loopback set to
BMC_ALL_LOOPS you command execution is aborted.
- Defined in
bmcTest.c
void
Bmc_TestVarsMgr(
const VarsMgr_ptr vars_mgr
)
- Bmc_TestVarsMgr
- Side Effects ...
- Defined in
bmcTest.c
outcome
Bmc_Utils_Check_k_l(
const int k,
const int l
)
- Returns SUCCESS if k and l are compatible, otherwise
return GENERIC_ERROR
- Defined in
bmcUtils.c
void
Bmc_Utils_ConvertLoopFromInteger(
const int iLoopback,
char* szLoopback,
const int _bufsize
)
- Inverse semantic of
Bmc_Utils_ConvertLoopFromString. bufsize is the maximum buffer size
- Side Effects String buffer passed as argument will change
- See Also
Bmc_Utils_ConvertLoopFromString
- Defined in
bmcUtils.c
int
Bmc_Utils_ConvertLoopFromString(
const char* strValue,
outcome* result
)
- Use this function to correctly convert a string
containing a loopback user-side value to the internal representation of
the same loopback value
- Side Effects result will change if supplied
- Defined in
bmcUtils.c
void
Bmc_Utils_ExpandMacrosInFilename(
const char* filename_to_be_expanded,
const SubstString* table_ptr,
const size_t table_len,
char* filename_expanded,
size_t buf_len
)
- This function is used in order to perform the macro expansion
of filenames. table_ptr is the pointer to a previously prepared table which fixes
any corrispondence from symbol to strings to be substituited from.
table_len is the number of rows in the table (i.e. the number of symbols to
search for.)
- Side Effects filename_expanded string data will change
- Defined in
bmcUtils.c
const char*
Bmc_Utils_GetAllLoopbacksString(
)
- Returns a constant string which represents the
"all loops" semantic.
- Defined in
bmcUtils.c
int
Bmc_Utils_GetAllLoopbacks(
)
- Returns the integer value which represents the
"all loops" semantic
- Defined in
bmcUtils.c
int
Bmc_Utils_GetNoLoopback(
)
- Returns the integer value which represents the
"no loop" semantic
- Defined in
bmcUtils.c
int
Bmc_Utils_GetSuccTime(
const int time,
const int k,
const int l
)
- Given time<=k and a [l, k] interval, returns next
time, or BMC_NO_LOOP if time is equal to k and there is no loop
- Defined in
bmcUtils.c
boolean
Bmc_Utils_IsAllLoopbacksString(
const char* str
)
- This is supplied in order to hide the internal value of
loopback which corresponds to the "all loops" semantic.
- Defined in
bmcUtils.c
boolean
Bmc_Utils_IsAllLoopbacks(
const int l
)
- This is supplied in order to hide the internal value of
loopback which corresponds to the "all loops" semantic.
- Defined in
bmcUtils.c
boolean
Bmc_Utils_IsNoLoopbackString(
const char* str
)
- This is supplied in order to hide the internal value of
loopback which corresponds to the "no loop" semantic.
- Defined in
bmcUtils.c
boolean
Bmc_Utils_IsNoLoopback(
const int l
)
- This is supplied in order to hide the internal value of
loopback which corresponds to the "no loop" semantic.
- Defined in
bmcUtils.c
boolean
Bmc_Utils_IsSingleLoopback(
const int l
)
- Both cases "no loop" and "all loops" make this
function returning false, since these values are not single loops.
- Defined in
bmcUtils.c
int
Bmc_Utils_RelLoop2AbsLoop(
const int upov_loop,
const int k
)
- For example the -4 value when k is 10 is
the value 6, but the value 4 (absolute loop value) is still 4
- Defined in
bmcUtils.c
int
Bmc_WffListMatchProperty(
node_ptr wffList,
BMC_PF_MATCH pCheck,
void* pCheckOptArgument,
int iMaxMatches,
unsigned int* aiMatchedIndexes,
BMC_PF_MATCH_ANSWER pAnswer,
void* pAnswerOptArgument
)
- This is a generic searching function for a property
across a list of wffs. Please note that searching is specific for a list
of wffs, but the searching semantic and behaviour are generic and
customizable.
Searching may be stopped after the Nth match, or can be continued till all
list elements have been checked (specify -1 in this case).
In any case searching cannot be carried out over the MAX_MATCHES
value.
Arguments:
Parameter name | Description |
wffList | A list of wffs to iterate in |
pCheck | Pointer to matching function.
The checking function type is BMC_PF_MATCH, and has three
parameters:
wff the formula to check for
index index of wff into list
pOpt generic pointer to custom structure (optional) |
pCheckOptArgument | Argument passed to pCheck
(specify NULL if you do not use it.) |
iMaxMatches | Maximum number of matching to be
found before return. This must be less of MAX_MATCHES.
Specify -1 to iterate across the entire list. |
aiMatchedIndexes | Optional int array which
will contain all match indexes.
Specify NULL if you do not need this functionality.
Array size must be less of MAX_MATCHES. |
pAnswer | Pointer to answer function
of type BMC_PF_MATCH_ANSWER. This function is called everytime
a match is found.
Specify NULL if you do not need for this functionality.
The answer function has the following prototype:
void answer(node_ptr wff, int index, void* pOpt)
where:
wff the formula that matches the criteria
index is the index of wff into the list
pOpt pointer to generic & customizable structure
(see pAnswerOptArgument below)
pAnswerOptArgument optional parameter for pAnswer function,
in order to ensure more flexibility. Specify NULL if you do not need
for this functionality.) |
- Side Effects Given aiMatchedIndexes array changes if at least one
match has found out
- Defined in
bmcCheck.c
int
Bmc_Wff_GetDepth(
node_ptr ltl_wff
)
- Returns 0 for propositional formulae, 1 or more for
temporal formulae
- Side Effects none
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkAnd(
node_ptr arg1,
node_ptr arg2
)
- Makes an and WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkEventually(
node_ptr arg
)
- Makes an eventually WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkFalsity(
)
- Makes a false WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkGlobally(
node_ptr arg
)
- Makes a globally WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkHistorically(
node_ptr arg
)
- Makes a historically WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkIff(
node_ptr arg1,
node_ptr arg2
)
- Makes an iff WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkImplies(
node_ptr arg1,
node_ptr arg2
)
- Makes an implies WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkNext(
node_ptr arg
)
- Makes a next WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkNnf(
node_ptr wff
)
- A positive (1) polarity will not negate entire formula
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkNot(
node_ptr arg
)
- Makes a not WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkOnce(
node_ptr arg
)
- Makes an once WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkOpNext(
node_ptr arg
)
- Makes an op_next WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkOpNotPrecNot(
node_ptr arg
)
- Makes an op_next WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkOpPrec(
node_ptr arg
)
- Makes an op_next WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkOr(
node_ptr arg1,
node_ptr arg2
)
- Makes an or WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkReleases(
node_ptr arg1,
node_ptr arg2
)
- Makes a releases WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkSince(
node_ptr arg1,
node_ptr arg2
)
- Makes an since WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkTriggered(
node_ptr arg1,
node_ptr arg2
)
- Makes a triggered WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkTruth(
)
- Makes a truth WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkUntil(
node_ptr arg1,
node_ptr arg2
)
- Makes an until WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
Bmc_Wff_MkXopNext(
node_ptr arg,
int x
)
- Applies op_next x times
- Side Effects node hash may change
- Defined in
bmcWff.c
static int
UsageBmcCheckInvar(
)
- Usage string for command check_invar_bmc
- Side Effects None
- See Also
Bmc_CommandCheckInvarBmc
- Defined in
bmcCmd.c
static int
UsageBmcCheckLtlSpecOnePb(
)
- Usage string for command check_ltlspec_bmc_onepb
- Side Effects None
- See Also
Bmc_CommandCheckLtlSpecBmcOnePb
- Defined in
bmcCmd.c
static int
UsageBmcCheckLtlSpec(
)
- Usage string for command check_ltlspec_bmc
- Side Effects None
- See Also
Bmc_CommandCheckLtlSpecBmc
- Defined in
bmcCmd.c
static int
UsageBmcGenInvar(
)
- Usage string for command gen_invar_bmc
- Side Effects None
- See Also
Bmc_CommandGenInvarBmc
- Defined in
bmcCmd.c
static int
UsageBmcGenLtlSpecOnePb(
)
- Usage string for command gen_ltlspec_bmc_onepb
- Side Effects None
- See Also
Bmc_CommandGenLtlSpecBmcOnePb
- Defined in
bmcCmd.c
static int
UsageBmcGenLtlSpec(
)
- Usage string for command gen_ltlspec_bmc
- Side Effects None
- See Also
Bmc_CommandGenLtlSpecBmc
- Defined in
bmcCmd.c
static int
UsageBmcSetup(
)
- Usage string for Bmc_CommandBmcSetup
- See Also
Bmc_CommandBmcSetup
- Defined in
bmcCmd.c
static int
UsageBmcSimulate(
)
- Usage string for UsageBmcSimulate
- Side Effects None
- See Also
Bmc_CommandBmcSimulate
- Defined in
bmcCmd.c
static int
UsageBmcTestTableau(
)
- Usage string for Bmc_TestTableau
- Side Effects None
- Defined in
bmcTest.c
outcome
bmc_CommandsWith_k_l_OptionsHandling(
const int argc,
const char** argv,
Prop_Ptr* pProperty,
Prop_Type type,
int* pb_length,
int* user_loop,
boolean* dimacsSpecified,
char* dimacsFilename,
const size_t dimacsFilename_len
)
- Handles options of bmc commands
{check,gen}_ltlspec_bmc[_onepb]. pProperty will contain the property must
be checked out, or NULL if all properties must be checked. Initial value
of ltlspec *must* be NULL
This function will check the values specified for length and loopback are
compatible with their constrains.
dimacsSpecified will be put to one (1) if the -o option is specified, zero
(0) otherwise.
Returns GENERIC_ERROR if an error has occurred;
Returns SUCCESS_REQUIRED_HELP if -h options had been specified;
Returns SUCCESS in all other cases.
- Side Effects pProperty might change if one or more valid
properties are specified. dimacsSpecified will change if -o option
is specified
- Defined in
bmcCmd.c
outcome
bmc_CommandsWithout_k_l_OptionsHandling(
const int argc,
const char** argv,
Prop_Ptr* pProperty,
Prop_Type type,
boolean* dimacsSpecified,
char* dimacsFilename,
const size_t dimacsFilename_len
)
- Handles options of bmc commands
{check,gen}_invar_bmc[_onepb]. pProperty will contain the property must
be checked out, or NULL if all properties must be checked. Initial value
of ltlspec *must* be NULL
dimacsSpecified will be put to one (1) if the -o option is specified, zero
(0) otherwise.
Returns GENERIC_ERROR if an error has occurred;
Returns SUCCESS_REQUIRED_HELP if -h options had been specified;
Returns SUCCESS in all other cases.
- Side Effects pProperty might change if one or more
valid properties were specified.
dimacsSpecified will change if -o option were specified.
- Defined in
bmcCmd.c
void
bmc_add_valid_wff_to_list(
node_ptr wff,
int index,
void* _pList
)
- private service for
Bmc_CheckFairnessListForPropositionalFormulae
- See Also
Bmc_CheckFairnessListForPropositionalFormulae
- Defined in
bmcCheck.c
int
bmc_check_if_wff_is_valid(
node_ptr wff,
int index,
void* _aiIndexes
)
- private service for
Bmc_CheckFairnessListForPropositionalFormulae
- See Also
Bmc_CheckFairnessListForPropositionalFormulae
- Defined in
bmcCheck.c
int
bmc_is_propositional_formula_aux(
node_ptr wff,
int index,
void* pOpt
)
- Wrapper that makes
Bmc_CheckFairnessListForPropositionalFormulae able to call
Bmc_IsPropositionalFormula with a mode generic interface.
Arguments 2 and 3 are practically unused, supplied to respect the generic
interface only.
- See Also
Bmc_CheckFairnessListForPropositionalFormulae
- Defined in
bmcCheck.c
void
bmc_sat_trace_calculateSymbModel(
const Bmc_SatTrace_ptr self,
const VarsMgr_ptr vars_mgr,
const int k
)
- Private service for class Bmc_SatTrace methods
- Defined in
bmcSat.c
node_ptr
bmc_sat_trace_prop2symb(
const Bmc_SatTrace_ptr self,
const VarsMgr_ptr vars_mgr
)
- Example of mapping of STATE VARIABLES and BE VARIABLES:
----------------------------------------------------------
VAR x y x' y' x0 y0 x1 y1 x2 y2
BE index 0 1 2 3 4 5 6 7 8 9
CNF index # 1 2 3 4 5 6 7 8 9
Time -2 | -1 | 0 | 1 | 2 |
Varindex 0 1 | 0 1 | 0 1 | 0 1 | 0 1 |
- Defined in
bmcSat.c
be_ptr
bmc_tableauGetEventuallyAtTime(
const VarsMgr_ptr vars_mgr,
const node_ptr ltl_wff,
const int intime,
const int k,
const int l
)
- ltl_wff is the 'p' part in 'F p'.
If intime<=k is out of [l, k] or if there is no loop,
iterates from intime to k, otherwise iterates from l to k
- Defined in
bmcTableauLTLformula.c
be_ptr
bmc_tableauGetGloballyAtTime(
const VarsMgr_ptr vars_mgr,
const node_ptr ltl_wff,
const int intime,
const int k,
const int l
)
- ltl_wff is the 'p' part in 'G p'
- See Also
bmc_tableauGetEventuallyAtTime
- Defined in
bmcTableauLTLformula.c
be_ptr
bmc_tableauGetNextAtTime(
const VarsMgr_ptr vars_mgr,
const node_ptr ltl_wff,
const int time,
const int k,
const int l
)
- Returns a falsity constants if the next operator leads
out of [l, k] and there is no loop
- Defined in
bmcTableauLTLformula.c
be_ptr
bmc_tableauGetReleasesAtTime_aux(
const VarsMgr_ptr vars_mgr,
const node_ptr p,
const node_ptr q,
const int time,
const int k,
const int l,
const int steps
)
- Builds the release operator expression
- Defined in
bmcTableauLTLformula.c
be_ptr
bmc_tableauGetReleasesAtTime(
const VarsMgr_ptr vars_mgr,
const node_ptr p,
const node_ptr q,
const int time,
const int k,
const int l
)
- Carries out the steps number to be performed, depending
on l,k and time, then calls bmc_tableauGetReleasesAtTime_aux
- See Also
bmc_tableauGetReleasesAtTime_aux
- Defined in
bmcTableauLTLformula.c
be_ptr
bmc_tableauGetUntilAtTime_aux(
const VarsMgr_ptr vars_mgr,
const node_ptr p,
const node_ptr q,
const int time,
const int k,
const int l,
const int steps
)
- auxiliary part of bmc_tableauGetUntilAtTime
- Defined in
bmcTableauLTLformula.c
be_ptr
bmc_tableauGetUntilAtTime(
const VarsMgr_ptr vars_mgr,
const node_ptr p,
const node_ptr q,
const int time,
const int k,
const int l
)
- Carries out the steps number to be performed, depending
on l,k and time, then calls bmc_tableauGetUntilAtTime_aux
- See Also
bmc_tableauGetUntilAtTime_aux
- Defined in
bmcTableauLTLformula.c
void
bmc_test_bexpr_output(
const VarsMgr_ptr vars_mgr,
FILE* f,
const node_ptr bexp,
const int output_type
)
- Write to specified FILE stream given node_ptr
formula with specified output_type format. There are
follow formats: BMC_BEXP_OUTPUT_SMV, BMC_BEXP_OUTPUT_LB
- Side Effects None
- Defined in
bmcTest.c
node_ptr
bmc_test_gen_tableau(
const Bmc_Fsm_ptr be_fsm,
const node_ptr ltl_nnf_wff,
const int k,
const int l,
boolean usePastOperators
)
- This function is used to test tableau formulae
- Defined in
bmcTest.c
node_ptr
bmc_test_gen_wff(
const VarsMgr_ptr vars_mgr,
int max_depth,
int max_conns,
boolean usePastOperators
)
- Builds a random LTL WFF with specified
max depth and max connectives.
- Side Effects node hash may change
- Defined in
bmcTest.c
node_ptr
bmc_test_mk_loopback_ltl(
const VarsMgr_ptr vars_mgr,
const int k,
const int l
)
- In the following example we suppose the loop starts
from 2 and finishes to 6 (the bound).
,-----------.
V |
o--o--o--o--o--o--o--o--o--o--o--o--o- (...continues indefinitely)
0 1 2 3 4 5 6 7 8 9 10 11 12
In general all variables in time 2 must be forced to be equivalent
to the corresponding variables timed in 6, the variables in 3 to 7,
and so on up to the variables in 6 (equivalent to variables in
10). Then variables in 7 (or 3 again) must be forced to be equivalent
to the varaibles in 11, and so on indefinitely.
In formula (let suppose we have only one boolean variable):
(p2 <-> p6) && (p6 <-> p10) ...
In a more compact (and finite!) form, related to this example:
XX(G (p <-> XXXX(p)))
The first two neXtes force the formula to be effective only from the loop
starting point.
The generic formula implemented in the code is the following one:
X^(l) (G ((p0 <-> X^(k-l)(p0)) &&
(p1 <-> X^(k-l)(p1)) &&
.
.
.
(pn <-> X^(k-l)(pn)))
)
where:
p0..pn are all boolean variables into the model
X^(n) is expanded to XXX..X n-times
- Defined in
bmcTest.c
node_ptr
bmc_wff_mkBinary(
int type,
node_ptr arg1,
node_ptr arg2
)
- Makes a binary WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
bmc_wff_mkConst(
int type
)
- Makes a constant WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
node_ptr
bmc_wff_mkUnary(
int type,
node_ptr arg
)
- Makes a unary WFF
- Side Effects node hash may change
- Defined in
bmcWff.c
static be_ptr
evaluateOn(
const VarsMgr_ptr vars_mgr,
const node_ptr pltl_f,
const node_ptr pltl_g,
const int fromTime,
const int toTime,
const int k,
const int l,
const int evalType,
const int evalDir
)
- When only one argument is passed in (pltl_g==NULL), the
tableaux at the proper time instants for that argument are
computed (throught recursive calls to "getTableauAtTime")
and either disjunctively or conjunctively put together
(depending on the value of the "evalType" parameter).
When two arguments are given, the second one is evaluated
according to the following scheme (here we represent the
disjunctive case; "and" and "or" have to be exchanged to
obtain the conjunctive case):
(Aj or (Bi and Bi+1 and ... and Bj-1))
where A is the first argument, B is the second one, j is the
time the first argument is currently being evaluated on, and
i is the starting time for the whole evaluation (this
evaluation scheme is adopted as it is shared by all the
binary time operators in the PLTL logic).
In both cases, the proper evaluation set is computed
by calling the "projectOntoMainDomain" function, which deals
with both bounded and loop paths.
- See Also
getTableauAtTime
projectOntoMainDomain
- Defined in
bmcTableauPLTLformula.c
static be_ptr
getTableauAtTime(
const VarsMgr_ptr vars_mgr,
const node_ptr pltl_wff,
const int time,
const int k,
const int l
)
- Tableaux for constant expressions and (negated) literals are
built immediately, while complex formulas are evaluated in a
compositional way. In particular, propositional operators are
evaluated throught recursive calls to the procedure
"getTableauAtTime" itself (no split on time instants is
necessary in this case). Time operators are evaluated (in a
uniform way) by means of a doubly recursive call, which
involves the "evaluateOn" procedure as a counterpart.
A concise representation of the set of time instants each time
operator refers to (together with its argument(s))
is passed to the "evaluateOn" procedure, which is then
responsible for recursively evaluating these arguments on the
proper set of integer time instants by calling
"getTableauAtTime" in turn.
- See Also
evaluateOn
- Defined in
bmcTableauPLTLformula.c
boolean
isPureFuture(
const node_ptr pltl_wff
)
- Checks wether a formula contains only future operators
- Defined in
bmcTableau.c
static EvalSet
projectOntoMainDomain(
const node_ptr pltl_wff,
int a,
int b,
const int k,
const int l,
const int interval_type,
const int eval_dir
)
- For bounded paths, the projection of the interval [a,b
- See Also
rho
evaluateOn
- Defined in
bmcTableauPLTLformula.c
static int
tau(
const node_ptr pltl_wff
)
- Recursively computes the (maximum) nesting depth of past
operators in the formula, which is an upper bound on its past
temporal horizon.
- See Also
projectOntoMainDomain
- Defined in
bmcTableauPLTLformula.c
(
)
- The function "rho" projects the time instant "i"
onto the main domain of a function f on a (k,l)-loop,
where l_f=l+p*tau(f) and k_f=k+p*tau(f)
(with p=k-l). It is rho(i,l,k)=i, when i
- Defined in
bmcTableauPLTLformula.c
(
)
- This control structure iterates on all the time
instants "i" in the EvalSet "set", according to the semantics of
EvalSet given above.
- Defined in
bmcTableauPLTLformula.c