ascend4/solver/logrel.h

/*
 *  Logical Relation Module
 *  by Vicente Rico-Ramirez
 *  Created: 09/96
 *  Version: $Revision: 1.6 $
 *  Version control file: $RCSfile: logrel.h,v $
 *  Date last modified: $Date: 1997/07/29 15:47:43 $
 *  Last modified by: $Author: rv2a $
 *
 *  This file is part of the SLV solver.
 *
 *  The SLV solver is free software; you can redistribute
 *  it and/or modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of the
 *  License, or (at your option) any later version.
 *
 *  The SLV solver is distributed in hope that it will be
 *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with the program; if not, write to the Free Software Foundation,
 *  Inc., 675 Mass Ave, Cambridge, MA 02139 USA.  Check the file named
 *  COPYING.  COPYING is found in ../compiler.
 *
 */

/*
 *  Contents:     Logical Relation module (ascend)
 *
 *  Dates:        09/96 - original version
 *
 *  Description:  This is the ascend version of the logrel module.  This
 *                version should be used by any user who receives his/her
 *                equations directly from an instance tree created by the
 *                ASCEND compiler.
 */
#ifndef logrel__already_included
#define logrel__already_included

/* 
 * requires #include "/base.h"
 * requires #include "/discrete.h" 
 */

/*********************************************************************\
  logrel_relation basic type operators.
\*********************************************************************/
  
enum logrel_enum {
  e_logrel_equal,
  e_logrel_not_equal
};

/*
 * enum logrel_enum:
 * The operator of a logical relation.
 */
  
struct logrel_relation {
   SlvBackendToken instance;
   struct dis_discrete **incidence;
   int32 n_incidences;      /* length of incidence */
   int32 mindex;        /* index in the slv_system_t master list */
   int32 sindex;        /* index in the slv_system_t solver list */
   int32 model;            /* index of a hypothetical MODEL rel is from */
   uint32 flags;        /* flags */
};
/* 
 * if you mess with the above struct, change the defaults for it in .c file 
 */


extern struct logrel_relation *logrel_create(SlvBackendToken ,
                         struct logrel_relation *);
/*
 *  logrel_create(instance,newlogrel)
 *  struct logrel_relation *newlogrel;
 *  SlvBackendToken instance;
 *
 *  Creates a logrelation given the logrelation instance.
 *  If the logrel supplied is NULL, we allocate the memory for the
 *  logrel we return, else we just init the memory you hand us and
 *  return it to you.
 *  We set the fields instance, nodeinfo.
 *  Setting the rest of the information is the job
 *  of the bridge building function between the ascend instance
 *  tree (or other logrelation back end) and the slv_system_t.
 *  In particular, the incidence list and indexing info is not
 *  handled here.
 */


extern SlvBackendToken logrel_instance(struct logrel_relation *);
/*
 *  logrel_instance(logrel)
 *  struct logrel_relation *logrel;
 *
 *  Returns the instance pointer from a logrel.
 */

extern void logrel_write_name(slv_system_t,struct logrel_relation *,FILE *);
/*
 *  logrel_write_name(sys,logrel,file);
 *
 *  Writes a name to the file given. 
 *  If sys is NULL, writes full ascend name. If file or logrel is NULL
 *  does not write.
 */

extern void logrel_destroy(struct logrel_relation *);
/*
 *  logrel_destroy(logrel)
 *  struct logrel_relation *logrel;
 *
 *  Destroys a logrelation.
 */

extern boolean logrel_equal(struct logrel_relation *);
extern boolean logrel_not_equal(struct logrel_relation *);
/*
 *  eq = logrel_equal(logrel)
 *  neq = logrel_not_equal(logrel)
 *  boolean eq,neq;
 *  struct logrel_relation *logrel;
 *
 *  Returns true if the given logrelation is satisfied if the
 *  operator in question is among those that make up the
 *  comparator of the logrelation.
 *  neq==TRUE implies logrel would be satisfied if lhs != rhs
 *  eq==TRUE implies logrel would be satisfied if lhs == rhs
 */

