Description of Functions - User and Developer Information
         ---------------------------------------------------------
 
In this section, each of the functions of the FSM library are described
in detail.  Each of these functions can be executed via the commandline driven program decada.  Each function can be run by passing the associated character to decada.  If only one command is passed to decada the default files in the data directory are used for input and output to the function.  Default input files have the extension data.  Default output files have the extension results.  For example, to run the minimization function using default files the command for running decada is:
decada b
This runs the minimization function using default input file min.data and default output file min.results.

To run the minimization function using specified files the command for running decada is:
decada b minFSM.x minresults.y
This runs the minimization function using default input file minFSM.x and default output file minresults.y.

Most of the functions can also be run from the FSM Analyzer GUI by selecting them from the Applications menu.  The GUI allows for either using default filenames or user specified files.


Augmentation:
------------
Default Input Files:  aug.data, aug_events.data
Default Output File:  aug.results

aug.results contains the aug.data FSM augmented with events listed in aug_events.data.
aug_events.data only contains the list of events (without controllability or masking info).


Underlying function: void AugmentFsm(FILE *fp, FSM *fsm_pr)
Modified Parameters: FSM *fsm_pr
Temporary Files Used: fsm.tmp
Source: Augmentation.h, augment.c

Augments a finite state machine.  This operation is typically carried out before using the library's synchronous composition routine fsm_sync_comp.  When an FSM is augmented, unshared events from the FSM with which it is going to be composed, are added as self loops at every state in the FSM.
fp is the pointer to a file containing the set of events that the FSM will be augmented with.
fsm_pr is the FSM to be augmented.

AugmentFsm Implementation Details:
 
The function AugmentFsm is used prior to doing a synchronous composition of
two finite state machines P and Q.  This is performed so as to implement
synchronous composition by strict synchronous composition between
augmented P and Q.
If Sigma_P denotes the event set of P and Sigma_Q denotes the event
set of Q, then P is augmented with the events belonging to the set
Sigma_Q - Sigma_P, i.e the state machine P is augmented with the events
belonging to Sigma_Q but not the events belonging to Sigma_P.
These events are inserted as self loops at every state in P.


Complement:
----------
Default Input File :  comp.data
Default Output File:  comp.results
 
comp.results contains the complement of comp.data FSM.


Underlying function: void fsm_complement(FSM *fsm_ptr)
Modified Parameters: FSM *fsm_ptr
Source: Complement.h, fsm_operators.c

Complements a given state machine.  fsm_ptr is the input FSM to be complemented.


Concatenate:
-----------
Default Input Files:  conc1.data, conc2.data
Default Output File:  conc.results
 
conc.results contains the resultant FSM of concatenating conc1.data FSM and conc2.data FSM.


Underlying function: void fsm_concatenate(FSM *fsm1_ptr, FSM *fsm2_ptr,FSM *fsm3_ptr)
Modified Parameters: FSM *fsm3_ptr
Source: Concatenation.h, fsm_operators.c
 
This function generates a state machine which is the concatenation
of the two input FSMs.  fsm1_ptr and fsm2_ptr are pointers to the
input FSMs.
fsm3_ptr is a pointer to the output FSM.

Controllability Check:
---------------------
Default Input Files :  control.data, (control.data_events)
Default Output File:  control.results
 
control.data contains the FSM to be checked.
control.data_events contains the controllability information (masking info is ignored) of control.data FSM.
Filename control.data_events is obtained automatically by concatenating "_events" to the first input filename. 
control.data_events is to be created before running this function through "Cont/Mask Info Table" in the GUI. Do not specify this event file as one of the input files.
This function checks whether the FSM specified in control.data is controllable or not.
control.results contains either "Controllable" or "Not Controllable".


Underlying function: int ControlCheck(FSM *fsm_ptr, FILE *fp)
Modified Parameters: integer return
Temporary Files Used: clist0.tmp
Source: ControlCheck.h, control.c

