be_ptr 
Be_And(
  Be_Manager_ptr  manager, 
  be_ptr  left, 
  be_ptr  right 
)
Builds a new be which is the conjunction between its two arguments


Be_Cnf_ptr 
Be_ConvertToCnf(
  Be_Manager_ptr  manager, 
  be_ptr  f 
)
Since it creates a new Be_Cnf structure, the caller is responsible for deleting it when it is no longer used (via Be_Cnf_Delete)

See Also Be_Cnf_Delete

void 
Be_DumpDavinci(
  Be_Manager_ptr  manager, 
  be_ptr  f, 
  FILE* outFile 
)
Dumps the given be into a file with Davinci format


void 
Be_DumpGdl(
  Be_Manager_ptr  manager, 
  be_ptr  f, 
  FILE* outFile 
)
Dumps the given be into a file with Davinci format


void 
Be_DumpSexpr(
  Be_Manager_ptr  manager, 
  be_ptr  f, 
  FILE* outFile 
)
Dumps the given be into a file


be_ptr 
Be_Falsity(
  Be_Manager_ptr  manager 
)
Builds a 'false' constant value


be_ptr 
Be_Iff(
  Be_Manager_ptr  manager, 
  be_ptr  left, 
  be_ptr  right 
)
Builds a new be which is the logical equivalence between its two arguments


be_ptr 
Be_Implies(
  Be_Manager_ptr  manager, 
  be_ptr  arg1, 
  be_ptr  arg2 
)
Builds a new be which is the implication between its two arguments


be_ptr 
Be_Index2Var(
  Be_Manager_ptr  manager, 
  int  varIndex 
)
If corresponding index had not been previously allocated, it will be allocated. If corresponding node does not exist in the dag, it will be inserted.


void 
Be_Init(
    
)
Call before any other function contained in this module

Side Effects Any module structure is allocated and initialized if required

See Also Be_Quit

boolean 
Be_IsConstant(
  Be_Manager_ptr  manager, 
  be_ptr  arg 
)
Returns true if the given be is a constant value, such as either False or True


boolean 
Be_IsFalse(
  Be_Manager_ptr  manager, 
  be_ptr  arg 
)
Returns true if the given be is the false value, otherwise returns false


boolean 
Be_IsTrue(
  Be_Manager_ptr  manager, 
  be_ptr  arg 
)
Returns true if the given be is the true value, otherwise returns false


be_ptr 
Be_Ite(
  Be_Manager_ptr  manager, 
  be_ptr  c, 
  be_ptr  t, 
  be_ptr  e 
)
Builds an if-then-else operation be

Side Effects ...


void* 
Be_Manager_Be2Spec(
  const Be_Manager_ptr  self, 
  be_ptr  be 
)
Converts a generic BE into a specific-format boolean expression (for example in rbc format)

See Also Be_Manager_Spec2Be

Be_Manager_ptr 
Be_Manager_Create(
  void* spec_manager, 
  Be_Spec2Be_fun  spec2be_converter, 
  Be_Be2Spec_fun  be2spec_converter 
)
spec_manager is the specific structure which is used to manage the low-level structure. For example the RbcManager class in the RBC dependant implementation. This does not assume the ownership of 'spec_manager'. If you dynamically created the spec_manager instance, you are responsible for deleting it after you deleted the Be_manager instance. This "virtual" function is supplied in order to be called by any specific class derived from Be_Manager, in its constructor code. spec2be and be2spec converters are gateways in order to polymorphically convert the low level support structure (for example a rbc pointer) to the generic be_ptr and viceversa.

See Also Be_RbcManager_Create Be_Manager_Delete

void 
Be_Manager_Delete(
  Be_Manager_ptr  self 
)
Call this function from the destructor of the derived class that implements the Be_Manager class. Any other use is to be considered unusual.

Side Effects self will be deleted from memory.

See Also Be_RbcManager_Delete Be_Manager_Create

void* 
Be_Manager_GetData(
  const Be_Manager_ptr  self 
)
When you instantiate a derived BE manager (for example the rbc manager) you can store any useful specific data by using Be_Manager_SetData. Those data can be lately retrieved by Be_Manager_GetData which gets a generic, structure-independent Be_Manager.

See Also Be_Manager_SetData

void 
Be_Manager_SetData(
  Be_Manager_ptr  self, 
  void* data 
)
You can retieve saved data by using the method Be_Manager_GetData. This implements a kind of inheritance mechanism.

Side Effects self will change its internal state.

See Also Be_Manager_GetData

be_ptr 
Be_Manager_Spec2Be(
  const Be_Manager_ptr  self, 
  void* spec_expr 
)
Calls self->spec2be_converter in order to implement the polymorphism mechanism

Side Effects Calls self->be2spec_converter in order to implement the polymorphism mechanism

See Also Be_Manager_Be2Spec

be_ptr 
Be_Not(
  Be_Manager_ptr  manager, 
  be_ptr  left 
)
Negates its argument


be_ptr 
Be_Or(
  Be_Manager_ptr  manager, 
  be_ptr  left, 
  be_ptr  right 
)
Builds a new be which is the disjunction of its two arguments


void 
Be_PrintStats(
  Be_Manager_ptr  manager, 
  int  clustSize, 
  FILE* outFile 
)
Prints out some statistical data about the underlying rbc structure


void 
Be_Quit(
    
)
Call as soon as you finished to use this module services

Side Effects Any module structure is deleted if required

See Also Be_Init

Be_Manager_ptr 
Be_RbcManager_Create(
  const size_t  capacity 
)
You must call Be_RbcManager_Delete when the created instance is no longer used.

See Also Be_RbcManager_Delete

void 
Be_RbcManager_Delete(
  Be_Manager_ptr  self 
)
Destroys the given Be_MAnager instance you previously created by using Be_RbcManager_Create

See Also Be_RbcManager_Create

void 
Be_RbcManager_Reserve(
  Be_Manager_ptr  self, 
  const size_t  size 
)
Changes the maximum number of variables the rbc manager can handle

Side Effects The given rbc manager will possibly change


be_ptr 
Be_ShiftVar(
  Be_Manager_ptr  manager, 
  be_ptr  f, 
  int  shift 
)
Shifting operation replaces each occurence of the variable x_i in `f' with the variable x_(i + shift). A simple lazy mechanism is implemented to optimize that cases which given expression is a constant in


be_ptr 
Be_Truth(
  Be_Manager_ptr  manager 
)
Builds a 'true' constant value


int 
Be_Var2Index(
  Be_Manager_ptr  manager, 
  be_ptr  var 
)
Converts the given variable (as boolean expression) into the corresponding index


be_ptr 
Be_VarSubst(
  Be_Manager_ptr  manager, 
  be_ptr  f, 
  int* subst 
)
Replaces every occurence of the variable x_i in in `f' with the variable x_j provided that subst[i

Side Effects f will change


be_ptr 
Be_Xor(
  Be_Manager_ptr  manager, 
  be_ptr  left, 
  be_ptr  right 
)
Builds a new be which is the exclusive-disjunction of its two arguments


void 
be_shiftHashInit(
    
)
Call be_shiftHash_Quit() before quit from the be module

Side Effects Private global var htShift_ptr will change

See Also Be_ShiftVar be_shiftHash_Quit

void 
be_shiftHash_Quit(
    
)
Call be_shiftHash_Quit() before quit from BMC module

Side Effects Private global var htShift_ptr will be put to NULL

See Also Be_ShiftVar be_shiftHashInit

Last updated on 2004/06/23 11h:09