extern enum logrel_enum logrel_relop(struct logrel_relation *);
/*
 * relop = logrel_relop(logrel);
 * logrel_enum relop;
 * struct logrel_relation *logrel;
 * Returns the type of the  operator of a given logrelation.
 */

extern char *logrel_make_name(slv_system_t,struct logrel_relation *);
/*
 *  name = logrel_make_name(sys,logrel)
 *  slv_system_t sys;
 *  struct logrel_relation *logrel;
 *  char *name;
 *
 *  Copies of the logrelation instance name can be made and returned.
 *  The string returned should be freed when no longer in use.
 */
 
extern int32 logrel_mindex(struct logrel_relation *);
extern void logrel_set_mindex(struct logrel_relation *,int32);
/*
 *  index = logrel_mindex(logrel)
 *  logrel_set_mindex(logrel,index)
 *  int32 index;
 *  struct logrel_relation *logrel;
 *
 *  Sets or retrieves the index number of the given logrelation as it
 *  appears in a slv_system_t master logrelation list.  
 */

extern int32 logrel_sindex(struct logrel_relation *);
extern void logrel_set_sindex(struct logrel_relation *,int32);
/*
 *  index = logrel_sindex(logrel)
 *  logrel_set_sindex(logrel,index)
 *  int32 index;
 *  struct logrel_relation *logrel;
 *
 *  Sets or retrieves the index number of the given logrelation as it
 *  appears in a solvers logrelation list. 
 */

extern int32 logrel_model(const struct logrel_relation *);
extern void logrel_set_model(struct logrel_relation *,int32);
/*
 *  index = logrel_model(logrel)
 *  logrel_set_model(logrel,index)
 *  int32 index;
 *  struct logrel_relation *logrel;
 *
 *  Sets or retrieves the model number of the given logrelation.
 *  Models are numbered from 1 to some upper limit.
 */

extern int32 logrel_residual(struct logrel_relation *);
extern void logrel_set_residual(struct logrel_relation *,int32);
/*
 *  residual = logrel_residual(logrel)
 *  logrel_set_residual(logrel,residual)
 *  int32 residual;
 *  struct logrel_relation *logrel;
 *
 *  Sets or retrieves the logical residual field of the given logrelation.
 *  Note that the residual is not actually computed by logrel_residual:
 *  there is no guarantee (from this function) that the residual is
 *  actually correct.
 */

extern int32 logrel_nominal(struct logrel_relation *);
/*
 *  nominal = logrel_nominal(logrel)
 *  int32 nominal;
 *  struct logrel_relation *logrel;
 *
 *  Retrieves the nominal field of the given logrelation.
 *  No slv client has any business being able to set the nominal,
 *  so no such operator is provided.
 */


#ifdef NDEBUG
#define logrel_n_incidences(lr) ((lr)->n_incidences)
#define logrel_set_incidences(lr,n,ilist) \
   (lr)->n_incidences=(n); (lr)->incidence = (ilist)
#else
#define logrel_n_incidences(lr) logrel_n_incidencesF(lr)
#define logrel_set_incidences(lr,n,ilist) \
   logrel_set_incidencesF((lr),(n),(ilist))
#endif /* NDEBUG */


extern int32 logrel_n_incidencesF(struct logrel_relation *);
extern void logrel_set_incidencesF(struct logrel_relation *,
                                   int32,struct dis_discrete **);
/*
 *  logrel_n_incidences(logrel)
 *  logrel_set_incidences(logrel,n,ilist)
 *  struct logrel_relation *logrel;
 *  struct dis_discrete **ilist;
 *  int32 n;
 *
 *  logrel_n_incidences returns the length of the incidence_list.
 *  Solver clients should not call logrel_set_incidences,
 *  it is only for use by constructors of bridges to logrelation
 *  back ends.
 */