Performs a control check on a given state machine.
fsm_ptr is the pointer to the FSM under consideration. 
fp contains the controllability information of all events in the FSM.  This file is generated from the input "_events" file before ControlCheck is called.
Returns TRUE if input FSM is controllable, or FALSE otherwise.

It is recommended to use ControlCheck in order to synthesize controllers.
 
ControlCheck Implementation Details:
 
This is a lower level function that checks if a system satisfies
controllability constraints.
If Sigma_u represents the set of uncontrollable events, then H subseteq
L(G) is said to be controllable with respect to system G, if any
uncontrollable event takes the state machine G | S, where S is a
generator for pr(H), to a state with a second co-ordinate a DUMP state,
in which case that state is marked ``bad".  The system is uncontrollable in
that case.  The aim of this function is to determine all such
uncontrollable states and mark them as bad, so that they can be eliminated
eventually during the course of controller synthesis.

Convert Non-DFSM to DFSM:
------------------------
Default Input File :  ndfsm_to_dfsm.data
Default Output File:  ndfsm_to_dfsm.results

ndfsm_to_dfsm.results contains the deterministic realization of non-deterministic FSM described in ndfsm_to_dfsm.data


Underlying function: void fsm_deterministic(FSM *fsm1_ptr,FSM *fsm2_ptr)
Modified Parameters: fsm2_ptr
Source: NDFSMtoDFSM, fsm_operators.c

This function is used to convert a non-deterministic machine to a
deterministic one.
fsm1_ptr is a pointer to the input non-deterministic FSM.
fsm2_ptr is a pointer to the output deterministic FSM.

Diagnosability Check Under Partial Observation:
---------------------------------------------
Default Input Files:  diagnosability_plant.data, diagnosability_spec.data, (diagnosability_plant.data_events)
Default Output File:  diagnosability.results
 
diagnosability_plant.data is the plant FSM.
diagnosability_spec.data is the specification FSM.
Filename diagnosability_plant.data_events is obtained automatically by concatenating "_events" to the first input filename. 
diagnosability_plant.data_events contains the masking information (controllability info is ignored) of diagnosability_plant.data.
diagnosability_plant.data_events is to be created before running this function through "Cont/Mask Info Table" in the GUI. Do not specify this event file as one of the input files.

Determines whether FSM of plant diagnosability_plant.data is diagnosable under specification diagnosability_spec.data with controllability information in diagnosability_plant.data_events.
diagnosability.results contains either "Diagnosable" or "Not Diagnosable".


Underlying function: int po_diagnosability(FSM *fsmIn)
Modified Parameters: FSM *fsmIn, integer return
Temporary Files Used: mmlistfiles.tmp, mlist*.tmp
Source: Diagnosability.h, partialobs.c

fsmIn is a pointer to an FSM that has been created using the specification and masking information before the function is called.  This FSM is modified in the process of determining diagnosability.
Returns TRUE if input FSM is diagnosable, or FALSE otherwise.


Graph Completion:
----------------
Default Input Files:  completion.data, completion_events.data
Default Output File:  completion.results

completion.results contains completion of completion.data FSM with list of events in completion_events.data
The completion operation makes sure each state contains the specified events specified in completion_events.data. If there is no transition from a state in the FSM on some event, there will be a transition added to the "dump" state.


Underlying function: void CompleteGraph(FILE *fp, FSM *fsm_in, FSM *fsm_out)
Modified Parameters: FSM *fsm_out
Temporary Files Used: tmp.out
Source: Completion.h, graph.c

Completes the graph of a finite state machine.
fp is a pointer to the file containing the event set of the machine whose graph is to be completed.
fsm_in is a pointer to an FSM structure to be completed.
fsm_out is a pointer to a FSM structure where the state machine of the completed graph is stored.
 
CompleteGraph Implementation Details:
 
