source: cegar_dev/cegar/main.c @ 106

Last change on this file since 106 was 4, checked in by syed, 14 years ago

input files added
File size: 249.8 KB
RevLine 
[3]1
2#include "io.h"
3#include "ioInt.h"
4#include "ntk.h"
5#include "ord.h"
6#include "part.h"
7#include "maig.h"
8#include "ntmaig.h"
9#include "fsm.h"
10#include "ctlp.h"
11#include "ctlsp.h"
12#include "mc.h"
13#include "mcInt.h"
14#include "grabInt.h"
15#include "bmc.h"
16#include "bmcInt.h"
17#include <stdio.h>
18#include <stdlib.h>
19
20
21/*---------------------------------------------------------------------------*/
22/* Constant declarations                                                     */
23/*---------------------------------------------------------------------------*/
24/*
25 * States of the state machine used to parse the input variable name list file.
26 */
27#define STATE_TEST 0 /* next char is in first column */
28#define STATE_WAIT 1 /* wait until end of line '\n' is reached */
29#define STATE_IN   2 /* parsing a variable name */
30
31/*
32 * Maximum permissible length of a variable name in the input variable name list file.
33 */
34#define MAX_NAME_LENGTH 200
35#define LENGTH_1 255
36#define SIZE_1 100
37
38/*
39 * INPUT FILES
40 */
41/*********************************************************/
42
[4]43#define BLIF_MV_FILE_C1 "concrete_model/concret_main.mv"
44#define FAIRNESS_FILE_C1 "concrete_model/machine_concret.fair"
45#define CTL_FILE_C1 "concrete_model/machine_concret.ctl"
46#define CNF_FILE_C1 "concrete_model/SATcnf_c1.cnf"
47#define DEBUG_FILE_C1 "concrete_model/debug_trace_crt"
[3]48
49
[4]50#define BLIF_MV_FILE_A1 "abstract_model/main_abstract.mv"
51#define FAIRNESS_FILE_A1 "abstract_model/main_abstract.fair"
52#define CTL_FILE_A1 "abstract_model/machine_concret.ctl"
53#define CNF_FILE_A1 "abstract_model/SATcnf_a1.cnf"
54#define DEBUG_FILE_A1 "abstract_model/debug_trace_abs"
[3]55
56/*****************************************************/
57/*
58#define BLIF_MV_FILE_C1 "PBS_VCI_PI/new_main.mv"
59#define FAIRNESS_FILE_C1 "PBS_VCI_PI/main_mod.fair"
60#define CTL_FILE_C1 "PBS_VCI_PI/propri_mod.ctl"
61#define CNF_FILE_C1 "PBS_VCI_PI/SATcnf_c1.cnf"
62#define CNF_FILE_C1_BIS "PBS_VCI_PI/SATcnf_c1_bis.cnf"
63#define DEBUG_FILE_C1 "PBS_VCI_PI/debug_trace"
64
65
66#define BLIF_MV_FILE_A1 "PBS_VCI_PI/new_main.mv"
67#define FAIRNESS_FILE_A1 "PBS_VCI_PI/main_mod.fair"
68#define CTL_FILE_A1 "PBS_VCI_PI/propri_mod.ctl"
69#define CNF_FILE_A1 "PBS_VCI_PI/SATcnf_a1.cnf"
70#define DEBUG_FILE_A1 "PBS_VCI_PI/debug_trace"
71*/
72
73//#define BLIF_MV_FILE_C1 "VCI_PI/Concrete/main_concret.mv"
74//#define FAIRNESS_FILE_C1 "VCI_PI/Concrete/main_concret.fair"
75//#define CTL_FILE_C1 "VCI_PI/Concrete/main_concret.ctl"
76//#define CNF_FILE_C1 "VCI_PI/Concrete/SATcnf_c1.cnf"
77//#define DEBUG_FILE_C1 "VCI_PI/Concrete/debug_trace"
78
79//#define BLIF_MV_FILE_A1 "VCI_PI/Concrete/main_concret.mv"
80//#define FAIRNESS_FILE_A1 "VCI_PI/Concrete/main_concret.fair"
81//#define CTL_FILE_A1 "VCI_PI/Concrete/main_concret.ctl"
82//#define CNF_FILE_A1 "VCI_PI/Concrete/SATcnf_a1.cnf"
83//#define DEBUG_FILE_A1 "VCI_PI/Concrete/debug_trace"
84
85//#define BLIF_MV_FILE_A1 "VCI_PI/main_abstract.mv"
86//#define FAIRNESS_FILE_A1 "VCI_PI/main_abstract.fair"
87//#define CTL_FILE_A1 "VCI_PI/main_concret.ctl"
88//#define CNF_FILE_A1 "VCI_PI/SATcnf_a1.cnf"
89//#define DEBUG_FILE_A1 "VCI_PI/debug_trace"
90
91// #define BLIF_MV_FILE_A1 "EX_A1/Abs_Phi1_and_Phi2/main_abstract.mv"
92// #define FAIRNESS_FILE_A1 "EX_A1/Abs_Phi1_and_Phi2/main_abstract.fair"
93// #define CTL_FILE_A1 "EX_A1/Abs_Phi1_and_Phi2/machine_concret.ctl"
94// #define CNF_FILE_A1 "EX_A1/Abs_Phi1_and_Phi2/SATcnf_a1.cnf"
95// #define DEBUG_FILE_A1 "EX_A1/Abs_Phi1_and_Phi2/debug_trace"
96
97// #define BLIF_MV_FILE_A1 "EX_A1/Abs_Phi1_and_Phi2_REFINED2/main_abstract.mv"
98// #define FAIRNESS_FILE_A1 "EX_A1/Abs_Phi1_and_Phi2_REFINED2/main_abstract.fair"
99// #define CTL_FILE_A1 "EX_A1/Abs_Phi1_and_Phi2_REFINED2/machine_concret.ctl"
100// #define CNF_FILE_A1 "EX_A1/Abs_Phi1_and_Phi2_REFINED2/SATcnf_a1.cnf"
101// #define DEBUG_FILE_A1 "EX_A1/Abs_Phi1_and_Phi2_REFINED2/debug_trace"
102
103// #define BLIF_MV_FILE_C1 "METRONOME/metronome.mv"
104// #define FAIRNESS_FILE_C1 "METRONOME/metronome.fair"
105// #define CTL_FILE_C1 "METRONOME/metronome.ctl"
106// #define CNF_FILE_C1 "METRONOME/SATcnf_c2.cnf"
107
108// #define BLIF_MV_FILE_C1 "GATES/NOT/Concret_Main.mv"
109// #define FAIRNESS_FILE_C1 "GATES/NOT/not.fair"
110// #define CTL_FILE_C1 "GATES/NOT/not.ctl"
111// #define CNF_FILE_C1 "GATES/NOT/SATcnf_not.cnf"
112
113// #define BLIF_MV_FILE_C1 "GATES/NOT2/Concret_Main.mv"
114// #define FAIRNESS_FILE_C1 "GATES/NOT2/not2.fair"
115// #define CTL_FILE_C1 "GATES/NOT2/not2.ctl"
116// #define CNF_FILE_C1 "GATES/NOT2/SATcnf_not2.cnf"
117
118// #define BLIF_MV_FILE_C1 "GATES/NOT4/Concret_Main.mv"
119// #define FAIRNESS_FILE_C1 "GATES/NOT4/not4.fair"
120// #define CTL_FILE_C1 "GATES/NOT4/not4.ctl"
121// #define CNF_FILE_C1 "GATES/NOT4/SATcnf_not4.cnf"
122
123// #define BLIF_MV_FILE_C1 "GATES/AND/Concret_Main.mv"
124// #define FAIRNESS_FILE_C1 "GATES/AND/and.fair"
125// #define CTL_FILE_C1 "GATES/AND/and.ctl"
126// #define CNF_FILE_C1 "GATES/AND/SATcnf_and.cnf"
127
128// #define BLIF_MV_FILE_C1 "GATES/AND2/Concret_Main.mv"
129// #define FAIRNESS_FILE_C1 "GATES/AND2/and2.fair"
130// #define CTL_FILE_C1 "GATES/AND2/and2.ctl"
131// #define CNF_FILE_C1 "GATES/AND2/SATcnf_and2.cnf"
132
133// #define BLIF_MV_FILE_C1 "GATES/OR/Concret_Main.mv"
134// #define FAIRNESS_FILE_C1 "GATES/OR/or.fair"
135// #define CTL_FILE_C1 "GATES/OR/or.ctl"
136// #define CNF_FILE_C1 "GATES/OR/SATcnf_or.cnf"
137
138// #define BLIF_MV_FILE_C1 "GATES/OR2/Concret_Main.mv"
139// #define FAIRNESS_FILE_C1 "GATES/OR2/or2.fair"
140// #define CTL_FILE_C1 "GATES/OR2/or2.ctl"
141// #define CNF_FILE_C1 "GATES/OR2/SATcnf_or2.cnf"
142
143// #define BLIF_MV_FILE_C1 "GATES/SFM2006_Circuit/Concret_Main.mv"
144// #define FAIRNESS_FILE_C1 "GATES/SFM2006_Circuit/sfm.fair"
145// #define CTL_FILE_C1 "GATES/SFM2006_Circuit/sfm.ctl"
146// #define CNF_FILE_C1 "GATES/SFM2006_Circuit/SATcnf_sfm.cnf"
147
148// #define BLIF_MV_FILE_C1 "GATES/SFM2006_Circuit2/Concret_Main.mv"
149// #define FAIRNESS_FILE_C1 "GATES/SFM2006_Circuit2/sfm2.fair"
150// #define CTL_FILE_C1 "GATES/SFM2006_Circuit2/sfm2.ctl"
151// #define CNF_FILE_C1 "GATES/SFM2006_Circuit2/SATcnf_sfm2.cnf"
152
153// #define BLIF_MV_FILE_C1 "GATES/SFM2006_Circuit3/Concret_Main.mv"
154// #define FAIRNESS_FILE_C1 "GATES/SFM2006_Circuit3/sfm3.fair"
155// #define CTL_FILE_C1 "GATES/SFM2006_Circuit3/sfm3.ctl"
156// #define CNF_FILE_C1 "GATES/SFM2006_Circuit3/SATcnf_sfm3.cnf"
157
158//#define BLIF_MV_FILE_A2 "MEE/metronome.mv"
159//#define FAIRNESS_FILE_A2 "EC1/machine_concret.fair"
160//#define CTL_FILE_A1 "EX1/machine_concret.ctl"
161//#define CNF_FILE_A2 "EX1/SATcnf_a2.cnf"
162
163/*---------------------------------------------------------------------------*/
164/* Structure declarations                                                    */
165/*---------------------------------------------------------------------------*/
166/**Struct**********************************************************************
167  Synopsis    [A struct to store a string of characters]
168******************************************************************************/
169typedef char string1 [255];
170
171
172/**Struct**********************************************************************
173  Synopsis    [A struct to store of variables in the counter-example.]
174******************************************************************************/
175typedef struct {
176  int       varIndex; // not really necessary
177  int       varId;
178  int       varValue;
179//  char      *varName
180//  char      *symbolicValue
181  string1      varName; // change to dynamic allocation later
182  string1      symbolicValue; // change to dynamic allocation later
183} CEXVarStruct;
184
185
186/**Struct**********************************************************************
187  Synopsis    [A struct to store counter-example data.]
188******************************************************************************/
189typedef struct {
190  int pathIndex;
191  int n_outputVar;
192  int n_inputVar;
193  CEXVarStruct *outputVar;
194  CEXVarStruct *inputVar;
195}CEXStruct;
196
197
198/*---------------------------------------------------------------------------*/
199/* Variable declarations                                                     */
200/*---------------------------------------------------------------------------*/
201Hrc_Manager_t *hmgrGlobalC;
202
203FILE *vis_stderr;
204FILE *vis_stdout;
205FILE *vis_historyFile;
206FILE *vis_stdpipe;
207array_t *vm_commandHistoryArray;
208char *vm_programName;
209static int mcTimeOut;   //Time-out value for model-checking
210static jmp_buf timeOutEnv;
211static long alarmLapTime;       /* starting CPU time for timeout */
212static jmp_buf env;
213
214extern FILE *IoYyin;
215extern int globalCurrentStackDepth;
216#ifdef IODEBUG
217extern int IoYydebug;
218#endif /*IODEBUG */
219
220char currentPath [LENGTH_1];
221static CEXVarStruct *testCEXVar;
222static CEXStruct *testCEX;
223
224
225/*---------------------------------------------------------------------------*/
226/* Static function prototypes                                                */
227/*---------------------------------------------------------------------------*/
228
229static Hrc_Manager_t *read_blif_mvMine (FILE *fp, Hrc_Manager_t *hmgr, boolean isCanonical, boolean isIncremental, boolean isVerbose);
230static int read_fairnessMine (Hrc_Manager_t ** hmgr, int argc, char ** argv);
231static int init_verifyMine (Hrc_Manager_t ** hmgr, int argc, char ** argv);
232static int flatten_hierarchyMine (Hrc_Manager_t ** hmgr, int argc, char ** argv);
233static int static_orderMine (Hrc_Manager_t ** hmgr, int argc, char ** argv);
234static int build_partition_mddsMine (Hrc_Manager_t ** hmgr, int argc, char ** argv);
235static int build_partition_maigsMine(Hrc_Manager_t ** hmgr, int argc, char ** argv);
236static int print_ioMine (Hrc_Manager_t **hmgr, int argc, char **argv);
237static int model_checkMine (Hrc_Manager_t **hmgr, int argc, char **argv);
238static int print_modelsMine(Hrc_Manager_t **hmgr, int argc, char **argv);
239static int print_fairnessMine(Hrc_Manager_t ** hmgr, int argc, char ** argv);
240static Hrc_Node_t *cdMine(Hrc_Manager_t **hmgr, int argc, char **argv); //returns child or parent node
241static Hrc_Node_t *lsMine(Hrc_Manager_t **hmgr, int argc, char **argv); //returns current node
242static char *pwdMine(Hrc_Manager_t **hmgr, int argc, char **argv); //returns the path of the current node
243static int print_latchesMine(Hrc_Manager_t **hmgr, int argc, char **argv);
244
245static boolean McPrintPassFailMine (mdd_manager *mddMgr, Fsm_Fsm_t *modelFsm, Mc_FwdBwdAnalysis traversalDirection, Ctlp_Formula_t *ctlFormula, mdd_t *ctlFormulaStates, mdd_t *modelInitialStates, array_t *modelCareStatesArray, McOptions_t *options, Mc_VerbosityLevel verbosity);
246static int McFsmDebugFormulaMine (McOptions_t *options, Ctlp_Formula_t *ctlFormula, Fsm_Fsm_t *modelFsm,   array_t *careSetArray);
247static array_t * McFsmStateDebugFormulaMine( McOptions_t *options, Ctlp_Formula_t *ctlFormula, mdd_t *aState,  Fsm_Fsm_t *modelFsm, array_t *careSetArray, array_t *prevCExArray);
248static array_t * FsmStateDebugConvertedFormulaMine(McOptions_t *options, Ctlp_Formula_t *ctlFormula, mdd_t *aState, Fsm_Fsm_t *modelFsm, array_t *careSetArray, array_t **preCExArray);
249static array_t * FsmPathDebugFormulaMine(McOptions_t *options, Ctlp_Formula_t *ctlFormula, Fsm_Fsm_t *modelFsm, McPath_t *witnessPath, array_t *careSetArray, array_t **preCExArray);
250
251static void DebugIDMine(McOptions_t *options, Ctlp_Formula_t *aFormula, mdd_t *aState, Fsm_Fsm_t *modelFsm);
252static void DebugTrueFalseMine(Ctlp_Formula_t *aFormula, mdd_t *aState, Fsm_Fsm_t *modelFsm);
253static array_t * DebugBooleanMine(McOptions_t *options, Ctlp_Formula_t *aFormula, mdd_t *aState, Fsm_Fsm_t *modelFsm, array_t *careSetArray, array_t **preCExArray);
254static McPath_t * DebugEXMine (Ctlp_Formula_t *aFormula, mdd_t *aState, Fsm_Fsm_t *modelFsm, array_t *careSetArray);
255static McPath_t * DebugEUMine (Ctlp_Formula_t *aFormula, mdd_t *aState, Fsm_Fsm_t *modelFsm, array_t *careSetArray);
256static McPath_t * DebugEGMine (Ctlp_Formula_t *aFormula, mdd_t *aState, Fsm_Fsm_t *modelFsm, array_t *careSetArray, McOptions_t *options);
257
258static array_t * FsmPathDebugEXFormulaMine(McOptions_t *options, Ctlp_Formula_t *ctlFormula, Fsm_Fsm_t *modelFsm, McPath_t *witnessPath, array_t *careSetArray, array_t **preCExArray);
259static array_t * FsmPathDebugEUFormulaMine(McOptions_t *options, Ctlp_Formula_t *ctlFormula, Fsm_Fsm_t *modelFsm, McPath_t *witnessPath, array_t *careSetArray, array_t **preCExArray);
260static array_t * FsmPathDebugEGFormulaMine(McOptions_t *options, Ctlp_Formula_t *ctlFormula, Fsm_Fsm_t *modelFsm, McPath_t *witnessPath, array_t *careSetArray, array_t **preCExArray);
261static array_t * FsmPathDebugEFFormulaMine(McOptions_t *options, Ctlp_Formula_t *ctlFormula, Fsm_Fsm_t *modelFsm, McPath_t *witnessPath, array_t *careSetArray, array_t **preCExArray);
262
263static array_t * FsmPathDebugAXFormulaMine(McOptions_t *options, Ctlp_Formula_t *ctlFormula, Fsm_Fsm_t *modelFsm, McPath_t *counterExamplePath, array_t *careSetArray, array_t **preCExArray);
264static array_t * FsmPathDebugAFFormulaMine(McOptions_t *options, Ctlp_Formula_t *ctlFormula, Fsm_Fsm_t *modelFsm, McPath_t *counterExamplePath, array_t *careSetArray, array_t **preCExArray);
265static array_t * FsmPathDebugAGFormulaMine(McOptions_t *options, Ctlp_Formula_t *ctlFormula, Fsm_Fsm_t *modelFsm, McPath_t *counterExamplePath, array_t *careSetArray, array_t **preCExArray);
266static array_t * FsmPathDebugAUFormulaMine(McOptions_t *options, mdd_t *aState, Ctlp_Formula_t *ctlFormula, Fsm_Fsm_t *modelFsm, array_t *careSetArray, array_t **preCExArray);
267
268static int Mc_PrintPathMine (array_t *aPath, Fsm_Fsm_t *modelFsm, boolean printInput);
269static void McPrintTransitionMine (mdd_t *aState, mdd_t *bState, mdd_t *uInput, mdd_t *vInput, array_t *stateSupport, array_t *inputSupport, boolean printInputs, Fsm_Fsm_t *modelFsm, CEXStruct *CEXPath, int seqNumber, BmcCnfClauses_t *cnfClauses);
270static void Mc_MintermPrintMine (mdd_t *aMinterm, array_t *support, Ntk_Network_t *aNetwork);
271static char *Mc_MintermToStringMine( mdd_t *aMinterm, array_t *aSupport, Ntk_Network_t *aNetwork, CEXStruct *CEXPath, int seqNumber, boolean inOutIndicator, BmcCnfClauses_t *cnfClauses);
272static array_t *McConvertMintermToValueArrayMine( mdd_t *aMinterm, array_t *aSupport, mdd_manager *mddMgr);
273static void McStatePassesOrFailsFormulaMine ( mdd_t *aState, Ctlp_Formula_t *formula, int pass, McDbgLevel debugLevel, Fsm_Fsm_t *modelFsm);
274static void McStateFailsFormulaMine (mdd_t *aState, Ctlp_Formula_t *formula, McDbgLevel debugLevel, Fsm_Fsm_t *modelFsm);
275static void McStatePassesFormulaMine( mdd_t *aState, Ctlp_Formula_t *formula, McDbgLevel debugLevel,Fsm_Fsm_t *modelFsm);
276
277static int _HrcStringCmp(const void * s1,  const void * s2);
278static McOptions_t *ParseMcOptions( int argc,  char **argv);
279static void TimeOutHandle(void);
280static Ord_OrderType StringConvertToOrderType(char *string);
281static boolean NetworkCheckSuppliedNodeList(Ntk_Network_t * network, lsList suppliedNodeList, Ord_OrderType orderType);
282static boolean FileReadNameList(FILE * fp, lsList * nameList, int verbose);
283static void _IoGlobalVariablesInitialize(void);
284static void _IoGlobalVariablesFree(void);
285static void _IoGlobalSubcktInfoFree(void);
286static void _IoSubcktArrayFree(array_t *array);
287static void _IoSubcktFree(IoSubckt_t *subckt);
288static void _IoGlobalResetInfoFree(void);
289static boolean _IoNodeTestCompatibilityAux(Hrc_Manager_t *hmgr, Hrc_Node_t *hnode1, Hrc_Node_t *hnode2, boolean mode);
290static void _IoManagerCanonicalize(Hrc_Manager_t *hmgr);
291static int nodenameCompare(const void * node1, const void * node2);
292static void PrintNodeStats(Hrc_Node_t *node, boolean isHnode);
293static void NodeListChildren(Hrc_Node_t *hnode, boolean recursiveFlag, int depth);
294static array_t *NodeListChildrenMine(Hrc_Node_t *hnode, boolean recursiveFlag, int depth);
295static void PrintSpace(int depth);
296static int cmp(const void * s1, const void * s2);
297static boolean MintermCheckWellFormed(mdd_t *aMinterm, array_t *aSupport, mdd_manager *mddMgr);
298static boolean SetCheckSupport(mdd_t *aMinterm, array_t *aSupport, mdd_manager *mddMgr);
299
300static char *CNFVariableNameConstructor(char *varName, int varEncoding, int pathIndex);
301static void BmcCnfGenerateClausesForPathMine (Ntk_Network_t *network, int from, int to, int initialState, BmcCnfClauses_t *cnfClauses, st_table *nodeToMvfAigTable, st_table *CoiTable);
302static void BmcGenerateClausesFromStateTostateMine (bAig_Manager_t  *manager, bAigEdge_t *fromAigArray, bAigEdge_t *toAigArray, int mvfSize, int fromState, int toState, BmcCnfClauses_t *cnfClauses, int outIndex);
303static void BmcWriteClausesMine( mAig_Manager_t  *maigManager, FILE *cnfFile, BmcCnfClauses_t *cnfClauses, BmcOption_t *options);
304static int *DecBinConverter (int decValue, int size, int *binValue);
305static int SATSolverFileGen (Hrc_Manager_t **hmgr, char *fileName, int steps, BmcOption_t *options);
306static int SATSolver (int steps, BmcOption_t *options);
307static void build_unroll_circuit(Ntk_Network_t * ntk, int bound,BmcOption_t * options,BmcCnfClauses_t* cnfClauses);
308static array_t * checkSATCircus( satManager_t *cm,BmcOption_t * options, boolean unsatcore,     satArray_t *clauseIndexInCore);
309static st_table * generateAllLatches(Ntk_Network_t * ntk);
310static void printSATAssig( array_t* result);
311static int findIndex(BmcCnfClauses_t* cnfClauses , char * nodeName);
312
313
314/********************************************************/
315/* Main                                                 */
316/********************************************************/
317
318int main(int  argc,  char **argv)
319{
320        vis_stderr =stderr;
321        vis_stdout = stdout;
322
323        Hrc_Manager_t *hmgrC;
324        Hrc_Manager_t *hmgrA;
325
326   (void)fprintf(vis_stderr,"\n============= VIS ============= \n\n");
327
328
329 /**** CONCRETE MODEL *****/
330   (void)fprintf(vis_stderr,">>>>>>>>>>>>>>>>> CONCRETE MODEL : LOAD & SET UP... \n\n");
331        // --- read_blif_mv ---
332   FILE *fpC;
333   fpC = Cmd_FileOpen(BLIF_MV_FILE_C1, "r", NIL(char *), 1);
334   boolean isCanonicalC = 0;
335   boolean isIncrementalC = 0; 
336   boolean isVerboseC = 0;
337   hmgrC = read_blif_mvMine (fpC, hmgrC, isCanonicalC, isIncrementalC, isVerboseC);
338   (void) fprintf(vis_stderr, "*** 'read_blif_mv' of the concrete model completed. *** \n");
339
340   hmgrGlobalC = hmgrC;
341
342        // --- print_io (display inputs and outputs) ---
343   int print_ioExecC;
344   int argcIOC = 1;
345   char *argvIOC[1] = {"print_io"};
346
347   print_ioExecC = print_ioMine (&hmgrC, argcIOC, argvIOC); 
348   (void) fprintf(vis_stderr, "*** 'print_io' for concrete model completed. *** \n");
349
350        // --- init_verify ---
351   int init_verifyExecC;
352   int argcIVC = 1;
353   char *argvIVC[1] = {"init_verify"};
354   init_verifyExecC = init_verifyMine (&hmgrC, argcIVC, argvIVC); 
355   (void) fprintf(vis_stderr, "*** 'init_verify' for concrete model completed. *** \n");
356
357        // --- build_partition_maigs ---
358   int build_part_maigsExecC;
359   int argcBPMAIGSC = 1;
360   char *argvBPMAIGSC[1] = {"build_partition_maigs"};
361   build_part_maigsExecC = build_partition_maigsMine (&hmgrC, argcBPMAIGSC, argvBPMAIGSC);
362   (void) fprintf(vis_stderr, "*** 'build_partition_maigs' for concrete model completed. *** \n");
363
364        // --- read_fairness ---
365   int fairnessReadC;
366   int argcFC = 2;
367   char *argvFC[2] = {"read_fairness", FAIRNESS_FILE_C1};
368   fairnessReadC = read_fairnessMine (&hmgrC, argcFC, argvFC); 
369   (void) fprintf(vis_stderr, "*** 'read_fairness' for concrete model completed. *** \n");
370
371        // --- print_fairness ---
372   int fairnessPrintC;
373   int argcFPC = 1;
374   char *argvFPC[1] = {"print_fairness"};
375   fairnessPrintC = print_fairnessMine (&hmgrC, argcFPC, argvFPC); 
376   (void) fprintf(vis_stderr, "*** 'print_fairness' for concrete model completed. *** \n");
377
378
379//      // --- print_latches (display latches in current node) ---
380//    int print_latchesExec;
381//    int argcPL = 1;
382//    char *argvPL[1]= {"print_latches"};
383//
384//    print_latchesExec = print_latchesMine (&hmgr, argcPL, argvPL);
385//    (void) fprintf(vis_stderr, "*** 'print_latches' completed. *** \n");
386
387   (void)fprintf(vis_stderr,"\n... CONCRETE MODEL : LOAD & SET UP DONE! <<<<<<<<<<<<<<<<\n\n");
388
389
390
391 /**** ABSTRACT MODEL *****/
392   (void)fprintf(vis_stderr,">>>>>>>>>>>>>>>>> ABSTRACT MODEL : LOAD & SET UP...\n");
393        // --- read_blif_mv ---
394   FILE *fpA;
395   fpA = Cmd_FileOpen(BLIF_MV_FILE_A1, "r", NIL(char *), 1);
396   boolean isCanonicalA = 0;
397   boolean isIncrementalA = 0; 
398   boolean isVerboseA = 0;
399   hmgrA = read_blif_mvMine (fpA, hmgrA, isCanonicalA, isIncrementalA, isVerboseA);
400   (void) fprintf(vis_stderr, "*** 'read_blif_mv' of the abstract model completed. *** \n");
401 
402
403        // --- print_io (display inputs and outputs) ---
404   int print_ioExecA;
405   int argcIOA = 1;
406   char *argvIOA[1] = {"print_io"};
407
408   print_ioExecA = print_ioMine (&hmgrA, argcIOA, argvIOA); 
409   (void) fprintf(vis_stderr, "*** 'print_io' for abstract model completed. *** \n");
410
411        // --- init_verify ---
412   int init_verifyExecA;
413   int argcIVA = 1;
414   char *argvIVA[1] = {"init_verify"};
415   init_verifyExecA = init_verifyMine (&hmgrA, argcIVA, argvIVA); 
416   (void) fprintf(vis_stderr, "*** 'init_verify' for abstract model completed. *** \n");
417
418        // --- read_fairness ---
419   int fairnessReadA;
420   int argcFA = 2;
421   char *argvFA[2] = {"read_fairness", FAIRNESS_FILE_A1};
422   fairnessReadA = read_fairnessMine (&hmgrA, argcFA, argvFA); 
423   (void) fprintf(vis_stderr, "*** 'read_fairness' for abstract model completed. *** \n");
424
425        // --- print_fairness ---
426   int fairnessPrintA;
427   int argcFPA = 1;
428   char *argvFPA[1] = {"print_fairness"};
429   fairnessPrintA = print_fairnessMine (&hmgrA, argcFPA, argvFPA); 
430   (void) fprintf(vis_stderr, "*** 'print_fairness' for abstract model completed. *** \n");
431
432   (void)fprintf(vis_stderr,"\n... ABSTRACT MODEL : LOAD & SET UP DONE! <<<<<<<<<<<<<<<<\n\n");
433
434        // --- model_check ---
435   int model_checkExecA;
436   int argcMCA = 4;
437//   char *argvMC[2]= {"model_check", "EX_C1/machine_concret.ctl"};
438//   char *argvMC[4]= {"model_check", "-d", "3", "EX_C1/machine_concret.ctl"};
439//   char *argvMCA[2]= {"model_check", CTL_FILE_A1};
440//   char *argvMCA[4]= {"model_check", "-d", "1", CTL_FILE_A1};
441   char *argvMCA[4]= {"model_check", "-d", "2", CTL_FILE_A1};
442//   char *argvMCA[4]= {"model_check", "-d", "3", CTL_FILE_A1};
443//   char *argvMCA[5]= {"model_check", "-i", "-d", "3", CTL_FILE_A1};
444//   char *argvMC[6]= {"model_check", "-i", "-W", "-d", "2", "EX_C1/machine_concret.ctl"};
445//   char *argvMCA[6]= {"model_check", "-d", "2", "-f", DEBUG_FILE_A1, CTL_FILE_A1};
446//   char *argvMC[6]= {"model_check", "-v", "2", "-d", "2", "EX_C1/machine_concret.ctl"};
447//   char *argvMC[7]= {"model_check", "-i", "-w", "EX_C1/w_node_file", "-d", "2", "EX_C1/machine_concret.ctl"};
448//   char *argvMC[7]= {"model_check", "-d", "3", "-f", DEBUG_FILE_A1, "-i", CTL_FILE_A1};
449//   char *argvMC[8]= {"model_check", "-d", "3", "-f", "EX_C1/debug_trace", "-v", "2", "EX_C1/machine_concret.ctl"};
450//   char *argvMC[9]= {"model_check", "-d", "3", "-f", "EX_C1/debug_trace", "-i", "-v", "2", "EX_C1/machine_concret.ctl"};
451
452   model_checkExecA = model_checkMine (&hmgrA, argcMCA, argvMCA);
453   (void) fprintf(vis_stderr, "*** 'model_check' of abstract model completed. *** \n");
454
455
456   (void) fprintf(vis_stderr,"\n========== END OF VIS ========= \n\n");
457
458   return 0;
459
460}
461
462
463/*---------------------------------------------------------------------------*/
464/*  Definition of static functions                                           */
465/*---------------------------------------------------------------------------*/
466
467/**Function********************************************************************
468
469  Synopsis []   
470
471  Description [Refer to 'Hrc_Manager_t * Io_BlifMvRead( FILE *fp,
472                Hrc_Manager_t *hmgr, boolean isCanonical, boolean isIncremental,
473                boolean isVerbose)' in ntkCmd.c]
474   
475  SideEffects []
476
477  SeeAlso     []
478
479******************************************************************************/
480
481static Hrc_Manager_t *read_blif_mvMine (FILE *fp, Hrc_Manager_t *hmgr, 
482                boolean isCanonical, boolean isIncremental, boolean isVerbose)
483{
484
485(void) fprintf(vis_stderr, "*** 'read_blif_mv' begins.  *** \n");
486
487  Hrc_Node_t *root;
488  static Hrc_Manager_t *newHmgr;
489
490  if (isIncremental == 0){
491    newHmgr = Hrc_ManagerAlloc(); 
492  }
493  else { /* isIncremental == 1 */
494    if (Hrc_ManagerReadCurrentNode(hmgr) == NIL(Hrc_Node_t)){
495      (void)fprintf(vis_stderr,"No hierarchy has been created. Cannot do inremental read-in.\n");
496      return NIL(Hrc_Manager_t);
497    }
498    newHmgr = hmgr;
499  }
500
501  if (setjmp(env)){
502    if (isIncremental == 0){
503      Hrc_ManagerFree(newHmgr);
504    }
505    else {
506      int i;
507      /* free all the new models defined in an incremental file */
508      for (i=0; i < array_n(globalNewModelArray); i++){
509        Hrc_ModelDelete(hmgr,Hrc_ModelReadName(array_fetch(Hrc_Model_t *,globalNewModelArray,i)));
510      }
511    }
512    _IoGlobalVariablesFree();
513    return NIL(Hrc_Manager_t);
514  }
515  else {
516    _IoGlobalVariablesInitialize();
517    if (isIncremental == 0){
518      globalYaccHmgr = newHmgr;
519    }
520    else {
521      globalYaccHmgr = hmgr;
522    }
523#ifdef IODEBUG
524    IoYydebug = 1;
525#endif /* IODEBUG */
526    IoYyin = fp;
527    IoYyrestart(IoYyin);
528    if (IoYyparse() == 1){
529      IoError();
530    }
531
532    /* globalNewModelArray contains all the models defined in the previous
533    IoYyparse(). If isIncremental==0, then they are simply all the models.
534    If isIncremental==1, then they are new models defined in the file. */
535
536    if (IoNetworkTestConsistency(newHmgr,globalNewModelArray,globalParserSubcktInfo,globalParserResetInfo,isVerbose) == 0){
537      IoError();
538    }
539
540    if (globalRootModel == NIL(Hrc_Model_t)){
541      globalRootModel = globalFirstModel;
542      globalRootInstanceName = util_strsav(Hrc_ModelReadName(globalRootModel));
543    }
544    else if (globalRootInstanceName == NIL(char)){
545      globalRootInstanceName = util_strsav(Hrc_ModelReadName(globalRootModel));
546    }
547
548    if (isCanonical == 1){
549      _IoManagerCanonicalize(newHmgr);
550    }
551
552    root = Hrc_ModelCreateHierarchy(newHmgr,globalRootModel,globalRootInstanceName);
553    FREE(globalRootInstanceName);
554
555    if (isIncremental == 0){
556      Hrc_ManagerSetRootNode(newHmgr,root);
557      Hrc_ManagerSetCurrentNode(newHmgr,root);
558      _IoGlobalVariablesFree();
559      return newHmgr;
560    }   
561    else { /* isIncremental == 1, note that newHmgr == hmgr  */
562      if (_IoNodeTestCompatibility(hmgr,Hrc_ManagerReadCurrentNode(hmgr),root) == 0){
563        int i;
564        (void)fprintf(vis_stderr,"The blif-mv file is not compatible with the existing hierarchy.\n");
565        Hrc_TreeReplace(NIL(Hrc_Node_t),root);
566        /* free all the new models defined in an incremental file */
567        for (i=0; i < array_n(globalNewModelArray); i++){
568          Hrc_ModelDelete(hmgr,Hrc_ModelReadName(array_fetch(Hrc_Model_t *,globalNewModelArray,i)));
569        }
570        _IoGlobalVariablesFree();
571        return NIL(Hrc_Manager_t);
572      }
573      Hrc_TreeReplace(Hrc_ManagerReadCurrentNode(hmgr),root);
574      Hrc_ManagerSetCurrentNode(hmgr,root);
575      _IoGlobalVariablesFree();
576      return hmgr;
577    }
578  }
579
580
581}
582
583
584/**Function********************************************************************
585
586  Synopsis []   
587
588  Description [Refer to 'static int CommandInitVerify(Hrc_Manager_t ** hmgr,
589                int argc, char ** argv);' in ntkCmd.c]
590   
591  SideEffects []
592
593  SeeAlso     []
594
595******************************************************************************/
596static int init_verifyMine (Hrc_Manager_t ** hmgr, int argc, char ** argv)
597{
598
599  (void) fprintf(vis_stderr, "*** 'init_verify' begins. *** \n");
600
601  int         c;
602  Hrc_Node_t *currentNode = Hrc_ManagerReadCurrentNode(*hmgr);
603 
604  /*
605   * Parse the command line.
606   */
607  util_getopt_reset();
608  while ((c = util_getopt(argc, argv, "bh")) != EOF) {
609    switch (c) {
610      case 'b':
611        break;
612      case 'h':
613        goto usage;
614      default:
615        goto usage;
616    }
617  }
618
619  if (currentNode == NIL(Hrc_Node_t)) { 
620    (void) fprintf(vis_stdout, "The hierarchy manager is empty.  Read in design.\n");
621    return 1;
622  }
623
624
625// ++ add condition to test if the functions failed
626  (void) fprintf(vis_stderr, "---- 'init_verify' : (1) ");
627        // --- init_verify : (1) flatten_hierarchy ---
628  int flatten_hierarchyExec;
629  int argcFH = 1;
630  char *argvFH[1]= {"flatten_hierarchy"};
631  flatten_hierarchyExec = flatten_hierarchyMine (hmgr, argcFH, argvFH);
632//  flatten_hierarchyExec = flatten_hierarchyMine (&(*hmgr), argcFH, argvFH);
633  (void) fprintf(vis_stderr, "---- 'init_verify' : (1) *** 'flatten_hierarchy' completed. *** \n");
634
635        // --- init_verify : (2) static_order ---
636 (void) fprintf(vis_stderr, "---- 'init_verify' : (2) ");
637  int static_orderExec;
638  int argcSO = 1;
639  char *argvSO[1]= {"static_order"};
640  static_orderExec = static_orderMine (hmgr, argcSO, argvSO);
641  (void) fprintf(vis_stderr, "---- 'init_verify' : (2) *** 'static_order' completed. *** \n");
642
643        // --- init_verify : (3) build_partition_mdds ---
644  (void) fprintf(vis_stderr, "---- 'init_verify' : (3) ");
645  int build_part_mddsExec;
646  int argcBPMDDS = 1;
647  char *argvBPMDDS[1]= {"build_partition_mdds"};
648  build_part_mddsExec =  build_partition_mddsMine (hmgr, argcBPMDDS, argvBPMDDS);
649  (void) fprintf(vis_stderr, "---- 'init_verify' : (3) *** 'build_partition_mdds' completed. *** \n");
650
651  return 0;             /* normal exit */
652
653
654usage:
655  (void) fprintf(vis_stderr, "usage: init_verify [-b] [-h]\n");
656  (void) fprintf(vis_stderr, "   -b  not used any longer.\n");
657  (void) fprintf(vis_stderr, "   -h  print the command usage\n");
658  return 1;             /* error exit */
659
660}
661
662
663/**Function********************************************************************
664
665  Synopsis []   
666
667  Description [Refer to 'static int CommandFlattenHierarchy(Hrc_Manager_t **
668                 hmgr, int argc, char ** argv);' in ntkCmd.c]
669   
670  SideEffects []
671
672  SeeAlso     []
673
674******************************************************************************/
675static int flatten_hierarchyMine (Hrc_Manager_t ** hmgr, int argc, char ** argv)
676{
677
678 (void) fprintf(vis_stderr, "*** 'flatten_hierarchy' begins. *** \n");
679
680  int            c;
681  Ntk_Network_t *network;
682  char          *fileName    = NIL(char);
683  int            verbose     = 0;       /* default */
684  int            sweep       = 1; 
685  lsList         varNameList = (lsList) NULL;
686  Hrc_Node_t    *currentNode = Hrc_ManagerReadCurrentNode(*hmgr);
687 
688  /*
689   * Parse the command line.
690   */
691  util_getopt_reset();
692  while ((c = util_getopt(argc, argv, "a:bhsv:")) != EOF) {
693    switch (c) {
694      case 'a':
695        fileName = util_optarg;
696        break;
697      case 'b':
698        break;
699      case 'h':
700        goto usage;
701      case 's':
702        sweep = 0;
703        break;       
704      case 'v':
705        verbose = atoi(util_optarg);
706        break;
707      default:
708        goto usage;
709    }
710  }
711
712  if (currentNode == NIL(Hrc_Node_t)) { 
713    (void) fprintf(vis_stdout, "The hierarchy manager is empty.  Read in design.\n");
714    return 1;
715  }
716   
717  /*
718   * Process the file containing the variable names.
719   */
720  if (fileName != NIL(char)) {
721    FILE *fp = Cmd_FileOpen(fileName, "r", NIL(char *), 0);
722    if (fp == NIL(FILE)) {
723      return 1;
724    }
725    else {
726      boolean status;
727     
728      error_init();
729      status = FileReadNameList(fp, &varNameList, verbose);
730      (void) fclose(fp);
731      if (status == FALSE) {
732        (void) fprintf(vis_stderr, "Error reading variable name file:\n");
733        (void) fprintf(vis_stderr, "%s", error_string());
734        (void) fprintf(vis_stderr, "Cannot perform flatten_hierarchy.\n");
735        return 1;
736      }
737    }
738  }
739
740 
741  /*
742   * If a network already exists, delete it.  Then create the new one, and
743   * register it with the hrcNode.
744   */
745  network = (Ntk_Network_t *) Hrc_NodeReadApplInfo(currentNode,
746                                                   NTK_HRC_NODE_APPL_KEY);
747  if (network != NIL(Ntk_Network_t)) {
748    (void) fprintf(vis_stdout, "Deleting current network and creating new one.\n");
749    Hrc_NodeFreeApplInfo(currentNode, NTK_HRC_NODE_APPL_KEY);
750  }
751
752  error_init();
753
754  network = Ntk_HrcNodeConvertToNetwork(currentNode, TRUE, varNameList);
755
756  /* Clean up the varNameList. */
757  if (varNameList != (lsList) NULL) {
758    lsGen  gen;
759    char  *varName;
760   
761    lsForEachItem(varNameList, gen, varName) {
762      FREE(varName);
763    }
764    (void) lsDestroy(varNameList, (void (*) (lsGeneric)) NULL);
765  }
766  /* sweep network */
767  if (network != NIL(Ntk_Network_t) && sweep ==1) {
768    Ntk_NetworkSweep(network, verbose); 
769  }
770 
771  if (network == NIL(Ntk_Network_t)) {
772    (void) fprintf(vis_stderr, "%s", error_string());
773    (void) fprintf(vis_stderr, "Cannot perform flatten_hierarchy.\n");
774    return 1;
775  }
776 
777  Hrc_NodeAddApplInfo(currentNode, NTK_HRC_NODE_APPL_KEY,
778                      (Hrc_ApplInfoFreeFn) Ntk_NetworkFreeCallback,
779                      (Hrc_ApplInfoChangeFn) NULL,  /* not currently used by hrc */
780                      (void *) network);
781
782  return 0;             /* normal exit */
783
784usage:
785  (void) fprintf(vis_stderr, "usage: flatten_hierarchy [-a file] [-b] [-h] [-s] [-v #]\n");
786  (void) fprintf(vis_stderr, "   -a file  variables to abstract\n");
787  (void) fprintf(vis_stderr, "   -b       not used any longer\n");
788  (void) fprintf(vis_stderr, "   -h       print the command usage\n");
789  (void) fprintf(vis_stderr, "   -s       do not perform a sweep\n"); 
790  (void) fprintf(vis_stderr, "   -v #     verbosity level\n");
791  return 1;             /* error exit */
792}
793
794
795/**Function********************************************************************
796
797  Synopsis []   
798
799  Description [Refer to 'static int CommandStaticOrder(Hrc_Manager_t ** hmgr,
800                int argc, char ** argv);' in ordCmd.c]
801   
802  SideEffects []
803
804  SeeAlso     []
805
806******************************************************************************/
807static int static_orderMine (Hrc_Manager_t ** hmgr, int argc, char ** argv)
808{
809
810 (void) fprintf(vis_stderr, "*** 'static_order' begins. *** \n");
811
812  int                   c;
813  FILE                 *fp;
814  static int            timeOutPeriod;
815  static int            verbose;
816  static Ord_NodeMethod nodeMethod;
817  static Ord_RootMethod rootMethod;
818  static Ord_OrderType  suppliedOrderType;
819  static Ord_OrderType  generatedOrderType;
820  static boolean        nsAfterSupport;
821  lsList                suppliedNodeList = (lsList) NULL;
822                                /* list of Ntk_Node_t * */
823  Ntk_Network_t        *network;
824
825  /*
826   * These are the default values.  These variables must be declared static
827   * to avoid lint warnings.  Since they are static, we must reinitialize
828   * them outside of the variable declarations.
829   */
830  timeOutPeriod      = 0; 
831  verbose            = 0;
832  nodeMethod         = Ord_NodesByDefault_c;
833  rootMethod         = Ord_RootsByDefault_c;
834  suppliedOrderType  = Ord_Unassigned_c;   /* default */
835  generatedOrderType = Ord_InputAndLatch_c;/* default */
836  nsAfterSupport     = FALSE;              /* default */
837 
838  /*
839   * Parse the command line.
840   */
841  util_getopt_reset();
842  while ((c = util_getopt(argc, argv, "av:o:s:t:n:r:h")) != EOF) {
843    switch (c) {
844      case 'a':
845        nsAfterSupport = TRUE;
846        break;
847      case 'h':
848        goto usage;
849      case 'v':
850        verbose = atoi(util_optarg);
851        break;
852      case 't':
853        timeOutPeriod = atoi(util_optarg);
854        break;
855      case 'o':
856        generatedOrderType = StringConvertToOrderType(util_optarg);
857        if ((generatedOrderType == Ord_NextStateNode_c)
858            || (generatedOrderType == Ord_Partial_c)) { 
859          (void) fprintf(vis_stderr, "disallowed output order type: %s\n", util_optarg);
860          goto usage;
861        }
862        else if (generatedOrderType == Ord_Unassigned_c) {
863          (void) fprintf(vis_stderr, "unknown output order type: %s\n", util_optarg);
864          goto usage;
865        }
866        break;
867      case 's':
868        suppliedOrderType = StringConvertToOrderType(util_optarg);
869        if (suppliedOrderType == Ord_Unassigned_c) {
870          (void) fprintf(vis_stderr, "unknown input order type: %s\n", util_optarg);
871          goto usage;
872        }
873        break;
874      case 'n':
875        if (strcmp("interleave", util_optarg) == 0) { 
876          nodeMethod = Ord_NodesByInterleaving_c;
877        }
878        else if (strcmp("merge_left", util_optarg) == 0) { 
879          nodeMethod = Ord_NodesByMergingLeft_c;
880        }
881        else if (strcmp("merge_right", util_optarg) == 0) { 
882          nodeMethod = Ord_NodesByMergingRight_c;
883        }
884        else if (strcmp("append", util_optarg) == 0) { 
885          nodeMethod = Ord_NodesByAppending_c;
886        }
887        else {
888          (void) fprintf(vis_stderr, "unknown node order method: %s\n", util_optarg);
889          goto usage;
890        }
891        break;
892      case 'r':
893        if (strcmp("depth", util_optarg) == 0) { 
894          rootMethod = Ord_RootsByDepth_c;
895        }
896        else if (strcmp("mincomm", util_optarg) == 0) { 
897          rootMethod = Ord_RootsByPerm_c;
898        }
899        else {
900          (void) fprintf(vis_stderr, "unknown root order method: %s\n", util_optarg);
901          goto usage;
902        }
903        break;
904      default:
905        goto usage;
906    }
907  }
908
909  network = Ntk_HrcManagerReadCurrentNetwork(*hmgr);
910  if (network == NIL(Ntk_Network_t)) {
911    return 1;
912  }
913
914  if ((suppliedOrderType == Ord_InputAndLatch_c) && (generatedOrderType == Ord_All_c)) {
915    (void) fprintf(vis_stderr, "-o all -s input_and_latch not currently supported\n");
916    return 1;
917  }
918
919  /*
920   * The minimum set of variables that can be ordered are those specified by
921   * Ord_InputAndLatch_c.  If these have already been ordered, then just return.
922   */
923  if (Ord_NetworkTestAreVariablesOrdered(network, Ord_InputAndLatch_c)) {
924    (void) fprintf(vis_stderr, "Variables already ordered. ");
925    (void) fprintf(vis_stderr, "Reinvoke flatten_hierarchy to undo variable ordering.\n");
926    return 1;
927  }
928 
929   
930  /*
931   * Process the input ordering file.
932   */
933  if (suppliedOrderType == Ord_Unassigned_c) {
934    if (argc - util_optind > 0) {
935      (void) fprintf(vis_stderr, "must specify -s if supplying order file\n");
936      goto usage;
937    }
938  }
939  else {
940    if (argc - util_optind == 0) {
941      (void) fprintf(vis_stderr, "order file not provided\n");
942      goto usage;
943    }
944    else if (argc - util_optind > 1) {
945      (void) fprintf(vis_stderr, "too many arguments\n");
946      goto usage;
947    }
948
949    fp = Cmd_FileOpen(argv[util_optind], "r", NIL(char *), 0);
950    if (fp == NIL(FILE)) {
951      (void) fprintf(vis_stderr, "File %s is not readable, please check if it exists\n", argv[util_optind]);
952      return 1;
953    }
954    else {
955      boolean status;
956     
957      error_init();
958      status = Ord_FileReadNodeList(fp, network, &suppliedNodeList, verbose);
959      if (status == FALSE) {
960        (void) fprintf(vis_stderr, "Error reading ordering file:\n");
961        (void) fprintf(vis_stderr, "%s", error_string());
962        (void) fprintf(vis_stderr, "Cannot perform static ordering.\n");
963        (void) fclose(fp);
964        return 1;
965      }
966      else if (NetworkCheckSuppliedNodeList(network, suppliedNodeList,
967                                            suppliedOrderType) == FALSE) { 
968        (void) fprintf(vis_stderr, "Incorrect nodes supplied:\n");
969        (void) fprintf(vis_stderr, "%s", error_string());
970        (void) fprintf(vis_stderr, "Cannot perform static ordering.\n");
971        (void) fclose(fp);
972        (void) lsDestroy(suppliedNodeList, (void (*) (lsGeneric)) NULL);
973        return 1;
974      }
975      else {
976        (void) fclose(fp);
977        if (verbose > 0) {
978          (void) fprintf(vis_stdout, "\nNodes supplied in ordering file, ");
979          (void) fprintf(vis_stdout, "according to -s option: \n");
980          OrdNodeListWrite(vis_stdout, suppliedNodeList);
981        }
982      }
983    }
984  }
985 
986 
987  /*
988   * In order for static ordering to proceed, network must not have any
989   * combinational cycles.
990   */
991  error_init();
992  if(Ntk_NetworkTestIsAcyclic(network) == 0) {
993    (void) fprintf(vis_stderr, "Combinational cycle found: ");
994    (void) fprintf(vis_stderr, "%s\n", error_string());
995    (void) fprintf(vis_stderr, "cannot perform static ordering\n");
996    if (suppliedOrderType != Ord_Unassigned_c) {
997      (void) lsDestroy(suppliedNodeList, (void (*) (lsGeneric)) NULL);
998    }
999    return 1;
1000  }
1001
1002  /* Start the timer before calling the variable ordering routine. */
1003  if (timeOutPeriod > 0){
1004    (void) signal(SIGALRM, (void(*)(int))TimeOutHandle);
1005    (void) alarm(timeOutPeriod);
1006    if (setjmp(timeOutEnv) > 0) {
1007      (void) fprintf(vis_stderr, "Timeout occurred after %d seconds.\n", timeOutPeriod);
1008      alarm(0);
1009      return 1;
1010    }
1011  }
1012
1013  /*
1014   * Order the variables.
1015   */
1016  Ord_NetworkOrderVariables(network, rootMethod, nodeMethod, nsAfterSupport, 
1017                            generatedOrderType, suppliedOrderType,
1018                            suppliedNodeList, verbose);
1019
1020  if (suppliedOrderType != Ord_Unassigned_c) {
1021    (void) lsDestroy(suppliedNodeList, (void (*) (lsGeneric)) NULL);
1022  }
1023
1024  /*
1025   * As a sanity check, make sure that all the variables in generatedOrderType
1026   * have an MDD id.
1027   */
1028  assert(Ord_NetworkTestAreVariablesOrdered(network, generatedOrderType));
1029 
1030  alarm(0);
1031  return 0;  /* Everything okay */
1032
1033  usage:
1034  (void) fprintf(vis_stderr, "usage: static_order [-a] [-h] [-n method] [-o type] [-r method] -s type [-t time] [-v #] file\n");
1035  (void) fprintf(vis_stderr, "   -a        order NS variables after support\n");
1036  (void) fprintf(vis_stderr, "   -h        print the command usage\n");
1037  (void) fprintf(vis_stderr, "   -n method node ordering method\n");
1038  (void) fprintf(vis_stderr, "             (interleave (default), append, merge_left, merge_right)\n");
1039  (void) fprintf(vis_stderr, "   -o type   nodes to order (all, input_and_latch (default))\n");
1040  (void) fprintf(vis_stderr, "   -r method root ordering method (depth, mincomm (default for < 30 latches))\n");
1041  (void) fprintf(vis_stderr, "   -s type   nodes in file (all, input_and_latch, next_state_node, partial)\n");
1042  (void) fprintf(vis_stderr, "   -t time   time out period (in seconds)\n");
1043  (void) fprintf(vis_stderr, "   -v #      verbosity level\n");
1044  (void) fprintf(vis_stderr, "   file      supplied ordering of nodes\n");
1045
1046  return 1;
1047
1048}
1049
1050
1051/**Function********************************************************************
1052
1053  Synopsis []   
1054
1055  Description [Refer to 'static int CommandBuildPartitionMdds(Hrc_Manager_t **
1056                 hmgr, int argc, char ** argv);' in partCmd.c]
1057   
1058  SideEffects []
1059
1060  SeeAlso     []
1061
1062******************************************************************************/
1063static int build_partition_mddsMine (Hrc_Manager_t ** hmgr, int argc, char ** argv)
1064{
1065
1066  (void) fprintf(vis_stderr, "*** 'build_partition_mdds' begins. *** \n");
1067
1068  static Part_PartitionMethod method;
1069  static boolean              inTermsOfLeaves;
1070  lsList                      nodeList = lsCreate();
1071  graph_t                     *partition;
1072  static int                  verbose;
1073  static int                  sanityCheck;
1074  static int                  timeOutPeriod;
1075  int                         c;
1076  int                         length;
1077  char                        *methodString;
1078  char                        *modelName;
1079  Hrc_Node_t                  *currentNode;
1080  Ntk_Network_t               *network = Ntk_HrcManagerReadCurrentNetwork(*hmgr);
1081  char *nodeName;
1082  char *tmpNodeName;
1083  char *realName;
1084  FILE *nodeFile;
1085  static boolean fileUsed;
1086
1087  fileUsed = FALSE;
1088  inTermsOfLeaves = FALSE;
1089  verbose = 0;
1090  sanityCheck = 0;
1091  timeOutPeriod = 0;
1092
1093  nodeFile = NIL(FILE);
1094  util_getopt_reset();
1095  while ((c = util_getopt(argc, argv, "f:hvin:s:t:")) != EOF) {
1096    switch(c) {
1097      case 'f':
1098        fileUsed = TRUE;
1099        nodeFile = Cmd_FileOpen(util_optarg, "r", &realName, 1);
1100        FREE(realName);
1101        if (nodeFile == NIL(FILE)){
1102          (void)fprintf(vis_stderr,"Cannot open %s\n", util_optarg);
1103          lsDestroy(nodeList, (void (*)(lsGeneric))0);
1104          return 1;
1105        }
1106        else{
1107          tmpNodeName = ALLOC(char, 512);
1108          while(fscanf(nodeFile, "%s\n", tmpNodeName) != EOF){
1109            if(*tmpNodeName != '#'){
1110              nodeName = ALLOC(char, strlen(tmpNodeName) + 2);
1111              sprintf(nodeName, "%s", tmpNodeName);
1112              lsNewEnd(nodeList, (lsGeneric)nodeName, NIL(lsHandle));
1113            }
1114          }
1115          FREE(tmpNodeName);
1116        }
1117        break;
1118      case 'h':
1119        goto usage;
1120      case 'i':
1121        inTermsOfLeaves = TRUE;
1122        break;
1123      case 'v':
1124        verbose = 1;
1125        break;
1126      case 's':
1127        sanityCheck = atoi(util_optarg);
1128        break;
1129      case 't':
1130        timeOutPeriod = atoi(util_optarg);
1131        break;
1132      case 'n':
1133        length = strlen(util_optarg);
1134        for(c = 0; c < length; c++) {
1135          if (util_optarg[c] == ',') {
1136            util_optarg[c] = 0;
1137          } /* End of if */
1138        } /* End of for */
1139        c = 0;
1140        while (c < length) {
1141          lsNewEnd(nodeList, &util_optarg[c], NIL(lsHandle));
1142          while (util_optarg[c++] != 0);
1143        } /* End of while */
1144        break;
1145      default:
1146        goto usage;
1147    }
1148  }
1149
1150  if (argc == util_optind) {
1151    /* No method specified. Choosing default */
1152    methodString = Cmd_FlagReadByName("partition_method");
1153    if (methodString == NIL(char)) {
1154      methodString = "default";
1155    }
1156  }
1157  else {
1158    methodString = argv[util_optind];
1159  }
1160
1161  if (strcmp(methodString,"inout") == 0) {
1162    method = Part_InOut_c;
1163    if (lsLength(nodeList) != 0) {
1164      (void) fprintf(vis_stderr, "Ignoring provided list of nodes in <inout>");
1165      (void) fprintf(vis_stderr, " method\n");
1166    } /* End of if */
1167    if (inTermsOfLeaves) {
1168      (void) fprintf(vis_stderr, "Ignoring -i flag in the <inout> method\n");
1169    } /* End of if */
1170  }
1171  else if (strcmp(methodString,"partial") == 0) {
1172    method = Part_Partial_c;
1173    /* Make sure a list of nodes has been provided */
1174    if (lsLength(nodeList) == 0) {
1175      (void) fprintf(vis_stderr, "Method <partial> requires a non-empty list");
1176      (void) fprintf(vis_stderr, " of nodes\n");
1177
1178      lsDestroy(nodeList, (void (*)(lsGeneric))0);
1179      goto usage;
1180    } /* End of if */
1181  }
1182  else if (strcmp(methodString,"total") == 0) {
1183    method = Part_Total_c;
1184    if (lsLength(nodeList) != 0) {
1185      (void) fprintf(vis_stderr, "Ignoring provided list of nodes in <total>");
1186      (void) fprintf(vis_stderr, " method\n");
1187    } /* End of if */
1188  }
1189  else if (strcmp(methodString,"frontier") == 0) {
1190    method = Part_Frontier_c;
1191  }
1192  else if (strcmp(methodString,"boundary") == 0) {
1193    method = Part_Boundary_c;
1194  }
1195  else if (strcmp(methodString, "fine") == 0) {
1196    method = Part_Fine_c;
1197  }
1198  else if (strcmp(methodString, "default") == 0) {
1199    method = Part_Default_c;
1200  }
1201  else {
1202    goto usage;
1203  }
1204
1205
1206  /* Check if the network has been read in */
1207  if (network == NIL(Ntk_Network_t)) {
1208    lsDestroy(nodeList, (void (*)(lsGeneric))0);
1209    return 1;
1210  }
1211
1212  /* Check if the network has the variables ordered */
1213  if (Ord_NetworkTestAreVariablesOrdered(network, Ord_InputAndLatch_c) ==
1214      FALSE) {
1215    (void) fprintf(vis_stdout, "The MDD variables have not been ordered. Use static_order.\n");
1216
1217    lsDestroy(nodeList, (void (*)(lsGeneric))0);
1218    return 1;
1219  }
1220
1221  /* Check if there is already a partition attached to the network */
1222  partition = (graph_t *) Ntk_NetworkReadApplInfo(network,
1223                                                  PART_NETWORK_APPL_KEY);
1224
1225  /* If there is, just return. */
1226  if (partition != NIL(graph_t)) {
1227    (void) fprintf(vis_stderr, "partition already built; reinvoke ");
1228    (void) fprintf(vis_stderr, "flatten_hierarchy to remove the current partition\n");
1229    return 1;
1230  }
1231
1232  /* Read the name of the model to be passed to Part_NetworkCreatePartition */
1233  currentNode = Hrc_ManagerReadCurrentNode(*hmgr);
1234  modelName = Hrc_NodeReadModelName(currentNode);
1235
1236  /* Set the timeout */
1237  if (timeOutPeriod > 0) {
1238    (void) signal(SIGALRM, (void(*)(int))TimeOutHandle);
1239    (void) alarm(timeOutPeriod);
1240    if (setjmp(timeOutEnv) > 0) {
1241      (void) fprintf(vis_stdout, "Partition: timeout occurred after ");
1242      (void) fprintf(vis_stdout, "%d seconds\n", timeOutPeriod);
1243      alarm(0);
1244
1245      /* Partial clean up */
1246      lsDestroy(nodeList, (void (*)(lsGeneric))0);
1247      return 1;
1248    }
1249  }
1250
1251  /*
1252   * Execute the partition algorithm. The two nil pointers is to indicate
1253   * that the graph must represent the complete network.
1254   */
1255  partition = Part_NetworkCreatePartition(network, currentNode, modelName, (lsList)0,
1256                                          (lsList)0, NIL(mdd_t), method, nodeList,
1257                                          inTermsOfLeaves, verbose,
1258                                          sanityCheck);
1259
1260  /* Register the partition in the network if any */
1261  Ntk_NetworkAddApplInfo(network, PART_NETWORK_APPL_KEY,
1262                         (Ntk_ApplInfoFreeFn) Part_PartitionFreeCallback,
1263                         (void *) partition);
1264
1265  /* Deactivate the alarm */
1266  alarm(0);
1267
1268  /* Clean up */
1269  if(fileUsed){
1270    lsDestroy(nodeList, PartNameFree);
1271  }
1272  else{
1273    lsDestroy(nodeList, (void (*)(lsGeneric))0);
1274  }
1275  return 0;
1276
1277usage:
1278  (void) fprintf(vis_stderr, "usage: build_partition_mdds [options] [method]\n");
1279  (void) fprintf(vis_stderr, "Options:\n");
1280  (void) fprintf(vis_stderr, "    -h\t\tprint the command usage\n");
1281  (void) fprintf(vis_stderr, "    -i\t\tBuild the functions in the partition in terms of the\n");
1282  (void) fprintf(vis_stderr, "      \t\tcombinational inputs of the system. This option is redundant if\n");
1283  (void) fprintf(vis_stderr, "      \t\tthe inout partition is chosen.\n");
1284  (void) fprintf(vis_stderr, "    -n <list>\tComma separated list of network nodes to preserve in the\n");
1285  (void) fprintf(vis_stderr, "             \tpartitioning. It only matters if the partial method has been\n");
1286  (void) fprintf(vis_stderr, "             \tselected.\n");
1287  (void) fprintf(vis_stderr, "    -f <file>\tSpecifies the file containing names of network nodes\n");
1288  (void) fprintf(vis_stderr, "             \tto preserve while partitioning. This option matters only \n");
1289  (void) fprintf(vis_stderr, "             \tif the partial method has been selected. Each node name must\n");
1290  (void) fprintf(vis_stderr, "             \tbe listed on a new line. Comments in <file> must begin with '#'.\n");
1291  (void) fprintf(vis_stderr, "    -s <num>\tLevel of severity check applied after computation. 0 being no\n");
1292  (void) fprintf(vis_stderr, "      \t\tcheck, 1 begin simple check and >1 being exhaustive check.\n");
1293  (void) fprintf(vis_stderr, "    -t <sec>\tTime in seconds allowed to build the partition. If the\n");
1294  (void) fprintf(vis_stderr, "            \tcomputation time goes above that limit, the process of building\n");
1295  (void) fprintf(vis_stderr, "            \tthe partition is aborted.\n");
1296  (void) fprintf(vis_stderr, "    -v\t\tverbose\n");
1297  (void) fprintf(vis_stderr, "Methods\n");
1298  (void) fprintf(vis_stderr, "    inout\tIt represents the network with one MDD for\n");
1299  (void) fprintf(vis_stderr, "         \teach combinational output as a function of the combinational\n");
1300  (void) fprintf(vis_stderr, "         \tinputs\n");
1301  (void) fprintf(vis_stderr, "    total\tPartitions the network preserving its structure. Every node in\n");
1302  (void) fprintf(vis_stderr, "         \tthe network will produce a vertex in the partition graph. The\n");
1303  (void) fprintf(vis_stderr, "         \tflag -i explained above controls the support of\n");
1304  (void) fprintf(vis_stderr, "         \tthe functions attached to the vertices.\n");
1305  (void) fprintf(vis_stderr, "    frontier\tThe default method. Partitions the network creating vertices for intermediate nodes\n");
1306  (void) fprintf(vis_stderr, "         \tas necessary to control the BDD size. The threshold value of the\n");
1307  (void) fprintf(vis_stderr, "         \tBDD can be specified by partition_threshold.\n");
1308  (void) fprintf(vis_stderr, "    partial\tPartitions the network preserving certain nodes specified with\n");
1309  (void) fprintf(vis_stderr, "           \tthe option -n or -f.\n");
1310  (void) fprintf(vis_stderr, "    boundary\tPartitions the network preserving all nodes that are \n");
1311  (void) fprintf(vis_stderr, "           \tsubcircuit IOs.\n");
1312
1313  lsDestroy(nodeList, (void (*)(lsGeneric))0);
1314
1315  return 1;            /* Error exit */
1316} /* End of CommandBuildPartitionMdds */
1317
1318
1319/**Function********************************************************************
1320
1321  Synopsis []   
1322
1323  Description [Refer to 'static int CommandBuildPartitionMAigs(Hrc_Manager_t
1324                ** hmgr, int argc, char ** argv);' in ntmaigCmd.c]
1325   
1326  SideEffects []
1327
1328  SeeAlso     []
1329
1330******************************************************************************/
1331static int build_partition_maigsMine(Hrc_Manager_t ** hmgr, int argc, char ** argv)
1332{
1333
1334  (void) fprintf(vis_stderr, "*** 'build_partition_maigs' begins. *** \n");
1335
1336  Ntk_Node_t    *node, *latch;
1337  lsGen          gen;
1338  array_t       *result; /* array of MvfAig_Function_t* */
1339  array_t       *roots;
1340  st_table      *leaves;
1341  array_t *inputs;
1342  Ntk_Network_t *network = Ntk_HrcManagerReadCurrentNetwork(*hmgr);
1343  mAig_Manager_t *manager;
1344  MvfAig_Function_t  *mvfAig;
1345  st_table       *nodeToMvfAigTable;  /* mapes each node with its mvfAig */
1346  int c, sweepFlag, DFSFlag;
1347  int i;
1348
1349  sweepFlag = 1;
1350  DFSFlag = 0;
1351  util_getopt_reset();
1352  while ((c = util_getopt(argc,argv,"sdnh")) != EOF){
1353    switch(c){
1354      case 's':
1355        sweepFlag = 1;
1356        break;
1357      case 'd':
1358        DFSFlag = 1;
1359        break;
1360      case 'n':
1361        sweepFlag = 0;
1362        break;
1363      case 'h':
1364        goto usage;
1365      default:
1366        goto usage;
1367    }
1368  }
1369  if (network == NIL(Ntk_Network_t)) {
1370    return 1;
1371  }
1372
1373  manager = Ntk_NetworkReadMAigManager(network);
1374
1375  if (manager == NIL(mAig_Manager_t)) {
1376      manager = mAig_initAig();
1377      Ntk_NetworkSetMAigManager(network, manager);
1378      /*
1379      mAig_mAigSetNetwork(manager, network);
1380      */
1381  }
1382
1383  /* Check if there is already a MvfAigs Table attached to the network */
1384  nodeToMvfAigTable = (st_table *) Ntk_NetworkReadApplInfo(network, 
1385                                                  MVFAIG_NETWORK_APPL_KEY);
1386
1387  if (nodeToMvfAigTable != NIL(st_table)){
1388    /*
1389    st_foreach_item(nodeToMvfAigTable, stGen, (char **) &node, (char **) &MvfAig) {
1390       printf("\nNode name = %s :",Ntk_NodeReadName(node));
1391       for (j=0; j< array_n(MvfAig); j++){
1392        printf(" %d ",array_fetch(bAigEdge_t, (array_t *) MvfAig, j));
1393       }
1394    }
1395    */
1396    (void) fprintf(vis_stderr, "maig partition already built; reinvoke\n");
1397    (void) fprintf(vis_stderr, "flatten_hierarchy to remove the current maig partition\n");
1398     return 1;
1399  }
1400
1401  roots = array_alloc(Ntk_Node_t *, 0);
1402  Ntk_NetworkForEachCombOutput(network, gen, node) {
1403    array_insert_last(Ntk_Node_t *, roots, node);
1404  }
1405  Ntk_NetworkForEachNode(network, gen, node) {
1406    if(Ntk_NodeTestIsShadow(node))      continue;
1407    if(Ntk_NodeTestIsCombInput(node))   continue;
1408    if(Ntk_NodeTestIsCombOutput(node))continue;
1409
1410    if(Ntk_NodeReadNumFanouts(node) == 0 && Ntk_NodeReadNumFanins(node)) {
1411        /**
1412      fprintf(vis_stdout, "WARNING : dangling node %s\n", Ntk_NodeReadName(node));
1413      **/
1414      array_insert_last(Ntk_Node_t *, roots, node);
1415    }
1416  }
1417
1418  leaves = st_init_table(st_ptrcmp, st_ptrhash);
1419
1420  inputs = array_alloc(Ntk_Node_t *, 16);
1421  Ntk_NetworkForEachCombInput(network, gen, node) {
1422    array_insert_last(Ntk_Node_t *, inputs, node);
1423  }
1424  array_sort(inputs, nodenameCompare);
1425  for(i=0; i<array_n(inputs); i++) {
1426    node = array_fetch(Ntk_Node_t *, inputs, i);
1427    st_insert(leaves,  node, (char *) ntmaig_UNUSED);
1428    Ntk_NodeSetMAigId(node, 
1429                       mAig_CreateVar(manager,
1430                                      Ntk_NodeReadName(node),
1431                                      Var_VariableReadNumValues(Ntk_NodeReadVariable(node))));
1432  }
1433
1434  if(DFSFlag == 0)
1435    bAig_BuildAigBFSManner(network, manager, leaves, sweepFlag);
1436
1437  result = ntmaig_NetworkBuildMvfAigs(network, roots, leaves);
1438
1439  nodeToMvfAigTable = (st_table *) Ntk_NetworkReadApplInfo(network, 
1440                                                  MVFAIG_NETWORK_APPL_KEY);
1441  Ntk_NetworkForEachLatch(network, gen, latch) {
1442    node  = Ntk_LatchReadDataInput(latch);
1443    st_lookup(nodeToMvfAigTable, node,  &mvfAig);
1444    Ntk_NodeSetMAigId(node, 
1445            mAig_CreateVarFromAig(manager, Ntk_NodeReadName(node), mvfAig));
1446    node  = Ntk_LatchReadInitialInput(latch);
1447    st_lookup(nodeToMvfAigTable, node,  &mvfAig);
1448    Ntk_NodeSetMAigId(node, 
1449            mAig_CreateVarFromAig(manager, Ntk_NodeReadName(node), mvfAig));
1450  }
1451
1452  roots->num = 0;
1453  Ntk_NetworkForEachLatch(network, gen, latch) {
1454    if(!st_lookup(nodeToMvfAigTable, latch,  &mvfAig))
1455      array_insert_last(Ntk_Node_t *, roots, latch);
1456  }
1457  result = ntmaig_NetworkBuildMvfAigs(network, roots, leaves);
1458
1459  array_free(roots);
1460  array_free(inputs);
1461  st_free_table(leaves);
1462
1463  /*
1464   * Free the array of MvfAigs.
1465   */
1466  MvfAig_FunctionArrayFree(result);
1467
1468  if(sweepFlag) 
1469    bAig_BddSweepMain(network, 0);
1470 
1471  return 0;
1472 
1473usage:
1474  (void) fprintf(vis_stderr, "usage: build_partition_maig [-h]\n");
1475  (void) fprintf(vis_stderr, "   -h print the command usage\n");
1476  (void) fprintf(vis_stderr, "   -n disable bdd sweeping\n");
1477  (void) fprintf(vis_stderr, "   -d build AIG DFS manner\n");
1478  return 1;             /* error exit */
1479
1480}
1481
1482/**Function********************************************************************
1483
1484  Synopsis []   
1485
1486  Description [Refer to 'static int CommandReadFairness(Hrc_Manager_t ** hmgr,
1487                 int argc, char ** argv)' in fsmCmd.c]
1488   
1489  SideEffects []
1490
1491  SeeAlso     []
1492
1493******************************************************************************/
1494
1495static int read_fairnessMine (Hrc_Manager_t ** hmgr, int argc, char ** argv)
1496{
1497
1498(void) fprintf(vis_stderr, "*** 'read_fairness' begins. *** \n");
1499 
1500  int       c;
1501  FILE      *fp;
1502  array_t   *formulaArray;
1503  Fsm_Fsm_t *fsm = Fsm_HrcManagerReadCurrentFsm(*hmgr);
1504 
1505  /*
1506   * Parse command line options.
1507   */
1508  util_getopt_reset();
1509  while ((c = util_getopt(argc, argv, "h")) != EOF) {
1510    switch(c) {
1511      case 'h':
1512        goto usage;
1513      default:
1514        goto usage;
1515    }
1516    /* NOT REACHED */
1517  }
1518
1519  if (fsm == NIL(Fsm_Fsm_t)) {
1520    (void) fprintf(vis_stderr, "** fair error: Fairness constraint not recorded.\n");
1521    return 1;
1522  }
1523
1524  /*
1525   * Open the fairness file.
1526   */
1527  if (argc - util_optind == 0) {
1528    (void) fprintf(vis_stderr, "** fair error: fairness file not provided\n");
1529    goto usage;
1530  }
1531  else if (argc - util_optind > 1) {
1532    (void) fprintf(vis_stderr, "** fair error: too many arguments\n");
1533    goto usage;
1534  }
1535
1536  fp = Cmd_FileOpen(argv[util_optind], "r", NIL(char *), 0);
1537  if (fp == NIL(FILE)) {
1538    return 1;
1539  }
1540
1541  /*
1542   * Parse the formulas in the file.
1543   */
1544  formulaArray = Ctlp_FileParseFormulaArray(fp);
1545  (void) fclose(fp);
1546
1547  if (formulaArray == NIL(array_t)) {
1548    (void) fprintf(vis_stderr, "** fair error: error reading fairness conditions.\n");
1549    return 1;
1550  }
1551  else if (array_n(formulaArray) == 0) {
1552    (void) fprintf(vis_stderr, "** fair error: fairness file is empty.\n");
1553    (void) fprintf(vis_stderr, "** fair error: Use reset_fairness to reset the fairness constraint.");
1554    return 1;
1555  }
1556  else {
1557    int             j;
1558    Fsm_Fairness_t *fairness;
1559    Ntk_Network_t  *network = Fsm_FsmReadNetwork(fsm);
1560
1561    /*
1562     * First check that each formula is semantically correct wrt the network.
1563     */
1564    error_init();
1565    for (j = 0; j < array_n(formulaArray); j++) {
1566      Ctlp_Formula_t *formula;
1567      boolean         status; 
1568     
1569      formula  = array_fetch(Ctlp_Formula_t *, formulaArray, j);
1570      status = Mc_FormulaStaticSemanticCheckOnNetwork(formula, network, FALSE);
1571     
1572      if (status == FALSE) {
1573        (void) fprintf(vis_stderr,
1574                       "** fair error: error reading fairness constraint "); 
1575        Ctlp_FormulaPrint(vis_stderr, formula);
1576        (void) fprintf(vis_stderr, ":\n");
1577        (void) fprintf(vis_stderr, "%s", error_string());
1578        (void) fprintf(vis_stderr, "\n");
1579        return 1;
1580      }
1581    }
1582
1583
1584    /*
1585     * Interpret the array of CTL formulas as a set of Buchi conditions.
1586     * Hence, create a single disjunct, consisting of k conjuncts, where k is
1587     * the number of CTL formulas read in.  The jth conjunct has the jth
1588     * formula as its finallyInf component, and NULL as its globallyInf
1589     * component.
1590     */
1591    fairness = FsmFairnessAlloc(fsm);   
1592    for (j = 0; j < array_n(formulaArray); j++) {
1593      Ctlp_Formula_t *formula = array_fetch(Ctlp_Formula_t *, formulaArray, j);
1594
1595      FsmFairnessAddConjunct(fairness, formula, NIL(Ctlp_Formula_t), 0, j);
1596    }
1597    array_free(formulaArray); /* Don't free the formulas themselves. */
1598
1599    /*
1600     * Remove any existing fairnessInfo associated with the FSM, and update
1601     * the fairnessInfo.constraint with the new fairness just read.
1602     */
1603    FsmFsmFairnessInfoUpdate(fsm, NIL(mdd_t), fairness, NIL(array_t));
1604
1605    return 0;
1606  }
1607
1608  usage:
1609  (void) fprintf(vis_stderr, "usage: read_fairness [-h] file\n");
1610  (void) fprintf(vis_stderr, "   -h    print the command usage\n");
1611  (void) fprintf(vis_stderr, "   file  file containing the list of conditions\n");
1612  return 1;
1613
1614}
1615
1616/**Function********************************************************************
1617
1618  Synopsis []   
1619
1620  Description [Refer to 'static int CommandPrintFairness(Hrc_Manager_t ** hmgr,
1621                 int argc, char ** argv)' in fsmCmd.c]
1622   
1623  SideEffects []
1624
1625  SeeAlso     []
1626
1627******************************************************************************/
1628
1629static int print_fairnessMine(Hrc_Manager_t ** hmgr, int argc, char ** argv)
1630{
1631
1632 (void) fprintf(vis_stderr, "*** 'print_fairness' begins. *** \n");
1633
1634  int            c;
1635  Fsm_Fairness_t *constraint;
1636  int             numDisjuncts;
1637  Fsm_Fsm_t      *fsm = Fsm_HrcManagerReadCurrentFsm(*hmgr);
1638
1639  /*
1640   * Parse command line options.
1641   */
1642  util_getopt_reset();
1643  while ((c = util_getopt(argc, argv, "h")) != EOF) {
1644    switch(c) {
1645      case 'h':
1646        goto usage;
1647      default:
1648        goto usage;
1649    }
1650    /* NOT REACHED */
1651  }
1652
1653  if (fsm == NIL(Fsm_Fsm_t)) {
1654    return 1;
1655  }
1656
1657  /*
1658   * Print the fairness constraint.  It is assumed that there is at least one
1659   * disjunct present.  Currently, only Buchi constraints can be printed out.
1660   */
1661  constraint = Fsm_FsmReadFairnessConstraint(fsm);
1662  assert(constraint != NIL(Fsm_Fairness_t));
1663  numDisjuncts = Fsm_FairnessReadNumDisjuncts(constraint);
1664  assert(numDisjuncts != 0);
1665
1666  if (numDisjuncts > 1) {
1667    (void) fprintf(vis_stdout, "Fairness constraint not Buchi...");
1668    (void) fprintf(vis_stdout, "don't know how to print.\n");
1669  }
1670  else {
1671    int i;
1672    int numConjuncts = Fsm_FairnessReadNumConjunctsOfDisjunct(constraint, 0);
1673
1674    (void) fprintf(vis_stdout, "Fairness constraint:\n");
1675    for (i = 0; i < numConjuncts; i++) {
1676      if (Fsm_FairnessReadGloballyInfFormula(constraint, 0, i) !=
1677          NIL(Ctlp_Formula_t)) {
1678        (void) fprintf(vis_stdout, "Fairness constraint not Buchi...");
1679        (void) fprintf(vis_stdout, "don't know how to print.\n");
1680      }
1681       
1682      Ctlp_FormulaPrint(vis_stdout,
1683                        Fsm_FairnessReadFinallyInfFormula(constraint, 0, i));
1684      (void) fprintf(vis_stdout, ";\n");
1685    }
1686  }
1687
1688  return 0;
1689
1690  usage:
1691  (void) fprintf(vis_stderr, "usage: print_fairness [-h]\n");
1692  (void) fprintf(vis_stderr, "   -h  print the command usage\n");
1693  return 1;
1694
1695}
1696
1697
1698/**Function********************************************************************
1699
1700  Synopsis []   
1701
1702  Description [Refer to 'static int CommandPrintIo(Hrc_Manager_t **hmgr, int
1703                argc, char **argv);' in hrcCmd.c]
1704   
1705  SideEffects []
1706
1707  SeeAlso     []
1708
1709******************************************************************************/
1710
1711static int print_ioMine (Hrc_Manager_t **hmgr, int argc, char **argv)
1712{
1713
1714(void) fprintf(vis_stderr, "*** 'print_io' begins. *** \n");
1715
1716 int c, i;
1717  Hrc_Node_t *node;
1718  Var_Variable_t *var;
1719  array_t *tmpArray;
1720 
1721  util_getopt_reset();
1722  while ((c = util_getopt(argc, argv, "h")) != EOF) {
1723    switch(c){
1724      case 'h':
1725        goto usage;
1726      default:
1727        goto usage;
1728    }
1729  }
1730  /* if there are some arguments left */
1731  if (argc != util_optind){
1732    goto usage;
1733  }
1734  node = Hrc_ManagerReadCurrentNode(*hmgr);
1735  if (node == NIL(Hrc_Node_t)){
1736    (void)fprintf(vis_stderr,"No file has been read in.\n");
1737    return 1;
1738  }
1739 
1740  if (Hrc_NodeReadNumFormalInputs(node) == 0){
1741    fprintf(vis_stdout,"No inputs\n");
1742  }
1743  else {
1744    tmpArray = array_alloc(char *,0);
1745    Hrc_NodeForEachFormalInput(node,i,var){
1746      array_insert_last(char *,tmpArray,Var_VariableReadName(var));
1747    }
1748    array_sort(tmpArray,_HrcStringCmp);
1749    fprintf(vis_stdout,"inputs:");
1750    for (i=0; i < array_n(tmpArray); i++){
1751      fprintf(vis_stdout," %s",array_fetch(char *,tmpArray,i));
1752    }
1753    fprintf(vis_stdout,"\n");
1754    array_free(tmpArray);
1755  }
1756
1757  if (Hrc_NodeReadNumFormalOutputs(node) == 0){
1758    fprintf(vis_stdout,"No outputs\n");
1759  }
1760  else {
1761    tmpArray = array_alloc(char *,0);
1762    Hrc_NodeForEachFormalOutput(node,i,var){
1763      array_insert_last(char *,tmpArray,Var_VariableReadName(var));
1764    }
1765    array_sort(tmpArray,_HrcStringCmp);
1766    fprintf(vis_stdout,"outputs:");
1767    for (i=0; i < array_n(tmpArray); i++){
1768      fprintf(vis_stdout," %s",array_fetch(char *,tmpArray,i));
1769    }
1770    fprintf(vis_stdout,"\n");
1771    array_free(tmpArray);
1772  }
1773  return 0;
1774
1775usage:
1776  (void) fprintf(vis_stderr,"usage: print_io [-h]\n");
1777  (void) fprintf(vis_stderr, "   -h \t\tprint the command usage\n");
1778  return 1; 
1779
1780}
1781
1782
1783/**Function********************************************************************
1784
1785  Synopsis []   
1786
1787  Description [Refer to 'static int CommandMc (Hrc_Manager_t **hmgr, int argc,
1788                char **argv)' function in mcCmd.c]
1789   
1790  SideEffects []
1791
1792  SeeAlso     []
1793
1794******************************************************************************/
1795static int model_checkMine (Hrc_Manager_t **hmgr, int argc, char **argv) 
1796{
1797
1798(void) fprintf(vis_stderr, "*** 'model_check' begins. *** \n");
1799
1800/* options */
1801  McOptions_t         *options;
1802  Mc_VerbosityLevel   verbosity;
1803  Mc_DcLevel          dcLevel;
1804  FILE                *ctlFile;
1805  int                 timeOutPeriod     = 0;
1806  Mc_FwdBwdAnalysis   traversalDirection;
1807  int                 buildOnionRings   = 0;
1808  FILE                *guideFile;
1809  FILE                *systemFile;
1810  Mc_GuidedSearch_t   guidedSearchType  = Mc_None_c;
1811  Ctlp_FormulaArray_t *hintsArray       = NIL(Fsm_HintsArray_t);
1812  array_t             *hintsStatesArray = NIL(array_t); /* array of mdd_t* */
1813  st_table            *systemVarBddIdTable;
1814  boolean             noShare           = 0;
1815  Mc_GSHScheduleType  GSHschedule;
1816  boolean             checkVacuity;
1817  boolean             performCoverageHoskote;
1818  boolean             performCoverageImproved;
1819
1820  /* CTL formulae */
1821  array_t *ctlArray;
1822  array_t *ctlNormalFormulaArray;
1823  int i;
1824  int numFormulae;
1825  /* FSM, network and image */
1826  Fsm_Fsm_t       *totalFsm = NIL(Fsm_Fsm_t);
1827  Fsm_Fsm_t       *modelFsm = NIL(Fsm_Fsm_t);
1828  Fsm_Fsm_t       *reducedFsm = NIL(Fsm_Fsm_t);
1829  Ntk_Network_t   *network;
1830  mdd_t           *modelCareStates = NIL(mdd_t);
1831  array_t         *modelCareStatesArray = NIL(array_t);
1832  mdd_t           *modelInitialStates;
1833  mdd_t           *fairStates;
1834  Fsm_Fairness_t  *fairCond;
1835  mdd_manager     *mddMgr;
1836  array_t         *bddIdArray;
1837  Img_ImageInfo_t *imageInfo;
1838  Mc_EarlyTermination_t *earlyTermination;
1839  /* Coverage estimation */
1840  mdd_t           *totalcoveredstates = NIL(mdd_t);
1841  array_t         *signalTypeList = array_alloc(int,0);
1842  array_t         *signalList = array_alloc(char *,0);
1843  array_t         *statesCoveredList = array_alloc(mdd_t *,0);
1844  array_t         *newCoveredStatesList = array_alloc(mdd_t *,0);
1845  array_t         *statesToRemoveList = array_alloc(mdd_t *,0);
1846
1847  /* Early termination is only partially implemented right now.  It needs
1848     distribution over all operators, including limited cases of temporal
1849     operators.  That should be relatively easy to implement. */
1850
1851  /* time keeping */
1852  long totalInitialTime; /* for model checking */
1853  long initialTime, finalTime; /* for model checking */
1854
1855  error_init();
1856  Img_ResetNumberOfImageComputation(Img_Both_c);
1857
1858  /* read options */
1859  if (!(options = ParseMcOptions(argc, argv))) {
1860    return 1;
1861  }
1862  verbosity = McOptionsReadVerbosityLevel(options);
1863  dcLevel = McOptionsReadDcLevel(options);
1864  ctlFile = McOptionsReadCtlFile(options);
1865  timeOutPeriod = McOptionsReadTimeOutPeriod(options);
1866  traversalDirection = McOptionsReadTraversalDirection(options);
1867  buildOnionRings =
1868    (McOptionsReadDbgLevel(options) != McDbgLevelNone_c || verbosity);
1869  noShare = McOptionsReadUseFormulaTree(options);
1870  GSHschedule = McOptionsReadSchedule(options);
1871  checkVacuity = McOptionsReadVacuityDetect(options);
1872   /* for the command mc -C foo.ctl */
1873  performCoverageHoskote = McOptionsReadCoverageHoskote(options);
1874  /* for the command mc -I foo.ctl */
1875  performCoverageImproved = McOptionsReadCoverageImproved(options);
1876
1877  /* Check for incompatible options and do some option-specific
1878   * intializations.
1879   */
1880
1881  if (traversalDirection == McFwd_c) {
1882    if (checkVacuity) {
1883      fprintf(vis_stderr, "** mc error: -V and -B are incompatible with -F\n");
1884      McOptionsFree(options);
1885      return 1;
1886    }
1887    if (performCoverageHoskote || performCoverageImproved) {
1888      fprintf(vis_stderr, "** mc error: -I and -C are incompatible with -F\n");
1889      McOptionsFree(options);
1890      return 1;
1891    }
1892  }
1893
1894  if (checkVacuity) {
1895    if (performCoverageHoskote || performCoverageImproved) {
1896      fprintf(vis_stderr, "** mc error: -I and -C are incompatible with -V and -B\n");
1897      McOptionsFree(options);
1898      return 1;
1899    }
1900  }
1901
1902  guideFile =  McOptionsReadGuideFile(options);
1903
1904  if(guideFile != NIL(FILE) ){
1905    guidedSearchType = Mc_ReadGuidedSearchType();
1906    if(guidedSearchType == Mc_None_c){  /* illegal setting */
1907      fprintf(vis_stderr, "** mc error: Unknown  hint type\n");
1908      fclose(guideFile);
1909      McOptionsFree(options);
1910      return 1;
1911    }
1912
1913    if(traversalDirection == McFwd_c){  /* illegal combination */
1914      fprintf(vis_stderr, "** mc error: -g is incompatible with -F\n");
1915      fclose(guideFile);
1916      McOptionsFree(options);
1917      return 1;
1918    }
1919
1920    if(Img_UserSpecifiedMethod() != Img_Iwls95_c &&
1921       Img_UserSpecifiedMethod() != Img_Monolithic_c &&
1922       Img_UserSpecifiedMethod() != Img_Mlp_c){
1923      fprintf(vis_stderr, "** mc error: -g only works with iwls95, MLP, or monolithic image methods.\n");
1924      fclose(guideFile);
1925      McOptionsFree(options);
1926      return 1;
1927    }
1928
1929    hintsArray = Mc_ReadHints(guideFile);
1930    fclose(guideFile); guideFile = NIL(FILE);
1931    if( hintsArray == NIL(array_t) ){
1932      McOptionsFree(options);
1933      return 1;
1934    }
1935
1936  } /* if guided search */
1937
1938  /* If don't-cares are used, -r implies -c.  Note that the satisfying
1939     sets of a subformula are only in terms of propositions therein
1940     and their cone of influence.  Hence, we can share satisfying sets
1941     among formulae.  I don't quite understand what the problem with
1942     don't-cares is (RB) */
1943  if (McOptionsReadReduceFsm(options))
1944    if (dcLevel != McDcLevelNone_c)
1945      McOptionsSetUseFormulaTree(options, TRUE);
1946
1947  if (traversalDirection == McFwd_c &&
1948      McOptionsReadDbgLevel(options) != McDbgLevelNone_c) {
1949    McOptionsSetDbgLevel(options, McDbgLevelNone_c);
1950    (void)fprintf(vis_stderr, "** mc warning : option -d is ignored.\n");
1951  }
1952
1953  /* Read CTL formulae */
1954  ctlArray = Ctlsp_FileParseCTLFormulaArray(ctlFile);
1955  fclose(ctlFile); ctlFile = NIL(FILE);
1956  if (ctlArray == NIL(array_t)) {
1957    (void) fprintf(vis_stderr,
1958                   "** mc error: error in parsing formulas from file\n");
1959    McOptionsFree(options);
1960    return 1;
1961  }
1962
1963  /* read network */
1964  network = Ntk_HrcManagerReadCurrentNetwork(*hmgr);
1965  if (network == NIL(Ntk_Network_t)) {
1966    fprintf(vis_stdout, "%s\n", error_string());
1967    error_init();
1968    Ctlp_FormulaArrayFree(ctlArray);
1969    McOptionsFree(options);
1970    return 1;
1971  }
1972
1973  /* read fsm */
1974  totalFsm = Fsm_NetworkReadOrCreateFsm(network);
1975  if (totalFsm == NIL(Fsm_Fsm_t)) {
1976    fprintf(vis_stdout, "%s\n", error_string());
1977    error_init();
1978    Ctlp_FormulaArrayFree(ctlArray);
1979    McOptionsFree(options);
1980    return 1;
1981  }
1982
1983  /* Assign variables to system if doing FAFW */
1984  systemVarBddIdTable = NIL(st_table);
1985  systemFile = McOptionsReadSystemFile(options);
1986  if (systemFile != NIL(FILE)) {
1987    systemVarBddIdTable = Mc_ReadSystemVariablesFAFW(totalFsm, systemFile);
1988    fclose(systemFile); systemFile = NIL(FILE);
1989    if (systemVarBddIdTable == (st_table *)-1 ) { /* FS: error message? */
1990      Ctlp_FormulaArrayFree(ctlArray);
1991      McOptionsFree(options);
1992      return 1;
1993    }
1994  } /* if FAFW */
1995
1996  if(options->FAFWFlag && systemVarBddIdTable == 0) {
1997    systemVarBddIdTable = Mc_SetAllInputToSystem(totalFsm);
1998  }
1999
2000  if (verbosity > McVerbosityNone_c)
2001    totalInitialTime = util_cpu_time();
2002  else /* to remove uninitialized variable warning */
2003    totalInitialTime = 0;
2004
2005  if(traversalDirection == McFwd_c){
2006    mdd_t *totalInitialStates;
2007    double nInitialStates;
2008
2009    totalInitialStates = Fsm_FsmComputeInitialStates(totalFsm);
2010    nInitialStates = mdd_count_onset(Fsm_FsmReadMddManager(totalFsm),
2011                                     totalInitialStates,
2012                                     Fsm_FsmReadPresentStateVars(totalFsm));
2013    mdd_free(totalInitialStates);
2014
2015    /* If the number of initial states is only one, we can use both
2016     * conversion formulas(init ^ f != FALSE and init ^ !f == FALSE),
2017     * however, if we have multiple initial states, we should use
2018     * p0 ^ !f == FALSE.
2019     */
2020    ctlNormalFormulaArray =
2021      Ctlp_FormulaArrayConvertToForward(ctlArray, (nInitialStates == 1.0),
2022                                        noShare);
2023    /* end conversion for forward traversal */
2024  } else if (noShare) { /* conversion for backward, no sharing */
2025    ctlNormalFormulaArray =
2026      Ctlp_FormulaArrayConvertToExistentialFormTree(ctlArray);
2027  }else{ /* conversion for backward, with sharing */
2028    /* Note that converting to DAG after converting to existential form would
2029       lead to more sharing, but it cannot be done since equal subformula that
2030       are converted from different formulae need different pointers back to
2031       their originals */
2032    if (checkVacuity) {
2033      ctlNormalFormulaArray =
2034        Ctlp_FormulaArrayConvertToExistentialFormTree(ctlArray);
2035    }
2036    else {
2037      array_t *temp = Ctlp_FormulaArrayConvertToDAG( ctlArray );
2038      array_free( ctlArray );
2039      ctlArray = temp;
2040      ctlNormalFormulaArray =
2041        Ctlp_FormulaDAGConvertToExistentialFormDAG(ctlArray);
2042    }
2043  }
2044  /* At this point, ctlNormalFormulaArray contains the formulas that are
2045     actually going to be checked, and ctlArray contains the formulas from
2046     which the conversion has been done.  Both need to be kept around until the
2047     end, for debugging purposes. */
2048
2049  numFormulae = array_n(ctlNormalFormulaArray);
2050
2051  /* time out */
2052  if (timeOutPeriod > 0) {
2053    /* Set the static variables used by the signal handler. */
2054    mcTimeOut = timeOutPeriod;
2055    alarmLapTime = util_cpu_ctime();
2056    (void) signal(SIGALRM, (void(*)(int))TimeOutHandle);
2057    (void) alarm(timeOutPeriod);
2058    if (setjmp(timeOutEnv) > 0) {
2059      (void) fprintf(vis_stdout,
2060                "# MC: timeout occurred after %d seconds.\n", timeOutPeriod);
2061      (void) fprintf(vis_stdout, "# MC: data may be corrupted.\n");
2062      if (verbosity > McVerbosityNone_c) {
2063        fprintf(vis_stdout, "-- total %d image computations and %d preimage computations\n",
2064                Img_GetNumberOfImageComputation(Img_Forward_c),
2065                Img_GetNumberOfImageComputation(Img_Backward_c));
2066      }
2067      alarm(0);
2068      return 1;
2069    }
2070  }
2071
2072
2073  /* Create reduced fsm, if necessary */
2074  if (!McOptionsReadReduceFsm(options)){
2075    /* We want to minimize only when "-r" option is not specified */
2076    /* reduceFsm would be NIL, if there is no reduction observed */
2077    assert (reducedFsm == NIL(Fsm_Fsm_t));
2078    reducedFsm = McConstructReducedFsm(network, ctlNormalFormulaArray);
2079    if (reducedFsm != NIL(Fsm_Fsm_t) && verbosity != McVerbosityNone_c) {
2080      mddMgr = Fsm_FsmReadMddManager(reducedFsm);
2081      bddIdArray = mdd_id_array_to_bdd_id_array(mddMgr,
2082                   Fsm_FsmReadPresentStateVars(reducedFsm));
2083      (void)fprintf(vis_stdout,"Local system includes ");
2084      (void)fprintf(vis_stdout,"%d (%d) multi-value (boolean) variables.\n",
2085                    array_n(Fsm_FsmReadPresentStateVars(reducedFsm)),
2086                    array_n(bddIdArray));
2087      array_free(bddIdArray);
2088    }
2089  }
2090
2091  /************** for all formulae **********************************/
2092  for(i = 0; i < numFormulae; i++) {
2093    int nImgComps, nPreComps;
2094    boolean result;
2095    Ctlp_Formula_t *ctlFormula = array_fetch(Ctlp_Formula_t *,
2096                                             ctlNormalFormulaArray, i);
2097
2098    modelFsm = NIL(Fsm_Fsm_t);
2099
2100    /* do a check */
2101    if (!Mc_FormulaStaticSemanticCheckOnNetwork(ctlFormula, network, FALSE)) {
2102      (void) fprintf(vis_stdout,
2103                     "** mc error: error in parsing Atomic Formula:\n%s\n",
2104                     error_string());
2105      error_init();
2106      Ctlp_FormulaFree(ctlFormula);
2107      continue;
2108    }
2109
2110    /* Create reduced fsm */
2111    if (McOptionsReadReduceFsm(options)) {
2112      /* We have not done top level reduction. */
2113      /* Using the same variable reducedFsm here   */
2114      array_t *oneFormulaArray = array_alloc(Ctlp_Formula_t *, 1);
2115
2116      assert(reducedFsm == NIL(Fsm_Fsm_t));
2117      array_insert_last(Ctlp_Formula_t *, oneFormulaArray, ctlFormula);
2118      reducedFsm = McConstructReducedFsm(network, oneFormulaArray);
2119      array_free(oneFormulaArray);
2120
2121      if (reducedFsm && verbosity != McVerbosityNone_c) {
2122        mddMgr = Fsm_FsmReadMddManager(reducedFsm);
2123        bddIdArray = mdd_id_array_to_bdd_id_array(mddMgr,
2124                       Fsm_FsmReadPresentStateVars(reducedFsm));
2125        (void)fprintf(vis_stdout,"Local system includes ");
2126        (void)fprintf(vis_stdout,"%d (%d) multi-value (boolean) variables.\n",
2127                      array_n(Fsm_FsmReadPresentStateVars(reducedFsm)),
2128                      array_n(bddIdArray));
2129        array_free(bddIdArray);
2130      }
2131    }/* if readreducefsm */
2132
2133    /* Let us see if we got any reduction via top level or via "-r" */
2134    if (reducedFsm == NIL(Fsm_Fsm_t))
2135      modelFsm = totalFsm; /* no reduction */
2136    else
2137      modelFsm = reducedFsm; /* some reduction at some point */
2138
2139    /* compute initial states */
2140    modelInitialStates = Fsm_FsmComputeInitialStates(modelFsm);
2141    if (modelInitialStates == NIL(mdd_t)) {
2142      int j;
2143      (void) fprintf(vis_stdout,
2144      "** mc error: Cannot build init states (mutual latch dependency?)\n%s\n",
2145                     error_string());
2146      if (modelFsm != totalFsm)
2147        Fsm_FsmFree(reducedFsm);
2148
2149      alarm(0);
2150
2151      for(j = i; j < numFormulae; j++)
2152        Ctlp_FormulaFree(
2153          array_fetch( Ctlp_Formula_t *, ctlNormalFormulaArray, j ) );
2154      array_free( ctlNormalFormulaArray );
2155
2156      Ctlp_FormulaArrayFree( ctlArray );
2157
2158      McOptionsFree(options);
2159
2160      return 1;
2161    }
2162
2163    earlyTermination = Mc_EarlyTerminationAlloc(McAll_c, modelInitialStates);
2164
2165    if(hintsArray != NIL(Ctlp_FormulaArray_t)) {
2166      hintsStatesArray = Mc_EvaluateHints(modelFsm, hintsArray);
2167      if( hintsStatesArray == NIL(array_t) ||
2168          (guidedSearchType == Mc_Global_c &&
2169           Ctlp_CheckClassOfExistentialFormula(ctlFormula) == Ctlp_Mixed_c)) {
2170        int j;
2171
2172        if( guidedSearchType == Mc_Global_c &&
2173            Ctlp_CheckClassOfExistentialFormula(ctlFormula) == Ctlp_Mixed_c)
2174          fprintf(vis_stderr, "** mc error: global hints incompatible with "
2175                  "mixed formulae\n");
2176
2177        Mc_EarlyTerminationFree(earlyTermination);
2178        mdd_free(modelInitialStates);
2179        if (modelFsm != totalFsm)
2180          Fsm_FsmFree(reducedFsm);
2181        alarm(0);
2182        for(j = i; j < numFormulae; j++)
2183          Ctlp_FormulaFree(
2184            array_fetch( Ctlp_Formula_t *, ctlNormalFormulaArray, j ) );
2185        array_free( ctlNormalFormulaArray );
2186        Ctlp_FormulaArrayFree( ctlArray );
2187        McOptionsFree(options);
2188        return 1;
2189      } /* problem with hints */
2190    } /* hints exist */
2191
2192    /* stats */
2193    if (verbosity > McVerbosityNone_c) {
2194      initialTime = util_cpu_time();
2195      nImgComps = Img_GetNumberOfImageComputation(Img_Forward_c);
2196      nPreComps = Img_GetNumberOfImageComputation(Img_Backward_c);
2197    } else { /* to remove uninitialized variable warnings */
2198      initialTime = 0;
2199      nImgComps = 0;
2200      nPreComps = 0;
2201    }
2202    mddMgr = Fsm_FsmReadMddManager(modelFsm);
2203
2204    /* compute don't cares. */
2205    if (modelCareStatesArray == NIL(array_t)) {
2206      long iTime; /* starting time for reachability analysis */
2207      if (verbosity > McVerbosityNone_c && i == 0)
2208        iTime = util_cpu_time();
2209      else /* to remove uninitialized variable warnings */
2210        iTime = 0;
2211
2212      /* ardc */
2213      if (dcLevel == McDcLevelArdc_c) {
2214        Fsm_ArdcOptions_t *ardcOptions = McOptionsReadArdcOptions(options);
2215
2216        modelCareStatesArray = Fsm_ArdcComputeOverApproximateReachableStates(
2217          modelFsm, 0, verbosity, 0, 0, 0, 0, 0, 0, ardcOptions);
2218        if (verbosity > McVerbosityNone_c && i == 0)
2219          Fsm_ArdcPrintReachabilityResults(modelFsm, util_cpu_time() - iTime);
2220
2221      /* rch dc */
2222      } else if (dcLevel >= McDcLevelRch_c) {
2223        modelCareStates =
2224          Fsm_FsmComputeReachableStates(modelFsm, 0, 1, 0, 0, 0, 0, 0,
2225                                        Fsm_Rch_Default_c, 0, 0,
2226                                        NIL(array_t), FALSE, NIL(array_t));
2227        if (verbosity > McVerbosityNone_c && i == 0) {
2228          Fsm_FsmReachabilityPrintResults(modelFsm, util_cpu_time() - iTime,
2229                                          Fsm_Rch_Default_c);
2230        }
2231
2232        modelCareStatesArray = array_alloc(mdd_t *, 0);
2233        array_insert(mdd_t *, modelCareStatesArray, 0, modelCareStates);
2234      } else {
2235        modelCareStates = mdd_one(mddMgr);
2236        modelCareStatesArray = array_alloc(mdd_t *, 0);
2237        array_insert(mdd_t *, modelCareStatesArray, 0, modelCareStates);
2238      }
2239    }
2240
2241    Fsm_MinimizeTransitionRelationWithReachabilityInfo(
2242      modelFsm, (traversalDirection == McFwd_c) ? Img_Both_c : Img_Backward_c,
2243      verbosity > 1);
2244
2245    /* fairness conditions */
2246    fairStates = Fsm_FsmComputeFairStates(modelFsm, modelCareStatesArray,
2247                                          verbosity, dcLevel, GSHschedule,
2248                                          McBwd_c, FALSE);
2249    fairCond = Fsm_FsmReadFairnessConstraint(modelFsm);
2250
2251    if (mdd_lequal(modelInitialStates, fairStates, 1, 0)) {
2252      (void)fprintf(vis_stdout,
2253                    "** mc warning: There are no fair initial states\n");
2254    }
2255    else if (!mdd_lequal(modelInitialStates, fairStates, 1, 1)) {
2256      (void)fprintf(vis_stdout,
2257                    "** mc warning: Some initial states are not fair\n");
2258    }
2259
2260    /* some user feedback */
2261    if (verbosity != McVerbosityNone_c) {
2262      (void)fprintf(vis_stdout, "Checking formula[%d] : ", i + 1);
2263      Ctlp_FormulaPrint(vis_stdout,
2264                        Ctlp_FormulaReadOriginalFormula(ctlFormula));
2265      (void)fprintf (vis_stdout, "\n");
2266      if (traversalDirection == McFwd_c) {
2267        (void)fprintf(vis_stdout, "Forward formula : ");
2268        Ctlp_FormulaPrint(vis_stdout, ctlFormula);
2269        (void)fprintf(vis_stdout, "\n");
2270      }
2271    }
2272
2273    /************** the actual computation **********************************/
2274    if (checkVacuity) {
2275      McVacuityDetection(modelFsm, ctlFormula, i,
2276                         fairStates, fairCond, modelCareStatesArray,
2277                         earlyTermination, hintsStatesArray,
2278                         guidedSearchType, modelInitialStates,
2279                         options);
2280    }
2281    else { /* Normal Model Checking */
2282      mdd_t *ctlFormulaStates =
2283        Mc_FsmEvaluateFormula(modelFsm, ctlFormula, fairStates,
2284                              fairCond, modelCareStatesArray,
2285                              earlyTermination, hintsStatesArray,
2286                              guidedSearchType, verbosity, dcLevel,
2287                              buildOnionRings, GSHschedule);
2288
2289      McEstimateCoverage(modelFsm, ctlFormula, i, fairStates, fairCond,
2290                         modelCareStatesArray, earlyTermination,
2291                         hintsStatesArray, guidedSearchType, verbosity,
2292                         dcLevel, buildOnionRings, GSHschedule,
2293                         traversalDirection, modelInitialStates,
2294                         ctlFormulaStates, &totalcoveredstates,
2295                         signalTypeList, signalList, statesCoveredList,
2296                         newCoveredStatesList, statesToRemoveList,
2297                         performCoverageHoskote, performCoverageImproved);
2298
2299      Mc_EarlyTerminationFree(earlyTermination);
2300      if(hintsStatesArray != NIL(array_t))
2301        mdd_array_free(hintsStatesArray);
2302      /* Set up things for possible FAFW analysis of counterexample. */
2303      Fsm_FsmSetFAFWFlag(modelFsm, options->FAFWFlag);
2304      Fsm_FsmSetSystemVariableFAFW(modelFsm, systemVarBddIdTable);
2305      /* user feedback on succes/fail */
2306      result = McPrintPassFailMine(mddMgr, modelFsm, traversalDirection,
2307                               ctlFormula, ctlFormulaStates,
2308                               modelInitialStates, modelCareStatesArray,
2309                               options, verbosity);
2310      Fsm_FsmSetFAFWFlag(modelFsm, 0);
2311      Fsm_FsmSetSystemVariableFAFW(modelFsm, NULL);
2312      mdd_free(ctlFormulaStates);
2313    }
2314
2315    if (verbosity > McVerbosityNone_c) {
2316      finalTime = util_cpu_time();
2317      fprintf(vis_stdout, "-- mc time = %10g\n",
2318        (double)(finalTime - initialTime) / 1000.0);
2319      fprintf(vis_stdout,
2320              "-- %d image computations and %d preimage computations\n",
2321              Img_GetNumberOfImageComputation(Img_Forward_c) - nImgComps,
2322              Img_GetNumberOfImageComputation(Img_Backward_c) - nPreComps);
2323    }
2324    mdd_free(modelInitialStates);
2325    mdd_free(fairStates);
2326    Ctlp_FormulaFree(ctlFormula);
2327
2328    if ((McOptionsReadReduceFsm(options)) &&
2329        (reducedFsm != NIL(Fsm_Fsm_t))) {
2330      /*
2331      ** We need to free the reducedFsm only if it was created under "-r"
2332      ** option and was non-NIL.
2333      */
2334      Fsm_FsmFree(reducedFsm);
2335      reducedFsm = NIL(Fsm_Fsm_t);
2336      modelFsm = NIL(Fsm_Fsm_t);
2337      if (modelCareStates) {
2338        mdd_array_free(modelCareStatesArray);
2339        modelCareStates = NIL(mdd_t);
2340        modelCareStatesArray = NIL(array_t);
2341      } else if (modelCareStatesArray) {
2342        modelCareStatesArray = NIL(array_t);
2343      }
2344    }
2345  }/* for all formulae */
2346
2347  if (verbosity > McVerbosityNone_c) {
2348    finalTime = util_cpu_time();
2349    fprintf(vis_stdout, "-- total mc time = %10g\n",
2350      (double)(finalTime - totalInitialTime) / 1000.0);
2351    fprintf(vis_stdout,
2352            "-- total %d image computations and %d preimage computations\n",
2353            Img_GetNumberOfImageComputation(Img_Forward_c),
2354            Img_GetNumberOfImageComputation(Img_Backward_c));
2355    /* Print tfm options if we have a global fsm. */
2356    if (!McOptionsReadReduceFsm(options) && modelFsm != NIL(Fsm_Fsm_t)) {
2357      imageInfo = Fsm_FsmReadImageInfo(modelFsm);
2358      if (Img_ImageInfoObtainMethodType(imageInfo) == Img_Tfm_c ||
2359          Img_ImageInfoObtainMethodType(imageInfo) == Img_Hybrid_c) {
2360        Img_TfmPrintStatistics(imageInfo, Img_Both_c);
2361      }
2362    }
2363  }
2364
2365  /* Print results of coverage computation */
2366  McPrintCoverageSummary(modelFsm, dcLevel,
2367                         options, modelCareStatesArray,
2368                         modelCareStates, totalcoveredstates,
2369                         signalTypeList, signalList, statesCoveredList,
2370                         performCoverageHoskote, performCoverageImproved);
2371  mdd_array_free(newCoveredStatesList);
2372  mdd_array_free(statesToRemoveList);
2373  array_free(signalTypeList);
2374  array_free(signalList);
2375  mdd_array_free(statesCoveredList);
2376  if (totalcoveredstates != NIL(mdd_t))
2377    mdd_free(totalcoveredstates);
2378
2379  if (modelCareStates) {
2380    mdd_array_free(modelCareStatesArray);
2381  }
2382
2383  if(hintsArray)
2384    Ctlp_FormulaArrayFree(hintsArray);
2385
2386  if ((McOptionsReadReduceFsm(options) == FALSE) &&
2387      (reducedFsm != NIL(Fsm_Fsm_t))) {
2388    /* If "-r" was not specified and we did some reduction at top
2389       level, we need to free it */
2390    Fsm_FsmFree(reducedFsm);
2391    reducedFsm = NIL(Fsm_Fsm_t);
2392    modelFsm = NIL(Fsm_Fsm_t);
2393  }
2394
2395  if(systemVarBddIdTable)
2396    st_free_table(systemVarBddIdTable);
2397  array_free(ctlNormalFormulaArray);
2398  (void) fprintf(vis_stdout, "\n");
2399
2400  Ctlp_FormulaArrayFree(ctlArray);
2401  McOptionsFree(options);
2402  alarm(0);
2403  return 0;
2404
2405}
2406
2407
2408/**Function********************************************************************
2409
2410  Synopsis    [Parse command line options for mc.]
2411
2412  SideEffects []
2413
2414******************************************************************************/
2415static McOptions_t *
2416ParseMcOptions(
2417  int argc,
2418  char **argv)
2419{
2420  unsigned int i;
2421  int c;
2422  char *guideFileName = NIL(char);
2423  char *variablesForSystem = NIL(char);
2424  FILE *guideFile = NIL(FILE);
2425  FILE *systemFile = NIL(FILE);
2426  boolean doCoverageHoskote = FALSE;
2427  boolean doCoverageImproved = FALSE;
2428  boolean useMore = FALSE;
2429  boolean reduceFsm = FALSE;
2430  boolean printInputs = FALSE;
2431  boolean useFormulaTree = FALSE;
2432  boolean vd = FALSE;
2433  boolean beer = FALSE;
2434  boolean FAFWFlag = FALSE;
2435  boolean GFAFWFlag = FALSE;
2436  FILE *inputFp=NIL(FILE);
2437  FILE *debugOut=NIL(FILE);
2438  char *debugOutName=NIL(char);
2439  Mc_DcLevel dcLevel = McDcLevelRch_c;
2440  McDbgLevel dbgLevel = McDbgLevelNone_c;
2441  Mc_VerbosityLevel verbosityLevel = McVerbosityNone_c;
2442  Mc_FwdBwdAnalysis fwdBwd = McFwd_c;
2443  McOptions_t *options = McOptionsAlloc();
2444  int timeOutPeriod = 0;
2445  Mc_FwdBwdAnalysis traversalDirection = McBwd_c;
2446  Fsm_ArdcOptions_t *ardcOptions;
2447  Mc_GSHScheduleType schedule = McGSH_EL_c;
2448
2449  /*
2450   * Parse command line options.
2451   */
2452
2453  util_getopt_reset();
2454  while ((c = util_getopt(argc, argv, "bcirmg:hv:d:D:VBf:t:CIFR:S:GWw:")) != EOF) {
2455    switch(c) {
2456    case 'g':
2457      guideFileName = util_strsav(util_optarg);
2458      break;
2459    case 'h':
2460      goto usage;
2461    case 'v':
2462      for (i = 0; i < strlen(util_optarg); i++) {
2463        if (!isdigit((int)util_optarg[i])) {
2464          goto usage;
2465        }
2466      }
2467      verbosityLevel = (Mc_VerbosityLevel) atoi(util_optarg);
2468      break;
2469    case 'd':
2470      for (i = 0; i < strlen(util_optarg); i++) {
2471        if (!isdigit((int)util_optarg[i])) {
2472          goto usage;
2473        }
2474      }
2475      dbgLevel = (McDbgLevel) atoi(util_optarg);
2476      break;
2477    case 'D':
2478      for (i = 0; i < strlen(util_optarg); i++) {
2479        if (!isdigit((int)util_optarg[i])) {
2480          goto usage;
2481        }
2482      }
2483      dcLevel = (Mc_DcLevel) atoi(util_optarg);
2484      break;
2485    case 'b':
2486      fwdBwd = McBwd_c;
2487      break;
2488    case 'V':         /*Vacuity detection option*/
2489      vd = TRUE;
2490      break;
2491    case 'B':         /*Vacuity detection Beer et al method option*/
2492      vd = TRUE;
2493      beer = TRUE;
2494      break;
2495    case 'f':
2496      debugOutName = util_strsav(util_optarg);
2497      break;
2498    case 'm':
2499      useMore = TRUE;
2500      break;
2501    case 'r' :
2502      reduceFsm = TRUE;
2503      break;
2504    case 'c':
2505      useFormulaTree = TRUE;
2506      break;
2507    case 't' :
2508      timeOutPeriod  = atoi(util_optarg);
2509      break;
2510    case 'i' :
2511      printInputs = TRUE;
2512      break;
2513    case 'F' :
2514      traversalDirection = McFwd_c;
2515      break;
2516    case 'S' :
2517      schedule = McStringConvertToScheduleType(util_optarg);
2518      break;
2519    case 'w':
2520      variablesForSystem = util_strsav(util_optarg);
2521    case 'W':
2522      FAFWFlag = 1;
2523      break;
2524    case 'G':
2525      GFAFWFlag = 1;
2526      break;
2527    case 'C' :
2528      doCoverageHoskote = TRUE;
2529      break;
2530    case 'I' :
2531      doCoverageImproved = TRUE;
2532      break;
2533    default:
2534      goto usage;
2535    }
2536  }
2537
2538  /*
2539   * Open the ctl file.
2540   */
2541  if (argc - util_optind == 0) {
2542    (void) fprintf(vis_stderr, "** mc error: file containing ctl formulas not provided\n");
2543    goto usage;
2544  }
2545  else if (argc - util_optind > 1) {
2546    (void) fprintf(vis_stderr, "** mc error: too many arguments\n");
2547    goto usage;
2548  }
2549
2550  McOptionsSetFwdBwd(options, fwdBwd);
2551  McOptionsSetUseMore(options, useMore);
2552  McOptionsSetReduceFsm(options, reduceFsm);
2553  McOptionsSetVacuityDetect(options, vd);
2554  McOptionsSetBeerMethod(options, beer);
2555  McOptionsSetUseFormulaTree(options, useFormulaTree);
2556  McOptionsSetPrintInputs(options, printInputs);
2557  McOptionsSetTimeOutPeriod(options, timeOutPeriod);
2558  McOptionsSetFAFWFlag(options, FAFWFlag + GFAFWFlag);
2559  McOptionsSetCoverageHoskote(options, doCoverageHoskote);
2560  McOptionsSetCoverageImproved(options, doCoverageImproved);
2561
2562  if((FAFWFlag > 0 || GFAFWFlag > 0) &&  dbgLevel == 0) {
2563    fprintf(vis_stderr, "** mc warning : -w and -W options are ignored without -d option\n");
2564  }
2565
2566  if((FAFWFlag > 0 || GFAFWFlag > 0) &&  printInputs == 0) {
2567    fprintf(vis_stderr, "** mc warning : -i is recommended with -w or -W option\n");
2568  }
2569  if(FAFWFlag) {
2570    if (bdd_get_package_name() != CUDD) {
2571      fprintf(vis_stderr, "** mc warning : -w and -W option is only available with CUDD\n");
2572      FAFWFlag = 0;
2573      FREE(variablesForSystem);
2574      variablesForSystem = NIL(char);
2575    }
2576  }
2577
2578
2579  if (schedule == McGSH_Unassigned_c) {
2580    (void) fprintf(vis_stderr, "unknown schedule: %s\n", util_optarg);
2581    goto usage;
2582  } else {
2583    McOptionsSetSchedule(options, schedule);
2584  }
2585  inputFp = Cmd_FileOpen(argv[util_optind], "r", NIL(char *), 0);
2586  if (inputFp == NIL(FILE)) {
2587    McOptionsFree(options);
2588    if (guideFileName != NIL(char)) FREE(guideFileName);
2589    return NIL(McOptions_t);
2590  }
2591  McOptionsSetCtlFile(options, inputFp);
2592
2593  if (debugOutName != NIL(char)) {
2594    debugOut = Cmd_FileOpen(debugOutName, "w", NIL(char *), 0);
2595    FREE(debugOutName);
2596    if (debugOut == NIL(FILE)) {
2597      McOptionsFree(options);
2598      if (guideFileName != NIL(char)) FREE(guideFileName);
2599      return NIL(McOptions_t);
2600    }
2601  }
2602  McOptionsSetDebugFile(options, debugOut);
2603
2604
2605  if (guideFileName != NIL(char)) {
2606    guideFile = Cmd_FileOpen(guideFileName, "r", NIL(char *), 0);
2607    if (guideFile == NIL(FILE)) {
2608      fprintf(vis_stderr, "** mc error: cannot open guided search file %s.\n",
2609              guideFileName);
2610      FREE(guideFileName);
2611      guideFileName = NIL(char);
2612      McOptionsFree(options);
2613      return NIL(McOptions_t);
2614    }
2615    FREE(guideFileName);
2616    guideFileName = NIL(char);
2617  }
2618  McOptionsSetGuideFile(options, guideFile);
2619
2620  if (variablesForSystem != NIL(char)) {
2621    systemFile = Cmd_FileOpen(variablesForSystem, "r", NIL(char *), 0);
2622    if (systemFile == NIL(FILE)) {
2623      fprintf(vis_stderr, "** mc error: cannot open system variables file for FAFW %s.\n",
2624              variablesForSystem);
2625      FREE(variablesForSystem);
2626      variablesForSystem = NIL(char);
2627      McOptionsFree(options);
2628      return NIL(McOptions_t);
2629    }
2630    FREE(variablesForSystem);
2631    variablesForSystem = NIL(char);
2632  }
2633  McOptionsSetVariablesForSystem(options, systemFile);
2634
2635  if ((verbosityLevel != McVerbosityNone_c) &&
2636       (verbosityLevel != McVerbosityLittle_c) &&
2637       (verbosityLevel != McVerbositySome_c) &&
2638       (verbosityLevel != McVerbosityMax_c)) {
2639    goto usage;
2640  }
2641  else {
2642    McOptionsSetVerbosityLevel(options, verbosityLevel);
2643  }
2644
2645  if ((dbgLevel != McDbgLevelNone_c) &&
2646       (dbgLevel != McDbgLevelMin_c) &&
2647       (dbgLevel != McDbgLevelMinVerbose_c) &&
2648       (dbgLevel != McDbgLevelMax_c) &&
2649       (dbgLevel != McDbgLevelInteractive_c)) {
2650    goto usage;
2651  }
2652  else {
2653    McOptionsSetDbgLevel(options, dbgLevel);
2654  }
2655
2656  if ((dcLevel != McDcLevelNone_c) &&
2657       (dcLevel != McDcLevelRch_c ) &&
2658       (dcLevel != McDcLevelRchFrontier_c ) &&
2659       (dcLevel != McDcLevelArdc_c )) {
2660    goto usage;
2661  }
2662  else {
2663    McOptionsSetDcLevel(options, dcLevel);
2664  }
2665
2666  McOptionsSetTraversalDirection(options, traversalDirection);
2667  if (dcLevel == McDcLevelArdc_c) {
2668    ardcOptions = Fsm_ArdcAllocOptionsStruct();
2669    Fsm_ArdcGetDefaultOptions(ardcOptions);
2670  } else
2671    ardcOptions = NIL(Fsm_ArdcOptions_t);
2672  McOptionsSetArdcOptions(options, ardcOptions);
2673
2674  return options;
2675
2676  usage:
2677  (void) fprintf(vis_stderr, "usage: model_check [-b][-c][-d dbg_level][-f dbg_file][-g <hintfile>][-h][-i][-m][-r][-V][-B][-t period][-C][-I][-P][-v verbosity_level][-D dc_level][-F][-S <schedule>] <ctl_file>\n");
2678  (void) fprintf(vis_stderr, "    -b \tUse backward analysis in debugging\n");
2679  (void) fprintf(vis_stderr, "    -c \tNo sharing of CTL parse tree. This option does not matter for vacuity detection.\n");
2680  (void) fprintf(vis_stderr, "    -d <dbg_level>\n");
2681  (void) fprintf(vis_stderr, "        debug_level = 0 => no debugging (Default)\n");
2682  (void) fprintf(vis_stderr, "        debug_level = 1 => automatic minimal debugging\n");
2683  (void) fprintf(vis_stderr, "        debug_level = 2 => automatic minimal debugging with extra verbosity\n");
2684  (void) fprintf(vis_stderr, "        debug_level = 3 => automatic maximal debugging\n");
2685  (void) fprintf(vis_stderr, "        debug_level = 4 => interactive debugging\n");
2686  (void) fprintf(vis_stderr, "    -f <dbg_out>\n");
2687  (void) fprintf(vis_stderr, "        write error trace to dbg_out\n");
2688  (void) fprintf(vis_stderr, "    -g <hint_file> \tSpecify file for guided search.\n");
2689  (void) fprintf(vis_stderr, "    -h \tPrints this usage message.\n");
2690  (void) fprintf(vis_stderr, "    -i \tPrint input values in debug traces.\n");
2691  (void) fprintf(vis_stderr, "    -m \tPipe debug output through more.\n");
2692  (void) fprintf(vis_stderr, "    -r  reduce FSM with respect to formula being verified\n");
2693  (void) fprintf(vis_stderr, "    -t <period> time out period\n");
2694  (void) fprintf(vis_stderr, "    -v <verbosity_level>\n");
2695  (void) fprintf(vis_stderr, "        verbosity_level = 0 => no feedback (Default)\n");
2696  (void) fprintf(vis_stderr, "        verbosity_level = 1 => code status\n");
2697  (void) fprintf(vis_stderr, "        verbosity_level = 2 => code status and CPU usage profile\n");
2698  (void) fprintf(vis_stderr, "    -w <node file> \tSpecify variables controlled by system.\n");
2699  (void) fprintf(vis_stderr, "    -B  vacuity detection for w-ACTL formulae using method of Beer et al \n");
2700  (void) fprintf(vis_stderr, "    -C Compute coverage of all observable signals using Hoskote et.al's implementation\n");
2701  (void) fprintf(vis_stderr, "    -D <dc_level>\n");
2702  (void) fprintf(vis_stderr, "        dc_level = 0 => no use of don't cares\n");
2703  (void) fprintf(vis_stderr, "        dc_level = 1 => use unreached states as don't cares (Default)\n");
2704  (void) fprintf(vis_stderr, "        dc_level = 2 => use unreached states as don't cares\n");
2705
2706  (void) fprintf(vis_stderr, "                        and aggressive use of DC's to simplify MDD's\n");
2707  (void) fprintf(vis_stderr, "        dc_level = 3 => use over-approximate unreached states as don't cares\n");
2708  (void) fprintf(vis_stderr, "                        and aggressive use of DC's to simplify MDD's\n");
2709  (void) fprintf(vis_stderr, "    -F \tUse forward model checking.\n");
2710  (void) fprintf(vis_stderr, "    -G \tUse general fate and free will algorithm.\n");
2711  (void) fprintf(vis_stderr, "    -I Compute coverage of all observable signals using improved coverage implementation\n");
2712  (void) fprintf(vis_stderr, "    -S <schedule>\n");
2713  (void) fprintf(vis_stderr, "       schedule is one of {EL,EL1,EL2,budget,random,off}\n");
2714  (void) fprintf(vis_stderr, "    -V  thorough vacuity detection\n");
2715  (void) fprintf(vis_stderr, "    -W \tUse fate and free will algorithm when all the variables are controlled by system.\n");
2716  (void) fprintf(vis_stderr, "    <ctl_file> The input file containing CTL formula to be checked.\n");
2717
2718  if (guideFileName != NIL(char)) FREE(guideFileName);
2719  McOptionsFree(options);
2720
2721  return NIL(McOptions_t);
2722}
2723
2724
2725/**Function********************************************************************
2726
2727  Synopsis []   
2728
2729  Description [Refer to 'static int CommandPrintModels (Hrc_Manager_t **hmgr,
2730                int argc, char **argv)' function in hrcCmd.c]
2731   
2732  SideEffects []
2733
2734  SeeAlso     []
2735
2736******************************************************************************/
2737
2738static int print_modelsMine(Hrc_Manager_t **hmgr, int argc, char **argv)
2739{
2740
2741 (void) fprintf(vis_stderr, "*** 'print_models' begins. *** \n");
2742
2743  st_generator *gen;
2744  char *name;
2745  Hrc_Model_t *model;
2746  Hrc_Node_t *node;
2747  int c;
2748 
2749  util_getopt_reset();
2750  while ((c = util_getopt(argc, argv, "h")) != EOF) {
2751    switch(c){
2752      case 'h':
2753        goto usage;
2754      default:
2755        goto usage;
2756    }
2757  }
2758  if(argc != 1) {
2759    goto usage;
2760  }
2761
2762  node = Hrc_ManagerReadCurrentNode(*hmgr);
2763  if (node == NIL(Hrc_Node_t)){
2764    (void)fprintf(vis_stderr,"No file has been read in.\n");
2765    return 1;
2766  }
2767
2768  Hrc_ManagerForEachModel(*hmgr, gen, name, model) {
2769    PrintNodeStats(Hrc_ModelReadMasterNode(model), FALSE);
2770    (void) fprintf(vis_stdout, "subckts = %d\n",
2771                   st_count(Hrc_ModelReadSubcktTable(model)));
2772  }
2773  return 0;
2774 
2775usage:
2776  (void) fprintf(vis_stderr, "usage: print_models [-h]\n");
2777  (void) fprintf(vis_stderr, "   -h \t\tprint the command usage\n"); 
2778  return 1;       
2779
2780}
2781
2782/**Function********************************************************************
2783
2784  Synopsis    [This function prints the statistics of a node.]
2785
2786  SideEffects []
2787
2788  SeeAlso     []
2789
2790******************************************************************************/
2791static void
2792PrintNodeStats(
2793  Hrc_Node_t *node,
2794  boolean isHnode)
2795{
2796  (void) fprintf(vis_stdout, "Model name = %s", Hrc_NodeReadModelName(node));
2797  if(isHnode) {
2798    (void) fprintf(vis_stdout, ", Instance name = %s\n",
2799                   Hrc_NodeReadInstanceName(node));
2800  }
2801  else {
2802    (void) fprintf(vis_stdout, "\n");
2803  }
2804  (void) fprintf(vis_stdout, "inputs = %d,", Hrc_NodeReadNumFormalInputs(node));
2805  (void) fprintf(vis_stdout, " outputs = %d,", Hrc_NodeReadNumFormalOutputs(node));
2806  (void) fprintf(vis_stdout, " variables = %d,", Hrc_NodeReadNumVariables(node));
2807  (void) fprintf(vis_stdout, " tables = %d,", Hrc_NodeReadNumTables(node));
2808  (void) fprintf(vis_stdout, " latches = %d", Hrc_NodeReadNumLatches(node));
2809  if(isHnode) {
2810    (void) fprintf(vis_stdout, ", children = %d\n", Hrc_NodeReadNumChildren(node));
2811  }
2812  else {
2813    (void) fprintf(vis_stdout, "\n");
2814  }
2815}
2816
2817/**Function********************************************************************
2818
2819  Synopsis [returns child or parent node (it is actually the current node)]   
2820
2821  Description [Refer to 'static int CommandCd (Hrc_Manager_t **hmgr,
2822                int argc, char **argv)' function in hrcCmd.c]
2823   
2824  SideEffects []
2825
2826  SeeAlso     []
2827
2828******************************************************************************/
2829static Hrc_Node_t *cdMine(Hrc_Manager_t **hmgr, int argc, char **argv)
2830{
2831
2832 (void) fprintf(vis_stderr, "*** 'cd' begins. *** \n");
2833
2834  Hrc_Node_t *currentNode, *parent, *child;
2835  int c;
2836
2837  util_getopt_reset();
2838  while ((c = util_getopt(argc, argv, "h")) != EOF) {
2839    switch(c){
2840      case 'h':
2841        goto usage;
2842      default:
2843        goto usage;
2844    }
2845  }
2846
2847  if (argc != 2){
2848    goto usage;
2849  }
2850 
2851  currentNode = Hrc_ManagerReadCurrentNode(*hmgr);
2852  if (currentNode == NIL(Hrc_Node_t)){
2853    (void)fprintf(vis_stdout,"No file has been read in.\n");
2854    return NIL(Hrc_Node_t);
2855  }
2856  /* go to the parent node */
2857  if (strcmp(*(++argv),"..") == 0){
2858    if ((parent = Hrc_NodeReadParentNode(currentNode)) == NIL(Hrc_Node_t)){
2859      (void)fprintf(vis_stderr,"You are at the root node. Can't cd to a parent.\n");
2860      return currentNode;
2861    }
2862    Hrc_ManagerSetCurrentNode(*hmgr,parent);
2863    return parent;
2864  }
2865
2866  if ((child = Hrc_NodeFindChildByName(currentNode,*argv)) == NIL(Hrc_Node_t)){
2867    (void)fprintf(vis_stderr,"No child node whose name is %s exists in the current node.\n",*argv);
2868    return currentNode;
2869  }
2870  Hrc_ManagerSetCurrentNode(*hmgr,child);
2871  return child;
2872
2873usage:
2874  (void)fprintf(vis_stderr,"usage: cd [-h] child_name or cd ..\n");
2875  (void) fprintf(vis_stderr, "   -h \t\tprint the command usage\n"); 
2876  return NIL(Hrc_Node_t);
2877}
2878
2879
2880/**Function********************************************************************
2881
2882  Synopsis [returns current node]   
2883
2884  Description [Refer to 'static int CommandLs (Hrc_Manager_t **hmgr,
2885                int argc, char **argv)' function in hrcCmd.c]
2886   
2887  SideEffects []
2888
2889  SeeAlso     []
2890
2891******************************************************************************/
2892static Hrc_Node_t *lsMine(Hrc_Manager_t **hmgr, int argc, char **argv){
2893
2894 (void) fprintf(vis_stderr, "*** 'ls' begins. *** \n");
2895
2896  int recursiveFlag = 0;
2897  int c;
2898  Hrc_Node_t *currentNode;
2899
2900  util_getopt_reset();
2901  while ((c = util_getopt(argc, argv, "hR")) != EOF) {
2902    switch(c){
2903      case 'h':
2904        goto usage;
2905      case 'R':
2906        recursiveFlag = 1;
2907        break;
2908      default:
2909        goto usage;
2910    }
2911  }
2912  /* if there are some arguments for ls */
2913  if (argc != util_optind){
2914    goto usage;
2915  }
2916
2917  currentNode = Hrc_ManagerReadCurrentNode(*hmgr);
2918  if (currentNode == NIL(Hrc_Node_t)){
2919    (void)fprintf(vis_stdout,"No file has been read in.\n");
2920    return NIL(Hrc_Node_t);
2921  }
2922  NodeListChildren(currentNode, recursiveFlag, 0);
2923  return currentNode;
2924
2925usage:
2926  (void)fprintf(vis_stderr,"usage: ls [-h] [-R]\n");
2927  (void) fprintf(vis_stderr, "   -h \t\tprint the command usage\n");
2928  (void) fprintf(vis_stderr, "   -R \t\tprint recursive tree\n"); 
2929 
2930  return NIL(Hrc_Node_t);
2931
2932}
2933
2934
2935/**Function********************************************************************
2936
2937  Synopsis []   
2938
2939  Description [Refer to 'static int CommandPwd (Hrc_Manager_t **hmgr,
2940                int argc, char **argv)' function in hrcCmd.c]
2941   
2942  SideEffects []
2943
2944  SeeAlso     []
2945
2946******************************************************************************/
2947static char *pwdMine(Hrc_Manager_t **hmgr, int argc, char **argv){
2948
2949  (void) fprintf(vis_stderr, "*** 'pwd' begins. *** \n");
2950
2951  Hrc_Node_t *currentNode;
2952  Hrc_Node_t *rootNode;
2953  char *separator, *hierarchicalName;
2954  int c;
2955 
2956  util_getopt_reset();
2957  while ((c = util_getopt(argc, argv, "h")) != EOF) {
2958    switch(c){
2959      case 'h':
2960        goto usage;
2961      default:
2962        goto usage;
2963    }
2964  }
2965  if (argc != 1){
2966    goto usage;
2967  }
2968 
2969  currentNode = Hrc_ManagerReadCurrentNode(*hmgr);
2970  if (currentNode == NIL(Hrc_Node_t)){
2971    (void)fprintf(vis_stdout,"No file has been read in.\n");
2972    return NIL(char);
2973  }
2974  rootNode = Hrc_ManagerReadRootNode(*hmgr);
2975  separator = (char *) ((rootNode == currentNode) ? "" : ".");
2976  hierarchicalName = Hrc_NodeFindHierarchicalName(currentNode, FALSE);
2977  (void)fprintf(vis_stdout,"%s%s%s\n", Hrc_NodeReadInstanceName(rootNode),
2978                separator, hierarchicalName);
2979  (void) sprintf(currentPath, "%s%s%s", Hrc_NodeReadInstanceName(rootNode), separator, hierarchicalName);
2980  FREE(hierarchicalName);
2981  return currentPath;
2982
2983usage:
2984  (void)fprintf(vis_stderr,"usage: pwd [-h]\n");
2985  (void) fprintf(vis_stderr, "   -h \t\tprint the command usage\n"); 
2986  return NIL(char);
2987
2988}
2989
2990
2991/**Function********************************************************************
2992
2993  Synopsis []   
2994
2995  Description [Refer to 'static int CommandPrintLatches (Hrc_Manager_t **hmgr,
2996                int argc, char **argv)' function in hrcCmd.c]
2997   
2998  SideEffects []
2999
3000  SeeAlso     []
3001
3002******************************************************************************/
3003static int print_latchesMine(Hrc_Manager_t **hmgr, int argc, char **argv){
3004
3005  (void) fprintf(vis_stderr, "*** 'print_latches' begins. *** \n");
3006
3007  int c, i;
3008  Hrc_Node_t *node;
3009  st_generator *gen;
3010  char *latchName;
3011  Hrc_Latch_t *latch;
3012  array_t *tmpArray;
3013 
3014  util_getopt_reset();
3015  while ((c = util_getopt(argc, argv, "h")) != EOF) {
3016    switch(c){
3017      case 'h':
3018        goto usage;
3019      default:
3020        goto usage;
3021    }
3022  }
3023  /* if there are some arguments left */
3024  if (argc != util_optind){
3025    goto usage;
3026  }
3027  node = Hrc_ManagerReadCurrentNode(*hmgr);
3028  if (node == NIL(Hrc_Node_t)){
3029    (void)fprintf(vis_stderr,"No file has been read in.\n");
3030    return 1;
3031  }
3032 
3033  if (Hrc_NodeReadNumLatches(node) == 0){
3034    fprintf(vis_stdout,"No latches\n");
3035  }
3036  else {
3037    tmpArray = array_alloc(char *,0);
3038    Hrc_NodeForEachLatch(node,gen,latchName,latch){
3039      array_insert_last(char *,tmpArray,latchName);
3040    }
3041    array_sort(tmpArray,_HrcStringCmp);
3042    for (i=0; i < array_n(tmpArray); i++){
3043      fprintf(vis_stdout,"%s ",array_fetch(char *,tmpArray,i));
3044    }
3045    fprintf(vis_stdout,"\n");
3046    array_free(tmpArray);
3047  }
3048  return 0;
3049
3050usage:
3051  (void) fprintf(vis_stderr,"usage: print_latches [-h]\n");
3052  (void) fprintf(vis_stderr, "   -h \t\tprint the command usage\n");
3053  return 1;
3054}
3055
3056/**Function********************************************************************
3057
3058  Synopsis    [Converts a string to an order type.]
3059
3060  Description [Converts a string to an order type. If string does not refer to
3061  one of the allowed order types, then returns Ord_Unassigned_c.]
3062
3063  SideEffects []
3064
3065******************************************************************************/
3066static Ord_OrderType
3067StringConvertToOrderType(
3068  char *string)
3069{
3070  if (strcmp("all", string) == 0) { 
3071    return Ord_All_c; 
3072  }
3073  else if (strcmp("input_and_latch", string) == 0) { 
3074    return Ord_InputAndLatch_c;
3075  }
3076  else if (strcmp("next_state_node", string) == 0) {
3077    return Ord_NextStateNode_c;
3078  }
3079  else if (strcmp("partial", string) == 0) {
3080    return Ord_Partial_c;
3081  }
3082  else {
3083    return Ord_Unassigned_c;
3084  }
3085}
3086
3087
3088/**Function********************************************************************
3089
3090  Synopsis    [The core routine for the command ls.]
3091
3092  Description [The core routine for the command ls. If the second argument
3093  is set to 1, it calls the ls routine recursively all the way down to leaves.]
3094
3095  SideEffects []
3096
3097  SeeAlso     []
3098
3099******************************************************************************/
3100static void
3101NodeListChildren(
3102  Hrc_Node_t *hnode,
3103  boolean recursiveFlag,
3104  int depth)
3105{
3106  st_generator *gen;
3107  char *childName;
3108  Hrc_Node_t *child;
3109  int newDepth, i;
3110  array_t *tmpArray;
3111
3112  newDepth = depth + 1;
3113  tmpArray = array_alloc(char *,0);
3114  Hrc_NodeForEachChild(hnode,gen,childName,child){
3115    array_insert_last(char *,tmpArray,childName);
3116  }
3117  array_sort(tmpArray,_HrcStringCmp);
3118  for (i=0; i < array_n(tmpArray); i++){
3119    PrintSpace(depth);
3120    childName = array_fetch(char *,tmpArray,i);
3121    (void)fprintf(vis_stdout,"%s\n",childName);
3122    if (recursiveFlag == 1){
3123      NodeListChildren(Hrc_NodeFindChildByName(hnode,childName),recursiveFlag,newDepth);
3124    } 
3125  } 
3126  array_free(tmpArray);
3127}
3128
3129/**Function********************************************************************
3130
3131  Synopsis    [The core routine for the command ls. Returns array_t]
3132
3133  Description [The core routine for the command ls. If the second argument
3134  is set to 1, it calls the ls routine recursively all the way down to leaves.]
3135
3136  SideEffects []
3137
3138  SeeAlso     []
3139
3140******************************************************************************/
3141static array_t *NodeListChildrenMine(Hrc_Node_t *hnode, boolean recursiveFlag, int depth){
3142
3143  st_generator *gen;
3144  char *childName;
3145  Hrc_Node_t *child;
3146  int newDepth, i;
3147  array_t *tmpArray;
3148
3149  newDepth = depth + 1;
3150  tmpArray = array_alloc(char *,0);
3151  Hrc_NodeForEachChild(hnode,gen,childName,child){
3152    array_insert_last(char *,tmpArray,childName);
3153  }
3154  array_sort(tmpArray,_HrcStringCmp);
3155  for (i=0; i < array_n(tmpArray); i++){
3156    PrintSpace(depth);
3157    childName = array_fetch(char *,tmpArray,i);
3158    (void)fprintf(vis_stdout,"%s\n",childName);
3159    if (recursiveFlag == 1){
3160      NodeListChildren(Hrc_NodeFindChildByName(hnode,childName),recursiveFlag,newDepth);
3161    } 
3162  } 
3163//  array_free(tmpArray);
3164 return tmpArray;
3165}
3166
3167/**Function********************************************************************
3168
3169  Synopsis    [Prints out spaces.]
3170
3171  SideEffects []
3172
3173  SeeAlso     []
3174
3175******************************************************************************/
3176static void
3177PrintSpace(int depth)
3178{
3179  int i;
3180  for (i=0; i < depth; i++){
3181    (void)fprintf(vis_stdout," ");
3182  }
3183}
3184
3185
3186/**Function********************************************************************
3187
3188  Synopsis    [Verifies that suppliedNodeList has the correct nodes.]
3189
3190  Description [Returns TRUE if the set of nodes in suppliedNodeList matches
3191  the set of nodes in network specified by orderType; else returns FALSE and
3192  writes a message to error_string. OrderType should be one of the following:
3193  1) Ord_All_c: should match the set of all nodes in network; 2)
3194  Ord_InputAndLatch_c: should match the set of inputs (primary + pseudo),
3195  latches, and next state nodes; 3) Ord_NextStateNode_c: should match the set
3196  of next state nodes; number should be the number of latches; 4)
3197  Ord_Partial_c: returns TRUE automatically.]
3198
3199  SideEffects []
3200
3201******************************************************************************/
3202static boolean
3203NetworkCheckSuppliedNodeList(
3204  Ntk_Network_t * network,
3205  lsList  suppliedNodeList,
3206  Ord_OrderType  orderType)
3207{
3208  lsGen         gen;
3209  st_generator *stGen;
3210  Ntk_Node_t   *node;
3211  st_table     *requiredNodes;
3212  st_table     *suppliedNodes;
3213  char         *dummy;
3214  boolean       returnFlag = TRUE;
3215 
3216  assert(orderType != Ord_Unassigned_c);
3217
3218  if (orderType == Ord_Partial_c) {
3219    return TRUE;
3220  }
3221 
3222  /* At this point, orderType must be one of the these. */
3223  assert((orderType == Ord_All_c) || (orderType == Ord_InputAndLatch_c)
3224         || (orderType == Ord_NextStateNode_c));
3225 
3226
3227  /*
3228   * Build up the table of required nodes. Next state nodes are included by
3229   * all 3 order types.
3230   */
3231  requiredNodes = st_init_table(st_ptrcmp, st_ptrhash);
3232  Ntk_NetworkForEachNode(network, gen, node) {
3233    if ((orderType == Ord_All_c) || Ntk_NodeTestIsNextStateNode(node)) {
3234      st_insert(requiredNodes, (char *) node, NIL(char));
3235    }
3236    else if ((orderType == Ord_InputAndLatch_c)
3237             && Ntk_NodeTestIsCombInput(node)) {
3238      st_insert(requiredNodes, (char *) node, NIL(char));
3239    }
3240    /* else, this node is not included by orderType */
3241  }
3242
3243  /*
3244   * Convert suppliedNodeList to the table of supplied nodes.
3245   */
3246  suppliedNodes = st_init_table(st_ptrcmp, st_ptrhash);
3247  lsForEachItem(suppliedNodeList, gen, node) {
3248    int status = st_insert(suppliedNodes, (char *) node, NIL(char));
3249    if (status) {
3250      error_append("node ");
3251      error_append(Ntk_NodeReadName(node));
3252      error_append(" appears more than once in ordering file\n");
3253      returnFlag = FALSE;
3254    }
3255  }
3256
3257  /*
3258   * Check that suppliedNodes is contained in requiredNodes.
3259   */
3260  st_foreach_item(suppliedNodes, stGen, &node, &dummy) {
3261    if (!st_is_member(requiredNodes, node)) {
3262      error_append("node ");
3263      error_append(Ntk_NodeReadName(node));
3264      error_append(" supplied but not required\n");
3265      returnFlag = FALSE;
3266    }
3267  }
3268 
3269  /*
3270   * Check that suppliedNodes is contained in requiredNodes.
3271   */
3272  st_foreach_item(requiredNodes, stGen, &node, &dummy) {
3273    if (!st_is_member(suppliedNodes, node)) {
3274      error_append("node ");
3275      error_append(Ntk_NodeReadName(node));
3276      error_append(" required but not supplied\n");
3277      returnFlag = FALSE;
3278    }
3279  }
3280 
3281  st_free_table(requiredNodes);
3282  st_free_table(suppliedNodes);
3283  return returnFlag;
3284}
3285
3286/**Function********************************************************************
3287
3288  Synopsis    [Returns a list of names corresponding to the names in a file.]
3289
3290  Description [Parses a file and builds a name list corresponding to the names
3291  found in the first "column" of each line of the file.  Any line starting
3292  with the comment character '#' or white space is ignored.  No checks are
3293  made to see if the names are well-formed in any respect. If a problem is
3294  found while parsing the file (e.g. name length exceeded), then a message is
3295  written to error_string, the partial name list is freed, and the function
3296  returns FALSE; otherwise, it returns TRUE, and a pointer to a list is
3297  returned.]
3298
3299  Comment [The parser consists of 3 states.  See the documentation
3300  accompanying the #defines defining the state names.  This code was adapted
3301  from Ord_FileReadNodeList.]
3302 
3303  SideEffects []
3304
3305******************************************************************************/
3306static boolean
3307FileReadNameList(
3308  FILE * fp,
3309  lsList * nameList /* of char *, for return */,
3310  int verbose)
3311{
3312  int     c;
3313  int     state;
3314  int     curPosition = 0;
3315  char   *name;
3316  char    string[MAX_NAME_LENGTH];
3317  boolean returnFlag = TRUE;
3318 
3319  *nameList = lsCreate();
3320
3321  state = STATE_TEST;
3322  while ((c = fgetc(fp)) != EOF) {
3323
3324    switch (state) {
3325      case STATE_TEST:
3326        /* At start of a new line. */
3327        if (c == '#') {
3328          /* Line starting with comment character; wait for newline */
3329          state = STATE_WAIT;
3330        }
3331        else if ((c == ' ') || (c == '\t')) {
3332          /* Line starting with white space; wait for newline */
3333          state = STATE_WAIT;
3334        }
3335        else if (c == '\n') {
3336          /* Line starting with newline; go to next line */
3337          state = STATE_TEST;
3338        }
3339        else {
3340          /* Assume starting a name. */
3341          curPosition = 0;
3342          string[curPosition++] = c;
3343          state = STATE_IN;
3344        }
3345        break;
3346      case STATE_WAIT:
3347        /*
3348         * Waiting for the newline character.
3349         */
3350        state = (c == '\n') ? STATE_TEST : STATE_WAIT;
3351        break;
3352      case STATE_IN:
3353        /*
3354         * Parsing a name.  If white space reached, then terminate the
3355         * name and process it.  Else, continue parsing.
3356         */
3357        if ((c == ' ') || (c == '\n') || (c == '\t')) {
3358          string[curPosition] = '\0';
3359          name = util_strsav(string);
3360          if (verbose > 1) {
3361            (void) fprintf(vis_stdout, "Reading name: %s\n", name);
3362          }
3363          (void) lsNewEnd(*nameList, (lsGeneric) name, LS_NH); 
3364         
3365          state = (c == '\n') ? STATE_TEST : STATE_WAIT;
3366        }
3367        else {
3368          string[curPosition++] = c;
3369          if (curPosition >= MAX_NAME_LENGTH) {
3370            error_append("maximum name length exceeded");
3371            returnFlag = FALSE;
3372          }
3373          state = STATE_IN; /* redundant, but be explicit */
3374        }
3375        break;
3376      default:
3377        fail("unrecognized state");
3378    }
3379  }
3380
3381  /*
3382   * Handle case where EOF terminates a name.
3383   */
3384  if (state == STATE_IN) {
3385    string[curPosition] = '\0';
3386    name = util_strsav(string);
3387    if (verbose > 1) {
3388      (void) fprintf(vis_stdout, "Reading name: %s\n", name);
3389    }
3390    (void) lsNewEnd(*nameList, (lsGeneric) name, LS_NH); 
3391         
3392  }
3393
3394  if (returnFlag) {
3395    return TRUE;
3396  }
3397  else {
3398    (void) lsDestroy(*nameList, (void (*) (lsGeneric)) NULL);
3399    return FALSE;
3400  }
3401}
3402
3403/**Function********************************************************************
3404
3405  Synopsis    [Initilizes all the global variables used in the parser.]
3406
3407  Description []
3408
3409  SideEffects []
3410
3411  SeeAlso     []
3412
3413******************************************************************************/
3414static void
3415_IoGlobalVariablesInitialize(void)
3416{
3417  globalLineNumber = 1;
3418  globalModel = NIL(Hrc_Model_t);
3419  globalHnode = NIL(Hrc_Node_t);
3420  globalFirstModel = NIL(Hrc_Model_t); /* set once */
3421  globalRootModel = NIL(Hrc_Model_t); /* set once */
3422  globalRootInstanceName = NIL(char); /* set once */
3423  globalMvNameArray = NIL(array_t);
3424  globalSymValueArray = NIL(array_t);
3425  globalTableInputArray = NIL(array_t);
3426  globalTableOutputArray = NIL(array_t);
3427  globalTableDefaultArray = NIL(array_t);
3428  globalTableSymCubeArray = NIL(array_t);
3429  globalFormalNameArray = NIL(array_t);
3430  globalActualNameArray = NIL(array_t);
3431
3432  globalSubcktArray = NIL(array_t);
3433  globalResetArray = NIL(array_t);
3434
3435  globalNewModelArray = array_alloc(Hrc_Model_t *,0);
3436
3437  globalCurrentStackDepth = 0;
3438
3439  /* a hash table from a model name to an array of resets/subcircuits in the model */
3440  globalParserResetInfo = st_init_table(st_ptrcmp,st_ptrhash);
3441  globalParserSubcktInfo = st_init_table(st_ptrcmp,st_ptrhash);
3442}
3443
3444/**Function********************************************************************
3445
3446  Synopsis    [Frees all the global data structures used in the parser.]
3447
3448  Description []
3449
3450  SideEffects []
3451
3452  SeeAlso     []
3453
3454******************************************************************************/
3455static void
3456_IoGlobalVariablesFree(void)
3457{
3458   array_free(globalNewModelArray);
3459   _IoGlobalResetInfoFree(); 
3460   _IoGlobalSubcktInfoFree();
3461}
3462
3463
3464/**Function********************************************************************
3465
3466  Synopsis    [Frees the subckt information only used by the parser.]
3467
3468  Description []
3469
3470  SideEffects []
3471
3472  SeeAlso     []
3473
3474******************************************************************************/
3475static void
3476_IoGlobalSubcktInfoFree(void)
3477{
3478  st_generator *gen;
3479  char *key, *val;
3480
3481  st_foreach_item(globalParserSubcktInfo,gen,&key,&val){
3482    if ((array_t *)val != NIL(array_t)){
3483      _IoSubcktArrayFree((array_t *)val);
3484    }
3485  }
3486  st_free_table(globalParserSubcktInfo);
3487}
3488
3489
3490/**Function********************************************************************
3491
3492  Synopsis    [Frees an array of the subckt data structure only used by the parser.]
3493
3494  Description []
3495
3496  SideEffects []
3497
3498  SeeAlso     []
3499
3500******************************************************************************/
3501static void
3502_IoSubcktArrayFree(array_t *array)
3503{
3504  int i;
3505
3506  for (i=0; i < array_n(array); i++){
3507    _IoSubcktFree(array_fetch(IoSubckt_t *,array,i));
3508  }
3509  array_free(array);
3510}
3511
3512/**Function********************************************************************
3513
3514  Synopsis    [Frees the subckt data structure used by the parser.]
3515
3516  Description []
3517
3518  SideEffects []
3519
3520  SeeAlso     []
3521
3522******************************************************************************/
3523static void
3524_IoSubcktFree(IoSubckt_t *subckt)
3525{
3526  FREE(subckt->modelName);
3527  FREE(subckt->instanceName);
3528  IoStringArrayFree(subckt->formalNameArray);
3529  IoStringArrayFree(subckt->actualNameArray);
3530  FREE(subckt);
3531}
3532
3533
3534/**Function********************************************************************
3535
3536  Synopsis    [Frees the reset data structure used only by the parser.]
3537
3538  Description []
3539
3540  SideEffects []
3541
3542  SeeAlso     []
3543
3544******************************************************************************/
3545static void
3546_IoGlobalResetInfoFree(void)
3547{
3548  st_generator *gen;
3549  char *key, *val;
3550  int i;
3551  Tbl_Table_t *resetTable;
3552
3553  st_foreach_item(globalParserResetInfo,gen,&key,&val){
3554    if ((array_t *)val != NIL(array_t)){
3555      for (i=0; i < array_n((array_t *)val); i++){
3556        resetTable = array_fetch(Tbl_Table_t *,(array_t *)val,i);
3557        if (resetTable != NIL(Tbl_Table_t)){
3558          Tbl_TableFree(resetTable);
3559        }
3560      }
3561      array_free((array_t *)val);
3562    }
3563  }
3564  st_free_table(globalParserResetInfo);
3565}
3566
3567
3568/**Function********************************************************************
3569
3570  Synopsis    [Checks if two hnodes are compatible with respect to their input
3571  or output interface depending on the last boolean flag.]
3572
3573  Description [Checks if two hnodes are compatible with respect to their input
3574  or output interface depending on the last boolean flag. 0 for input and 1
3575  for output.]
3576
3577  SideEffects []
3578
3579  SeeAlso     []
3580
3581******************************************************************************/
3582static boolean
3583_IoNodeTestCompatibilityAux(
3584  Hrc_Manager_t *hmgr,
3585  Hrc_Node_t *hnode1,
3586  Hrc_Node_t *hnode2,
3587  boolean mode)
3588{
3589  int i, n;
3590  array_t *formalVars1, *formalVars2;
3591  Var_Variable_t *var1, *var2;
3592
3593  if (mode == 0){
3594    formalVars1 = Hrc_NodeReadFormalInputs(hnode1);
3595    formalVars2 = Hrc_NodeReadFormalInputs(hnode2);
3596  }
3597  else {
3598    formalVars1 = Hrc_NodeReadFormalOutputs(hnode1);
3599    formalVars2 = Hrc_NodeReadFormalOutputs(hnode2);
3600  }
3601  if ((n = array_n(formalVars1)) != array_n(formalVars2)){
3602    error_append("Two hnodes have different number of formal ");
3603    if (mode == 0){
3604      error_append("inputs.\n");
3605    }
3606    else {
3607      error_append("outputs.\n");
3608    }
3609    return 0;
3610  } 
3611  for (i=0; i < n; i++){
3612    var1 = array_fetch(Var_Variable_t *,formalVars1,i);
3613    var2 = array_fetch(Var_Variable_t *,formalVars2,i);
3614    if (strcmp(Var_VariableReadName(var1),Var_VariableReadName(var2)) != 0){
3615      error_append("Two hnodes have different ports, ");
3616      error_append(Var_VariableReadName(var1));
3617      error_append(" and ");
3618      error_append(Var_VariableReadName(var2));
3619      error_append("\n");
3620      return 0; 
3621    }
3622    if (Var_VariablesTestHaveSameDomain(var1,var2) == 0){
3623      error_append("Two hnodes have ports defined over different domains, ");
3624      error_append(Var_VariableReadName(var1));
3625      error_append(" and ");
3626      error_append(Var_VariableReadName(var2));
3627      error_append("\n");
3628      return 0; 
3629    }
3630  }
3631  return 1;
3632}
3633
3634
3635/**Function********************************************************************
3636
3637  Synopsis    [Canonicalizes all the tables in a given manager using
3638  Tbl_TableCanonicalize().]
3639
3640  SideEffects [The original tables will be overwritten.]
3641
3642  SeeAlso     []
3643
3644******************************************************************************/
3645static void
3646_IoManagerCanonicalize(
3647  Hrc_Manager_t *hmgr)
3648{
3649  int i;
3650  Hrc_Model_t *model;
3651  Hrc_Node_t *node;
3652  Tbl_Table_t *table;
3653  st_generator *gen, *gen2;
3654  char *modelName, *latchName;
3655  Hrc_Latch_t *latch;
3656
3657  Hrc_ManagerForEachModel(hmgr,gen,modelName,model){
3658    node = Hrc_ModelReadMasterNode(model);
3659    Hrc_NodeForEachNameTable(node,i,table){
3660      Tbl_TableCanonicalize(table);
3661    }
3662    Hrc_NodeForEachLatch(node,gen2,latchName,latch){
3663      Tbl_TableCanonicalize(Hrc_LatchReadResetTable(latch));
3664    }
3665  }
3666}
3667
3668
3669/**Function********************************************************************
3670
3671  Synopsis    [Handle function for timeout.]
3672
3673  Description [This function is called when the time out occurs.
3674  Since alarm is set with an elapsed time, this function checks if the
3675  CPU time corresponds to the timeout of the command.  If not, it
3676  reprograms the alarm to fire again later.]
3677
3678  SideEffects []
3679
3680******************************************************************************/
3681static void
3682TimeOutHandle(void)
3683{
3684  int seconds = (int) ((util_cpu_ctime() - alarmLapTime) / 1000);
3685
3686  if (seconds < mcTimeOut) {
3687    unsigned slack = (unsigned) (mcTimeOut - seconds);
3688    (void) signal(SIGALRM, (void(*)(int)) TimeOutHandle);
3689    (void) alarm(slack);
3690  } else {
3691    longjmp(timeOutEnv, 1);
3692  }
3693} /* TimeOutHandle */
3694
3695
3696/**Function********************************************************************
3697
3698  Synopsis    []
3699
3700  Description []
3701 
3702  SideEffects []
3703
3704  SeeAlso     []
3705
3706******************************************************************************/
3707static int
3708nodenameCompare(
3709  const void * node1,
3710  const void * node2)
3711{
3712Ntk_Node_t *v1, *v2;
3713char *name1, *name2;
3714
3715  v1 = *(Ntk_Node_t **)(node1);
3716  v2 = *(Ntk_Node_t **)(node2);
3717  name1 = Ntk_NodeReadName(v1);
3718  name2 = Ntk_NodeReadName(v2);
3719 
3720  return (strcmp(name1, name2));
3721} 
3722
3723
3724/**Function********************************************************************
3725
3726  Synopsis    [This function is used for string comparison in array_sort.]
3727
3728  Description [This function is used for string comparison in array_sort.]
3729   
3730  SideEffects []
3731
3732  SeeAlso     []
3733
3734******************************************************************************/
3735static int
3736_HrcStringCmp(
3737  const void * s1,
3738  const void * s2)
3739{
3740  return(strcmp(*(char **)s1, *(char **)s2));
3741}
3742
3743
3744/**Function********************************************************************
3745
3746  Synopsis [Prints whether model checking passed or failed]
3747
3748  Description [Prints whether model checking passed or failed, and if
3749  requested, a debug trace.]
3750
3751  SideEffects []
3752
3753******************************************************************************/
3754static boolean
3755McPrintPassFailMine(
3756  mdd_manager *mddMgr,
3757  Fsm_Fsm_t *modelFsm,
3758  Mc_FwdBwdAnalysis traversalDirection,
3759  Ctlp_Formula_t *ctlFormula,
3760  mdd_t *ctlFormulaStates,
3761  mdd_t *modelInitialStates,
3762  array_t *modelCareStatesArray,
3763  McOptions_t *options,
3764  Mc_VerbosityLevel verbosity)
3765{
3766  (void) fprintf(vis_stdout, "![McPrintPassFailMine] Original CTL Formula : ");
3767   Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(ctlFormula));
3768  (void) fprintf(vis_stdout, "\n![McPrintPassFailMine] MC CTL Formula : ");   
3769  Ctlp_FormulaPrint(vis_stdout, ctlFormula);
3770    fprintf(vis_stdout, "\n");
3771  if (mdd_lequal(modelInitialStates, ctlFormulaStates, 1, 1)) {
3772    fprintf(vis_stdout, "# MC: formula passed --- ");
3773    Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(ctlFormula));
3774    fprintf(vis_stdout, "\n");
3775    return TRUE;
3776  }
3777  else {
3778    fprintf(vis_stdout, "# MC: formula failed --- ");
3779    Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(ctlFormula));
3780    fprintf(vis_stdout, "\n");
3781    if (McOptionsReadDbgLevel(options) != McDbgLevelNone_c) {
3782      McFsmDebugFormulaMine(options, ctlFormula,modelFsm, modelCareStatesArray);
3783    }
3784    return FALSE;
3785  }
3786}
3787
3788
3789/**Function********************************************************************
3790
3791  Synopsis [Debug CTL formula in existential normal form]
3792
3793  Description [Debug CTL formula in existential normal form. The extent to
3794  which debug information is generated is a function of options settings.
3795
3796  The debugger works with ctlFormula, but uses the pointers back to
3797  the original formula that it was converted from, to give the user
3798  more sensible feedback.  To do this, it relies on a specific
3799  translation: only EF, AU, AF, AG, and AX are converted.  Hence, the
3800  only times that the converted bit is set, we have a conversion of
3801  one of these formulas, and the operator is either EU, or negation.
3802  in the latter case, we can conclude from the child of the negation
3803  what formula we converted from: EX means AX, EG means AF, EU means AG,
3804  and OR means AU.
3805  ]
3806
3807  SideEffects [Affects vis_stdpipe]
3808
3809  SeeAlso     [Ctlp_FormulaConvertToExistentialForm]
3810
3811******************************************************************************/
3812static int
3813McFsmDebugFormulaMine(
3814  McOptions_t *options,
3815  Ctlp_Formula_t *ctlFormula,
3816  Fsm_Fsm_t *modelFsm,
3817  array_t *careSetArray)
3818{
3819  (void) fprintf(vis_stdout, "![McFsmDebugFormulaMine]  Original CTL Formula : ");
3820  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(ctlFormula));
3821  (void) fprintf(vis_stdout, "\n![McFsmDebugFormulaMine]  MC CTL Formula : ");   
3822  Ctlp_FormulaPrint(vis_stdout, ctlFormula);
3823  fprintf(vis_stdout, "\n");
3824  mdd_t *modelInitialStates = Fsm_FsmComputeInitialStates(modelFsm);
3825  mdd_t *goodStates = Ctlp_FormulaObtainLatestApprox(ctlFormula);
3826  mdd_t *badStates = mdd_and(modelInitialStates, goodStates, 1, 0);
3827  mdd_t *witnessSuccState;
3828  FILE *debugFile = McOptionsReadDebugFile(options);
3829  FILE *oldStdOut;
3830  FILE *oldStdErr;
3831  extern FILE *vis_stdpipe;
3832  char *nrOfTracesString;
3833  int nrOfTraces;   /* nr of debug traces that we output */
3834  int i;            /* counts debug traces               */
3835  array_t *completeCExArray;
3836  array_t *initCExArray;
3837  initCExArray = array_alloc(mdd_t *, 0);
3838
3839  mdd_free(modelInitialStates);
3840
3841  oldStdOut = vis_stdout;
3842  oldStdErr = vis_stderr;
3843 
3844  nrOfTracesString = Cmd_FlagReadByName("nr_counterexamples");
3845  if(nrOfTracesString == NIL(char))
3846    nrOfTraces = 1;
3847  else
3848    nrOfTraces = atoi(nrOfTracesString);
3849
3850 (void) fprintf(vis_stderr, "[McFsmDebugFormulaMine] Number of debug traces = %d \n", nrOfTraces);
3851 
3852  if (debugFile) {
3853    vis_stdpipe = debugFile;
3854    vis_stdout = vis_stdpipe;
3855   (void)fprintf(vis_stdpipe, "# MC: formula failed --- ");
3856    Ctlp_FormulaPrint(vis_stdpipe,Ctlp_FormulaReadOriginalFormula(ctlFormula));
3857    (void)fprintf(vis_stdpipe, "\n");
3858  } else if (McOptionsReadUseMore(options)){
3859    vis_stdpipe = popen("more", "w");
3860    vis_stdout = vis_stdpipe;
3861    vis_stderr = vis_stdpipe;
3862  }
3863  else
3864    vis_stdpipe = vis_stdout;
3865
3866  for(i = 0; i < nrOfTraces; i++){
3867    (void)fprintf(vis_stdout, "# MC: Calling debugger for trace %d\n",
3868                  i+1);
3869    witnessSuccState = McComputeACloseState(badStates, goodStates, modelFsm);
3870
3871    completeCExArray = McFsmStateDebugFormulaMine(options, ctlFormula, witnessSuccState, modelFsm,
3872                           careSetArray, initCExArray);
3873    (void) fprintf(vis_stdout, "\n![McFsmDebugFormulaMine] -> nb completeCExArray : %d \n", array_n(completeCExArray));
3874//    (void) fprintf(vis_stdout, "\n![McFsmDebugFormulaMine] -> nb initCExArray : %d \n", array_n(initCExArray));
3875
3876    (void) fprintf(vis_stdout, "\n![McFsmDebugFormulaMine] START xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \n");
3877    boolean printInputs = McOptionsReadPrintInputs( options );
3878    Mc_PrintPathMine( completeCExArray, modelFsm, printInputs );
3879    (void) fprintf(vis_stdout, "\n![McFsmDebugFormulaMine] END xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \n");
3880
3881    (void)fprintf(vis_stdout, "\n");
3882
3883    mdd_free(witnessSuccState);
3884  }
3885  mdd_free(badStates);
3886  mdd_free(goodStates);
3887
3888  if (vis_stdout != oldStdOut && vis_stdout != debugFile)
3889    (void)pclose(vis_stdpipe);
3890
3891  vis_stdout = oldStdOut;
3892  vis_stderr = oldStdErr;
3893
3894  return 1;
3895}
3896
3897
3898/**Function********************************************************************
3899
3900  Synopsis [Debug CTL formula in existential normal form at state aState]
3901
3902  Description [Debug CTL formula in existential normal form at state
3903  aState. Formula is assumed to have been CONVERTED to existential normal
3904  form.]
3905
3906  SideEffects []
3907
3908******************************************************************************/
3909static array_t *
3910McFsmStateDebugFormulaMine(
3911  McOptions_t *options,
3912  Ctlp_Formula_t *ctlFormula,
3913  mdd_t *aState,
3914  Fsm_Fsm_t *modelFsm,
3915  array_t *careSetArray,
3916  array_t *prevCExArray)
3917{
3918  (void) fprintf(vis_stdout, "![McFsmStateDebugFormulaMine] Original CTL Formula : ");
3919  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(ctlFormula));
3920  (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] MC CTL Formula : ");   
3921  (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] 0 --> nb prevCExArray : %d \n", array_n(prevCExArray));
3922  Ctlp_FormulaPrint(vis_stdout, ctlFormula);
3923  fprintf(vis_stdout, "\n");
3924
3925
3926  Ctlp_Formula_t *originalFormula;
3927  array_t *cExampleArray;
3928//  array_t *preCExArray;
3929  array_t *fullCExArray;
3930  McDbgLevel debugLevel = McOptionsReadDbgLevel( options );
3931
3932  //prevCExArray = array_alloc(mdd_t *, 0);
3933//  fullCExArray = prevCExArray;
3934  if ( ctlFormula == NIL(Ctlp_Formula_t) ) {
3935        (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] * END * \n");
3936        fullCExArray = prevCExArray; 
3937    return fullCExArray;
3938  }
3939  if ( Ctlp_FormulaTestIsConverted( ctlFormula ) ) {
3940    (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] >> FsmStateDebugConvertedFormulaMine \n");
3941    cExampleArray = FsmStateDebugConvertedFormulaMine(options, ctlFormula, aState, modelFsm,
3942                                  careSetArray, &prevCExArray);
3943
3944    (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] 1 --> nb cExampleArray : %d ", array_n(cExampleArray ));
3945    (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] 1 --> nb prevCExArray : %d ", array_n(prevCExArray));
3946
3947//    boolean printInputs = McOptionsReadPrintInputs( options );
3948//    Mc_PrintPathMine( cExampleArray, modelFsm, printInputs );
3949   
3950    if (array_n(prevCExArray)==0 ) {
3951       fullCExArray = cExampleArray;
3952    }
3953    else {
3954       fullCExArray = McCreateMergedPath(cExampleArray, prevCExArray);
3955    }
3956
3957    (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] 1 --> nb fullCExArray : %d ", array_n(fullCExArray ));
3958    prevCExArray = fullCExArray;
3959    (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] 1 --> nb prevCExArray End : %d ", array_n(prevCExArray));
3960
3961/*    (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] START OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO00000000O\n");
3962    boolean printInputs = McOptionsReadPrintInputs( options );
3963    Mc_PrintPathMine( fullCExArray, modelFsm, printInputs );
3964    (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] END 0OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO00000000O\n");
3965*/
3966    (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] * END * \n");
3967    return fullCExArray;
3968  }
3969
3970  originalFormula = Ctlp_FormulaReadOriginalFormula( ctlFormula );
3971
3972  switch ( Ctlp_FormulaReadType( ctlFormula ) ) {
3973
3974    case Ctlp_ID_c :
3975     (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] >> DebugIDMine \n");
3976      DebugIDMine( options, ctlFormula, aState, modelFsm );
3977      fullCExArray = prevCExArray; 
3978      break;
3979
3980    case Ctlp_TRUE_c:
3981    case Ctlp_FALSE_c:
3982     (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] >> DebugTrueFalseMine \n");
3983      DebugTrueFalseMine( ctlFormula, aState, modelFsm );
3984      fullCExArray = prevCExArray; 
3985      break;
3986
3987    case Ctlp_EQ_c:
3988    case Ctlp_XOR_c:
3989    case Ctlp_THEN_c:
3990    case Ctlp_NOT_c:
3991    case Ctlp_AND_c:
3992    case Ctlp_OR_c:
3993     (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] >> DebugBooleanMine \n");
3994        (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] 2 --> nb prevCExArray : %d \n", array_n(prevCExArray));
3995      cExampleArray = DebugBooleanMine(options, ctlFormula, aState, modelFsm, careSetArray, &prevCExArray);
3996
3997        (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] 2 --> nb cExampleArray : %d ", array_n(cExampleArray ));
3998
3999
4000/*        if (array_n(prevCExArray)==0 ) {
4001            fullCExArray = cExampleArray;
4002        }
4003        else {
4004            fullCExArray = McCreateMergedPath(cExampleArray, prevCExArray);
4005        }
4006*/
4007
4008        fullCExArray = cExampleArray; 
4009        prevCExArray = fullCExArray;
4010        (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] 2 --> nb prevCExArray after DB : %d ", array_n(prevCExArray));
4011        (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] 2 --> nb fullCExArray : %d ", array_n(fullCExArray ));
4012
4013      break;
4014
4015    case Ctlp_EX_c:
4016    case Ctlp_EU_c:
4017    case Ctlp_EG_c:
4018     (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] >> Ctlp_EG_c\n");
4019      if ( !McStateSatisfiesFormula( ctlFormula, aState ) ) {
4020        mdd_t *passStates = Ctlp_FormulaObtainLatestApprox(ctlFormula);
4021        mdd_t *closeState;
4022        Ntk_Network_t *modelNetwork = Fsm_FsmReadNetwork(modelFsm);
4023        array_t *PSVars = Fsm_FsmReadPresentStateVars(modelFsm);
4024        (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] >> McStateFailsFormulaMine \n");
4025
4026        McStateFailsFormulaMine(aState, originalFormula, debugLevel, modelFsm);
4027        if (mdd_is_tautology(passStates, 0)) {
4028          fprintf(vis_stdout,
4029                  "--No state satisfies the formula\n");
4030          mdd_free(passStates);
4031
4032          fullCExArray = prevCExArray; 
4033          break;
4034        }
4035        fprintf(vis_stdout,
4036                "--A simple counter example does not exist since it\n");
4037        fprintf(vis_stdout,
4038                "  requires generating all paths from the state\n");
4039        fprintf(vis_stdout,
4040                "--A state at minimum distance satisfying the formula is\n");
4041        closeState = McComputeACloseState(passStates, aState, modelFsm);
4042        mdd_free(passStates);
4043        (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] >> Mc_MintermPrintMine \n");
4044        Mc_MintermPrintMine(closeState, PSVars, modelNetwork);
4045        mdd_free(closeState);
4046
4047        fullCExArray = prevCExArray; 
4048
4049        break;
4050      }
4051      else {
4052        McPath_t *witnessPath = NIL(McPath_t);
4053        if ( Ctlp_FormulaReadType( ctlFormula ) == Ctlp_EX_c ) {
4054          (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] >> DebugEXMine \n");
4055          witnessPath = DebugEXMine(ctlFormula, aState, modelFsm, careSetArray);
4056        }
4057        else if  ( Ctlp_FormulaReadType( ctlFormula ) == Ctlp_EU_c ) {
4058          (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] >> DebugEUMine \n");
4059          witnessPath = DebugEUMine(ctlFormula, aState, modelFsm, careSetArray);
4060        }
4061        else {
4062          (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] >> DebugEGMine \n");
4063          witnessPath = DebugEGMine(ctlFormula, aState, modelFsm, careSetArray,
4064                                options);
4065        }
4066        (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] >> FsmPathDebugFormulaMine \n");
4067        cExampleArray = FsmPathDebugFormulaMine(options, ctlFormula, modelFsm, witnessPath,
4068                            careSetArray, &prevCExArray);
4069        (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] 3 --> nb cExampleArray : %d ", array_n(cExampleArray ));
4070       (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] 3 --> nb prevCExArray : %d ", array_n(prevCExArray));
4071 
4072/*        if (array_n(prevCExArray)==0 ) {
4073            fullCExArray = cExampleArray;
4074        }
4075        else {
4076            fullCExArray = McCreateMergedPath(cExampleArray, prevCExArray);
4077        }
4078*/
4079        fullCExArray = prevCExArray; 
4080        (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] 3 --> nb fullCExArray : %d ", array_n(fullCExArray ));
4081
4082//        McPathFree( witnessPath );  //NOTE: INITIALLY FREED
4083      }
4084      break;
4085
4086    case Ctlp_Cmp_c:
4087    case Ctlp_Init_c:
4088    case Ctlp_FwdU_c:
4089    case Ctlp_FwdG_c:
4090    case Ctlp_EY_c:
4091    case Ctlp_EH_c:
4092        fullCExArray = prevCExArray; 
4093      break;
4094
4095    default: {
4096      fail("Bad switch in debugging normal formula\n");
4097      fullCExArray = prevCExArray; 
4098    }
4099  }
4100// *prevCExArray = fullCExArray;
4101 (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] LAST --> nb prevCExArray End: %d ", array_n(prevCExArray));
4102/* (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] START OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO00000000O\n");
4103 boolean printInputs = McOptionsReadPrintInputs( options );
4104 Mc_PrintPathMine( prevCExArray, modelFsm, printInputs );
4105 (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] END 0OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO00000000O\n");
4106*/
4107 (void) fprintf(vis_stdout, "\n![McFsmStateDebugFormulaMine] * END * \n");
4108 return fullCExArray;
4109
4110}
4111
4112/**Function********************************************************************
4113
4114  Synopsis    [Debug a converted formula]
4115
4116  Comment [There are five kinds of formula that are converted: EF, AU, AF, AG,
4117  AX.  The Ctlp_Formula_t structure has a pointer back to the original formula
4118  (where one exists). For the non-trivial cases (AU, AF, AG, AX) if the
4119  formula is false, we create a counter example, i.e. a fair path which fails
4120  the property. The AG, AX, AF cases are simple; the AU case is tricky because
4121  this can be failed on two ways.]
4122
4123  SideEffects []
4124
4125******************************************************************************/
4126static array_t *
4127FsmStateDebugConvertedFormulaMine(
4128  McOptions_t *options,
4129  Ctlp_Formula_t *ctlFormula,
4130  mdd_t *aState,
4131  Fsm_Fsm_t *modelFsm,
4132  array_t *careSetArray,
4133  array_t **preCExArray)
4134{
4135  (void) fprintf(vis_stdout, "![FsmStateDebugConvertedFormulaMine] Original CTL Formula : ");
4136  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(ctlFormula));
4137  (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] MC CTL Formula : ");   
4138//  (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] ---> nb prevCExArray : %d \n", array_n(prevCExArray));
4139  Ctlp_FormulaPrint(vis_stdout, ctlFormula);
4140  fprintf(vis_stdout, "\n");
4141
4142  McPath_t *witnessPath;
4143  McPath_t *counterExamplePath;
4144
4145  array_t *cExArray;
4146
4147  Ctlp_Formula_t *originalFormula =Ctlp_FormulaReadOriginalFormula(ctlFormula);
4148  Ctlp_Formula_t *lFormula = Ctlp_FormulaReadLeftChild( ctlFormula );
4149  McDbgLevel debugLevel = McOptionsReadDbgLevel( options );
4150
4151  if ( Ctlp_FormulaReadType( ctlFormula ) == Ctlp_EU_c ) {
4152    (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] >> Ctlp_EU_c \n");
4153    if ( !McStateSatisfiesFormula( ctlFormula, aState ) ) {
4154      mdd_t *passStates = Ctlp_FormulaObtainLatestApprox(ctlFormula);
4155      mdd_t *closeState;
4156      Ntk_Network_t *modelNetwork = Fsm_FsmReadNetwork(modelFsm);
4157      array_t *PSVars = Fsm_FsmReadPresentStateVars(modelFsm);
4158      (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] >> McStateFailsFormulaMine \n");
4159      McStateFailsFormulaMine( aState, originalFormula, debugLevel, modelFsm );
4160      if (mdd_is_tautology(passStates, 0)) {
4161          fprintf(vis_stdout,
4162                  "--No state satisfies the formula\n");
4163      } else {
4164        fprintf(vis_stdout,
4165                "\n--A simple counter example does not exist since it\n");
4166        fprintf(vis_stdout,
4167                "  requires generating all paths from the state\n");
4168        fprintf(vis_stdout,
4169                "--A state at minimum distance satisfying the formula is\n");
4170        closeState = McComputeACloseState(passStates, aState, modelFsm);
4171        (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] >> Mc_MintermPrintMine \n");
4172        Mc_MintermPrintMine(closeState, PSVars, modelNetwork);
4173        mdd_free(closeState);
4174      }
4175      mdd_free(passStates);
4176    }
4177    else {
4178      (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] >> DebugEUMine \n");
4179      witnessPath = DebugEUMine(ctlFormula, aState, modelFsm, careSetArray);
4180      (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] >> FsmPathDebugEFFormulaMine\n");
4181      cExArray = FsmPathDebugEFFormulaMine(options, ctlFormula, modelFsm, witnessPath,
4182                            careSetArray, preCExArray);
4183//      McPathFree( witnessPath );
4184    }
4185    cExArray = *preCExArray;
4186    (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] ** END ** \n");
4187    return cExArray;
4188    //return cExArray; // EF Formula not yet treated
4189  }
4190
4191  /*
4192   * The original formula must be an AX,AF,AG, or AU formula
4193   */
4194  if ( McStateSatisfiesFormula( ctlFormula, aState ) ) {
4195    (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] >> McStatePassesFormulaMine\n");
4196    McStatePassesFormulaMine( aState, originalFormula, debugLevel, modelFsm );
4197    fprintf(vis_stdout,
4198            "--A simple witness does not exist since it requires\n");
4199    fprintf(vis_stdout, "  generating all paths from the state\n");
4200    (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] ** END ** \n");
4201    cExArray = *preCExArray; //Added to avoid seg fault
4202    return cExArray; // maybe aState gotta checkout later!!
4203  }
4204
4205  switch ( Ctlp_FormulaReadType( lFormula ) ) {
4206    case Ctlp_EX_c: {
4207      (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] >> DebugEXMine\n");
4208      counterExamplePath = DebugEXMine(lFormula, aState, modelFsm, careSetArray);
4209      (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] >> FsmPathDebugAXFormulaMine\n");
4210      cExArray = FsmPathDebugAXFormulaMine(options, ctlFormula, modelFsm, counterExamplePath, careSetArray, preCExArray);
4211//      McPathFree( counterExamplePath );  //NOTE: INITIALLY FREED
4212      break;
4213    }
4214
4215    case Ctlp_EG_c: {
4216      (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] >> DebugEGMine\n");
4217      counterExamplePath = DebugEGMine(lFormula, aState, modelFsm, careSetArray,
4218                                   options);
4219      (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] >> FsmPathDebugAFFormulaMine\n");
4220      cExArray = FsmPathDebugAFFormulaMine(options, ctlFormula, modelFsm, counterExamplePath,
4221                            careSetArray, preCExArray);
4222//      McPathFree( counterExamplePath ); //NOTE: INITIALLY FREED
4223      break;
4224    }
4225
4226    case Ctlp_EU_c: {
4227      (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] >> DebugEUMine\n");
4228      counterExamplePath = DebugEUMine(lFormula, aState, modelFsm, careSetArray);
4229      (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] >> FsmPathDebugAGFormulaMine\n");
4230      cExArray = FsmPathDebugAGFormulaMine(options, ctlFormula, modelFsm, counterExamplePath,
4231                            careSetArray, preCExArray);
4232//      McPathFree( counterExamplePath );  //NOTE: INITIALLY FREED
4233      break;
4234    }
4235
4236    case Ctlp_OR_c: {
4237      /*
4238       * need special functions bcoz of two possibilities
4239       */
4240      (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] >> FsmPathDebugAUFormulaMine\n");
4241      cExArray = FsmPathDebugAUFormulaMine(options, aState, ctlFormula, modelFsm,
4242                            careSetArray, preCExArray);
4243 
4244      break;
4245    }
4246
4247    default: fail("Bad formula type in handling converted operator\n");
4248  }
4249  (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] LAST ---> nb preCExArray : %d", array_n(*preCExArray));
4250  (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] LAST ---> nb cExArray : %d", array_n(cExArray ));
4251
4252//   boolean printInputs = McOptionsReadPrintInputs( options );
4253//  (void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] printInputs = %s \n", (printInputs==TRUE)? "TRUE":"FALSE");
4254//  Mc_PrintPathMine(cExArray, modelFsm, printInputs );
4255(void) fprintf(vis_stdout, "\n![FsmStateDebugConvertedFormulaMine] ** END ** \n");
4256 return cExArray;
4257}
4258
4259
4260/**Function********************************************************************
4261
4262  Synopsis [Debug a formula of the form EX, EG, EU, EF.]
4263
4264  SideEffects []
4265
4266******************************************************************************/
4267static array_t *
4268FsmPathDebugFormulaMine(
4269  McOptions_t *options,
4270  Ctlp_Formula_t *ctlFormula,
4271  Fsm_Fsm_t *modelFsm,
4272  McPath_t *witnessPath,
4273  array_t *careSetArray,
4274  array_t **preCExArray)
4275{
4276  (void) fprintf(vis_stdout, "![FsmPathDebugFormulaMine] Original CTL Formula : ");
4277  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(ctlFormula));
4278  (void) fprintf(vis_stdout, "\n![FsmPathDebugFormulaMine] MC CTL Formula : ");   
4279//  (void) fprintf(vis_stdout, "\n![FsmPathDebugFormulaMine] ---> nb prevCExArray : %d \n", array_n(prevCExArray));
4280  Ctlp_FormulaPrint(vis_stdout, ctlFormula);
4281  fprintf(vis_stdout, "\n");
4282
4283  array_t *witnessArray;
4284  switch ( Ctlp_FormulaReadType( ctlFormula ) ) {
4285    case Ctlp_EX_c: {
4286      witnessArray = FsmPathDebugEXFormulaMine(options, ctlFormula, modelFsm, witnessPath,
4287                            careSetArray, preCExArray);
4288      break;
4289    }
4290
4291    case Ctlp_EU_c: {
4292      witnessArray = FsmPathDebugEUFormulaMine(options, ctlFormula, modelFsm, witnessPath,
4293                            careSetArray, preCExArray);
4294      break;
4295    }
4296
4297    case Ctlp_EG_c: {
4298      witnessArray = FsmPathDebugEGFormulaMine(options, ctlFormula, modelFsm, witnessPath,
4299                            careSetArray, preCExArray);
4300      break;
4301    }
4302    default: {
4303      fail("bad switch in converting converted formula\n");
4304    }
4305  }
4306
4307  (void) fprintf(vis_stdout, "\n![FsmPathDebugFormulaMine] ---> witnessArray : %d *END*\n", array_n(witnessArray));
4308
4309  return witnessArray;
4310}
4311
4312
4313/**Function********************************************************************
4314
4315  Synopsis    [Debug an Atomic Formula]
4316
4317  Description [Debug an Atomic Formula. As per the semantics of fair CTL, a
4318  state satisfies an Atomic Formula just in case the given wire computes the
4319  appropriate Boolean function on that state as input. The state has to be
4320  fair; however we do NOT justify the fairness by printing a path to a fair
4321  cycle.  THe user can achieve this effect by adding ANDing in a formula EG
4322  TRUE.]
4323
4324  SideEffects []
4325
4326******************************************************************************/
4327static void
4328DebugIDMine(
4329  McOptions_t *options,
4330  Ctlp_Formula_t *aFormula,
4331  mdd_t *aState,
4332  Fsm_Fsm_t *modelFsm)
4333{
4334
4335  (void) fprintf(vis_stdout, "![DebugIDMine] Original CTL Formula : ");
4336  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(aFormula));
4337  (void) fprintf(vis_stdout, "\n![DebugIDMine] MC CTL Formula : ");   
4338  Ctlp_FormulaPrint(vis_stdout, aFormula);
4339  fprintf(vis_stdout, "\n");
4340
4341  Ctlp_Formula_t *originalFormula = Ctlp_FormulaReadOriginalFormula(aFormula); 
4342  McDbgLevel debugLevel = McOptionsReadDbgLevel( options );
4343
4344  if ( McStateSatisfiesFormula( aFormula, aState ) ) {
4345    McStatePassesFormulaMine( aState, originalFormula, debugLevel, modelFsm );
4346  }
4347  else {
4348    McStateFailsFormulaMine( aState, originalFormula, debugLevel, modelFsm );
4349  }
4350}
4351
4352/**Function********************************************************************
4353
4354  Synopsis    [Debug a TRUE/FALSE formula]
4355
4356  SideEffects []
4357
4358******************************************************************************/
4359static void
4360DebugTrueFalseMine(
4361  Ctlp_Formula_t *aFormula,
4362  mdd_t *aState,
4363  Fsm_Fsm_t *modelFsm)
4364{
4365  (void) fprintf(vis_stdout, "![DebugTrueFalseMine] Original CTL Formula : ");
4366  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(aFormula));
4367  (void) fprintf(vis_stdout, "\n![[DebugTrueFalseMine] MC CTL Formula : ");   
4368  Ctlp_FormulaPrint(vis_stdout, aFormula);
4369
4370  fprintf(vis_stdout, "\n");
4371  fprintf(vis_stdout, "--Nothing to debug for %s\n",
4372    ((Ctlp_FormulaReadType(aFormula) == Ctlp_TRUE_c) ? "TRUE\n" : "FALSE\n"));
4373}
4374
4375/**Function********************************************************************
4376
4377  Synopsis    [Debug a Boolean formula]
4378
4379  Desciption  [Debug a Boolean formula. For Boolean formula built out of binary
4380  connective, we may debug only one branch, if say the formula is an AND and
4381  the left branch is fails.]
4382
4383  SideEffects []
4384
4385******************************************************************************/
4386static array_t *
4387DebugBooleanMine(
4388  McOptions_t *options,
4389  Ctlp_Formula_t *aFormula,
4390  mdd_t *aState,
4391  Fsm_Fsm_t *modelFsm,
4392  array_t *careSetArray,
4393  array_t **preCExArray)
4394{
4395  (void) fprintf(vis_stdout, "![DebugBooleanMine] Original CTL Formula : ");
4396  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(aFormula));
4397  (void) fprintf(vis_stdout, "\n![DebugBooleanMine] MC CTL Formula : ");
4398  (void) fprintf(vis_stdout, "\n![DebugBooleanMine] 0 ---> nb prevCExArray : %d \n", array_n(*preCExArray));
4399  Ctlp_FormulaPrint(vis_stdout, aFormula);
4400  fprintf(vis_stdout, "\n");
4401
4402  Ctlp_Formula_t *originalFormula = Ctlp_FormulaReadOriginalFormula(aFormula);
4403  Ctlp_Formula_t *lFormula = Ctlp_FormulaReadLeftChild( aFormula );
4404  Ctlp_Formula_t *rFormula = Ctlp_FormulaReadRightChild( aFormula );
4405  McDbgLevel debugLevel = McOptionsReadDbgLevel(options);
4406
4407  if (McStateSatisfiesFormula(aFormula, aState)) {
4408    McStatePassesFormulaMine(aState, originalFormula, debugLevel, modelFsm);
4409  } else {
4410    McStateFailsFormulaMine(aState, originalFormula, debugLevel, modelFsm);
4411  }
4412
4413  /* We always debug the first (left) child. */
4414    array_t *cExArray;
4415//  array_t *prevCExArray;
4416//  prevCExArray = array_alloc(mdd_t *, 0); //Note: added just to respect arg requirements but not used
4417   cExArray = McFsmStateDebugFormulaMine(options, lFormula, aState, modelFsm, careSetArray, *preCExArray);
4418//  (void) fprintf(vis_stdout, "\n![DebugBooleanMine] 1 ---> nb prevCExArray : %d \n", array_n(*preCExArray));
4419//  (void) fprintf(vis_stdout, "\n![DebugBooleanMine] 1 ---> nb cExArray : %d \n", array_n(cExArray));
4420  /* What we do for the second child depends on the type of the formula.
4421   * For Ctlp_AND_c, Ctlp_OR_c, Ctlp_THEN_c the right child may not be
4422   * needed.  With early termination, the right child may not have the
4423   * information required to produce a counterexample;  hence, its debugging
4424   * is not optional.  (We may get incorrect answers.)
4425   */
4426  if (Ctlp_FormulaReadType(aFormula) == Ctlp_AND_c) {
4427    /* If aFormula fails and aState does not satisfy lFormula
4428     * 1. The information about aState at the right child is not
4429     *    necessarilty correct.  (aState was a don't care state.)
4430     * 2. A counterexample to lFormula is a counterexample to
4431     *    aFormula.
4432     * So, if aFormula fails, we should debug the right child only if
4433     * aState satisfies lFormula.
4434     * If, on the other hand, aFormula passes, then aState must satisfy
4435     * lFormula, and we need to witness both lFormula and rFormula.
4436     */
4437    if (McStateSatisfiesFormula(lFormula, aState)) {
4438      cExArray = McFsmStateDebugFormulaMine(options, rFormula, aState, modelFsm,
4439                             careSetArray, *preCExArray);
4440//  (void) fprintf(vis_stdout, "\n![DebugBooleanMine] 2 ---> nb prevCExArray : %d \n", array_n(*preCExArray));
4441//  (void) fprintf(vis_stdout, "\n![DebugBooleanMine] 2 ---> nb cExArray : %d \n", array_n(cExArray));
4442    }
4443  } else if (Ctlp_FormulaReadType(aFormula) == Ctlp_OR_c) {
4444    /* if aFormula passes, we should debug the right child only if
4445     * aState does not satisfy lFormula.
4446     * If, on the other hand, aFormula fails, then aState may not satisfy
4447     * lFormula, and we need to produce counterexamples for both lFormula
4448     * and rFormula.
4449     */
4450    if (!McStateSatisfiesFormula(lFormula, aState)) {
4451      cExArray = McFsmStateDebugFormulaMine(options, rFormula, aState, modelFsm,
4452                             careSetArray, *preCExArray);
4453//  (void) fprintf(vis_stdout, "\n![DebugBooleanMine] 3 ---> nb prevCExArray : %d \n", array_n(*preCExArray));
4454//  (void) fprintf(vis_stdout, "\n![DebugBooleanMine] 3 ---> nb cExArray : %d \n", array_n(cExArray));
4455    }
4456  } else if (Ctlp_FormulaReadType(aFormula) == Ctlp_THEN_c) {
4457    /* This case is like the OR, with the polarity of the left
4458     * left child reversed.
4459     */
4460    if (McStateSatisfiesFormula(lFormula, aState)) {
4461      cExArray = McFsmStateDebugFormulaMine(options, rFormula, aState, modelFsm,
4462                             careSetArray, *preCExArray);
4463//  (void) fprintf(vis_stdout, "\n![DebugBooleanMine] 4 ---> nb prevCExArray : %d \n", array_n(*preCExArray));
4464//  (void) fprintf(vis_stdout, "\n![DebugBooleanMine] 4 ---> nb cExArray : %d \n", array_n(cExArray));
4465    }
4466  } else if (Ctlp_FormulaReadType(aFormula) != Ctlp_NOT_c) {
4467    /* For Ctlp_EQ_c and Ctlp_XOR_c both children must be debugged. */
4468    cExArray = McFsmStateDebugFormulaMine(options, rFormula, aState, modelFsm, careSetArray, *preCExArray);
4469//  (void) fprintf(vis_stdout, "\n![DebugBooleanMine] 5 ---> nb prevCExArray : %d \n", array_n(*preCExArray));
4470//  (void) fprintf(vis_stdout, "\n![DebugBooleanMine] 5 ---> nb cExArray : %d \n", array_n(cExArray));
4471  }
4472  (void) fprintf(vis_stdout, "\n![DebugBooleanMine] LAST ---> nb prevCExArray : %d ", array_n(*preCExArray));
4473  (void) fprintf(vis_stdout, "\n![DebugBooleanMine] LAST ---> nb cExArray : %d *END*\n", array_n(cExArray));
4474  return cExArray;
4475}
4476
4477
4478/**Function********************************************************************
4479
4480  Synopsis    [Debug a formula of type EX.]
4481
4482  Description [Debug a formula of type EX at specified state. It is assumed
4483  that aState satisfies the EX formula.]
4484
4485  SideEffects []
4486
4487******************************************************************************/
4488static McPath_t *
4489DebugEXMine(
4490  Ctlp_Formula_t *aFormula,
4491  mdd_t *aState,
4492  Fsm_Fsm_t *modelFsm,
4493  array_t *careSetArray)
4494{
4495  (void) fprintf(vis_stdout, "![DebugEXMine] Original CTL Formula : ");
4496  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(aFormula));
4497  (void) fprintf(vis_stdout, "\n![DebugEXMine] MC CTL Formula : ");   
4498  Ctlp_FormulaPrint(vis_stdout, aFormula);
4499  fprintf(vis_stdout, "\n");
4500
4501  mdd_t *aDupState = mdd_dup( aState );
4502  mdd_t *aStateSuccs;
4503  mdd_t *statesSatisfyingLeftFormula;
4504  mdd_t *targetStates;
4505  mdd_t *witnessSuccState;
4506  Ctlp_Formula_t *lFormula;
4507  McPath_t *witnessPath = McPathAlloc();
4508  array_t *stemArray = array_alloc( mdd_t *, 0 );
4509  Img_ImageInfo_t * imageInfo = Fsm_FsmReadOrCreateImageInfo(modelFsm, 0, 1);
4510
4511  /*
4512   * By using careSet here, can end up with unreachable successors
4513   */
4514  aStateSuccs = Img_ImageInfoComputeImageWithDomainVars(imageInfo,
4515                        aState, aState, careSetArray);
4516
4517  lFormula = Ctlp_FormulaReadLeftChild( aFormula );
4518  statesSatisfyingLeftFormula = Ctlp_FormulaObtainLatestApprox( lFormula );
4519
4520  targetStates = mdd_and( aStateSuccs, statesSatisfyingLeftFormula, 1, 1 );
4521  mdd_free( aStateSuccs ); mdd_free( statesSatisfyingLeftFormula );
4522
4523  witnessSuccState = Mc_ComputeACloseState( targetStates, aState, modelFsm );
4524  mdd_free( targetStates );
4525
4526  array_insert_last( mdd_t *, stemArray, aDupState );
4527  array_insert_last( mdd_t *, stemArray, witnessSuccState );
4528
4529  McPathSetStemArray( witnessPath, stemArray );
4530
4531  return witnessPath;
4532}
4533
4534/**Function********************************************************************
4535
4536  Synopsis    [Debug a formula of type EU.]
4537
4538  Description [Debug a formula of type EU at specified state. It is assumed that
4539  state fails formula.]
4540
4541  SideEffects []
4542
4543******************************************************************************/
4544static McPath_t *
4545DebugEUMine(
4546  Ctlp_Formula_t *aFormula,
4547  mdd_t *aState,
4548  Fsm_Fsm_t *modelFsm,
4549  array_t *careSetArray)
4550{
4551  (void) fprintf(vis_stdout, "![DebugEUMine] Original CTL Formula : ");
4552  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(aFormula));
4553  (void) fprintf(vis_stdout, "\n![DebugEUMine] MC CTL Formula : ");   
4554  Ctlp_FormulaPrint(vis_stdout, aFormula);
4555  fprintf(vis_stdout, "\n");
4556
4557  McPath_t *witnessPath = McPathAlloc();
4558  array_t *OnionRings = (array_t *) Ctlp_FormulaReadDebugData( aFormula );
4559  array_t *pathToCore = Mc_BuildPathToCore(aState, OnionRings, 
4560                                           modelFsm,
4561                                           McGreaterOrEqualZero_c );
4562
4563  McPathSetStemArray( witnessPath, pathToCore );
4564
4565  return witnessPath;
4566}
4567
4568/**Function********************************************************************
4569
4570  Synopsis    [Debug a formula of type EG.]
4571
4572  Description [Debug a formula of type EG at specified state. It is assumed
4573  that state fails formula. Refer to Clarke et al DAC 1995 for details of the
4574  algorithm.]
4575
4576  SideEffects []
4577
4578******************************************************************************/
4579static McPath_t *
4580DebugEGMine(
4581  Ctlp_Formula_t *aFormula,
4582  mdd_t *aState,
4583  Fsm_Fsm_t *modelFsm,
4584  array_t *careSetArray,
4585  McOptions_t *options)
4586{
4587  (void) fprintf(vis_stdout, "![DebugEGMine] Original CTL Formula : ");
4588  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(aFormula));
4589  (void) fprintf(vis_stdout, "\n![DebugEGMine] MC CTL Formula : ");   
4590  Ctlp_FormulaPrint(vis_stdout, aFormula);
4591  fprintf(vis_stdout, "\n");
4592
4593  array_t *arrayOfOnionRings = (array_t *) Ctlp_FormulaReadDebugData(aFormula);
4594  mdd_t *invariantMdd = Ctlp_FormulaObtainLatestApprox( aFormula );
4595  McPath_t *fairPath = McBuildFairPath(aState, invariantMdd, arrayOfOnionRings,
4596                                        modelFsm, careSetArray,
4597                                        McOptionsReadVerbosityLevel(options),
4598                                        McOptionsReadDcLevel(options),
4599                                        McOptionsReadFwdBwd(options));
4600  mdd_free( invariantMdd );
4601
4602  return fairPath;
4603}
4604
4605
4606/**Function********************************************************************
4607
4608  Synopsis [Debug a path for EX type formula.]
4609
4610  SideEffects []
4611
4612******************************************************************************/
4613static array_t *
4614FsmPathDebugEXFormulaMine(
4615  McOptions_t *options,
4616  Ctlp_Formula_t *ctlFormula,
4617  Fsm_Fsm_t *modelFsm,
4618  McPath_t *witnessPath,
4619  array_t *careSetArray,
4620  array_t **preCExArray)
4621{
4622
4623  (void) fprintf(vis_stdout, "![FsmPathDebugEXFormulaMine] Original CTL Formula : ");
4624  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(ctlFormula));
4625  (void) fprintf(vis_stdout, "\n![FsmPathDebugEXFormulaMine] MC CTL Formula : ");   
4626//  (void) fprintf(vis_stdout, "\n![FsmPathDebugEXFormulaMine] ---> nb prevCExArray : %d \n", array_n(prevCExArray));
4627  Ctlp_FormulaPrint(vis_stdout, ctlFormula);
4628  fprintf(vis_stdout, "\n");
4629
4630  array_t *PSVars = Fsm_FsmReadPresentStateVars( modelFsm );
4631  array_t *witnessArray = McPathReadStemArray( witnessPath );
4632  mdd_t *firstState = array_fetch( mdd_t *, witnessArray, 0 );
4633  char *firstStateName = Mc_MintermToString(firstState, PSVars,
4634                                Fsm_FsmReadNetwork(modelFsm));
4635  Ctlp_Formula_t *lChild = Ctlp_FormulaReadLeftChild( ctlFormula );
4636  char *ctlFormulaText = Ctlp_FormulaConvertToString( ctlFormula );
4637  boolean printInputs = McOptionsReadPrintInputs( options );
4638  mdd_t *secondlastState;
4639  if(array_n(witnessArray)<2)
4640    {
4641      fprintf(vis_stdout,"witnessArray has less than two elements, return\n");
4642      if (array_n(witnessArray) > 0) return witnessArray;
4643      else return NIL(array_t);
4644    }
4645  secondlastState= array_fetch( mdd_t *, witnessArray, (array_n(witnessArray)-1) );
4646
4647    (void) fprintf(vis_stderr, "-[FsmPathDebugEXFormulaMine] array_n(witnessArrayEX) = %d\n",array_n(witnessArray));
4648
4649  if( McOptionsReadDbgLevel( options ) == McDbgLevelMin_c)
4650    fprintf(vis_stdout, "--State\n%spasses EX formula\n\n",
4651            firstStateName); 
4652  else
4653    fprintf(vis_stdout, "--State\n%spasses formula %s\n\n", firstStateName,
4654            ctlFormulaText );
4655 
4656  FREE(firstStateName);
4657  FREE(ctlFormulaText);
4658
4659    array_t *cExArray;
4660//  array_t *prevCExArray;
4661//  prevCExArray = array_alloc(mdd_t *, 0); //Note: added just to respect arg requirements but not used
4662 
4663  switch ( McOptionsReadDbgLevel( options ) ) {
4664  case McDbgLevelMin_c:
4665  case McDbgLevelMinVerbose_c:
4666  case McDbgLevelMax_c:
4667    fprintf(vis_stdout, " --Counter example begins\n");
4668    Mc_PrintPath( witnessArray, modelFsm, printInputs );
4669    fprintf(vis_stdout, " --Counter example ends\n\n");
4670//    cExArray = McFsmStateDebugFormulaMine(options, lChild, secondlastState, modelFsm, careSetArray, prevCExArray);
4671    cExArray = McFsmStateDebugFormulaMine(options, lChild, secondlastState, modelFsm, careSetArray, *preCExArray);
4672    break;
4673  case McDbgLevelInteractive_c:
4674    fprintf(vis_stdout, " --Counter example begins\n");
4675    Mc_PrintPath( witnessArray, modelFsm, printInputs );
4676    fprintf(vis_stdout, " --Counter example ends\n\n");
4677    if (McQueryContinue("Continue debugging EX formula? (1-yes,0-no)\n")) 
4678//    cExArray = McFsmStateDebugFormulaMine(options, lChild, secondlastState, modelFsm, careSetArray, prevCExArray);
4679    cExArray = McFsmStateDebugFormulaMine(options, lChild, secondlastState, modelFsm, careSetArray, *preCExArray);
4680    break;
4681  default: 
4682    fail("Reached bad switch in FsmPathDebugEXFormulaMine\n");
4683  }
4684//  (void) fprintf(vis_stdout, "\n![FsmPathDebugEXFormulaMine] ---> nb prevCExArray : %d *END*\n", array_n(prevCExArray));
4685//  array_free(prevCExArray);
4686  return witnessArray;
4687}
4688
4689
4690/**Function********************************************************************
4691
4692  Synopsis [Debug a path for EU type formula.]
4693
4694  SideEffects []
4695
4696******************************************************************************/
4697static array_t *
4698FsmPathDebugEUFormulaMine(
4699  McOptions_t *options,
4700  Ctlp_Formula_t *ctlFormula,
4701  Fsm_Fsm_t *modelFsm,
4702  McPath_t *witnessPath,
4703  array_t *careSetArray,
4704  array_t **preCExArray)
4705{
4706  (void) fprintf(vis_stdout, "![FsmPathDebugEUFormulaMine] Original CTL Formula : ");
4707  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(ctlFormula));
4708  (void) fprintf(vis_stdout, "\n![FsmPathDebugEUFormulaMine] MC CTL Formula : ");   
4709//  (void) fprintf(vis_stdout, "\n![FsmPathDebugEUFormulaMine] ---> nb prevCExArray : %d \n", array_n(prevCExArray));
4710  Ctlp_FormulaPrint(vis_stdout, ctlFormula);
4711  fprintf(vis_stdout, "\n");
4712  array_t *cExArray;
4713//  array_t *prevCExArray;
4714//  prevCExArray = array_alloc(mdd_t *, 0); //Note: added just to respect arg requirements but not used
4715
4716  char *ctlFormulaText = Ctlp_FormulaConvertToString( ctlFormula );
4717  Ctlp_Formula_t *lFormula = Ctlp_FormulaReadLeftChild( ctlFormula );
4718  Ctlp_Formula_t *rFormula = Ctlp_FormulaReadRightChild( ctlFormula );
4719  char *lFormulaText = Ctlp_FormulaConvertToString( lFormula );
4720  char *rFormulaText = Ctlp_FormulaConvertToString( rFormula );
4721  array_t *PSVars = Fsm_FsmReadPresentStateVars( modelFsm );
4722  array_t *witnessArray = McPathReadStemArray( witnessPath );
4723  mdd_t *firstState = array_fetch( mdd_t *, witnessArray, 0 );
4724  mdd_t *lastState = GET_NORMAL_PT(array_fetch_last( mdd_t *, witnessArray ));
4725  char *firstStateName = Mc_MintermToString(firstState, PSVars,
4726                                            Fsm_FsmReadNetwork(modelFsm));
4727  McDbgLevel debugLevel = McOptionsReadDbgLevel( options );
4728  boolean printInputs = McOptionsReadPrintInputs( options );
4729
4730 if( McOptionsReadDbgLevel( options ) == McDbgLevelMin_c)
4731   fprintf(vis_stdout, "--State\n%spasses EU formula\n\n",
4732           firstStateName); 
4733 else
4734   fprintf(vis_stdout, "--State\n%spasses formula %s\n\n", firstStateName,
4735           ctlFormulaText );
4736
4737    if ( array_n(witnessArray ) == 1 ) {
4738         (void) fprintf(vis_stderr, "-[FsmPathDebugEUFormulaMine] *VERIFICATION REQUIRED!* CEx n_state = %d \n", array_n(witnessArray));
4739         Mc_PrintPath(witnessArray, modelFsm, printInputs); // added
4740    }
4741
4742    (void) fprintf(vis_stderr, "-[FsmPathDebugEUFormulaMine] array_n(witnessArrayEU) = %d\n",array_n(witnessArray));
4743
4744 FREE(firstStateName);
4745 FREE(ctlFormulaText);
4746 
4747  switch ( debugLevel ) {
4748  case McDbgLevelMin_c:
4749  case McDbgLevelMinVerbose_c:
4750      if ( array_n(witnessArray ) == 1 ) {
4751        if( debugLevel != McDbgLevelMin_c )
4752          fprintf(vis_stdout, "since %s is true at this state", rFormulaText);
4753//          cExArray = McFsmStateDebugFormulaMine(options, rFormula, lastState, modelFsm, careSetArray, prevCExArray);
4754          cExArray = McFsmStateDebugFormulaMine(options, rFormula, lastState, modelFsm, careSetArray, *preCExArray);
4755      }
4756      else {
4757        if( debugLevel != McDbgLevelMin_c )
4758          fprintf(vis_stdout, "--Path on which %s is true till %s is true\n",
4759                  lFormulaText, rFormulaText);
4760        fprintf(vis_stdout, " --Counter example begins\n");
4761        Mc_PrintPath(witnessArray, modelFsm, printInputs);
4762        fprintf(vis_stdout, " --Counter example ends\n\n");
4763//        cExArray = McFsmStateDebugFormulaMine(options, rFormula, lastState, modelFsm, careSetArray, prevCExArray);
4764        cExArray = McFsmStateDebugFormulaMine(options, rFormula, lastState, modelFsm, careSetArray, *preCExArray);
4765      }
4766    break;
4767  case McDbgLevelMax_c:
4768  case McDbgLevelInteractive_c: 
4769    if ( array_n(witnessArray ) == 1 ) {
4770      fprintf(vis_stdout, "since %s is true at this state", rFormulaText);
4771//      cExArray = McFsmStateDebugFormulaMine(options, rFormula, lastState, modelFsm, careSetArray, prevCExArray);
4772      cExArray = McFsmStateDebugFormulaMine(options, rFormula, lastState, modelFsm, careSetArray, *preCExArray);
4773    }
4774    else {
4775      int i;
4776      fprintf(vis_stdout, "--Path on which %s is true till %s is true\n",
4777                  lFormulaText, rFormulaText);
4778      fprintf(vis_stdout, " --Counter example begins\n");
4779      Mc_PrintPath(witnessArray,modelFsm,printInputs);
4780      fprintf(vis_stdout, " --Counter example ends\n\n");
4781      for( i=0 ; i < ( array_n( witnessArray ) - 1 ); i++ ) {
4782        mdd_t *aState = array_fetch( mdd_t *, witnessArray, i );
4783     
4784        if (debugLevel == McDbgLevelMax_c ||
4785            (debugLevel == McDbgLevelInteractive_c &&
4786             McQueryContinue(
4787               "Continue debugging EU formula? (1-yes,0-no)\n"))) {
4788//        cExArray = McFsmStateDebugFormulaMine(options, lFormula, aState, modelFsm, careSetArray, prevCExArray);
4789          cExArray = McFsmStateDebugFormulaMine(options, lFormula, aState, modelFsm, careSetArray, *preCExArray);
4790        }
4791    }
4792//      cExArray = McFsmStateDebugFormulaMine(options, rFormula, lastState, modelFsm, careSetArray, prevCExArray);
4793      cExArray = McFsmStateDebugFormulaMine(options, rFormula, lastState, modelFsm, careSetArray, *preCExArray);
4794    }
4795    break;
4796  default: 
4797    fail("Should not be here - bad switch in debugging EU formula\n");
4798  }
4799
4800  FREE(lFormulaText);
4801  FREE(rFormulaText);
4802//  (void) fprintf(vis_stdout, "\n![FsmPathDebugEUFormulaMine] ---> nb prevCExArray : %d *END*\n", array_n(prevCExArray));
4803//  array_free(prevCExArray);
4804  return witnessArray;
4805}
4806
4807/**Function********************************************************************
4808
4809  Synopsis [Debug a path for EG type formula.]
4810
4811  SideEffects []
4812
4813******************************************************************************/
4814static array_t *
4815FsmPathDebugEGFormulaMine(
4816  McOptions_t *options,
4817  Ctlp_Formula_t *ctlFormula,
4818  Fsm_Fsm_t *modelFsm,
4819  McPath_t *witnessPath,
4820  array_t *careSetArray,
4821  array_t **preCExArray)
4822{
4823  (void) fprintf(vis_stdout, "![FsmPathDebugEGFormulaMine] Original CTL Formula : ");
4824  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(ctlFormula));
4825  (void) fprintf(vis_stdout, "\n![FsmPathDebugEGFormulaMine] MC CTL Formula : ");   
4826//  (void) fprintf(vis_stdout, "\n![FsmPathDebugEGFormulaMine] ---> nb prevCExArray : %d \n", array_n(prevCExArray));
4827  Ctlp_FormulaPrint(vis_stdout, ctlFormula);
4828  fprintf(vis_stdout, "\n");
4829  array_t *cExArray;
4830//  array_t *prevCExArray;
4831//  prevCExArray = array_alloc(mdd_t *, 0); //Note: added just to respect arg requirements but not used
4832
4833  mdd_t *firstState;
4834  char *firstStateName;
4835  array_t *witnessArray;
4836  array_t *witness; 
4837  char *ctlFormulaText = Ctlp_FormulaConvertToString( ctlFormula );
4838  array_t *PSVars = Fsm_FsmReadPresentStateVars( modelFsm );
4839  array_t *stemArray = McPathReadStemArray( witnessPath );
4840  array_t *cycleArray = McPathReadCycleArray( witnessPath );
4841  Ctlp_Formula_t *lFormula = Ctlp_FormulaReadLeftChild( ctlFormula );
4842  char *lFormulaText = Ctlp_FormulaConvertToString( lFormula );
4843  McDbgLevel debugLevel = McOptionsReadDbgLevel( options );
4844  boolean printInputs = McOptionsReadPrintInputs( options );
4845
4846  witnessArray = McCreateMergedPath( stemArray, cycleArray );
4847  firstState = array_fetch( mdd_t *, witnessArray, 0 );
4848  firstStateName = Mc_MintermToString(firstState, PSVars,Fsm_FsmReadNetwork(modelFsm));
4849 
4850
4851    (void) fprintf(vis_stderr, "-[FsmPathDebugEGFormulaMine] array_n(stemArrayEG) = %d\n",array_n(stemArray));
4852    (void) fprintf(vis_stderr, "-[FsmPathDebugEGFormulaMine] array_n(cycleArrayEG) = %d\n",array_n(cycleArray));
4853    (void) fprintf(vis_stderr, "-[FsmPathDebugEGFormulaMine] array_n(witnessArrayEG) = %d\n",array_n(witnessArray));
4854
4855
4856
4857  if( McOptionsReadDbgLevel( options ) == McDbgLevelMin_c)
4858    fprintf(vis_stdout, "--State\n%spasses EG formula\n\n",
4859            firstStateName); 
4860  else
4861    fprintf(vis_stdout, "--State\n%spasses formula %s\n\n", firstStateName,
4862            ctlFormulaText );
4863 
4864  FREE(firstStateName);
4865  FREE(ctlFormulaText);
4866
4867  switch ( debugLevel ) {
4868  case McDbgLevelMin_c:
4869  case McDbgLevelMinVerbose_c: {
4870    McPath_t *normalPath = McPathNormalize( witnessPath );
4871    array_t *stem = McPathReadStemArray( normalPath );
4872    array_t *cycle = McPathReadCycleArray( normalPath );
4873
4874    (void) fprintf(vis_stderr, "-[FsmPathDebugEGFormulaMine] array_n(stemNormEG) = %d\n",array_n(stem));
4875    (void) fprintf(vis_stderr, "-[FsmPathDebugEGFormulaMine] array_n(cycleNormEG) = %d\n",array_n(cycle));
4876    witness = McCreateMergedPath( stem, cycle );
4877    (void) fprintf(vis_stderr, "-[FsmPathDebugEGFormulaMine] array_n(witnessNormEG) = %d\n",array_n(witness));
4878    (void) fprintf(vis_stderr, "-[FsmPathDebugEGFormulaMine] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n");
4879    Mc_PrintPath( witness, modelFsm, printInputs );
4880    (void) fprintf(vis_stderr, "-[FsmPathDebugEGFormulaMine] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n");
4881
4882    if(debugLevel != McDbgLevelMin_c)
4883      fprintf(vis_stdout, "--Witness is a fair path where %s is always true\n",
4884              lFormulaText);
4885   
4886    FREE( lFormulaText );
4887    fprintf(vis_stdout, " --Counter example begins\n");
4888    (void) fprintf( vis_stdout, "--Fair path stem:\n");
4889    Mc_PrintPath( stem, modelFsm, printInputs );
4890   
4891    (void) fprintf( vis_stdout, "--Fair path cycle:\n");
4892    Mc_PrintPath( cycle, modelFsm, printInputs );
4893    fprintf(vis_stdout, "\n");
4894    fprintf(vis_stdout, " --Counter example ends\n\n");
4895    McPathFree( normalPath );
4896    break;
4897  }
4898  case McDbgLevelMax_c:
4899  case McDbgLevelInteractive_c: {
4900    McPath_t *normalPath = McPathNormalize( witnessPath );
4901    array_t *stem = McPathReadStemArray( normalPath );
4902    array_t *cycle = McPathReadCycleArray( normalPath );
4903    int i;
4904
4905    (void) fprintf(vis_stderr, "-[FsmPathDebugEGFormulaMine] array_n(stemNormEG) = %d\n",array_n(stem));
4906    (void) fprintf(vis_stderr, "-[FsmPathDebugEGFormulaMine] array_n(cycleNormEG) = %d\n",array_n(cycle));
4907    witness = McCreateMergedPath( stem, cycle );
4908    (void) fprintf(vis_stderr, "-[FsmPathDebugEGFormulaMine] array_n(witnessNormEG) = %d\n",array_n(witness));
4909    (void) fprintf(vis_stderr, "-[FsmPathDebugEGFormulaMine] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n");
4910    Mc_PrintPath( witness, modelFsm, printInputs );
4911    (void) fprintf(vis_stderr, "-[FsmPathDebugEGFormulaMine] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n");
4912
4913    fprintf(vis_stdout, "--Witness is a fair path where %s is always true\n",
4914              lFormulaText);
4915    fprintf(vis_stdout, " --Counter example begins\n");
4916    (void) fprintf( vis_stdout, "--Fair path stem:\n");
4917    Mc_PrintPath( stem, modelFsm, printInputs );
4918    (void) fprintf( vis_stdout, "--Fair path cycle:\n");
4919    Mc_PrintPath( cycle, modelFsm, printInputs );
4920    fprintf(vis_stdout, " --Counter example ends\n\n");
4921    for( i=0 ; i < ( array_n( witnessArray )-1  ); i++ ) {
4922      mdd_t *aState = array_fetch( mdd_t *, witnessArray, i );
4923   
4924      if (debugLevel == McDbgLevelMax_c ||
4925          (debugLevel == McDbgLevelInteractive_c &&
4926           McQueryContinue(
4927             "--Continue debugging EG formula? (1-yes,0-no)\n"))) {
4928//      cExArray = McFsmStateDebugFormulaMine(options, lFormula, aState, modelFsm, careSetArray, prevCExArray);
4929        cExArray = McFsmStateDebugFormulaMine(options, lFormula, aState, modelFsm, careSetArray, *preCExArray);
4930      }
4931    }
4932    break;
4933  }
4934  default:
4935    fail("Bad switch in FsmPathDebugEGFormulaMine\n");
4936    witness = NIL(array_t);
4937  }
4938
4939  McNormalizeBddPointer(witnessArray);
4940  mdd_array_free( witnessArray );
4941//  (void) fprintf(vis_stdout, "\n![FsmPathDebugEGFormulaMine] ---> nb prevCExArray : %d *END*\n", array_n(prevCExArray));
4942//  array_free(prevCExArray);
4943  return witness;
4944}
4945
4946/**Function********************************************************************
4947
4948  Synopsis    [Debug a EF  formula]
4949
4950  SideEffects []
4951
4952******************************************************************************/
4953static array_t *
4954FsmPathDebugEFFormulaMine(
4955  McOptions_t *options,
4956  Ctlp_Formula_t *ctlFormula,
4957  Fsm_Fsm_t *modelFsm,
4958  McPath_t *witnessPath,
4959  array_t *careSetArray,
4960  array_t **preCExArray)
4961{
4962  (void) fprintf(vis_stdout, "![FsmPathDebugEFFormulaMine] Original CTL Formula : ");
4963  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(ctlFormula));
4964  (void) fprintf(vis_stdout, "\n![FsmPathDebugEFFormulaMine] MC CTL Formula : ");   
4965//  (void) fprintf(vis_stdout, "\n![FsmPathDebugEFFormulaMine] ---> nb prevCExArray : %d \n", array_n(prevCExArray));
4966  Ctlp_FormulaPrint(vis_stdout, ctlFormula);
4967  fprintf(vis_stdout, "\n");
4968  array_t *cExArray;
4969//  array_t *prevCExArray;
4970//  prevCExArray = array_alloc(mdd_t *, 0); //Note: added just to respect arg requirements but not used
4971
4972  Ctlp_Formula_t *originalFormula = Ctlp_FormulaReadOriginalFormula(ctlFormula);
4973  char *originalFormulaText = Ctlp_FormulaConvertToString( originalFormula );
4974
4975  array_t *PSVars = Fsm_FsmReadPresentStateVars( modelFsm );
4976  array_t *witnessArray = McPathReadStemArray( witnessPath );
4977
4978  mdd_t *firstState = array_fetch( mdd_t *, witnessArray, 0 );
4979  mdd_t *lastState = array_fetch_last( mdd_t *, witnessArray );
4980  char *firstStateName = Mc_MintermToString(firstState, PSVars,
4981                                        Fsm_FsmReadNetwork(modelFsm));
4982
4983  Ctlp_Formula_t *rFormula = Ctlp_FormulaReadRightChild( ctlFormula );
4984  Ctlp_Formula_t *rOriginalFormula = Ctlp_FormulaReadOriginalFormula(rFormula);
4985  char *rOriginalFormulaText = Ctlp_FormulaConvertToString( rOriginalFormula );
4986  char *rFormulaText = Ctlp_FormulaConvertToString( rFormula );
4987  McDbgLevel debugLevel = McOptionsReadDbgLevel( options );
4988  boolean printInputs = McOptionsReadPrintInputs( options );
4989
4990  if( McOptionsReadDbgLevel( options ) == McDbgLevelMin_c)
4991    fprintf(vis_stdout, "--State\n%spasses EF formula\n\n",
4992            firstStateName); 
4993  else
4994    fprintf(vis_stdout, "--State\n%spasses formula %s\n\n", firstStateName,
4995          originalFormulaText );
4996 
4997// Added in case if there's no counter example => CTL fails at initial state
4998//  (void) fprintf(vis_stderr, "-[FsmPathDebugAGFormulaMine] 1) CEx n_state = %d \n", array_n(witnessArray));
4999    if ( array_n(witnessArray ) == 1 ) {
5000         (void) fprintf(vis_stderr, "-[FsmPathDebugEFFormulaMine] *VERIFICATION REQUIRED!* CEx n_state = %d \n", array_n(witnessArray));
5001         Mc_PrintPath(witnessArray, modelFsm, printInputs); // added
5002    }
5003    (void) fprintf(vis_stderr, "-[FsmPathDebugEFFormulaMine] array_n(witnessArrayEF) = %d\n",array_n(witnessArray));
5004
5005  FREE(firstStateName);
5006  FREE(originalFormulaText);
5007
5008  switch ( debugLevel ) {
5009  case McDbgLevelMin_c:
5010  case McDbgLevelMinVerbose_c:
5011    if ( array_n(witnessArray ) == 1 ) {
5012      if( debugLevel !=  McDbgLevelMin_c)
5013        fprintf(vis_stdout, "since %s is true at this state\n",
5014                rOriginalFormulaText);
5015     
5016      FREE( rOriginalFormulaText );
5017//      cExArray = McFsmStateDebugFormulaMine(options, rFormula, lastState, modelFsm, careSetArray, prevCExArray);
5018      cExArray = McFsmStateDebugFormulaMine(options, rFormula, lastState, modelFsm, careSetArray, *preCExArray);
5019    }
5020    else {
5021      if( debugLevel !=  McDbgLevelMin_c)
5022        fprintf(vis_stdout,
5023                "--Witness is a path to a state where %s is finally true\n",
5024                rOriginalFormulaText);
5025      (void) fprintf( vis_stdout, "\n--Fair path stem:\n");
5026      FREE( rOriginalFormulaText );
5027      fprintf(vis_stdout, " --Counter example begins\n");
5028      Mc_PrintPath( witnessArray, modelFsm, printInputs );
5029      fprintf(vis_stdout, " --Counter example ends\n\n");
5030    }
5031    break;
5032  case McDbgLevelMax_c:
5033  case McDbgLevelInteractive_c:
5034    if ( array_n(witnessArray ) == 1 ) {
5035//      cExArray = McFsmStateDebugFormulaMine(options, rFormula, lastState, modelFsm, careSetArray, prevCExArray);
5036      cExArray = McFsmStateDebugFormulaMine(options, rFormula, lastState, modelFsm, careSetArray, *preCExArray);
5037    }
5038    else
5039      {
5040        fprintf(vis_stdout,
5041                "--Witness is a path to a state where %s is finally true\n",
5042                rOriginalFormulaText);
5043        fprintf(vis_stdout, " --Counter example begins\n");
5044      Mc_PrintPath( witnessArray, modelFsm, printInputs);
5045      fprintf(vis_stdout, " --Counter example ends\n\n");
5046      if (debugLevel == McDbgLevelMax_c ||
5047          (debugLevel == McDbgLevelInteractive_c &&
5048           McQueryContinue(
5049             "--Continue debugging EF formula? (1-yes,0-no)\n")))
5050        {
5051//      cExArray = McFsmStateDebugFormulaMine(options, rFormula, lastState, modelFsm, careSetArray, prevCExArray);
5052        cExArray = McFsmStateDebugFormulaMine(options, rFormula, lastState, modelFsm, careSetArray, *preCExArray);
5053        }
5054      }
5055    break;
5056  default:
5057    fail("bad switch in debugging EF\n");
5058  }
5059//  (void) fprintf(vis_stdout, "\n![FsmPathDebugEFFormulaMine] ---> nb prevCExArray : %d *END*\n", array_n(prevCExArray));
5060//  array_free(prevCExArray);
5061  FREE(rFormulaText);
5062 return witnessArray;
5063}
5064
5065
5066/**Function********************************************************************
5067
5068  Synopsis    [Debug a AX formula]
5069
5070  SideEffects []
5071
5072******************************************************************************/
5073static array_t *
5074FsmPathDebugAXFormulaMine(
5075  McOptions_t *options,
5076  Ctlp_Formula_t *ctlFormula,
5077  Fsm_Fsm_t *modelFsm,
5078  McPath_t *counterExamplePath,
5079  array_t *careSetArray,
5080  array_t **preCExArray)
5081{
5082  (void) fprintf(vis_stdout, "![FsmPathDebugAXFormulaMine] Original CTL Formula : ");
5083  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(ctlFormula));
5084  (void) fprintf(vis_stdout, "\n![FsmPathDebugAXFormulaMine] MC CTL Formula : ");   
5085//  (void) fprintf(vis_stdout, "\n![FsmPathDebugAXFormulaMine] ---> nb prevCExArray : %d \n", array_n(prevCExArray));
5086  Ctlp_FormulaPrint(vis_stdout, ctlFormula);
5087  fprintf(vis_stdout, "\n");
5088  array_t *cExArray;
5089//  array_t *prevCExArray;
5090//  prevCExArray = array_alloc(mdd_t *, 0); //Note: added just to respect arg requirements but not used
5091
5092  Ctlp_Formula_t *originalFormula = Ctlp_FormulaReadOriginalFormula(ctlFormula);
5093  char *originalFormulaText = Ctlp_FormulaConvertToString( originalFormula );
5094  Ctlp_Formula_t *lFormula = Ctlp_FormulaReadLeftChild( ctlFormula );
5095  Ctlp_Formula_t *llFormula = Ctlp_FormulaReadLeftChild( lFormula );
5096  Ctlp_Formula_t *lllFormula = Ctlp_FormulaReadLeftChild( llFormula );
5097
5098  array_t *PSVars = Fsm_FsmReadPresentStateVars( modelFsm );
5099  array_t *witnessArray = McPathReadStemArray( counterExamplePath );
5100  mdd_t *firstState = array_fetch( mdd_t *, witnessArray, 0 );
5101  mdd_t *lastState = array_fetch( mdd_t *, witnessArray, 1 );
5102  char *firstStateName = Mc_MintermToString(firstState, PSVars,
5103                                            Fsm_FsmReadNetwork(modelFsm));
5104  boolean printInputs = McOptionsReadPrintInputs( options );
5105
5106    (void) fprintf(vis_stderr, "-[FsmPathDebugAXFormulaMine] array_n(witnessArrayAX) = %d\n",array_n(witnessArray));
5107 
5108  if( McOptionsReadDbgLevel( options ) == McDbgLevelMin_c)
5109    fprintf(vis_stdout, "--State\n%sfails AX formula\n\n",
5110            firstStateName); 
5111  else
5112      fprintf(vis_stdout, "--State\n%sfails %s\n\n", firstStateName,
5113          originalFormulaText );
5114
5115  FREE(firstStateName);
5116  FREE(originalFormulaText);
5117
5118  switch ( McOptionsReadDbgLevel( options ) ) {
5119  case McDbgLevelMin_c:
5120  case McDbgLevelMinVerbose_c:
5121  case McDbgLevelMax_c:
5122    fprintf(vis_stdout, " --Counter example begins\n"); 
5123    Mc_PrintPath( witnessArray, modelFsm, printInputs );
5124    fprintf(vis_stdout, " --Counter example ends\n\n");
5125    fprintf(vis_stdout, "\n");
5126//    cExArray = McFsmStateDebugFormulaMine(options, lllFormula, lastState, modelFsm, careSetArray, prevCExArray);
5127    cExArray = McFsmStateDebugFormulaMine(options, lllFormula, lastState, modelFsm, careSetArray, *preCExArray);
5128    break;
5129  case McDbgLevelInteractive_c:
5130    fprintf(vis_stdout, " --Counter example begins\n");
5131    Mc_PrintPath( witnessArray, modelFsm, printInputs );
5132    fprintf(vis_stdout, " --Counter example ends\n\n");
5133    if ( McQueryContinue("Continue debugging EX formula? (1-yes,0-no)\n") ) {
5134//      cExArray = McFsmStateDebugFormulaMine(options, lllFormula, lastState, modelFsm, careSetArray, prevCExArray);
5135      cExArray = McFsmStateDebugFormulaMine(options, lllFormula, lastState, modelFsm, careSetArray, *preCExArray);
5136    }
5137    break;
5138  default: 
5139    fail("Bad switch in FsmPathDebugAXFormulaMine\n");
5140  }
5141
5142//  (void) fprintf(vis_stdout, "\n![FsmPathDebugAXFormulaMine] ---> nb prevCExArray : %d *END*\n", array_n(prevCExArray));
5143// array_free(prevCExArray);
5144 return witnessArray;
5145}
5146
5147/**Function********************************************************************
5148
5149  Synopsis    [Debug a AF formula]
5150
5151  SideEffects []
5152
5153******************************************************************************/
5154static array_t *
5155FsmPathDebugAFFormulaMine(
5156  McOptions_t *options,
5157  Ctlp_Formula_t *ctlFormula,
5158  Fsm_Fsm_t *modelFsm,
5159  McPath_t *counterExamplePath,
5160  array_t *careSetArray,
5161  array_t **preCExArray)
5162{
5163  (void) fprintf(vis_stdout, "![FsmPathDebugAFFormulaMine] Original CTL Formula : ");
5164  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(ctlFormula));
5165  (void) fprintf(vis_stdout, "\n![FsmPathDebugAFFormulaMine] MC CTL Formula : ");   
5166//  (void) fprintf(vis_stdout, "\n![FsmPathDebugAFFormulaMine] ---> nb prevCExArray : %d \n", array_n(prevCExArray));
5167  Ctlp_FormulaPrint(vis_stdout, ctlFormula);
5168  fprintf(vis_stdout, "\n");
5169  array_t *cExArray;
5170//  array_t *prevCExArray;
5171//  prevCExArray = array_alloc(mdd_t *, 0); //Note: added just to respect arg requirements but not used
5172
5173
5174  Ctlp_Formula_t *originalFormula = Ctlp_FormulaReadOriginalFormula(ctlFormula);
5175  char *originalFormulaText = Ctlp_FormulaConvertToString( originalFormula );
5176  Ctlp_Formula_t *lFormula = Ctlp_FormulaReadLeftChild( ctlFormula );
5177  Ctlp_Formula_t *llFormula = Ctlp_FormulaReadLeftChild( lFormula );
5178  Ctlp_Formula_t *lllFormula = Ctlp_FormulaReadLeftChild( llFormula );
5179  Ctlp_Formula_t *lllOriginalFormula = Ctlp_FormulaReadOriginalFormula(
5180                                        lllFormula);
5181  char *lllOriginalFormulaText = Ctlp_FormulaConvertToString(
5182                                        lllOriginalFormula);
5183
5184  mdd_t *firstState;
5185  array_t *witnessArray;
5186  array_t *witness;
5187  array_t *PSVars = Fsm_FsmReadPresentStateVars( modelFsm );
5188  array_t *stemArray = McPathReadStemArray( counterExamplePath );
5189  array_t *cycleArray = McPathReadCycleArray( counterExamplePath );
5190  char *firstStateName;
5191  McDbgLevel debugLevel = McOptionsReadDbgLevel( options );
5192  boolean printInputs = McOptionsReadPrintInputs( options );
5193
5194  witnessArray = McCreateMergedPath( stemArray, cycleArray );
5195  firstState = array_fetch( mdd_t *, witnessArray, 0 );
5196  firstStateName = Mc_MintermToString(firstState, PSVars,
5197                                        Fsm_FsmReadNetwork(modelFsm));
5198
5199    (void) fprintf(vis_stderr, "-[FsmPathDebugAFFormulaMine] array_n(stemArrayEG) = %d\n",array_n(stemArray));
5200    (void) fprintf(vis_stderr, "-[FsmPathDebugAFFormulaMine] array_n(cycleArrayEG) = %d\n",array_n(cycleArray));
5201    (void) fprintf(vis_stderr, "-[FsmPathDebugAFFormulaMine] array_n(witnessArrayEG) = %d\n",array_n(witnessArray));
5202
5203
5204
5205  if( McOptionsReadDbgLevel( options ) == McDbgLevelMin_c)
5206    fprintf(vis_stdout, "--State\n%sfails AF formula\n\n",
5207            firstStateName); 
5208  else
5209    fprintf(vis_stdout, "--State\n%sfails %s\n\n", firstStateName,
5210            originalFormulaText );
5211  FREE(firstStateName);
5212  FREE(originalFormulaText);
5213
5214  switch ( debugLevel ) {
5215  case McDbgLevelMin_c:
5216  case McDbgLevelMinVerbose_c: {
5217    McPath_t *normalPath = McPathNormalize( counterExamplePath );
5218    array_t *stem = McPathReadStemArray( normalPath );
5219    array_t *cycle = McPathReadCycleArray( normalPath );
5220
5221    (void) fprintf(vis_stderr, "-[FsmPathDebugAFFormulaMine] array_n(stemNormEG) = %d\n",array_n(stem));
5222    (void) fprintf(vis_stderr, "-[FsmPathDebugAFFormulaMine] array_n(cycleNormEG) = %d\n",array_n(cycle));
5223    witness = McCreateMergedPath( stem, cycle );
5224    (void) fprintf(vis_stderr, "-[FsmPathDebugAFFormulaMine] array_n(witnessNormEG) = %d\n",array_n(witness));
5225    (void) fprintf(vis_stderr, "-[FsmPathDebugAFFormulaMine] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n");
5226    Mc_PrintPath( witness, modelFsm, printInputs );
5227    (void) fprintf(vis_stderr, "-[FsmPathDebugAFFormulaMine] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n");
5228
5229    if( debugLevel !=  McDbgLevelMin_c)
5230      fprintf(vis_stdout, "--A fair path on which %s is always false:\n",
5231              lllOriginalFormulaText );
5232   
5233    fprintf(vis_stdout, " --Counter example begins\n");
5234    (void) fprintf( vis_stdout, "--Fair path stem:\n");
5235    Mc_PrintPath( stem, modelFsm, printInputs );
5236   
5237    (void) fprintf( vis_stdout, "--Fair path cycle:\n");
5238    Mc_PrintPath( cycle, modelFsm, printInputs );
5239    fprintf(vis_stdout, "\n");
5240    fprintf(vis_stdout, " --Counter example ends\n\n");
5241    McPathFree( normalPath );
5242    break;
5243  }
5244  case McDbgLevelMax_c:
5245  case McDbgLevelInteractive_c: {
5246    int i;
5247    McPath_t *normalPath = McPathNormalize( counterExamplePath );
5248    array_t *stem = McPathReadStemArray( normalPath );
5249    array_t *cycle = McPathReadCycleArray( normalPath );
5250
5251    (void) fprintf(vis_stderr, "-[FsmPathDebugAFFormulaMine] array_n(stemNormEG) = %d\n",array_n(stem));
5252    (void) fprintf(vis_stderr, "-[FsmPathDebugAFFormulaMine] array_n(cycleNormEG) = %d\n",array_n(cycle));
5253    witness = McCreateMergedPath( stem, cycle );
5254    (void) fprintf(vis_stderr, "-[FsmPathDebugAFFormulaMine] array_n(witnessNormEG) = %d\n",array_n(witness));
5255    (void) fprintf(vis_stderr, "-[FsmPathDebugAFFormulaMine] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n");
5256    Mc_PrintPath( witness, modelFsm, printInputs );
5257    (void) fprintf(vis_stderr, "-[FsmPathDebugAFFormulaMine] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n");
5258
5259
5260    fprintf(vis_stdout, "--A fair path on which %s is always false:\n",
5261              lllOriginalFormulaText ); 
5262    fprintf(vis_stdout, " --Counter example begins\n");
5263    (void) fprintf( vis_stdout, "--Fair path stem:\n");
5264    Mc_PrintPath( stem, modelFsm, printInputs );
5265   
5266    (void) fprintf( vis_stdout, "--Fair path cycle:\n");
5267    Mc_PrintPath( cycle, modelFsm, printInputs );
5268    fprintf(vis_stdout, "\n");
5269    fprintf(vis_stdout, " --Counter example ends\n\n");
5270    McPathFree( normalPath );
5271    for( i=0 ; i < ( array_n( witnessArray )-1  ); i++ ) {
5272      mdd_t *aState = array_fetch( mdd_t *, witnessArray, i );
5273   
5274      if (debugLevel == McDbgLevelMax_c ||
5275          (debugLevel == McDbgLevelInteractive_c &&
5276           McQueryContinue(
5277             "--Continue debugging AF formula? (1-yes,0-no)\n"))) {
5278//      cExArray = McFsmStateDebugFormulaMine(options, lllFormula, aState, modelFsm, careSetArray, prevCExArray);
5279        cExArray = McFsmStateDebugFormulaMine(options, lllFormula, aState, modelFsm, careSetArray, *preCExArray);
5280      }
5281    }
5282
5283    break;
5284  }
5285  default: {
5286    fail("Bad case in switch for debugging AF formula\n");
5287    witness = NIL(array_t);
5288  }
5289  }
5290 
5291//  array_free(prevCExArray);
5292  McNormalizeBddPointer(witnessArray);
5293  mdd_array_free( witnessArray );
5294  FREE(lllOriginalFormulaText);
5295//  (void) fprintf(vis_stdout, "\n![FsmPathDebugAFFormulaMine] ---> nb prevCExArray : %d *END*\n", array_n(prevCExArray));
5296 return witness;
5297}
5298
5299/**Function********************************************************************
5300
5301  Synopsis    [Debug an AG formula.]
5302 
5303  Description [Debugs an AG formula.  What it really wants is a formula of the
5304  form !EF! phi, that was converted from the formula AG phi, with all the
5305  converted pointers set as required: the top ! points to the original AG
5306  formula, and top node of phi points to the original phi.]
5307
5308  SideEffects []
5309
5310******************************************************************************/
5311static array_t *
5312FsmPathDebugAGFormulaMine(
5313  McOptions_t *options,
5314  Ctlp_Formula_t *ctlFormula,
5315  Fsm_Fsm_t *modelFsm,
5316  McPath_t *counterExamplePath,
5317  array_t *careSetArray,
5318  array_t **preCExArray)
5319{
5320  (void) fprintf(vis_stdout, "![FsmPathDebugAGFormulaMine] Original CTL Formula : ");
5321  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(ctlFormula));
5322  (void) fprintf(vis_stdout, "\n![FsmPathDebugAGFormulaMine] MC CTL Formula : ");   
5323//  (void) fprintf(vis_stdout, "\n![FsmPathDebugAGFormulaMine] ---> nb prevCExArray : %d \n", array_n(prevCExArray));
5324  Ctlp_FormulaPrint(vis_stdout, ctlFormula);
5325  fprintf(vis_stdout, "\n");
5326  array_t *cExArray;
5327//  array_t *prevCExArray;
5328//  prevCExArray = array_alloc(mdd_t *, 0); //Note: added just to respect arg requirements but not used
5329
5330  Ctlp_Formula_t *originalFormula = Ctlp_FormulaReadOriginalFormula(ctlFormula);
5331  char *originalFormulaText = Ctlp_FormulaConvertToString( originalFormula );
5332  Ctlp_Formula_t *lFormula = Ctlp_FormulaReadLeftChild( ctlFormula );
5333  Ctlp_Formula_t *lrFormula = Ctlp_FormulaReadRightChild( lFormula );
5334  Ctlp_Formula_t *lrlFormula = Ctlp_FormulaReadLeftChild( lrFormula );
5335  Ctlp_Formula_t *lrlOriginalFormula = Ctlp_FormulaReadOriginalFormula(
5336                                        lrlFormula);
5337  char *lrlOriginalFormulaText = Ctlp_FormulaConvertToString(
5338                                        lrlOriginalFormula);
5339
5340  array_t *PSVars = Fsm_FsmReadPresentStateVars( modelFsm );
5341  array_t *witnessArray = McPathReadStemArray( counterExamplePath );
5342  mdd_t *firstState = array_fetch( mdd_t *, witnessArray, 0 );
5343  mdd_t *lastState = GET_NORMAL_PT(array_fetch_last( mdd_t *, witnessArray ));
5344  char *firstStateName = Mc_MintermToString(firstState, PSVars,
5345                                            Fsm_FsmReadNetwork(modelFsm));
5346
5347//   CEXStruct CEXPath [array_n( aPath )];
5348// *Mc_MintermToStringMine( mdd_t *aMinterm, array_t *aSupport, Ntk_Network_t *aNetwork, CEXStruct *CEXPath, int seqNumber, boolean inOutIndicator, BmcCnfClauses_t *cnfClauses);
5349    (void) fprintf(vis_stderr, "-[FsmPathDebugAGFormulaMine] array_n(witnessArrayAG) = %d\n",array_n(witnessArray));
5350
5351  McDbgLevel debugLevel = McOptionsReadDbgLevel( options );
5352  boolean printInputs = McOptionsReadPrintInputs( options );
5353
5354  assert( Ctlp_FormulaReadType(ctlFormula) == Ctlp_NOT_c );
5355  assert( Ctlp_FormulaTestIsConverted(ctlFormula) );
5356  assert( Ctlp_FormulaReadType(originalFormula) == Ctlp_AG_c );
5357  assert( originalFormulaText != NIL(char) );
5358  assert( Ctlp_FormulaReadType(lFormula) == Ctlp_EU_c );
5359  assert( Ctlp_FormulaReadType(Ctlp_FormulaReadLeftChild(lFormula)) ==
5360          Ctlp_TRUE_c );
5361  assert( Ctlp_FormulaReadType(lrFormula) == Ctlp_NOT_c  );
5362  assert( lrlOriginalFormula != NIL(Ctlp_Formula_t) );
5363 
5364  if( McOptionsReadDbgLevel( options ) == McDbgLevelMin_c)
5365    fprintf(vis_stdout, "--State\n%sfails AG formula\n\n",
5366            firstStateName); 
5367  else
5368    fprintf(vis_stdout, "--State\n%sfails %s\n\n", firstStateName,
5369            originalFormulaText );
5370
5371// Added in case if there's no counter example => CTL fails at initial state
5372//  (void) fprintf(vis_stderr, "-[FsmPathDebugAGFormulaMine] 1) CEx n_state = %d \n", array_n(witnessArray));
5373  if ( array_n(witnessArray ) == 1 ) {
5374//     (void) fprintf(vis_stderr, "-[FsmPathDebugAGFormulaMine] 2) CEx n_state = %d \n", array_n(witnessArray));
5375      Mc_PrintPath(witnessArray, modelFsm, printInputs); // added
5376  }
5377  FREE(firstStateName);
5378  FREE(originalFormulaText);
5379
5380  switch ( debugLevel ) {
5381  case McDbgLevelMin_c:
5382  case McDbgLevelMinVerbose_c:{
5383    if ( array_n(witnessArray ) == 1 ) {
5384      if( debugLevel !=  McDbgLevelMin_c)
5385        fprintf(vis_stdout, "since %s is false at this state\n",
5386                lrlOriginalFormulaText );
5387//      cExArray = McFsmStateDebugFormulaMine(options, lrlFormula, lastState, modelFsm, careSetArray, prevCExArray);
5388      cExArray = McFsmStateDebugFormulaMine(options, lrlFormula, lastState, modelFsm, careSetArray, *preCExArray);
5389    }
5390    else {
5391      if( debugLevel !=  McDbgLevelMin_c)
5392        fprintf(vis_stdout,
5393                "--Counter example is a path to a state where %s is false\n",
5394                lrlOriginalFormulaText);
5395      fprintf(vis_stdout, " --Counter example begins\n");
5396      Mc_PrintPath(witnessArray, modelFsm, printInputs);
5397      fprintf(vis_stdout, " --Counter example ends\n\n");
5398//      cExArray = McFsmStateDebugFormulaMine(options, lrlFormula, lastState, modelFsm, careSetArray, prevCExArray);
5399      cExArray = McFsmStateDebugFormulaMine(options, lrlFormula, lastState, modelFsm, careSetArray, *preCExArray);
5400    }
5401    break;
5402  }
5403  case McDbgLevelMax_c:
5404  case McDbgLevelInteractive_c: {
5405    if ( array_n(witnessArray ) == 1 ) {
5406      if( debugLevel !=  McDbgLevelMin_c)
5407        fprintf(vis_stdout, "since %s is false at this state\n",
5408                lrlOriginalFormulaText );
5409//      cExArray = McFsmStateDebugFormulaMine(options, lrlFormula, lastState, modelFsm, careSetArray, prevCExArray);
5410        cExArray = McFsmStateDebugFormulaMine(options, lrlFormula, lastState, modelFsm, careSetArray, *preCExArray);
5411    }
5412    else {
5413      fprintf(vis_stdout,
5414                "--Counter example is a path to a state where %s is false\n",
5415                lrlOriginalFormulaText);
5416      fprintf(vis_stdout, " --Counter example begins\n");
5417      Mc_PrintPath( witnessArray, modelFsm, printInputs);
5418      fprintf(vis_stdout, " --Counter example ends\n\n");
5419      if (debugLevel == McDbgLevelMax_c ||
5420          (debugLevel == McDbgLevelInteractive_c &&
5421           McQueryContinue(
5422             "--Continue debugging AG formula? (1-yes,0-no)\n")))
5423        {
5424//      cExArray = McFsmStateDebugFormulaMine(options, lrlFormula, lastState, modelFsm, careSetArray, prevCExArray);
5425        cExArray = McFsmStateDebugFormulaMine(options, lrlFormula, lastState, modelFsm, careSetArray, *preCExArray);
5426        }
5427      }
5428    break;
5429  }
5430  default: {
5431    fail("bad switch in debugging AG\n");
5432  }
5433  }
5434//    (void) fprintf(vis_stdout, "\n![FsmPathDebugAGFormulaMine] ---> nb prevCExArray : %d *END*\n", array_n(prevCExArray));
5435//  array_free(prevCExArray);
5436  FREE(lrlOriginalFormulaText);
5437//  (void) fprintf(vis_stdout, "\n![FsmPathDebugAGFormulaMine] *** Mc_PrintPathMine STARTS ----------------------\n");
5438//  Mc_PrintPathMine(witnessArray, modelFsm, printInputs);
5439//  (void) fprintf(vis_stdout, "![FsmPathDebugAGFormulaMine]  Mc_PrintPathMine ENDS *** -------------------------\n");
5440  return witnessArray;
5441}
5442
5443/**Function********************************************************************
5444
5445  Synopsis    [Debug a AU formula]
5446
5447  SideEffects []
5448
5449******************************************************************************/
5450static array_t *
5451FsmPathDebugAUFormulaMine(
5452  McOptions_t *options,
5453  mdd_t *aState,
5454  Ctlp_Formula_t *ctlFormula,
5455  Fsm_Fsm_t *modelFsm,
5456  array_t *careSetArray,
5457  array_t **preCExArray)
5458{
5459  (void) fprintf(vis_stdout, "![FsmPathDebugAUFormulaMine] Original CTL Formula : ");
5460  Ctlp_FormulaPrint(vis_stdout, Ctlp_FormulaReadOriginalFormula(ctlFormula));
5461  (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] MC CTL Formula : ");   
5462//  (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] 0 ---> nb preCExArray : %d \n", array_n(*preCExArray));
5463  Ctlp_FormulaPrint(vis_stdout, ctlFormula);
5464  fprintf(vis_stdout, "\n");
5465  array_t *cExArray;
5466//  array_t *prevCExArray;
5467//  prevCExArray = array_alloc(mdd_t *, 0); //Note: added just to respect arg requirements but not used
5468
5469  Ctlp_Formula_t *originalFormula = Ctlp_FormulaReadOriginalFormula(ctlFormula);
5470  char *originalFormulaText = Ctlp_FormulaConvertToString( originalFormula );
5471  Ctlp_Formula_t *lFormula = Ctlp_FormulaReadLeftChild( ctlFormula );
5472  Ctlp_Formula_t *lrFormula = Ctlp_FormulaReadRightChild( lFormula );
5473  Ctlp_Formula_t *lrlFormula = Ctlp_FormulaReadLeftChild( lrFormula );
5474  Ctlp_Formula_t *lrllFormula = Ctlp_FormulaReadLeftChild( lrlFormula );
5475  Ctlp_Formula_t *llFormula = Ctlp_FormulaReadLeftChild( lFormula );
5476  Ctlp_Formula_t *llrFormula = Ctlp_FormulaReadRightChild( llFormula );
5477  Ctlp_Formula_t *llrlFormula = Ctlp_FormulaReadLeftChild( llrFormula );
5478  Ctlp_Formula_t *llrllFormula = Ctlp_FormulaReadLeftChild( llrlFormula );
5479  Ctlp_Formula_t *fFormula = llrllFormula;
5480  Ctlp_Formula_t *gFormula = lrllFormula;
5481  Ctlp_Formula_t *fOriginalFormula = Ctlp_FormulaReadOriginalFormula(fFormula);
5482  Ctlp_Formula_t *gOriginalFormula = Ctlp_FormulaReadOriginalFormula(gFormula);
5483  char *fText = Ctlp_FormulaConvertToString( fOriginalFormula );
5484  char *gText = Ctlp_FormulaConvertToString( gOriginalFormula );
5485
5486  array_t *PSVars = Fsm_FsmReadPresentStateVars( modelFsm );
5487  char *firstStateName = Mc_MintermToString(aState, PSVars,
5488                                        Fsm_FsmReadNetwork(modelFsm));
5489  McDbgLevel debugLevel = McOptionsReadDbgLevel( options );
5490  boolean printInputs = McOptionsReadPrintInputs( options );
5491
5492  if( McOptionsReadDbgLevel( options ) == McDbgLevelMin_c)
5493    fprintf(vis_stdout, "--State\n%sfails AU formula\n\n",
5494            firstStateName); 
5495  else
5496    fprintf(vis_stdout, "--State\n%sfails %s\n\n", firstStateName,
5497            originalFormulaText );
5498  FREE(firstStateName);
5499  FREE(originalFormulaText);
5500
5501  /* orginal formula is A(fUg) => converted is !((E[!g U (!f*!g)]) + (EG!g)) */
5502
5503  if ( McStateSatisfiesFormula( llFormula, aState ) ) {
5504    /*
5505     * the case E[!g U (!f*!g)] is true
5506     */
5507    McPath_t *counterExamplePath = DebugEUMine(llFormula, aState, modelFsm,
5508                                           careSetArray);
5509   
5510    array_t *stemArray = McPathReadStemArray( counterExamplePath );
5511    array_t *witnessArray = stemArray;
5512    mdd_t *firstState = array_fetch( mdd_t *, witnessArray, 0 );
5513    mdd_t *lastState = array_fetch_last( mdd_t *, witnessArray );
5514    char *firstStateName = Mc_MintermToString(firstState, PSVars,
5515                                Fsm_FsmReadNetwork(modelFsm));
5516
5517// Added in case if there's no counter example => CTL fails at initial state
5518//  (void) fprintf(vis_stderr, "-[FsmPathDebugAUFormulaMine] 1) CEx n_state = %d \n", array_n(witnessArray));
5519    if ( array_n(witnessArray ) == 1 ) {
5520         (void) fprintf(vis_stderr, "-[FsmPathDebugAUFormulaMine] *VERIFICATION REQUIRED!* CEx n_state = %d \n", array_n(witnessArray));
5521         Mc_PrintPath(witnessArray, modelFsm, printInputs); // added
5522    }
5523    (void) fprintf(vis_stderr, "-[FsmPathDebugAUFormulaMine] array_n(witnessArrayEU) = %d\n",array_n(witnessArray));
5524
5525    switch ( debugLevel ) {
5526    case McDbgLevelMinVerbose_c: 
5527      fprintf(vis_stdout,
5528              "--Counter example is a fair path where %s is false until %s is also false\n",
5529              gText, fText);
5530    case McDbgLevelMin_c:
5531      fprintf(vis_stdout, " --Counter example begins\n");
5532      Mc_PrintPath(witnessArray, modelFsm, printInputs);
5533      fprintf(vis_stdout, " --Counter example ends\n\n");
5534//      cExArray = McFsmStateDebugFormulaMine(options, llrFormula, lastState, modelFsm, careSetArray, prevCExArray);
5535      cExArray = McFsmStateDebugFormulaMine(options, llrFormula, lastState, modelFsm, careSetArray, *preCExArray);
5536//    (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] 1 ---> nb preCExArray : %d \n", array_n(*preCExArray));
5537      break;
5538       
5539    case McDbgLevelMax_c:
5540    case McDbgLevelInteractive_c: {
5541      if ( array_n(witnessArray ) == 1 ) {
5542        fprintf(vis_stdout,
5543                "--At state %s\nformula %s is false and\nformula %s is also false\n",
5544                firstStateName, fText, gText);
5545        if (debugLevel == McDbgLevelMax_c ||
5546            (debugLevel == McDbgLevelInteractive_c &&
5547             McQueryContinue(
5548               "Continue debugging AU formula? (1-yes,0-no)\n"))) {
5549//        cExArray = McFsmStateDebugFormulaMine(options, fFormula, aState, modelFsm, careSetArray, prevCExArray);
5550//        cExArray = McFsmStateDebugFormulaMine(options, gFormula, aState, modelFsm, careSetArray, prevCExArray);
5551          cExArray = McFsmStateDebugFormulaMine(options, fFormula, aState, modelFsm, careSetArray, *preCExArray);
5552          cExArray = McFsmStateDebugFormulaMine(options, gFormula, aState, modelFsm, careSetArray, *preCExArray);
5553//    (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] 2 ---> nb preCExArray : %d \n", array_n(*preCExArray));
5554        }
5555      }
5556      else {
5557        int i;
5558        fprintf(vis_stdout, " --Counter example begins\n");
5559        Mc_PrintPath(witnessArray,modelFsm,printInputs);
5560        fprintf(vis_stdout, " --Counter example ends\n\n");
5561        for( i=0 ; i < ( array_n( witnessArray ) - 1 ); i++ ) {
5562          mdd_t *aState = array_fetch( mdd_t *, witnessArray, i );
5563         
5564          if (debugLevel == McDbgLevelMax_c ||
5565              (debugLevel == McDbgLevelInteractive_c &&
5566               McQueryContinue(
5567                 "Continue debugging AU formula? (1-yes,0-no)\n"))) {
5568//          cExArray = McFsmStateDebugFormulaMine(options, gFormula, aState, modelFsm, careSetArray, prevCExArray);
5569           cExArray = McFsmStateDebugFormulaMine(options, llrFormula, lastState, modelFsm, careSetArray, *preCExArray);
5570//    (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] 3 ---> nb preCExArray : %d \n", array_n(*preCExArray));
5571          }
5572        }
5573       
5574        if (debugLevel == McDbgLevelMax_c ||
5575            (debugLevel == McDbgLevelInteractive_c &&
5576             McQueryContinue(
5577               "Continue debugging AU formula? (1-yes,0-no)\n"))) {
5578//        cExArray = McFsmStateDebugFormulaMine(options, fFormula, lastState, modelFsm, careSetArray, prevCExArray);
5579//        cExArray = McFsmStateDebugFormulaMine(options, gFormula, lastState, modelFsm, careSetArray, prevCExArray);
5580          cExArray = McFsmStateDebugFormulaMine(options, fFormula, lastState, modelFsm, careSetArray, *preCExArray);
5581          cExArray = McFsmStateDebugFormulaMine(options, gFormula, lastState, modelFsm, careSetArray, *preCExArray);
5582//    (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] 4 ---> nb preCExArray : %d \n", array_n(*preCExArray));
5583        }
5584      }
5585      break;
5586    }
5587   
5588    default: {
5589      fail("Unknown case in debugging AU\n");
5590    }
5591    }/* case */
5592//    McPathFree( counterExamplePath );  NOTE: INITIALLY FREED
5593
5594//    (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] ---> nb prevCExArray : %d \n", array_n(prevCExArray));
5595
5596//    array_free(prevCExArray);
5597    FREE( fText );
5598    FREE( gText );
5599//  (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] *** Mc_PrintPathMine WA STARTS  ------------------\n");
5600//  Mc_PrintPathMine(witnessArray, modelFsm, printInputs);
5601//  (void) fprintf(vis_stdout, "![FsmPathDebugAUFormulaMine]  Mc_PrintPathMine WA ENDS *** -------------------\n");
5602
5603    *preCExArray = cExArray;
5604//    (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] LAST ---> nb cExArray : %d \n", array_n(cExArray));
5605//    (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] LAST ---> nb preCExArray : %d \n", array_n(*preCExArray));
5606    (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] ---> nb witnessArray : %d *END*\n", array_n(witnessArray));
5607    return witnessArray;
5608  }
5609  else {
5610    /*
5611     * must be the case that EG!g
5612     */
5613    McPath_t *counterExamplePath = DebugEGMine(lrFormula, aState, modelFsm,
5614                                           careSetArray, 
5615                                           options);
5616
5617    assert( McStateSatisfiesFormula( lrFormula, aState ) );
5618
5619    array_t *stemArray = McPathReadStemArray( counterExamplePath );
5620    array_t *cycleArray = McPathReadCycleArray( counterExamplePath );
5621    array_t *witnessArray = McCreateMergedPath( stemArray, cycleArray );
5622    McPath_t *normalPath = McPathNormalize( counterExamplePath );
5623    array_t *stem = McPathReadStemArray( normalPath );
5624    array_t *cycle = McPathReadCycleArray( normalPath );
5625
5626//    (void) fprintf(vis_stderr, "-[FsmPathDebugAUFormulaMine] array_n(stemArrayEG) = %d\n",array_n(stemArray));
5627//    (void) fprintf(vis_stderr, "-[FsmPathDebugAUFormulaMine] array_n(cycleArrayEG) = %d\n",array_n(cycleArray));
5628//    (void) fprintf(vis_stderr, "-[FsmPathDebugAUFormulaMine] array_n(witnessArrayEG) = %d\n",array_n(witnessArray));
5629    (void) fprintf(vis_stderr, "-[FsmPathDebugAUFormulaMine] array_n(stemNormEG) = %d\n",array_n(stem));
5630    (void) fprintf(vis_stderr, "-[FsmPathDebugAUFormulaMine] array_n(cycleNormEG) = %d\n",array_n(cycle));
5631    array_t *witness = McCreateMergedPath( stem, cycle );
5632    (void) fprintf(vis_stderr, "-[FsmPathDebugAUFormulaMine] array_n(witnessNormEG) = %d\n",array_n(witness));
5633//    (void) fprintf(vis_stderr, "-[FsmPathDebugAUFormulaMine] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n");
5634//    Mc_PrintPathMine( witness, modelFsm, printInputs );
5635//    (void) fprintf(vis_stderr, "-[FsmPathDebugAUFormulaMine] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n");
5636
5637
5638
5639    if( debugLevel !=  McDbgLevelMin_c)
5640      fprintf(vis_stdout,
5641              "--Counter example is a fair path where %s is always false\n",
5642              gText);
5643
5644    switch ( debugLevel ) {
5645    case McDbgLevelMin_c:
5646    case McDbgLevelMinVerbose_c:{
5647/*      McPath_t *normalPath = McPathNormalize( counterExamplePath );
5648      array_t *stem = McPathReadStemArray( normalPath );
5649      array_t *cycle = McPathReadCycleArray( normalPath );
5650*/     
5651
5652      fprintf(vis_stdout, " --Counter example begins\n");
5653      (void) fprintf( vis_stdout, "--Fair path stem:\n");
5654      Mc_PrintPath( stem, modelFsm, printInputs );
5655     
5656      (void) fprintf( vis_stdout, "--Fair path cycle:\n");
5657      Mc_PrintPath( cycle, modelFsm, printInputs );
5658      fprintf(vis_stdout, " --Counter example ends\n\n");
5659      McPathFree( normalPath );
5660
5661      break;
5662    }
5663   
5664    case McDbgLevelMax_c:
5665    case McDbgLevelInteractive_c:
5666      {
5667    int i;
5668/*    array_t *stemArray = McPathReadStemArray( counterExamplePath );
5669    array_t *cycleArray = McPathReadCycleArray( counterExamplePath );
5670    array_t *witnessArray = McCreateMergedPath( stemArray, cycleArray );
5671    McPath_t *normalPath = McPathNormalize( counterExamplePath );
5672    array_t *stem = McPathReadStemArray( normalPath );
5673    array_t *cycle = McPathReadCycleArray( normalPath );
5674 */   
5675    fprintf(vis_stdout, " --Counter example begins\n");
5676    (void) fprintf( vis_stdout, "--Fair path stem:\n");
5677    Mc_PrintPath( stem, modelFsm, printInputs );
5678   
5679    (void) fprintf( vis_stdout, "--Fair path cycle:\n");
5680    Mc_PrintPath( cycle, modelFsm, printInputs );
5681    fprintf(vis_stdout, " --Counter example ends\n\n");
5682    McPathFree( normalPath );
5683    for( i=0 ; i < ( array_n( witnessArray )-1  ); i++ ) {
5684      mdd_t *aState = array_fetch( mdd_t *, witnessArray, i );
5685   
5686      if (debugLevel == McDbgLevelMax_c ||
5687          (debugLevel == McDbgLevelInteractive_c &&
5688           McQueryContinue(
5689             "--Continue debugging AU formula? (1-yes,0-no)\n"))) {
5690//      cExArray = McFsmStateDebugFormulaMine(options, lrllFormula, aState, modelFsm, careSetArray, prevCExArray);
5691        cExArray = McFsmStateDebugFormulaMine(options, lrllFormula, aState, modelFsm, careSetArray, *preCExArray);
5692        *preCExArray = cExArray; 
5693//    (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] EG 1 ---> nb preCExArray : %d \n", array_n(*preCExArray));
5694      }
5695    }
5696    break;
5697  }
5698
5699    default: {
5700      fail("Bad switch in debugging AU formula\n");
5701    }
5702    }/* case */
5703   
5704//    McPathFree( counterExamplePath ); NOTE: INITIALLY FREED
5705//    array_free(prevCExArray);
5706    FREE( fText );
5707    FREE( gText );
5708//    (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] ---> nb prevCExArray : %d \n", array_n(prevCExArray));
5709
5710//    *preCExArray = cExArray; // preCExArray = &cExArray;
5711
5712//    (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] LAST ---> nb cExArray : %d \n", array_n(cExArray));
5713//    (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] LAST ---> nb preCExArray : %d \n", array_n(*preCExArray));
5714    (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] ---> nb witness : %d *END*\n", array_n(witness));
5715
5716//  (void) fprintf(vis_stdout, "\n![FsmPathDebugAUFormulaMine] *** Mc_PrintPathMine STARTS ------------------ \n");
5717//   Mc_PrintPathMine(witness, modelFsm, printInputs);
5718//  (void) fprintf(vis_stdout, "![FsmPathDebugAUFormulaMine]  Mc_PrintPathMine ENDS *** --------------------- \n");
5719    return witness;
5720  }
5721
5722}
5723
5724
5725
5726/**Function********************************************************************
5727
5728  Synopsis [Utility function - prints states on path, inputs for transitions]
5729
5730  SideEffects []
5731
5732******************************************************************************/
5733static int
5734Mc_PrintPathMine(
5735  array_t *aPath,
5736  Fsm_Fsm_t *modelFsm,
5737  boolean printInput)
5738{
5739  (void) fprintf(vis_stderr, "![Mc_PrintPathMine] \n");
5740  int check, forced, i;
5741  int numForced;
5742  mdd_t *inputSet=NIL(mdd_t);
5743  mdd_t *uInput = NIL(mdd_t);
5744  mdd_t *vInput = NIL(mdd_t);
5745
5746  array_t *psVars = Fsm_FsmReadPresentStateVars( modelFsm );
5747  array_t *inputVars = Fsm_FsmReadInputVars( modelFsm );
5748  mdd_manager *mddMgr =  Fsm_FsmReadMddManager( modelFsm );
5749
5750  forced = 0;
5751  check = 1;
5752  numForced = 0;
5753
5754
5755   (void) fprintf(vis_stderr, " --- [Mc_PrintPathMine] NUMBER OF STEPS IN THE COUNTER EXAMPLE PATH = %d \n", array_n( aPath ));
5756
5757   CEXStruct CEXPath [array_n( aPath )];
5758   //CEXStruct *testCEX;
5759   //testCEX  = (CEXStruct *)malloc(sizeof(CEXStruct)*array_n( aPath )); 
5760
5761        // --- SAT Solver File Generation ---
5762   BmcOption_t *options =  BmcOptionAlloc();
5763   int steps = (array_n( aPath ) - 1); // taille du contre exemple
5764//   SATSolverFileGen (&hmgr, CNF_FILE, steps, options);
5765   BmcCnfClauses_t   *cnfClauses = NIL(BmcCnfClauses_t);
5766   cnfClauses = BmcCnfClausesAlloc();
5767   Ntk_Network_t * ntk = Ntk_HrcManagerReadCurrentNetwork(hmgrGlobalC);
5768   build_unroll_circuit(ntk,steps,options,cnfClauses); 
5769   (void) fprintf(vis_stderr, "*** CNF clauses for current network generated. *** \n\n");
5770
5771   (void) fprintf(vis_stderr, "*** Generating CNF clauses for Counter Example... *** \n\n");
5772
5773  for( i = -1 ; i < (array_n( aPath )-1); i++ ) {
5774
5775    CEXPath[i+1].pathIndex = i+1;
5776    CEXPath[i+1].n_outputVar = array_n( psVars );
5777
5778    (void) fprintf(vis_stderr, " --- [Mc_PrintPathMine] CEX PATH INDEX: CEXPath[%d].pathIndex = %d \n", i+1, CEXPath[i+1].pathIndex);
5779    (void) fprintf(vis_stderr, " --- [Mc_PrintPathMine] NUMBER OF OUTPUTS: CEXPath[%d].n_outputVar = %d \n", i+1, CEXPath[i+1].n_outputVar);
5780
5781    //deviceInfo  = (deviceStruct *)malloc(sizeof(deviceStruct)*diagInfo.n_failures);
5782    CEXPath[i+1].outputVar = (CEXVarStruct *)malloc(sizeof(CEXVarStruct)*CEXPath[i+1].n_outputVar); 
5783    //deviceInfo[i].dData  = (dataStruct *)malloc(sizeof(dataStruct)*(deviceInfo[i].nb_d_data));
5784
5785    mdd_t *aState = ( i == -1 ) ? NIL(mdd_t) : array_fetch( mdd_t *, aPath, i );
5786    mdd_t *bState = array_fetch( mdd_t *, aPath, (i+1) );
5787
5788//   (void) fprintf(vis_stderr, " --- [Mc_PrintPathMine] aState = %ld \n", aState);
5789//   (void) fprintf(vis_stderr, " --- [Mc_PrintPathMine] bState = %ld \n", bState);
5790
5791   Ntk_Network_t *modelNetwork = Fsm_FsmReadNetwork(modelFsm);
5792
5793   char *aStateString = aState ? Mc_MintermToString( aState, psVars, modelNetwork ) : NIL(char);
5794   char *bStateString = Mc_MintermToStringMine( bState, psVars, modelNetwork, CEXPath, (i+1), FALSE, cnfClauses);
5795//   (void) fprintf(vis_stderr, " --- [Mc_PrintPathMine] aState = %s \n", aStateString);
5796//   (void) fprintf(vis_stderr, " --- [Mc_PrintPathMine] bState = %s \n", bStateString);
5797
5798
5799    if((long)aState%2) {
5800      aState = (mdd_t *)((long)aState -1);
5801      forced++;
5802    }
5803    else        forced = 0;
5804
5805    if((long)bState%2) {
5806      bState = (mdd_t *)((long)bState -1);
5807    }
5808
5809    if ( printInput == TRUE && i != -1) {
5810      inputSet = Mc_FsmComputeDrivingInputMinterms( modelFsm, aState, bState );
5811      vInput = Mc_ComputeACloseMinterm( inputSet, uInput, inputVars, mddMgr );
5812    }
5813    if(forced)  {
5814      fprintf(vis_stdout, "---- Forced %d\n", forced);
5815      numForced ++;
5816    }
5817    McPrintTransitionMine( aState, bState, uInput, vInput, psVars, inputVars,
5818                       printInput, modelFsm, CEXPath, (i+1), cnfClauses);
5819
5820
5821
5822    if ( uInput != NIL(mdd_t) ) {
5823      mdd_free(uInput);
5824    }
5825    uInput = vInput;
5826
5827    if ( inputSet != NIL(mdd_t) ) {
5828      mdd_free(inputSet);
5829    }
5830  }
5831
5832  if ( vInput != NIL(mdd_t) ) {
5833    mdd_free(uInput);
5834  }
5835
5836  if(Fsm_FsmReadFAFWFlag(modelFsm) > 0) {
5837    fprintf(vis_stdout,
5838        "# MC: the number of non-trivial forced segments %d\n",
5839        numForced);
5840  }
5841
5842    FILE   *cnfFile = fopen(CNF_FILE_C1,"w");
5843    mAig_Manager_t * maigManager = Ntk_NetworkReadMAigManager(ntk);
5844    BmcWriteClausesMine(maigManager, cnfFile, cnfClauses, options);
5845    fclose(cnfFile);
5846
5847   (void) fprintf(vis_stderr, "*** Generation of CNF clauses for Counter Example completed. *** \n\n");
5848        // --- SAT Solver ---
5849  options->satInFile= CNF_FILE_C1;
5850  options->verbosityLevel=BmcVerbositySome_c;
5851   
5852  SATSolver (steps, options);
5853  (void) fprintf(vis_stderr, "*** SAT Solver completed. *** \n");
5854
5855  return 1;
5856}
5857
5858
5859/**Function********************************************************************
5860
5861  Synopsis [Print a transition to vis_stdout.]
5862
5863  Description [Print a transition to vis_stdout. The transition is supposed to be
5864  from aState to bState on input vInput. If uInput is not NIL, instead of
5865  printing vInput, we only print the places where it differs from uInput. If there
5866  is no difference anywhere, we print "-Unchanged-". Similarly, we print only the
5867  incremental difference from aState to bState; if there is none, we print "-Unchanged-".
5868  If aState is NIL we simply print bState and return.]
5869
5870  SideEffects []
5871
5872******************************************************************************/
5873static void
5874McPrintTransitionMine(
5875  mdd_t *aState,
5876  mdd_t *bState,
5877  mdd_t *uInput,
5878  mdd_t *vInput,
5879  array_t *stateSupport,
5880  array_t *inputSupport,
5881  boolean printInputs,
5882  Fsm_Fsm_t *modelFsm,
5883  CEXStruct *CEXPath, 
5884  int seqNumber,
5885  BmcCnfClauses_t *cnfClauses)
5886{
5887  (void) fprintf(vis_stderr, "![McPrintTransitionMine] \n");
5888  Ntk_Network_t *modelNetwork = Fsm_FsmReadNetwork( modelFsm );
5889  char *aString = aState ? Mc_MintermToString( aState, stateSupport, modelNetwork ) : NIL(char);
5890  char *bString = Mc_MintermToString( bState, stateSupport, modelNetwork );
5891
5892  char *tmp1String = aString;
5893  char *tmp2String = bString;
5894  char *ptr1;
5895  char *ptr2;
5896  st_table   *node2MvfAigTable;
5897
5898  node2MvfAigTable =
5899        (st_table *)Ntk_NetworkReadApplInfo(modelNetwork, MVFAIG_NETWORK_APPL_KEY);
5900
5901  if ( aState == NIL(mdd_t) ) {
5902    fprintf( vis_stdout, "--State %d:\n%s\n", seqNumber, bString );
5903    FREE(bString);
5904    return;
5905  }
5906
5907  fprintf(vis_stdout, "--Goes to state %d:\n", seqNumber );
5908
5909  {
5910    boolean unchanged=TRUE;
5911    while ( (tmp1String != NIL(char)) && ((ptr1 = strchr( tmp1String, '\n' ) ) != NIL(char) ) ) {
5912      ptr2 = strchr( tmp2String, '\n' );
5913      *ptr1 = 0;
5914      *ptr2 = 0;
5915      if ( (strcmp( tmp1String, tmp2String ) ) ) {
5916        fprintf( vis_stdout, "%s\n", tmp2String );
5917        unchanged = FALSE;
5918      }
5919      tmp1String = & (ptr1[1]);
5920      tmp2String = & (ptr2[1]);
5921    }
5922    if (unchanged == TRUE) {
5923      fprintf( vis_stdout, "<Unchanged>\n");
5924    }
5925  }
5926
5927     if ( array_n( inputSupport ) > 0 ) {
5928         CEXPath[seqNumber].n_inputVar = array_n( inputSupport );
5929        }
5930     else CEXPath[seqNumber].n_inputVar = 0;
5931
5932    (void) fprintf(vis_stderr, " ---- [McPrintTransitionMine] NUMBER OF INPUTS: CEXPath[%d].n_inputVar = %d \n", seqNumber, CEXPath[seqNumber].n_inputVar);
5933    CEXPath[seqNumber].inputVar = (CEXVarStruct *)malloc(sizeof(CEXVarStruct)*CEXPath[seqNumber].n_inputVar); 
5934
5935  if ( printInputs == TRUE ) {
5936
5937//    (void) fprintf(vis_stderr, " ---- [McPrintTransitionMine] NUMBER OF INPUTS = %d \n", array_n( inputSupport ));
5938
5939
5940    /* first test that there are inputs */
5941    if ( array_n( inputSupport ) > 0 ) {
5942      fprintf(vis_stdout, "--On input:\n");
5943
5944      if ( uInput == NIL(mdd_t) ) {
5945        char *vString = Mc_MintermToStringMine( vInput, inputSupport, modelNetwork, CEXPath, seqNumber, TRUE, cnfClauses);
5946        fprintf(vis_stdout, "%s", vString );
5947        FREE(vString);
5948      }
5949      else {
5950        boolean unchanged=TRUE;
5951        char *uString = Mc_MintermToString( uInput, inputSupport, modelNetwork );
5952        char *vString = Mc_MintermToStringMine( vInput, inputSupport, modelNetwork, CEXPath, seqNumber, TRUE, cnfClauses);
5953        tmp1String = uString;
5954        tmp2String = vString;
5955//      (void) fprintf(vis_stderr, " ---- [McPrintTransitionMine] uString = %s \n", uString);
5956//      (void) fprintf(vis_stderr, " ---- [McPrintTransitionMine] vString = %s \n", vString);
5957
5958        while ( (tmp1String != NIL(char)) && ((ptr1 = strchr( tmp1String, '\n' ) ) != NIL(char) ) ) {
5959          ptr2 = strchr( tmp2String, '\n' );
5960          *ptr1 = 0;
5961          *ptr2 = 0;
5962          if ( (strcmp( tmp1String, tmp2String ) ) ) {
5963            fprintf( vis_stdout, "%s\n", tmp2String );
5964            unchanged = FALSE;
5965          }
5966          tmp1String = & (ptr1[1]);
5967          tmp2String = & (ptr2[1]);
5968        }
5969        if (unchanged == TRUE) {
5970          fprintf( vis_stdout, "<Unchanged>\n");
5971        }
5972        FREE(uString);
5973        FREE(vString);
5974      }
5975    }
5976  }
5977
5978  FREE( aString );
5979  FREE( bString );
5980  fprintf (vis_stdout, "\n");
5981}
5982
5983
5984/**Function********************************************************************
5985
5986  Synopsis [Print a minterm.]
5987
5988  SideEffects []
5989
5990******************************************************************************/
5991static void
5992Mc_MintermPrintMine(
5993  mdd_t *aMinterm,
5994  array_t *support,
5995  Ntk_Network_t *aNetwork)
5996{
5997  char *tmpString = Mc_MintermToString( aMinterm, support, aNetwork ); // to be modified!!
5998  fprintf( vis_stdout, "%s", tmpString );
5999  FREE(tmpString);
6000}
6001
6002
6003/**Function********************************************************************
6004
6005  Synopsis [Return a string for a minterm. Only used in 'Mc_PrintPathMine'
6006                 function]
6007
6008  SideEffects []
6009
6010******************************************************************************/
6011static char *
6012Mc_MintermToStringMine(
6013  mdd_t *aMinterm,
6014  array_t *aSupport,
6015  Ntk_Network_t *aNetwork,
6016  CEXStruct *CEXPath,
6017  int seqNumber,
6018  boolean inOutIndicator, // TRUE = input Variables, FALSE = output Variables (independent printInput option)
6019  BmcCnfClauses_t *cnfClauses) 
6020{
6021  (void) fprintf(vis_stderr, "![Mc_MintermToStringMine] \n");
6022  int i;
6023  char *tmp1String;
6024  char *tmp2String;
6025  char bodyString[McMaxStringLength_c];
6026  char *mintermString = NIL(char);
6027  mdd_manager *mddMgr = Ntk_NetworkReadMddManager( aNetwork );
6028  array_t *valueArray;
6029  array_t *stringArray = array_alloc( char *, 0 );
6030  char *symbolicValue; 
6031
6032  aMinterm = GET_NORMAL_PT(aMinterm);
6033  valueArray = McConvertMintermToValueArrayMine(aMinterm, aSupport, mddMgr);
6034//  (void) fprintf(vis_stderr, " ---- [Mc_MintermToStringMine] CEX n outputs = %d \n", array_n( aSupport ));
6035//  (void) fprintf(vis_stderr, " ----- [Mc_MintermToStringMine] Number of variables = %d \n", array_n( aSupport ));
6036 
6037//  CEXVarStruct testBB [array_n( aSupport)];
6038
6039  for ( i = 0 ; i < array_n( aSupport ); i++ ) {
6040
6041    int mddId = array_fetch( int, aSupport, i );
6042    int value = array_fetch( int, valueArray, i );
6043    Ntk_Node_t *node = Ntk_NetworkFindNodeByMddId( aNetwork, mddId );
6044    char *nodeName = Ntk_NodeReadName( node );
6045    Var_Variable_t *nodeVar = Ntk_NodeReadVariable( node );
6046
6047//    (void) fprintf(vis_stderr, "\n ----- [Mc_MintermToStringMine] VARIABLE %d: \n", i+1 );
6048//    (void) fprintf(vis_stderr, " ----- [Mc_MintermToStringMine] nodeName = %s \n", nodeName);
6049//    (void) fprintf(vis_stderr, " ----- [Mc_MintermToStringMine] mddId = %d \n", mddId);
6050//    (void) fprintf(vis_stderr, " ----- [Mc_MintermToStringMine] value = %d \n", value);
6051
6052    if ( Var_VariableTestIsSymbolic( nodeVar ) ) {
6053      symbolicValue = Var_VariableReadSymbolicValueFromIndex(nodeVar, value );
6054//      (void) fprintf(vis_stderr, " ----- [Mc_MintermToStringMine] symbolic value = %s \n", symbolicValue);
6055      sprintf( bodyString, "%s:%s", nodeName, symbolicValue );
6056      //testBB[i].symbolicValue = symbolicValue;
6057 //     sprintf(testBB[i].symbolicValue, "%s", symbolicValue);
6058    }
6059    else {
6060      sprintf( bodyString, "%s:%d", nodeName, value );
6061      //testBB[i].symbolicValue = NIL(char);
6062      symbolicValue = "NIL";
6063//      sprintf(testBB[i].symbolicValue, "%s", "NIL");
6064    }
6065
6066
6067   if (inOutIndicator == TRUE) {
6068        CEXPath[seqNumber].inputVar[i].varIndex = i;
6069        CEXPath[seqNumber].inputVar[i].varId = mddId;
6070        CEXPath[seqNumber].inputVar[i].varValue = value;
6071        sprintf(CEXPath[seqNumber].inputVar[i].varName, "%s", nodeName);
6072        sprintf(CEXPath[seqNumber].inputVar[i].symbolicValue, "%s", symbolicValue);
6073   }
6074   else{
6075        CEXPath[seqNumber].outputVar[i].varIndex = i;
6076        CEXPath[seqNumber].outputVar[i].varId = mddId;
6077        CEXPath[seqNumber].outputVar[i].varValue = value;
6078        sprintf(CEXPath[seqNumber].outputVar[i].varName, "%s", nodeName);
6079        sprintf(CEXPath[seqNumber].outputVar[i].symbolicValue, "%s", symbolicValue);
6080   }
6081
6082//    testBB[i].varIndex = i;
6083//    testBB[i].varId = mddId;
6084//    testBB[i].varValue = value;
6085//    sprintf(testBB[i].varName, "%s", nodeName);
6086//   testBB[i].varName = nodeName;
6087
6088
6089
6090    tmp1String = util_strsav( bodyString );
6091    array_insert_last( char *, stringArray, tmp1String );
6092  }
6093  array_free(valueArray);
6094
6095  array_sort( stringArray, cmp);
6096
6097  for ( i = 0 ; i < array_n( stringArray ); i++ ) {
6098    tmp1String = array_fetch( char *, stringArray, i );
6099    if( i == 0 )  {
6100      mintermString = util_strcat3(tmp1String, "", "" );
6101    }
6102    else {
6103      tmp2String = util_strcat3(mintermString, "\n", tmp1String );
6104      FREE(mintermString);
6105      mintermString = tmp2String;
6106    }
6107    FREE(tmp1String);
6108  }
6109  array_free( stringArray );
6110
6111  tmp1String = util_strcat3(mintermString, "\n", "");
6112  FREE(mintermString);
6113  mintermString = tmp1String;
6114
6115   int j, k;
6116   boolean indexFound;
6117   int lookUpResult;
6118   int n_bitValue; // number of bit - 1 = highest bit number representing the value of the variable
6119   int *cnfIndex= malloc(sizeof(int)*SIZE_1);
6120   int newIndex;
6121   array_t * newClause;
6122   char *tempCNFString;
6123
6124  for ( i = 0 ; i < array_n( aSupport ); i++ ) {
6125
6126   j=0;
6127   indexFound = TRUE;
6128
6129   if (inOutIndicator == TRUE) {
6130/*      (void) fprintf(vis_stderr, "\n CEXPath[%d].inputVar[%d].varIndex = %d \n", seqNumber, i, CEXPath[seqNumber].inputVar[i].varIndex);
6131        (void) fprintf(vis_stderr, " CEXPath[%d].inputVar[%d].varId = %d \n", seqNumber, i, CEXPath[seqNumber].inputVar[i].varId);
6132        (void) fprintf(vis_stderr, "\n");
6133        (void) fprintf(vis_stderr, " CEXPath[%d].inputVar[%d].varValue = %d \n", seqNumber, i, CEXPath[seqNumber].inputVar[i].varValue);
6134        (void) fprintf(vis_stderr, " CEXPath[%d].inputVar[%d].varName = %s \n", seqNumber, i, CEXPath[seqNumber].inputVar[i].varName);
6135        (void) fprintf(vis_stderr, " CEXPath[%d].inputVar[%d].symbolicValue = %s \n", seqNumber, i, CEXPath[seqNumber].inputVar[i].symbolicValue);
6136*/
6137
6138        // insertion of cnf clauses related to the input in Counter Example at each state
6139        do{
6140            tempCNFString = CNFVariableNameConstructor(CEXPath[seqNumber].inputVar[i].varName, j, seqNumber-1); // the sequence of input begins at -1 and ends at (last sequence-1)
6141            lookUpResult = st_lookup(cnfClauses->cnfIndexTable, tempCNFString, &cnfIndex[j]);
6142 //         (void) fprintf(vis_stderr, "[SeqNumber: %d][i: %d][j: %d] tempCNFString = %s; lookUpResult = %d; cnfIndex = %d;\n", seqNumber, i, j, tempCNFString, lookUpResult, cnfIndex);
6143           if (lookUpResult == 0) {
6144              indexFound = FALSE;
6145           }
6146           else {
6147              indexFound = TRUE;
6148              (void) fprintf(vis_stderr, " [CNF Index Search] Variable bit name = %s => CNF Index = %d \n", tempCNFString, cnfIndex[j]);
6149              j++;
6150           }
6151        }while ((indexFound == TRUE)&&(j<SIZE_1));
6152
6153        if ((indexFound == FALSE)&&(j<SIZE_1)){
6154            n_bitValue = j-1;
6155//          (void) fprintf(vis_stderr, " [Counter] n_bitValue = %d ::: j = %d. \n", n_bitValue, j);
6156            if (n_bitValue > 0){
6157                // Value decomposition en binary. Then affectation of the value of each bit of the variable in CNF format for each index of the variable
6158
6159                int *binaryValue = malloc (sizeof(int)*(n_bitValue+1));
6160                binaryValue = DecBinConverter (CEXPath[seqNumber].inputVar[i].varValue, (n_bitValue+1), binaryValue);
6161
6162//           (void) fprintf(vis_stderr, "---- Decimal Value = %d ==> Binary Value = ", CEXPath[seqNumber].inputVar[i].varValue);
6163//          for (k=0; k < n_bitValue+1; k++){
6164//              (void) fprintf(vis_stderr, "%d ", binaryValue[n_bitValue-k]);
6165//          }
6166
6167                for (k=0; k<(n_bitValue+1); k++){
6168
6169                   newClause = array_alloc(int,1);
6170                  // if varValue = 1 => cnfIndex; if varValue = 0 => -cnfIndex
6171//                (void) fprintf(vis_stderr, "CNF Index = %d : Value = %d \n", cnfIndex[k], binaryValue[k]);
6172//                 if (binaryValue[k] == 0) array_insert(int,newClause,0,-cnfIndex[k]);
6173//                 else array_insert(int, newClause, 0, cnfIndex[k]);
6174
6175// NOTE: MSB is on lowest bit encoding
6176//                (void) fprintf(vis_stderr, "CNF Index = %d : Value = %d \n", cnfIndex[k], binaryValue[n_bitValue-k]);
6177                   if (binaryValue[n_bitValue-k] == 0) array_insert(int,newClause,0,-cnfIndex[k]);
6178                   else array_insert(int, newClause, 0, cnfIndex[k]);
6179                   BmcCnfInsertClause(cnfClauses, newClause);
6180                   array_free(newClause);
6181                }
6182                free (binaryValue);
6183 //             (void) fprintf(vis_stderr, "![WARNING] Variable is coded in more than one bit. This case is not yet treated. <n_bitValue = %d> \n", n_bitValue);
6184
6185            }
6186            else{
6187                if (n_bitValue == 0){
6188                   newClause = array_alloc(int,1);
6189                  // if varValue = 1 => cnfIndex; if varValue = 0 => -cnfIndex
6190                   if (CEXPath[seqNumber].inputVar[i].varValue == 0) array_insert(int,newClause,0,-cnfIndex[0]);
6191                   else array_insert(int, newClause, 0, cnfIndex[0]);
6192                   BmcCnfInsertClause(cnfClauses, newClause);
6193                   array_free(newClause);
6194                }
6195                else { // n_bitValue = -1 or <0
6196                   (void) fprintf(vis_stderr, "![WARNING] Variable CNF index not found. Verification required. \n", CEXPath[seqNumber].outputVar[i].varName, seqNumber);
6197                }
6198            }
6199        }
6200        else {
6201        (void) fprintf(vis_stderr, "![WARNING] Too many CNF index found for %s at state %d! Verification required.. counter j exceeded security constraint (j < SIZE_1 = 100). \n" );
6202        }
6203
6204
6205   }
6206   else{
6207/*      (void) fprintf(vis_stderr, "\n CEXPath[%d].outputVar[%d].varIndex = %d \n", seqNumber, i, CEXPath[seqNumber].outputVar[i].varIndex);
6208        (void) fprintf(vis_stderr, " CEXPath[%d].outputVar[%d].varId = %d \n", seqNumber, i, CEXPath[seqNumber].outputVar[i].varId);
6209        (void) fprintf(vis_stderr, " CEXPath[%d].outputVar[%d].varValue = %d \n", seqNumber, i, CEXPath[seqNumber].outputVar[i].varValue);
6210        (void) fprintf(vis_stderr, " CEXPath[%d].outputVar[%d].varName = %s \n", seqNumber, i, CEXPath[seqNumber].outputVar[i].varName);
6211        (void) fprintf(vis_stderr, " CEXPath[%d].outputVar[%d].symbolicValue = %s \n", seqNumber, i, CEXPath[seqNumber].outputVar[i].symbolicValue);
6212*/
6213
6214//--- CNF: insertion of cnf clauses related to Counter Example output at each state
6215//      if (i>0){ // to exclude the states in CNF 
6216
6217        do{
6218            tempCNFString = CNFVariableNameConstructor(CEXPath[seqNumber].outputVar[i].varName, j, seqNumber);
6219        //int findIndex(BmcCnfClauses_t* cnfClauses , char * nodeName)
6220        //propIndex = findIndex(cnfClauses, tempCNFString);
6221            lookUpResult = st_lookup(cnfClauses->cnfIndexTable, tempCNFString, &cnfIndex[j]);
6222 //         (void) fprintf(vis_stderr, "[SeqNumber: %d][i: %d][j: %d] tempCNFString = %s; lookUpResult = %d; cnfIndex = %d;\n", seqNumber, i, j, tempCNFString, lookUpResult, cnfIndex);
6223           if (lookUpResult == 0) {
6224              indexFound = FALSE;
6225           }
6226           else {
6227              indexFound = TRUE;
6228              (void) fprintf(vis_stderr, " [CNF Index Search] Variable bit name = %s => CNF Index = %d \n", tempCNFString, cnfIndex[j]);
6229              j++;
6230           }
6231        }while ((indexFound == TRUE)&&(j<SIZE_1));
6232
6233        if ((indexFound == FALSE)&&(j<SIZE_1)){
6234            n_bitValue = j-1;
6235//          (void) fprintf(vis_stderr, " [Counter] n_bitValue = %d ::: j = %d. \n", n_bitValue, j);
6236            if (n_bitValue > 0){
6237                // Value decomposition en binary. Then affectation of the value of each bit of the variable in CNF format for each index of the variable
6238
6239                int *binaryValue = malloc (sizeof(int)*(n_bitValue+1));
6240                binaryValue = DecBinConverter (CEXPath[seqNumber].outputVar[i].varValue, (n_bitValue+1), binaryValue);
6241
6242//          (void) fprintf(vis_stderr, "####### Decimal Value = %d ==> Binary Value = ", CEXPath[seqNumber].outputVar[i].varValue);
6243//          for (k=0; k<(n_bitValue+1); k++){
6244//              (void) fprintf(vis_stderr, "%d ", binaryValue[n_bitValue-k]);
6245//          }
6246//              (void) fprintf(vis_stderr, "\n");
6247
6248                for (k=0; k<(n_bitValue+1); k++){
6249//              for (k=(n_bitValue); k>=0; k--){
6250                   newClause = array_alloc(int,1);
6251                  // if varValue = 1 => cnfIndex; if varValue = 0 => -cnfIndex
6252//                (void) fprintf(vis_stderr, "CNF Index = %d : Value = %d \n", cnfIndex[k], binaryValue[k]);
6253//                 if (binaryValue[k] == 0) array_insert(int,newClause,0,-cnfIndex[k]);
6254//                 else array_insert(int, newClause, 0, cnfIndex[k]);
6255// NOTE: MSB is on lowest bit encoding
6256//                (void) fprintf(vis_stderr, "CNF Index = %d : Value = %d \n", cnfIndex[k], binaryValue[n_bitValue-k]);
6257                   if (binaryValue[n_bitValue-k] == 0) array_insert(int,newClause,0,-cnfIndex[k]);
6258                   else array_insert(int, newClause, 0, cnfIndex[k]);
6259                   BmcCnfInsertClause(cnfClauses, newClause);
6260                   array_free(newClause);
6261                   
6262                }
6263                free (binaryValue);
6264 //             (void) fprintf(vis_stderr, "![WARNING] Variable is coded in more than one bit. This case is not yet treated. <n_bitValue = %d> \n", n_bitValue);
6265
6266            }
6267            else{
6268                if (n_bitValue == 0){
6269                   newClause = array_alloc(int,1);
6270                  // if varValue = 1 => cnfIndex; if varValue = 0 => -cnfIndex
6271                   if (CEXPath[seqNumber].outputVar[i].varValue == 0) array_insert(int,newClause,0,-cnfIndex[0]);
6272                   else array_insert(int, newClause, 0, cnfIndex[0]);
6273                   BmcCnfInsertClause(cnfClauses, newClause);
6274                   array_free(newClause);
6275                }
6276                else { // n_bitValue = -1 or <0
6277                   (void) fprintf(vis_stderr, "![WARNING] Variable CNF index not found. Verification required. \n", CEXPath[seqNumber].outputVar[i].varName, seqNumber);
6278                }
6279            }
6280        }
6281        else {
6282        (void) fprintf(vis_stderr, "![WARNING] Too many CNF index found for %s at state %d! Verification required.. counter j exceeded security constraint (j < SIZE_1 = 100). \n" );
6283        }
6284//      }
6285    }
6286  }
6287
6288  return mintermString;
6289}
6290
6291
6292
6293/**Function********************************************************************
6294
6295  Synopsis [Convert a minterm to an array of integers]
6296
6297  SideEffects []
6298
6299******************************************************************************/
6300static array_t *
6301McConvertMintermToValueArrayMine(
6302  mdd_t *aMinterm,
6303  array_t *aSupport,
6304  mdd_manager *mddMgr)
6305{
6306  (void) fprintf(vis_stderr, "![McConvertMintermToValueArrayMine] \n");
6307  array_t *resultValueArray;
6308
6309  /* this will be performed only in v0s-g executables */
6310  assert( MintermCheckWellFormed( aMinterm, aSupport, mddMgr ));
6311
6312  resultValueArray = array_alloc( int, 0 );
6313  {
6314    int i;
6315    for( i = 0 ; i < array_n( aSupport ); i++ ) {
6316      int aSupportVar = array_fetch( int, aSupport, i );
6317      int j;
6318      for( j = 0 ; TRUE ; j++) {
6319
6320        mdd_t *faceMdd, *tmpMdd;
6321        array_t *tmpArray = array_alloc( int, 0 );
6322
6323        array_insert_last( int, tmpArray, j );
6324        faceMdd = mdd_literal( mddMgr, aSupportVar, tmpArray );
6325        array_free( tmpArray );
6326
6327        tmpMdd = mdd_and( faceMdd, aMinterm, 1, 1 );
6328        mdd_free( faceMdd );
6329        if ( !mdd_is_tautology( tmpMdd, 0 ) ) {
6330          mdd_free( tmpMdd );
6331          array_insert_last( int, resultValueArray, j );
6332          break;
6333        }
6334        mdd_free( tmpMdd );
6335      }
6336    }
6337  }
6338
6339  return resultValueArray;
6340}
6341
6342/**Function********************************************************************
6343
6344  Synopsis [Print message saying given state passes formula.]
6345
6346  SideEffects []
6347
6348******************************************************************************/
6349static void
6350McStatePassesFormulaMine(
6351  mdd_t *aState,
6352  Ctlp_Formula_t *formula,
6353  McDbgLevel debugLevel,
6354 Fsm_Fsm_t *modelFsm)
6355{
6356  McStatePassesOrFailsFormulaMine( aState, formula, 1, debugLevel,  modelFsm );
6357}
6358
6359
6360/**Function********************************************************************
6361
6362  Synopsis [Print message saying given state fails formula.]
6363
6364  SideEffects []
6365
6366******************************************************************************/
6367static void
6368McStateFailsFormulaMine(
6369  mdd_t *aState,
6370  Ctlp_Formula_t *formula,
6371  McDbgLevel debugLevel,
6372  Fsm_Fsm_t *modelFsm)
6373{
6374  McStatePassesOrFailsFormulaMine( aState, formula, 0,  debugLevel, modelFsm );
6375}
6376
6377
6378/**Function********************************************************************
6379
6380  Synopsis [Utility function - prints state passes or fails formula]
6381
6382  SideEffects []
6383
6384******************************************************************************/
6385static void
6386McStatePassesOrFailsFormulaMine (
6387  mdd_t *aState,
6388  Ctlp_Formula_t *formula,
6389  int pass,
6390  McDbgLevel debugLevel,
6391  Fsm_Fsm_t *modelFsm)
6392{
6393
6394  (void) fprintf(vis_stderr, "![McStatePassesOrFailsFormulaMine] \n");
6395  array_t *PSVars = Fsm_FsmReadPresentStateVars( modelFsm );
6396  char *formulaText = Ctlp_FormulaConvertToString( formula );
6397  Ntk_Network_t *modelNetwork = Fsm_FsmReadNetwork( modelFsm );
6398
6399  /* Nodes created in converting formulae like AU may not have text
6400   * attached to them. */
6401  if (formulaText == NIL(char))
6402    return;
6403
6404  fprintf( vis_stdout, "--State\n");
6405  Mc_MintermPrintMine( aState, PSVars, modelNetwork );
6406  if ( pass )
6407    fprintf( vis_stdout, "passes ");
6408  else
6409    fprintf( vis_stdout, "fails ");
6410
6411  if( debugLevel > McDbgLevelMin_c)
6412    fprintf(vis_stdout, "%s.\n\n", formulaText);
6413  else
6414    fprintf(vis_stdout, "\n\n");
6415
6416  FREE(formulaText);
6417}
6418
6419
6420/**Function********************************************************************
6421
6422  Synopsis [Compare two strings in the from of char **]
6423
6424  SideEffects []
6425
6426******************************************************************************/
6427static int
6428cmp(
6429  const void * s1,
6430  const void * s2)
6431{
6432  return(strcmp(*(char **)s1, *(char **)s2));
6433}
6434
6435
6436
6437/**Function********************************************************************
6438
6439  Synopsis [Test that given mdd is a minterm.]
6440
6441  SideEffects []
6442
6443******************************************************************************/
6444static boolean
6445MintermCheckWellFormed(
6446  mdd_t *aMinterm,
6447  array_t *aSupport,
6448  mdd_manager *mddMgr)
6449{
6450
6451  /* first check its support */
6452  if (!SetCheckSupport(aMinterm, aSupport, mddMgr)) {
6453    return FALSE;
6454  }
6455
6456  /* now check its a minterm */
6457  {
6458    float cardinality = mdd_count_onset( mddMgr, aMinterm, aSupport );
6459    if ( cardinality != 1 ) {
6460      fprintf( vis_stderr, "-- onset is not one\n");
6461      return FALSE;
6462    }
6463  }
6464  return TRUE;
6465}
6466
6467
6468/**Function********************************************************************
6469
6470  Synopsis [Test that given mdd is a minterm.]
6471
6472  SideEffects []
6473
6474******************************************************************************/
6475static boolean
6476SetCheckSupport(
6477  mdd_t *aMinterm,
6478  array_t *aSupport,
6479  mdd_manager *mddMgr)
6480{
6481  if (!mdd_check_support(mddMgr, aMinterm, aSupport)) {
6482    fprintf(vis_stderr,
6483      "** mc error: support of minterm is not contained in claimed support\n");
6484    return FALSE;
6485  }
6486  return TRUE;
6487}
6488
6489
6490/**Function********************************************************************
6491
6492  Synopsis [CNF Clause generator - variable name contruction]
6493
6494  SideEffects []
6495
6496******************************************************************************/
6497static char *CNFVariableNameConstructor(char *varName, int varEncoding, int pathIndex)
6498{
6499  char tempStr [LENGTH_1];
6500  char *cnfVarName;
6501  int nChar; 
6502
6503      nChar = sprintf(tempStr, "%s_%d_%d", varName, varEncoding, pathIndex); // value sign has to be added later
6504      cnfVarName = tempStr;
6505      //(void) fprintf(vis_stderr, "[TEST] CNF Variable Name : %s [number of characters = %d] >> return : %s\n", tempStr, nChar, cnfVarName);
6506
6507  return cnfVarName;
6508}
6509
6510/**Function********************************************************************
6511
6512  Synopsis [
6513               c = a <-> b = (a=0)*(b=0) + (a=1)*(b=1) ....
6514           For a given term (a=i)*(b=i), if either is Zero,  don't generate
6515                                         clauses for this term.
6516                                         if both are One, don't generate clauses
6517                                         for c.
6518  ]
6519
6520  SideEffects []
6521
6522******************************************************************************/
6523static void
6524BmcGenerateClausesFromStateTostateMine(
6525   bAig_Manager_t  *manager,
6526   bAigEdge_t      *fromAigArray,
6527   bAigEdge_t      *toAigArray,
6528   int             mvfSize, 
6529   int             fromState,
6530   int             toState,
6531   BmcCnfClauses_t *cnfClauses,
6532   int             outIndex) 
6533{
6534  array_t    *clause, *tmpclause;
6535  int        toIndex, fromIndex, cnfIndex;
6536  int        i;
6537
6538  /* used to turn off the warning messages: might be left uninitialized.
6539     We are sure that these two variables will not be used uninitialized.
6540  */
6541  toIndex =0;
6542  fromIndex = 0;
6543 
6544  for(i=0; i< mvfSize; i++){
6545    if ((fromAigArray[i] == bAig_One) && (toAigArray[i] == bAig_One)){
6546      return;   /* the clause is always true */
6547    }
6548  }
6549  clause  = array_alloc(int, 0);
6550  for(i=0; i< mvfSize; i++){
6551    if ((fromAigArray[i] != bAig_Zero) && (toAigArray[i] != bAig_Zero)){
6552      if (toAigArray[i] != bAig_One){ 
6553         /* to State */
6554
6555         toIndex = BmcGenerateCnfFormulaForAigFunction(manager,toAigArray[i],
6556                                                       toState,cnfClauses);
6557      }
6558      if (fromAigArray[i] != bAig_One){ 
6559         /* from State */
6560         fromIndex = BmcGenerateCnfFormulaForAigFunction(manager,
6561                                                         fromAigArray[i],
6562                                                         fromState,
6563                                                         cnfClauses);
6564      }
6565     /*
6566      Create new var for the output of this node. We don't create variable for this node, we only
6567      use its index number.
6568     */
6569     cnfIndex = cnfClauses->cnfGlobalIndex++;  /* index of the output of the OR of T(from, to) */
6570     
6571     assert(abs(cnfIndex) <= cnfClauses->cnfGlobalIndex);
6572     assert(abs(fromIndex) <= cnfClauses->cnfGlobalIndex);
6573     assert(abs(toIndex) <= cnfClauses->cnfGlobalIndex);
6574     
6575     if (toAigArray[i] == bAig_One){       
6576       tmpclause  = array_alloc(int, 2);
6577       array_insert(int, tmpclause, 0, -fromIndex);
6578       array_insert(int, tmpclause, 1, cnfIndex);
6579       BmcCnfInsertClause(cnfClauses, tmpclause);
6580       array_free(tmpclause); 
6581
6582       tmpclause  = array_alloc(int, 2);
6583       array_insert(int, tmpclause, 0, fromIndex);
6584       array_insert(int, tmpclause, 1, -cnfIndex);
6585       BmcCnfInsertClause(cnfClauses, tmpclause);
6586       array_free(tmpclause);       
6587
6588     } else if (fromAigArray[i] == bAig_One){
6589       tmpclause  = array_alloc(int, 2);
6590       array_insert(int, tmpclause, 0, -toIndex);
6591       array_insert(int, tmpclause, 1, cnfIndex);
6592       BmcCnfInsertClause(cnfClauses, tmpclause);
6593       array_free(tmpclause);
6594
6595       tmpclause  = array_alloc(int, 2);
6596       array_insert(int, tmpclause, 0, toIndex);
6597       array_insert(int, tmpclause, 1, -cnfIndex);
6598       BmcCnfInsertClause(cnfClauses, tmpclause);
6599       array_free(tmpclause);
6600       
6601     } else {
6602       tmpclause  = array_alloc(int, 3);
6603       array_insert(int, tmpclause, 0, -toIndex);
6604       array_insert(int, tmpclause, 1, -fromIndex);
6605       array_insert(int, tmpclause, 2,  cnfIndex);
6606       BmcCnfInsertClause(cnfClauses, tmpclause);
6607       array_free(tmpclause);
6608
6609       tmpclause  = array_alloc(int, 2);
6610       array_insert(int, tmpclause, 0, toIndex);
6611       array_insert(int, tmpclause, 1, -cnfIndex);
6612       BmcCnfInsertClause(cnfClauses, tmpclause);
6613       array_free(tmpclause);
6614
6615       tmpclause  = array_alloc(int, 2);
6616       array_insert(int, tmpclause, 0, fromIndex);
6617       array_insert(int, tmpclause, 1, -cnfIndex);
6618       BmcCnfInsertClause(cnfClauses, tmpclause);
6619       array_free(tmpclause);
6620     }
6621     array_insert_last(int, clause, cnfIndex);
6622    } /* if */
6623//      (void) fprintf(vis_stderr, "[CNF] (%d) > To : %d; From : %d; cnfIndex : %d \n", i, toIndex, fromIndex, cnfIndex);
6624  } /* for i loop */
6625  if (outIndex != 0 ){
6626    array_insert_last(int, clause, -outIndex);
6627  }
6628  BmcCnfInsertClause(cnfClauses, clause);
6629  array_free(clause);
6630 
6631  return;
6632}
6633
6634
6635/**Function********************************************************************
6636
6637  Synopsis    [Generate CNF formula for a path from state 'from' to state 'to']
6638
6639  Description [Unfold the transition relation 'k' states (k = to-from +1), and
6640  generate clauses for each state.
6641 
6642           For a multi-valued latch of 4 vlaues. Two binary variables are used
6643           to rpresent X, x1 and x0. For this latch, there exist three multi-valued
6644           functions.
6645           One for the binary reoresentation of the variable. For example the
6646           second entry of the mvf = 1, iff ~x1 and x0.
6647           The second mfv is for the data input of the latch. If the And/Inv graph
6648           attached to an entry of this mvf equal to 1, X equal to the binary
6649           representation corresponding to this entry. For example, if the And/
6650           INV graph attached to the first entry =1, then X = ~x1 & ~x0.
6651           To generate the CNF to the transition relation, first generate CNF to
6652           next state varaible using mvf of the latch.  Then, generate CNF for
6653           latch data input using current state variavles. Finaly, generate CNF
6654           for the AND of these two MVF.  This for every entry of the MVF. Then
6655           OR the results.
6656           The third MVF is for the initial value of the latch.  It is treat the
6657           same as the latch data input except if the initial value is constant.
6658   
6659  The initialState value may be either BMC_INITIAL_STATES to generate the clause for the intial states.
6660  BMC_NO_INITIAL_STATES otherwise.
6661  ]
6662
6663  SideEffects []
6664
6665  SeeAlso     []
6666
6667******************************************************************************/
6668static void
6669BmcCnfGenerateClausesForPathMine(
6670   Ntk_Network_t   *network,
6671   int             from,
6672   int             to,
6673   int             initialState,
6674   BmcCnfClauses_t *cnfClauses,
6675   st_table        *nodeToMvfAigTable,
6676   st_table        *CoiTable)
6677{
6678  mAig_Manager_t  *manager   = Ntk_NetworkReadMAigManager(network);
6679  st_generator    *stGen;
6680 
6681  Ntk_Node_t         *latch, *latchData, *latchInit;
6682  MvfAig_Function_t  *initMvfAig, *dataMvfAig, *latchMvfAig;
6683  bAigEdge_t         *initBAig, *latchBAig, *dataBAig;
6684 
6685  int        i, k, mvfSize;
6686
6687  st_foreach_item(CoiTable, stGen, &latch, NULL) {
6688   
6689 
6690   latchInit  = Ntk_LatchReadInitialInput(latch);
6691   latchData  = Ntk_LatchReadDataInput(latch);
6692
6693   /* Get the multi-valued function for each node*/
6694   initMvfAig = Bmc_ReadMvfAig(latchInit, nodeToMvfAigTable);
6695   if (initMvfAig ==  NIL(MvfAig_Function_t)){
6696     (void) fprintf(vis_stderr, "No multi-valued function for this node %s \n", Ntk_NodeReadName(latchInit));
6697     return;
6698   } 
6699   dataMvfAig = Bmc_ReadMvfAig(latchData, nodeToMvfAigTable);
6700   if (dataMvfAig ==  NIL(MvfAig_Function_t)){
6701     (void) fprintf(vis_stderr, "No multi-valued function for this node %s \n", Ntk_NodeReadName(latchData));
6702     return;
6703   }
6704   latchMvfAig = Bmc_ReadMvfAig(latch, nodeToMvfAigTable);
6705   if (latchMvfAig ==  NIL(MvfAig_Function_t)){
6706     latchMvfAig = Bmc_NodeBuildMVF(network, latch);
6707     array_free(latchMvfAig);
6708     latchMvfAig = Bmc_ReadMvfAig(latch, nodeToMvfAigTable);
6709   }
6710     
6711   mvfSize   = array_n(initMvfAig);
6712   initBAig  = ALLOC(bAigEdge_t, mvfSize);
6713   dataBAig  = ALLOC(bAigEdge_t, mvfSize);
6714   latchBAig = ALLOC(bAigEdge_t, mvfSize);   
6715
6716   for(i=0; i< mvfSize; i++){
6717     dataBAig[i]  = bAig_GetCanonical(manager, MvfAig_FunctionReadComponent(dataMvfAig,  i));
6718     latchBAig[i] = bAig_GetCanonical(manager, MvfAig_FunctionReadComponent(latchMvfAig, i));
6719     initBAig[i]  = bAig_GetCanonical(manager, MvfAig_FunctionReadComponent(initMvfAig,  i));
6720   }
6721   /*
6722   if (from == 0){
6723   */
6724   if (initialState == BMC_INITIAL_STATES){
6725   /* Generate the CNF for the initial state of the latch */
6726     BmcGenerateClausesFromStateTostateMine(manager, initBAig, latchBAig, mvfSize, -1, 0, cnfClauses, 0);
6727   }
6728   /* Generate the CNF for the transition functions */   
6729   for (k=from; k < to; k++){
6730     BmcGenerateClausesFromStateTostateMine(manager, dataBAig, latchBAig, mvfSize, k, k+1, cnfClauses, 0);
6731   } /* for k state loop */
6732
6733   FREE(initBAig);
6734   FREE(dataBAig);
6735   FREE(latchBAig);
6736  }/* For each latch loop*/
6737 
6738  return;
6739}
6740
6741
6742
6743/**Function********************************************************************
6744
6745  Synopsis [Write the set of clauses in diamacs format to the output file.]
6746
6747  SideEffects []
6748
6749******************************************************************************/
6750static void
6751BmcWriteClausesMine(
6752   mAig_Manager_t  *maigManager,
6753   FILE            *cnfFile,
6754   BmcCnfClauses_t *cnfClauses,
6755   BmcOption_t     *options)
6756{
6757  st_generator *stGen;
6758  char         *name;
6759  int          cnfIndex, i, k;
6760
6761  if (options->verbosityLevel == BmcVerbosityMax_c) {     
6762    fprintf(vis_stderr,
6763            "\n--- [CNF] Number of Variables = %d Number of Clauses = %d\n",
6764            cnfClauses->cnfGlobalIndex-1,  cnfClauses->noOfClauses);
6765  }
6766  st_foreach_item_int(cnfClauses->cnfIndexTable, stGen, &name, &cnfIndex) {
6767    fprintf(cnfFile, "c %s %d\n",name, cnfIndex);
6768  }
6769  (void) fprintf(cnfFile, "p cnf %d %d\n", cnfClauses->cnfGlobalIndex-1,
6770                 cnfClauses->noOfClauses);
6771  if (cnfClauses->clauseArray != NIL(array_t)) {
6772    for (i = 0; i < cnfClauses->nextIndex; i++) {
6773      k = array_fetch(int, cnfClauses->clauseArray, i);
6774      (void) fprintf(cnfFile, "%d%c", k, (k == 0) ? '\n' : ' ');
6775    }
6776  }
6777  return;
6778}
6779
6780
6781/**Function********************************************************************
6782
6783  Synopsis [Decimal value to binary converter - Done by Me]
6784
6785  SideEffects []
6786
6787******************************************************************************/
6788
6789static int *DecBinConverter (int decValue, int size, int *binValue){
6790
6791 int i;
6792// int tempVal;
6793// int *binValue = malloc (sizeof(int)*size);
6794 
6795// tempVal = decValue;
6796 for (i=0; i<size; i++){
6797//   (void) fprintf(vis_stderr, " ***** tempVal = %d \n", tempVal);
6798   binValue[i] = decValue & 1;
6799   decValue = decValue >> 1;
6800 } 
6801
6802 return binValue;
6803}
6804
6805
6806/**Function********************************************************************
6807
6808  Synopsis []   
6809
6810  Description [- Done by Cecile Braunstein]
6811   
6812  SideEffects []
6813
6814  SeeAlso     []
6815
6816******************************************************************************/
6817static void printSATAssig( array_t* result)
6818{
6819        int k;
6820        printf("RESULT : \n");
6821        for(k=0; k< array_n(result); k++){
6822                printf("%d\n",array_fetch(int, result, k));
6823        }
6824}
6825
6826/**Function********************************************************************
6827
6828  Synopsis []   
6829
6830  Description [- Done by Cecile Braunstein]
6831   
6832  SideEffects []
6833
6834  SeeAlso     []
6835
6836******************************************************************************/
6837static int findIndex(BmcCnfClauses_t* cnfClauses , char * nodeName)
6838{       
6839        int index;
6840
6841         st_lookup(cnfClauses->cnfIndexTable,nodeName,&index);
6842        return index;
6843
6844}
6845
6846
6847/**Function********************************************************************
6848
6849  Synopsis []   
6850
6851  Description [- Done by Cecile Braunstein]
6852   
6853  SideEffects []
6854
6855  SeeAlso     []
6856
6857******************************************************************************/
6858static st_table * generateAllLatches(Ntk_Network_t * ntk)
6859{
6860    st_table        *CoiTable = st_init_table(st_ptrcmp, st_ptrhash);
6861        lsGen           gen ;
6862        Ntk_Node_t              *node;
6863
6864        Ntk_NetworkForEachNode(ntk,gen, node){
6865                if (Ntk_NodeTestIsLatch(node)){
6866                        st_insert(CoiTable, (char *) node, (char *) 0);
6867                }
6868        }
6869        return CoiTable;
6870}
6871
6872
6873/**Function********************************************************************
6874
6875  Synopsis []   
6876
6877  Description [- Done by Cecile Braunstein]
6878   
6879  SideEffects []
6880
6881  SeeAlso     []
6882
6883******************************************************************************/
6884static void build_unroll_circuit(Ntk_Network_t * ntk, int bound, BmcOption_t * options,BmcCnfClauses_t* cnfClauses)
6885{
6886  (void) fprintf(vis_stderr, "\n*** Generating CNF clauses for current network. *** \n");
6887
6888    st_table    *CoiTable =  generateAllLatches(ntk);
6889    lsGen       gen ;
6890    Ntk_Node_t  *node;
6891
6892
6893       
6894        Ntk_NetworkForEachNode(ntk,gen, node){
6895                if (Ntk_NodeTestIsLatch(node)){
6896                        st_insert(CoiTable, (char *) node, (char *) 0);
6897                }
6898        }
6899
6900         options->verbosityLevel = BmcVerbosityMax_c;
6901         options->satSolver = CirCUs;
6902         options->timeOutPeriod = 0;
6903         options->printInputs = TRUE;
6904         options->minK = bound;
6905         options->maxK = bound;
6906         options->step = bound;
6907         options->dbgLevel = 1;
6908
6909     //nodeToMvfAigTable Maps each node to its Multi-function And/Inv graph
6910     st_table* nodeToMvfAigTable = (st_table *) Ntk_NetworkReadApplInfo(ntk, MVFAIG_NETWORK_APPL_KEY);
6911     assert(nodeToMvfAigTable != NIL(st_table));
6912
6913     // Create clauses database
6914        int initState = BMC_INITIAL_STATES;
6915        BmcCnfGenerateClausesForPathMine(ntk, 0, bound, initState, cnfClauses, nodeToMvfAigTable, CoiTable);
6916
6917}
6918
6919
6920/**Function********************************************************************
6921
6922  Synopsis [SAT Solver CNF File generator - Done by Cecile Braunstein]
6923
6924  Description [ OBSOLETE!!! ]
6925
6926  SideEffects []
6927
6928******************************************************************************/
6929
6930static int SATSolverFileGen (Hrc_Manager_t ** hmgr, char *fileName, int steps, BmcOption_t *options)
6931{
6932
6933  (void) fprintf(vis_stderr, "\n*** Generating CNF File for SAT Solver. *** \n");
6934 
6935//   BmcOption_t *options =  BmcOptionAlloc();
6936   BmcCnfClauses_t   *cnfClauses = NIL(BmcCnfClauses_t);
6937   cnfClauses = BmcCnfClausesAlloc();
6938   Ntk_Network_t * ntk = Ntk_HrcManagerReadCurrentNetwork(*hmgr);
6939   build_unroll_circuit(ntk,steps,options,cnfClauses);
6940
6941   int propIndex;
6942   int newIndex;
6943   array_t * newClause;
6944   char *tempCNFString;
6945
6946   tempCNFString = CNFVariableNameConstructor("o2", 0, 0);
6947   propIndex = findIndex(cnfClauses, tempCNFString);
6948   newClause = array_alloc(int,1);
6949   array_insert(int,newClause,0,-propIndex);
6950   BmcCnfInsertClause(cnfClauses, newClause);
6951   array_free(newClause);
6952
6953   tempCNFString = CNFVariableNameConstructor("o2", 0, 1);
6954   propIndex = findIndex(cnfClauses, tempCNFString);
6955   newClause = array_alloc(int,1);
6956   array_insert(int,newClause,0,-propIndex);
6957   BmcCnfInsertClause(cnfClauses, newClause);
6958   array_free(newClause);
6959
6960   tempCNFString = CNFVariableNameConstructor("o2", 0, 2);
6961   propIndex = findIndex(cnfClauses, tempCNFString);
6962   newClause = array_alloc(int,1);
6963   array_insert(int,newClause,0, -propIndex);
6964   BmcCnfInsertClause(cnfClauses, newClause);
6965   array_free(newClause);
6966
6967   tempCNFString = CNFVariableNameConstructor("o2", 0, 3);
6968   propIndex = findIndex(cnfClauses, tempCNFString);
6969   newClause = array_alloc(int,1);
6970   array_insert(int,newClause,0, propIndex);
6971   BmcCnfInsertClause(cnfClauses, newClause);
6972   array_free(newClause);
6973
6974
6975   FILE   *cnfFile = fopen(fileName,"w");
6976   mAig_Manager_t * maigManager = Ntk_NetworkReadMAigManager(ntk);
6977   BmcWriteClausesMine(maigManager, cnfFile, cnfClauses, options);
6978   fclose(cnfFile);
6979
6980 return 0;
6981}
6982
6983
6984/**Function********************************************************************
6985
6986  Synopsis [- Done by Cecile Braunstein]   
6987
6988  Description []
6989   
6990  SideEffects []
6991
6992  SeeAlso     []
6993
6994******************************************************************************/
6995
6996static array_t * checkSATCircus( satManager_t *cm,BmcOption_t * options, boolean unsatcore, satArray_t *clauseIndexInCore)
6997{
6998
6999  satOption_t  *satOption;
7000  array_t      *result = NIL(array_t);
7001  int          maxSize;
7002
7003  satOption = sat_InitOption();
7004  satOption->verbose = options->verbosityLevel;
7005  //satOption->unsatCoreFileName = "Ucore.txt";
7006  satOption->clauseDeletionHeuristic = 0;
7007  satOption->coreGeneration = unsatcore;
7008  satOption->minimizeConflictClause = 1;
7009
7010  cm->comment = ALLOC(char, 2);
7011  cm->comment[0] = ' ';
7012  cm->comment[1] = '\0';
7013  cm->stdOut = stdout;
7014  cm->stdErr = stderr;
7015
7016  cm->option = satOption;
7017  cm->each = sat_InitStatistics();
7018
7019  cm->unitLits = sat_ArrayAlloc(16);
7020  cm->pureLits = sat_ArrayAlloc(16);
7021
7022  maxSize = 10000 << (bAigNodeSize-4);
7023  cm->nodesArray = ALLOC(bAigEdge_t, maxSize);
7024  cm->maxNodesArraySize = maxSize;
7025  cm->nodesArraySize = bAigNodeSize;
7026
7027  sat_AllocLiteralsDB(cm);
7028       
7029  sat_ReadCNF(cm, options->satInFile);
7030  sat_Main(cm);
7031   if(cm->status == SAT_UNSAT) {
7032    if (options->verbosityLevel != BmcVerbosityNone_c){
7033      (void) fprintf(vis_stderr, "# UNSAT\n");
7034          }
7035          if(unsatcore)
7036          {
7037                clauseIndexInCore =  cm->clauseIndexInCore;
7038          }
7039    fflush(cm->stdOut);
7040
7041        }else if(cm->status == SAT_SAT) {
7042    if (options->verbosityLevel != BmcVerbosityNone_c){
7043      (void) fprintf(vis_stderr, "# SAT\n");
7044    }
7045    fflush(cm->stdOut);
7046    result = array_alloc(int, 0);
7047    {
7048      int i, size, value;
7049     
7050      size = cm->initNumVariables * bAigNodeSize;
7051      for(i=bAigNodeSize; i<=size; i+=bAigNodeSize) {
7052                value = SATvalue(i);
7053                if(value == 1) {
7054                        array_insert_last(int, result, SATnodeID(i));
7055                }
7056                else if(value == 0) {
7057                        array_insert_last(int, result, -(SATnodeID(i)));
7058                }
7059      }
7060    }
7061  }
7062  return result;
7063}
7064
7065
7066/**Function********************************************************************
7067
7068  Synopsis [SAT Solver - Done by Cecile Braunstein]
7069
7070  SideEffects []
7071
7072******************************************************************************/
7073
7074static int SATSolver (int steps, BmcOption_t *options)
7075{
7076
7077   (void) fprintf(vis_stderr, "*** SAT Solver begins. *** \n");
7078
7079  // Read another design and build new clauses
7080   satManager_t *cm;
7081   cm = sat_InitManager(0);
7082   array_t      * result = NIL(array_t);
7083   satArray_t   * coreArray= sat_ArrayAlloc(1024);
7084   result = checkSATCircus(cm,options,steps,coreArray);
7085
7086 return 0;
7087}
7088
7089
7090
7091
Note: See TracBrowser for help on using the repository browser.