extern const struct dis_discrete
**logrel_incidence_list(struct logrel_relation *);
extern struct dis_discrete
**logrel_incidence_list_to_modify(struct logrel_relation *);
/*
 *  bv = logrel_incidence_list(logrel)
 *  struct logrel_relation *logrel;
 *  struct dis_discrete **bv;
 *
 *  Returns a pointer to an array logrel_n_incidences(logrel) long of bvars.
 *  Each element of the array is a struct dis_discrete *.
 *  If there is no incidence, NULL is returned.
 *  Pointers in this array will be unique. 
 *  The list belongs to the logrelation. Do not destroy it. 
 *  Do not change it.
 *
 *  BV IS NOT a NULL-TERMINATED LIST.
 */

/*
 * logrelation filtration functions.
 * We coulhave 32 binary (one bit) flags a client may want to query
 * in arbitrary combinations and paying attention to only certain of
 * the bits. We will provide a set of macros and functions for each of
 * these bits and for operations on the whole set.
 */

typedef struct logrel_filter_structure {
  uint32 matchbits;
  uint32 matchvalue;
} logrel_filter_t;

extern int logrel_apply_filter(struct logrel_relation *,logrel_filter_t *);
/*
 *  value = logrel_apply_filter(logrel,filter)
 *  int value;
 *  struct logrel_relation *logrel;
 *  logrel_filter_t *filter;
 *
 *  Returns 1 only if all of the positions specified in
 *  filter->matchbits have the same values in
 *  filter->matchvalue and the logrelation's flags value.
 *  Bits set to 0 in filter->matchbits are ignored for the test.
 */
  
extern uint32 logrel_flags(struct logrel_relation *);
extern void logrel_set_flags(struct logrel_relation *,uint32);
/*
 *  struct logrel_relation *logrel;
 *  uint32 flags;
 *
 * logrel_flags(logrel) returns the flags field of the logrelation.
 * logrel_set_flags(logrel,flags) sets the entire flag field to the
 * value of flags given.
 */

extern uint32 logrel_flagbit(struct logrel_relation *,uint32);
/* 
 *  logrel_flagbit(logrel,name);
 *  struct logrel_relation *logrel;
 *  uint32 name;        
 *  name should be a LOGREL_xx flag defined above)
 *  Returns the value of the bit specified from the logrelation flags.
 */

extern void logrel_set_flagbit(struct logrel_relation *,uint32, uint32);
/*
 *  struct logrel_relation *logrel;
 *  unsigned int NAME,oneorzero;
 *  logrel_set_flagbit(logrel,NAME,oneorzero)
 *
 *  Sets the bit, which should be referred to by its macro name,
 *  on if oneorzero is >0 and off is oneorzero is 0.
 *  The macro names are the defined up at the top of this file.
 *
 *  Example: logrel_set_flags(logrel,LOGREL_INCLUDED,1) turns on the
 *  LOGREL_INCLUDED bit.
 *  What it really does is:
 *  if (oneorzero) {
 *    logrel->flags |= field;
 *  } else {
 *    logrel->flags &= ~field;
 *  }
 *  In unix, see also man 3f bit or man not.
 */

/* 
 * the bit flags. explained afterward. several are for use of
 * transient clients and should be ignored by solver engines 
 */
#define LOGREL_INCLUDED 0x1
/* 
 * INCLUDED is as yet a funny one. treat it as readonly because
 * you can only change it using a int function and not the
 * bit manipulation functions. It is here in the bits because
 * it is useful in filters sometimes.
 */