A complete graph of a state machine G denoted G is obtained by
completing the transition function of G.  A new state called
the ``dump" state is added to the state machine G and all the undefined
transitions at each state in G are added to indicate a transition from that
state to the dump state so the language of G equals Sigma^*.
The program reads in the file containing the set of events defined in G and
then adds a transition whenever it is undefined at any state from that state
to the dump state.
The dump state itself has all the transitions in G defined as a transition
retaining the state machine at the dump state itself.  For obtaining a FSM
accepting the complement of language accepted by G all the states other than
the dump state are unmarked while the dump state is marked.


Masking:
------
Default Input Files:  mask.data, (mask.data_events)
Default Output File:  mask.results

mask.data is the FSM to be masked.
mask.data_events contains the masking information (controllability info is ignored) of mask.data.
Filename mask.data_events is obtained automatically by concatenating "_events" to the first input filename.
mask.data_events is to be created before running this function through "Cont/Mask Info Table" in the GUI. Do not specify this event file as one of the input files.

Underlying function: void fsm_mask(FILE *fp, FSM *fsm1_ptr, FSM* fsm2_ptr)
Modified Parameters: FSM* fsm2_ptr
Temporary Files Used: mlist0.data
Source: Mask.h, fsm_general.c
 
Masks a state machine.
fp is a pointer to the input file containing the masking information.  This file is created from mask.data_events before calling the function.
fsm1_ptr is a pointer to the FSM to be masked.
fsm2_ptr is a pointer to the resulting masked FSM.


Minimization:
------------
Default Input File :  min.data
Default Output File:  min.results

min.results contains the minimal realization of min.data FSM


Underlying function: int fsm_minimize(FSM *fsm_ptr)
Modified Parameters: FSM *fsm_ptr, integer return
Minimization.h, fsm_operators.c
 
Minimizes a state machine.
fsm_ptr is a pointer to the machine to be minimized.
fsm_ptr also contains the result minimal machine.
Returns integer 1 if the input machine was itself minimal, 0 otherwise.

Multiple File (Non-Strict) Synchronous Composition:
--------------------------------------------------
Default Input File: mfile_sync.data
Default Output File: mfile_sync.results

mfile_sync.data contains a list of FSM files to do synchronous composition between.
mfile_sync.results contains synchronous composition of all FSM files listed in mfile_sync.data


Underlying Functions: multiplefile_complete_fsm_sync_comp(FILE*, FSM*)

This function constructs a state machine which is the synchronous composition of two or more 
   given state machines. The resultant state machine accepts the language which is
   the intersection of the languages accepted by the input state machines.

   The first argument is file pointer to the file containing the input names files for the
   sync comp operation.
   The second argument is file pointer to the file containing the resultant fsm after the 
   sync comp operation.


Non-Strict Synchronous Composition:
-----------------------------------
Default Input Files:  e1.data, e2.data
Default Output File:  complete_sc.results
 
complete_sc.results contains the non-strict synchronous composition of 
e1.data FSM and e2.data FSM.

Non-strict synchronous is obtained by performing the following:
e1.data FSM is augmented with events only in e2.data FSM;
e2.data FSM is augmented with events only in e1.data FSM;
Strict synchronous composition of the two FSMs is then performed.


Underlying function: void complete_fsm_sync_comp(FSM *fsm1_ptr, FSM *fsm2_ptr, FSM *fsm3_ptr);
Modified Parameters: FSM *fsm3_ptr
Source: CompSynchComp.h, fsm_operators.c

Constructs a state machine which is the non-strict synchronous composition of two given state machines fsm1_ptr and fsm2_ptr.  The resultant state machine fsm3_ptr accepts the language which is the intersection of the languages accepted by the two input state machines.


Normality Check Under Partial Observation:
-----------------------------------------
Default Input Files:  normality_plant.data, normality_spec.data, (normality_plant.data_events)
Default Output File:  normality.results
 
normality_plant.data is the plant FSM.
normality_spec.data is the specification FSM.
Filename normality_plant.data_events is obtained automatically by concatenating "_events" to the first input filename.
normality_plant.data_events contains the masking information (controllability info is ignored) of normality_plant.data.
normality_plant.data_events is to be created before running this function through "Cont/Mask Info Table" in the GUI. Do not specify this event file as one of the input files.
This function determines whether FSM of plant po_plant.data is normal under specification 

Determines whether FSM of plant normality_plant.data is normal under specification normality_spec.data with masking information in normality_plant.data_events.
normality.results contains either "Normal" or "Not Normal".


Underlying function: int po_normality(FSM *fsmR, MULT_MASKL *mmaskL)
Modified Parameters: FSM *fsmR, integer return
Temporary Files Used: mmlistfiles.tmp, mlist*.tmp
Source: Normality.h, partialobs.c
 
NormalityCheck Implementation Details:
 
This function determines if  desired behavior given as FSM S is normal with
respect to a plant G.
The plant G is composed with the completion of supervisor S to obtain
a new machine called S1.
S2 is obtained by adding a self loop on every unobservable transition at
each state and also an epsilon transition is added for every unobservable
transition from one state to another state.
Now S1 is composed with S2 and if any of the reachable states in the
resultant state machine is unmarked, then the plant is deemed normal.


Observability Check Under Partial Observation:
---------------------------------------------
Default Input Files: observability_plant.data, observability_spec.data, (observability_plant.data_events)
Default Output File: observability.results

observability_plant.data is the plant FSM.
observability_spec.data is the specification FSM.
observability_plant.data_events contains the masking information (controllability info is ignored) of observability_plant.data.
Filename observability_plant.data_events is obtained automatically by concatenating "_events" to the first input filename. 
observability_plant.data_events is to be created before running this function through "Cont/Mask Info Table" in the GUI. Do not specify this event file as one of the input files.

Determines observability of plant observability_plant.data under specification observability_spec.data masking information in observability_plant.data_events.
observability.results contains either "Observable" or "Not Observable".


Underlying function: int po_observability(FSM *fsmR)
Modified Parameters: FSM *fsmR, integer return
Temporary Files Used: mmlistfiles.tmp, mlist*.tmp
Source: Observability.h, partialobs.c

fsmR is a pointer to an FSM that has been created using the specification and masking information before the function is called.  This FSM is modified in the process of determining observability.
Returns TRUE if input FSM is observable, or FALSE otherwise


Quotient:
--------
Default Input Files:  quo1.data, quo2.data
Default Output File:  quo.results

quo.results contains the resulting FSM of quotient operation between quo1.data FSM and quo2.data FSM.
Quotient operation removes quo2.data FSM suffix from quo1.data FSM.


Underlying function: void fsm_quotient(FSM *fsm1_ptr,FSM *fsm2_ptr,FSM *fsm3_ptr)
Modified Parameters: FSM *fsm3_ptr
Source: Quotient.h, fsm_operators.c

Generates the quotient of the two input state
machines fsm1_ptr and fsm2_ptr.
fsm3_ptr is a pointer to the FSM result.


Reachability:
-----------
Default Input File :  reach.data
Default Output File:  reach.results

reach.results contains number of states and state names reachable from initial state described in reach.data FSM


Underlying function: int fsm_reachability(FSM*, char*, char*, NAME_LIST**)
 
The function to compute the reach of a given state takes four
arguments.  The first is a pointer to the FSM under consideration.
The next argument is the name of the state whose reach is to be
computed.  The third argument is either ALL if all transitions
are to be considered or the name of a single transition which is to be
considered for the reachability computation. The last argument is
used to return the names of the reachable states.  The function
returns an integer corresponding to the number of reachable states.

Remove Epsilon Transition:
--------------------------
Default Input File :  epsilon.data
Default Output File:  epsilon.results

epsilon.results contains resulting FSM after removing epsilon transitions from epsilon.data FSM