#define LOGREL_SATISFIED 0x2
#define LOGREL_EQUALITY 0x4
/* Conditional Modeling */
#define LOGREL_INWHEN      0x8
#define LOGREL_ACTIVE      0x10 
/* Conditional LogRelations (Boundaries) */
#define LOGREL_CONDITIONAL 0x20 
#define LOGREL_IN_BLOCK 0x40 
/*
 * LOGREL_INCLUDED  solvers, ui clients. user wants eqn in problem.
 *              bit should be treated as readonly. use logrel_set_*
 *              to change.
 * LOGREL_SATISFIED  has logrel been pronounced satisfied by someone?
 *           bit should be treated as readonly. use logrel_set_*
 *           to change.
 * LOGREL_EQUALITY  is logrelation an equality? readonly for clients.
 * LOGREL_INWHEN    is logrelation in a when? readonly for clients.
 * LOGREL_ACTIVE        is this logrelation currently a part of my problem?
 * LOGREL_CONDITIONAL   is logrelation conditional? readonly for clients.
 * LOGREL_IN_BLOCK      is the logrelation in the current block of registered
 *              client? for clients.
 */

/* 
 * the bit flag lookups 
 */
#ifdef NDEBUG
#define logrel_satisfied(lr)     ((lr)->flags & LOGREL_SATISFIED)
#define logrel_equality(lr)      ((lr)->flags & LOGREL_EQUALITY)
#define logrel_in_when(lr)   ((lr)->flags & LOGREL_INWHEN)
#define logrel_active(lr)    ((lr)->flags & LOGREL_ACTIVE)
#define logrel_conditional(lr)   ((lr)->flags & LOGREL_CONDITIONAL)
#define logrel_in_block(lr)      ((lr)->flags & LOGREL_IN_BLOCK)
#else
#define logrel_satisfied(lr)     logrel_flagbit((lr),LOGREL_SATISFIED)
#define logrel_equality(lr)      logrel_flagbit((lr),LOGREL_EQUALITY)
#define logrel_in_when(lr)   logrel_flagbit((lr),LOGREL_INWHEN)
#define logrel_active(lr)    logrel_flagbit((lr),LOGREL_ACTIVE)
#define logrel_conditional(lr)   logrel_flagbit((lr),LOGREL_CONDITIONAL)
#define logrel_in_bolck(lr)      logrel_flagbit((lr),LOGREL_IN_BLOCK)
#endif /* NDEBUG */

/* 
 * bit flag assignments. any value other than 0 for bv turns the
 * named flag to 1. 0 sets it to 0.
 */
#define logrel_set_satisfied(lr,bv)   \
        logrel_set_flagbit((lr),LOGREL_SATISFIED,(bv))
#define logrel_set_equality(lr,bv)    \
        logrel_set_flagbit((lr),LOGREL_EQUALITY,(bv))
#define logrel_set_in_when(lr,bv)   \
        logrel_set_flagbit((lr),LOGREL_INWHEN,(bv))
#define logrel_set_active(lr,bv)   \
        logrel_set_flagbit((lr),LOGREL_ACTIVE,(bv))
#define logrel_set_conditional(lr,bv)    \
        logrel_set_flagbit((lr),LOGREL_CONDITIONAL,(bv))
#define logrel_set_in_block(lr,bv)    \
        logrel_set_flagbit((lr),LOGREL_IN_BLOCK,(bv))

extern uint32 logrel_included(struct logrel_relation *);
extern void logrel_set_included(struct logrel_relation *,uint32);
/*
 *  included = logrel_included(logrel)
 *  logrel_set_included(logrel,included)
 *  uint32 included;
 *  struct logrel_relation *logrel;
 *
 *  Sets or retrieves the included field of the given logrelation.
 *  This has side effect on the ascend instance, so it isn't
 *  implemented with the rest of the macros above. This needs to
 *  change.
 */

#endif  /* logrel_already_included  */
1	/*
2	* Logical Relation Module
3	* by Vicente Rico-Ramirez
4	* Created: 09/96
5	* Version: $Revision: 1.6 $
6	* Version control file: $RCSfile: logrel.h,v $
7	* Date last modified: $Date: 1997/07/29 15:47:43 $
8	* Last modified by: $Author: rv2a $
9	*
10	* This file is part of the SLV solver.
11	*
12	* The SLV solver is free software; you can redistribute
13	* it and/or modify it under the terms of the GNU General Public License as
14	* published by the Free Software Foundation; either version 2 of the
15	* License, or (at your option) any later version.
16	*
17	* The SLV solver is distributed in hope that it will be
18	* useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with the program; if not, write to the Free Software Foundation,
24	* Inc., 675 Mass Ave, Cambridge, MA 02139 USA. Check the file named
25	* COPYING. COPYING is found in ../compiler.
26	*
27	*/
28
29	/*
30	* Contents: Logical Relation module (ascend)
31	*
32	* Dates: 09/96 - original version
33	*
34	* Description: This is the ascend version of the logrel module. This
35	* version should be used by any user who receives his/her
36	* equations directly from an instance tree created by the
37	* ASCEND compiler.
38	*/
39	#ifndef logrel__already_included
40	#define logrel__already_included
41
42	/*
43	* requires #include "/base.h"
44	* requires #include "/discrete.h"
45	*/
46
47	/*********************************************************************\
48	logrel_relation basic type operators.
49	\*********************************************************************/
50
51	enum logrel_enum {
52	e_logrel_equal,
53	e_logrel_not_equal
54	};
55
56	/*
57	* enum logrel_enum:
58	* The operator of a logical relation.
59	*/
60
61	struct logrel_relation {
62	SlvBackendToken instance;
63	struct dis_discrete **incidence;
64	int32 n_incidences; /* length of incidence */
65	int32 mindex; /* index in the slv_system_t master list */
66	int32 sindex; /* index in the slv_system_t solver list */
67	int32 model; /* index of a hypothetical MODEL rel is from */
68	uint32 flags; /* flags */
69	};
70	/*
71	* if you mess with the above struct, change the defaults for it in .c file
72	*/
73
74
75	extern struct logrel_relation *logrel_create(SlvBackendToken ,
76	struct logrel_relation *);
77	/*
78	* logrel_create(instance,newlogrel)
79	* struct logrel_relation *newlogrel;
80	* SlvBackendToken instance;
81	*
82	* Creates a logrelation given the logrelation instance.
83	* If the logrel supplied is NULL, we allocate the memory for the
84	* logrel we return, else we just init the memory you hand us and
85	* return it to you.
86	* We set the fields instance, nodeinfo.
87	* Setting the rest of the information is the job
88	* of the bridge building function between the ascend instance
89	* tree (or other logrelation back end) and the slv_system_t.
90	* In particular, the incidence list and indexing info is not
91	* handled here.
92	*/
93
94
95	extern SlvBackendToken logrel_instance(struct logrel_relation *);
96	/*
97	* logrel_instance(logrel)
98	* struct logrel_relation *logrel;
99	*
100	* Returns the instance pointer from a logrel.
101	*/
102
103	extern void logrel_write_name(slv_system_t,struct logrel_relation ,FILE );
104	/*
105	* logrel_write_name(sys,logrel,file);
106	*
107	* Writes a name to the file given.
108	* If sys is NULL, writes full ascend name. If file or logrel is NULL
109	* does not write.
110	*/
111
112	extern void logrel_destroy(struct logrel_relation *);
113	/*
114	* logrel_destroy(logrel)
115	* struct logrel_relation *logrel;
116	*
117	* Destroys a logrelation.
118	*/
119
120	extern boolean logrel_equal(struct logrel_relation *);
121	extern boolean logrel_not_equal(struct logrel_relation *);
122	/*
123	* eq = logrel_equal(logrel)
124	* neq = logrel_not_equal(logrel)
125	* boolean eq,neq;
126	* struct logrel_relation *logrel;
127	*
128	* Returns true if the given logrelation is satisfied if the
129	* operator in question is among those that make up the
130	* comparator of the logrelation.
131	* neq==TRUE implies logrel would be satisfied if lhs != rhs
132	* eq==TRUE implies logrel would be satisfied if lhs == rhs
133	*/
134
135	extern enum logrel_enum logrel_relop(struct logrel_relation *);
136	/*
137	* relop = logrel_relop(logrel);
138	* logrel_enum relop;
139	* struct logrel_relation *logrel;
140	* Returns the type of the operator of a given logrelation.
141	*/
142
143	extern char logrel_make_name(slv_system_t,struct logrel_relation );
144	/*
145	* name = logrel_make_name(sys,logrel)
146	* slv_system_t sys;
147	* struct logrel_relation *logrel;
148	* char *name;
149	*
150	* Copies of the logrelation instance name can be made and returned.
151	* The string returned should be freed when no longer in use.
152	*/
153
154	extern int32 logrel_mindex(struct logrel_relation *);
155	extern void logrel_set_mindex(struct logrel_relation *,int32);
156	/*
157	* index = logrel_mindex(logrel)
158	* logrel_set_mindex(logrel,index)
159	* int32 index;
160	* struct logrel_relation *logrel;
161	*
162	* Sets or retrieves the index number of the given logrelation as it
163	* appears in a slv_system_t master logrelation list.
164	*/
165
166	extern int32 logrel_sindex(struct logrel_relation *);
167	extern void logrel_set_sindex(struct logrel_relation *,int32);
168	/*
169	* index = logrel_sindex(logrel)
170	* logrel_set_sindex(logrel,index)
171	* int32 index;
172	* struct logrel_relation *logrel;
173	*
174	* Sets or retrieves the index number of the given logrelation as it
175	* appears in a solvers logrelation list.
176	*/
177
178	extern int32 logrel_model(const struct logrel_relation *);
179	extern void logrel_set_model(struct logrel_relation *,int32);
180	/*
181	* index = logrel_model(logrel)
182	* logrel_set_model(logrel,index)
183	* int32 index;
184	* struct logrel_relation *logrel;
185	*
186	* Sets or retrieves the model number of the given logrelation.
187	* Models are numbered from 1 to some upper limit.
188	*/
189
190	extern int32 logrel_residual(struct logrel_relation *);
191	extern void logrel_set_residual(struct logrel_relation *,int32);
192	/*
193	* residual = logrel_residual(logrel)
194	* logrel_set_residual(logrel,residual)
195	* int32 residual;
196	* struct logrel_relation *logrel;
197	*
198	* Sets or retrieves the logical residual field of the given logrelation.
199	* Note that the residual is not actually computed by logrel_residual:
200	* there is no guarantee (from this function) that the residual is
201	* actually correct.
202	*/
203
204	extern int32 logrel_nominal(struct logrel_relation *);
205	/*
206	* nominal = logrel_nominal(logrel)
207	* int32 nominal;
208	* struct logrel_relation *logrel;
209	*
210	* Retrieves the nominal field of the given logrelation.
211	* No slv client has any business being able to set the nominal,
212	* so no such operator is provided.
213	*/
214
215
216	#ifdef NDEBUG
217	#define logrel_n_incidences(lr) ((lr)->n_incidences)
218	#define logrel_set_incidences(lr,n,ilist) \
219	(lr)->n_incidences=(n); (lr)->incidence = (ilist)
220	#else
221	#define logrel_n_incidences(lr) logrel_n_incidencesF(lr)
222	#define logrel_set_incidences(lr,n,ilist) \
223	logrel_set_incidencesF((lr),(n),(ilist))
224	#endif /* NDEBUG */
225
226
227	extern int32 logrel_n_incidencesF(struct logrel_relation *);
228	extern void logrel_set_incidencesF(struct logrel_relation *,
229	int32,struct dis_discrete **);
230	/*
231	* logrel_n_incidences(logrel)
232	* logrel_set_incidences(logrel,n,ilist)
233	* struct logrel_relation *logrel;
234	* struct dis_discrete **ilist;
235	* int32 n;
236	*
237	* logrel_n_incidences returns the length of the incidence_list.
238	* Solver clients should not call logrel_set_incidences,
239	* it is only for use by constructors of bridges to logrelation
240	* back ends.
241	*/
242
243	extern const struct dis_discrete
244	*logrel_incidence_list(struct logrel_relation );
245	extern struct dis_discrete
246	*logrel_incidence_list_to_modify(struct logrel_relation );
247	/*
248	* bv = logrel_incidence_list(logrel)
249	* struct logrel_relation *logrel;
250	* struct dis_discrete **bv;
251	*
252	* Returns a pointer to an array logrel_n_incidences(logrel) long of bvars.
253	* Each element of the array is a struct dis_discrete *.
254	* If there is no incidence, NULL is returned.
255	* Pointers in this array will be unique.
256	* The list belongs to the logrelation. Do not destroy it.
257	* Do not change it.
258	*
259	* BV IS NOT a NULL-TERMINATED LIST.
260	*/
261
262	/*
263	* logrelation filtration functions.
264	* We coulhave 32 binary (one bit) flags a client may want to query
265	* in arbitrary combinations and paying attention to only certain of
266	* the bits. We will provide a set of macros and functions for each of
267	* these bits and for operations on the whole set.
268	*/
269
270	typedef struct logrel_filter_structure {
271	uint32 matchbits;
272	uint32 matchvalue;
273	} logrel_filter_t;
274
275	extern int logrel_apply_filter(struct logrel_relation ,logrel_filter_t );
276	/*
277	* value = logrel_apply_filter(logrel,filter)
278	* int value;
279	* struct logrel_relation *logrel;
280	* logrel_filter_t *filter;
281	*
282	* Returns 1 only if all of the positions specified in
283	* filter->matchbits have the same values in
284	* filter->matchvalue and the logrelation's flags value.
285	* Bits set to 0 in filter->matchbits are ignored for the test.
286	*/
287
288	extern uint32 logrel_flags(struct logrel_relation *);
289	extern void logrel_set_flags(struct logrel_relation *,uint32);
290	/*
291	* struct logrel_relation *logrel;
292	* uint32 flags;
293	*
294	* logrel_flags(logrel) returns the flags field of the logrelation.
295	* logrel_set_flags(logrel,flags) sets the entire flag field to the
296	* value of flags given.
297	*/
298
299	extern uint32 logrel_flagbit(struct logrel_relation *,uint32);
300	/*
301	* logrel_flagbit(logrel,name);
302	* struct logrel_relation *logrel;
303	* uint32 name;
304	* name should be a LOGREL_xx flag defined above)
305	* Returns the value of the bit specified from the logrelation flags.
306	*/
307
308	extern void logrel_set_flagbit(struct logrel_relation *,uint32, uint32);
309	/*
310	* struct logrel_relation *logrel;
311	* unsigned int NAME,oneorzero;
312	* logrel_set_flagbit(logrel,NAME,oneorzero)
313	*
314	* Sets the bit, which should be referred to by its macro name,
315	* on if oneorzero is >0 and off is oneorzero is 0.
316	* The macro names are the defined up at the top of this file.
317	*
318	* Example: logrel_set_flags(logrel,LOGREL_INCLUDED,1) turns on the
319	* LOGREL_INCLUDED bit.
320	* What it really does is:
321	* if (oneorzero) {
322	* logrel->flags \|= field;
323	* } else {
324	* logrel->flags &= ~field;
325	* }
326	* In unix, see also man 3f bit or man not.
327	*/
328
329	/*
330	* the bit flags. explained afterward. several are for use of
331	* transient clients and should be ignored by solver engines
332	*/
333	#define LOGREL_INCLUDED 0x1
334	/*
335	* INCLUDED is as yet a funny one. treat it as readonly because
336	* you can only change it using a int function and not the
337	* bit manipulation functions. It is here in the bits because
338	* it is useful in filters sometimes.
339	*/
340	#define LOGREL_SATISFIED 0x2
341	#define LOGREL_EQUALITY 0x4
342	/* Conditional Modeling */
343	#define LOGREL_INWHEN 0x8
344	#define LOGREL_ACTIVE 0x10
345	/* Conditional LogRelations (Boundaries) */
346	#define LOGREL_CONDITIONAL 0x20
347	#define LOGREL_IN_BLOCK 0x40
348	/*
349	* LOGREL_INCLUDED solvers, ui clients. user wants eqn in problem.
350	* bit should be treated as readonly. use logrel_set_*
351	* to change.
352	* LOGREL_SATISFIED has logrel been pronounced satisfied by someone?
353	* bit should be treated as readonly. use logrel_set_*
354	* to change.
355	* LOGREL_EQUALITY is logrelation an equality? readonly for clients.
356	* LOGREL_INWHEN is logrelation in a when? readonly for clients.
357	* LOGREL_ACTIVE is this logrelation currently a part of my problem?
358	* LOGREL_CONDITIONAL is logrelation conditional? readonly for clients.
359	* LOGREL_IN_BLOCK is the logrelation in the current block of registered
360	* client? for clients.
361	*/
362
363	/*
364	* the bit flag lookups
365	*/
366	#ifdef NDEBUG
367	#define logrel_satisfied(lr) ((lr)->flags & LOGREL_SATISFIED)
368	#define logrel_equality(lr) ((lr)->flags & LOGREL_EQUALITY)
369	#define logrel_in_when(lr) ((lr)->flags & LOGREL_INWHEN)
370	#define logrel_active(lr) ((lr)->flags & LOGREL_ACTIVE)
371	#define logrel_conditional(lr) ((lr)->flags & LOGREL_CONDITIONAL)
372	#define logrel_in_block(lr) ((lr)->flags & LOGREL_IN_BLOCK)
373	#else
374	#define logrel_satisfied(lr) logrel_flagbit((lr),LOGREL_SATISFIED)
375	#define logrel_equality(lr) logrel_flagbit((lr),LOGREL_EQUALITY)
376	#define logrel_in_when(lr) logrel_flagbit((lr),LOGREL_INWHEN)
377	#define logrel_active(lr) logrel_flagbit((lr),LOGREL_ACTIVE)
378	#define logrel_conditional(lr) logrel_flagbit((lr),LOGREL_CONDITIONAL)
379	#define logrel_in_bolck(lr) logrel_flagbit((lr),LOGREL_IN_BLOCK)
380	#endif /* NDEBUG */
381
382	/*
383	* bit flag assignments. any value other than 0 for bv turns the
384	* named flag to 1. 0 sets it to 0.
385	*/
386	#define logrel_set_satisfied(lr,bv) \
387	logrel_set_flagbit((lr),LOGREL_SATISFIED,(bv))
388	#define logrel_set_equality(lr,bv) \
389	logrel_set_flagbit((lr),LOGREL_EQUALITY,(bv))
390	#define logrel_set_in_when(lr,bv) \
391	logrel_set_flagbit((lr),LOGREL_INWHEN,(bv))
392	#define logrel_set_active(lr,bv) \
393	logrel_set_flagbit((lr),LOGREL_ACTIVE,(bv))
394	#define logrel_set_conditional(lr,bv) \
395	logrel_set_flagbit((lr),LOGREL_CONDITIONAL,(bv))
396	#define logrel_set_in_block(lr,bv) \
397	logrel_set_flagbit((lr),LOGREL_IN_BLOCK,(bv))
398
399	extern uint32 logrel_included(struct logrel_relation *);
400	extern void logrel_set_included(struct logrel_relation *,uint32);
401	/*
402	* included = logrel_included(logrel)
403	* logrel_set_included(logrel,included)
404	* uint32 included;
405	* struct logrel_relation *logrel;
406	*
407	* Sets or retrieves the included field of the given logrelation.
408	* This has side effect on the ascend instance, so it isn't
409	* implemented with the rest of the macros above. This needs to
410	* change.
411	*/
412
413	#endif /* logrel_already_included */