Underlying function: void fsm_remove_epsilon(FSM *fsm1_ptr,FSM *fsm2_ptr)
Modified Parameters: FSM *fsm2_ptr
Source: RemoveEp.h, fsm_operators.c
 
Removes epsilon transitions from a
state machine.  
fsm1_ptr is a pointer to the input FSM
fsm2_ptr is a pointer to the output FSM.
Note: epsilon-transitions are denoted by the character '*'.


Rename:
------
Default Input File :  rename.data
Default Output File:  rename.results
 
rename.results contains the rename.data FSM with its states renamed.
The states are named in sequence with the following character strings:
"a00", "a01", ..., "a99", "b00", ..., "z00", ..., "z99".

Useful when the names of states of a FSM get too large or
awkward to read. The function can generate up to 2600 unique names.
The function takes one argument which is a pointer to the machine whose
states are to be renamed.


Underlying function: void fsm_rename(FSM *fsm_ptr)
Modified Parameters: fsm_ptr
Source: Rename.h, fsm_general.c

Renames all the states of a FSM.
fsm_ptr is a pointer to an FSM to be renamed.


Shuffle Product:
---------------
Default Input Files:  shuff_prod1.data, shuff_prod2.data
Default Output File:  shuff_prod.results

shuff_prod.results contains the resultant FSM of shuffle product of shuff_prod1.data FSM and shuff_prod2.data FSM.
Shuffle products returns the language resulting from operating two FSMs unsynchronously.

 
Underlying function: void fsm_shuffle(FSM *fsm1_ptr,FSM *fsm2_ptr,FSM *fsm3_ptr)
Modified Parameters: 
Source: ShuffleProduct.h, fsm_operators.c

Generates the shuffle product of two input FSMs fsm1_ptr and fsm2_ptr.
fsm3_ptr is a pointer to the resultant FSM.


Supremal Controllable Sublanguage:
---------------------------------
Default Input Files:  supcon_plant.data, supcon_spec.data, (supcon_plant.data_events)
Default Output File:  supcon.results

supcon_plant.data corresponds to the plant FSM.
supcon_spec.data is the specification FSM file.
supcon_plant.data_events contains the controllability info of the plant FSM (masking info provided is ignored). 
supcon_plant.data_events is obtained automatically by concatenating "_events" to the first input filename. 
supcon_plant.data_events is to be created before running this function through "Cont/Mask Info Table" in the GUI. Do not specify this event file as one of the input files.
supcon.results is the supremal controllable sublanguage of plant supcon_plant.data FSM and spec supcon_spec.data FSM using controllability information in supcon_plant.data_events file.
 

Underlying function: void fsm_sup_con_sublang(FSM *fsmL,FSM *fsmK,FSM *fsmLK, FILE *fpuncevents)
Modified Parameters: FSM *fsm3_ptr
Temporary Files Used: clist0.tmp, tmplist.out, tmpfsm.out
Source: SupremalContSubLang.h, fsm_operators.c
 
This function is used to compute the supremal controllable sublanguage of a language K with respect to another
language L.  The first argument is a pointer to the machine representing L, the second a pointer to the machine
representing K while the third argument is a pointer to the structure in which the result is to be returned.
fpuncevents is a file with list of uncontrollable events that is generated before the function call.

Supremal Normal & Controllable Sublanguage:
-------------------------------------------
Default Input Files:  supconnorm_plant.data, supconnorm_spec.data, (supconnorm_plant.data_events)
Default Output File:  supconnorm.results

supconnorm_plant.data contains the plant FSM.
supconnorm_spec.data is the specification FSM file.
sunconnorm_plant.data_events contains the controllability and masking info of the plant FSM.
supconnorm_plant.data_events is obtained automatically by concatenating "_events" to the first input filename. 
supcon_plant.data_events is to be created before running this function through "Cont/Mask Info Table" in the GUI. Do not specify this event file as one of the input files.
supconnorm.results is the supremal controllable normal sublanguage of plant supconnorm_plant.data FSM and spec supconnorm_spec.data FSM using controllability and masking information in supconnorm_plant.data_events file.


Underlying function: void fsm_sup_cont_norm_sublang(FILE* fpmaskinfo,FILE* fpuncevents, FSM* fsmG, FSM* fsmH, FSM* fsmResult)
Modified Parameters: FSM* fsmResult
Temporary Files Used: mlist0.tmp, clist0.tmp, trlist.tmp
Source: SupConNorm.h, fsm_operators.c

Generates the supremal controllable and normal sublanguage of the language G (supconnorm_plant.data ) with respect to another language H (supconnorm_spec.data), mask M (fpmaskinfo), and controllability info C (fpuncevents).

fpmaskinfo is a file pointer containing information about the mask M.  Generated from supconnorm_plant.data_events before calling this function.
fpuncevents is file pointer containing information about the controllability info C  Generated from supconnorm_plant.data_events before calling this function.
fsmG is a pointer to the state machine which is a generator for G.
fsmH is a pointer to the state machine which is a generator for H.
fsmResult is a pointer to the resultant state machine


Strict Synchronous Composition:
------------------------------
Default Input Files:  strict_synch_comp1.data, strict_synch_comp2.data
Default Output File:  strict_synch_comp.results
 
strict_synch_comp.results contains the strict synchronous composition of strict_synch_comp1.data FSM and strict_synch_comp2.data FSM.


Underlying function: void fsm_sync_comp(FSM *fsm1_ptr,FSM *fsm2_ptr,FSM *fsm3_ptr)
Modified Parameters: FSM *fsm3_ptr
Source: StrictSynchComp.h, fsm_operators.c

Generates the synchronous composition of two input FSMs fsm1_ptr and fsm2_ptr.
fsm3_ptr is a pointer to the resultant FSM.


Trim:
----
Default Input File :  trim.data
Default Output File:  trim.results
 
trim.results contains the trimmed FSM described in trim.data
The trim operation removes all states that do not lead to a final state and all states that are not reachable from the initial state.


Underlying function: void fsm_trim(FSM *fsm_ptr)
Modified Parameters: fsm_ptr
Source: Trim.h, fsm_general.c

Trims a state machine.  
fsm_ptr is a pointer to the FSM that is to be trimmed.
The trimmed machine is returned via fsm_ptr.

UnMasking:
---------
Default Input Files:  unmask.data, (unmask.data_events)
Default Output File:  unmask.results

unmask.data_events contains the masking information (controllability info is ignored) of unmask.data.
unmask.data_events is obtained automatically by concatenating "_events" to the first input filename. 
unmask.data_events is to be created before running this function through "Cont/Mask Info Table" in the GUI. Do not specify this event file as one of the input files.
 
Underlying function: void fsm_unmask(FILE *fp, FSM *fsm1_ptr,FSM *fsm2_ptr)
Modified Parameters: FSM *fsm2_ptr
Temporary Files Used: mlist0.tmp
Source: UnMask.h, fsm_general.c


Unmasks a state machine i.e. does the inverse of the mask function.
fp is a pointer to the input file containing the masking information.  fp is generated from unmask.data_events before calling this function.
fsm1_ptr is a pointer to the machine to be unmasked.
fsm2_ptr is a pointer to the resultant unmasked FSM.

Union:
-----
Default Input Files:  union1.data, union2.data
Default Output File:  union.results
 
union.results contains the union of union1.data FSM and union2.data FSM.


Underlying function: void fsm_union(FSM *fsm1_ptr,FSM *fsm2_ptr,FSM *fsm3_ptr)
Modified Parameters: FSM *fsm3_ptr
Source: Union.h fsm_operators.c

Generates the union of two FSMs fsm1_ptr and fsm2_ptr.
fsm3_ptr is a pointer to the resultant machine.
	

                  Data Structures – Developer Information
                  ---------------------------------------
 
The following data structures are defined in fsm.h.
 
Transition information:
-----------------
The structure used to store information corresponding to the transitions of a state is shown below:
 
struct _trlist {
	char		*input;   
	struct _stlist  *next_state; 
	struct _trlist  *next;  
};

typedef struct _trlist TR_LIST;
 
input stores the name of the event triggering the transition. 
next_state is a pointer to the state to which this transition leads to.
All of the transitions allowed from a particular state are stored together in the
form of a linked list. next is a pointer to the next transition in this list.
 
State information:
-------------
 
The structure used to store information corresponding to the states of an FSM is shown below:
 
struct _stlist {
	char		*name;
	enum MRKD	marked;
	TR_LIST		*trans;
	struct _stlist  *next;
};

typedef struct _stlist ST_LIST;

name stores the name of the state.
marked determines whether this state is a final state
or not.  The MRKD enumeration is declared as enum MRKD {UNMKD, MKD};
trans is a pointer to the linked list of transitions allowed from this state
All of the states in an FSM are stored together in the form of a linked list.
next is a pointer to the next state in this list.

FSM information:
-------------
 
Currently the structure FSM show below is composed of just the ST_LIST linked list.
 
struct _fsm {
	ST_LIST		*states;
};

typedef struct _fsm FSM;
 
If future extensions of the library require more information pertaining to the FSM additional fields can be defined in the FSM structure.
 
Structure for storing names:
---------------------
Structure NAME_LIST shown below is used to create a linked list of character strings.  This could be names of states or names of transitions.  Currently it is only used by the reachability function. ???translist in fsmoperators is similar.
  
The structure used for this is shown below:
 
struct _namelist {
	char 		   name[MAX_LENGTH];
	struct _namelist   *next;
};

typedef struct _namelist NAME_LIST;
 
name is a character array used to store the name of the
state.  MAX_LENGTH is defined in the file fsm.h and refers to the maximum length of strings to be used in the program.  
next is a pointer to the next structure in this linked list.

Structures for Controllability and Masking information
------------------------------------------------------

The following structures are usually populated from information contained in the controllability/masking (_events) file.

MASK_LIST structure shown below is used for containing mask information for one supervisor. 

struct _masklist {
	char			original[MAX_LENGTH];
	char			masked[MAX_LENGTH];
	struct _masklist 	*next;
};

typedef struct _masklist MASK_LIST;

original stores the name of the event.
masked stores the name of the event as observed by the supervisor.
next is a pointer to the next structure in this linked list.
Through this linked list you can traverse through all of the events and determine their masked value.

MULT_MASKL structure shown below is used for containing mask information for multiple supervisors.

struct mult_masklists{
	MASK_LIST *masklist;
	struct mult_masklists *next;
};

typedef struct mult_masklists MULT_MASKL;

masklist is a pointer to a MASK_LIST structure.
next is a pointer to the next structure in this linked list.
Through this linked list you can traverse through all of the supervisors and determine their masking information.

CONT_LIST structure shown below is used for containing controllability information for one supervisor.

struct _contlist {
	char	event[MAX_LENGTH];
	enum TYPE type;
	struct _contlist	*next;
};

typedef struct _contlist CONT_LIST;

event stores the name of the event.
TYPE signifies if the event is controllable or uncontrollable for this supervisor.  The TYPE enumeration is declared as enum TYPE {UNCONT, CONT};
next is a pointer to the next structure in this linked list.
Through this linked list you can traverse through all of the events and determine their controllability value.

MULT_CONTL structure shown below is used for containing controllability information for multiple supervisors.

struct mult_contlists{
	CONT_LIST *contlist;
	struct mult_contlists *next;
};

typedef struct mult_contlists MULT_CONTL;

contlist is a pointer to a CONT_LIST structure.
next is a pointer to the next structure in this linked list.
Through this linked list you can traverse through all of the supervisors and determine their controllability information.
				