ascend4/solver/conditional.c

/*
 *  Conditional Module
 *  by Vicente Rico-Ramirez
 *  Created: 09/96
 *  Version: $Revision: 1.10 $
 *  Version control file: $RCSfile: conditional.c,v $
 *  Date last modified: $Date: 1998/03/30 22:06:52 $
 *  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.
 *
 */

#include "utilities/ascConfig.h"
#include "utilities/ascMalloc.h"
#include "general/list.h"
#include "general/dstring.h"
#include "compiler/instance_enum.h"
#include "compiler/compiler.h"
#include "compiler/child.h"
#include "compiler/fractions.h"
#include "compiler/dimen.h"
#include "compiler/type_desc.h"
#include "compiler/atomvalue.h"
#include "compiler/parentchild.h"
#include "compiler/instquery.h"
#include "compiler/instance_io.h"
#include "solver/slv_types.h"
#include "solver/var.h"
#include "solver/rel.h"
#include "solver/discrete.h"
#include "solver/conditional.h"
#include "solver/logrel.h"
#include "solver/bnd.h"
#include "solver/slv_server.h"
#include "solver/analyze.h"


#ifndef IPTR
#define IPTR(i) ((struct Instance *)(i))
#endif
#define WHEN_DEBUG FALSE

/*
 *                        When utility functions
 */

/* forward declaration */
void when_case_destroy(struct when_case *);

static const struct w_when g_when_defaults = {
   NULL,        /* instance */
   NULL,        /* variables */
   NULL,        /* cases */
   -1,              /* number of cases */
   -1,          /* mindex */
   -1,          /* sindex */
   -1,          /* model index */
   (WHEN_INCLUDED)  /* flags */
};


static struct w_when *when_copy(const struct w_when *when)
{
   struct w_when *newwhen;
   newwhen = (struct w_when *)ascmalloc( sizeof(struct w_when) );
   *newwhen = *when;
   return(newwhen);
}


struct w_when *when_create(SlvBackendToken instance,
               struct w_when *newwhen)
{
  if (newwhen==NULL) {
    newwhen = when_copy(&g_when_defaults); /* malloc the when */
  } else {
    *newwhen = g_when_defaults;        /* init the space we've been sent */
  }
  assert(newwhen!=NULL);
  newwhen->instance = instance;
  return(newwhen);
}


void when_destroy_cases(struct w_when *when)
{
  int32 c,len;
  struct when_case *cur_case;

  len = gl_length(when->cases);
  for(c=1;c<=len;c++){
    cur_case = (struct when_case *)(gl_fetch(when->cases,c));
    when_case_destroy(cur_case);
  }
  gl_destroy(when->cases);
}


void when_destroy(struct w_when *when)
{
   struct Instance *inst;
   if (when==NULL) return;
   if (when->dvars != NULL) {
     gl_destroy(when->dvars);
     when->dvars = NULL;
   }
   if (when->cases != NULL) {
     when_destroy_cases(when);
     when->cases = NULL;
   }
   inst = IPTR(when->instance);
   if (inst) {
     if (GetInterfacePtr(inst)==when) {
       SetInterfacePtr(inst,NULL);
     }
   }
}

SlvBackendToken when_instance(struct w_when *when)
{
  if (when==NULL) return NULL;
  return (SlvBackendToken) when->instance;
}


void when_write_name(slv_system_t sys,struct w_when *when,
             FILE *fp)
{
  if (when == NULL || fp==NULL) return;
  if (sys!=NULL) {
    WriteInstanceName(fp,when_instance(when),slv_instance(sys));
  } else {
    WriteInstanceName(fp,when_instance(when),NULL);
  }
}


struct gl_list_t *when_dvars_list( struct w_when *when)
{
   assert(when);
   return( when->dvars );
}


void when_set_dvars_list( struct w_when *when, struct gl_list_t *dvlist)
{
   assert(when);
   when->dvars = dvlist;
}


struct gl_list_t *when_cases_list( struct w_when *when)
{
   assert(when);
   return( when->cases );
}


void when_set_cases_list( struct w_when *when, struct gl_list_t *clist)
{
   assert(when);
   when->cases = clist;
}

int32 when_num_cases(struct w_when *when)
{
   return( when->num_cases );
}

void when_set_num_cases( struct w_when *when, int32 num_cases)
{
   when->num_cases = num_cases;
}

int32 when_mindex( struct w_when *when)
{
   return( when->mindex );
}

void when_set_mindex( struct w_when *when, int32 index)
{
   when->mindex = index;
}


int32 when_sindex( struct w_when *when)
{
   return( when->sindex );
}

void when_set_sindex( struct w_when *when, int32 index)
{
   when->sindex = index;
}

int32 when_model(const struct w_when *when)
{
   return((const int32) when->model );
}

void when_set_model( struct w_when *when, int32 index)
{
   when->model = index;
}

int32 when_apply_filter(struct w_when *w,
                        when_filter_t *filter)
{
  if (w==NULL || filter==NULL) {
    FPRINTF(stderr,"when_apply_filter miscalled with NULL\n");
    return FALSE;
  }
  return ( (filter->matchbits & w->flags) ==
           (filter->matchbits & filter->matchvalue) );
}


uint32 when_flags( struct w_when *when)
{
  return when->flags;
}

void when_set_flags(struct w_when *when, uint32 flags)
{
  when->flags = flags;
}

uint32 when_flagbit(struct w_when *when, uint32 one)
{
  if (when==NULL || when->instance == NULL) {
    FPRINTF(stderr,"ERROR: when_flagbit called with bad when.\n");
    return 0;
  }
  return (when->flags & one);
}

void when_set_flagbit(struct w_when *when, uint32 field,
              uint32 one)
{
  if (one) {
    when->flags |= field;
  } else {
    when->flags &= ~field;
  }
}


/*
 *                  When Case  utility functions
 */


/* we are depending on ansi initialization to 0 for the
 * values field OF this struct.
 */
static
const struct when_case g_case_defaults = {
   {0},         /* values */
   NULL,        /* relations */
   NULL,        /* logrelations */
   NULL,        /* whens */
   -1,                  /* case number */
   -1,                  /* number relations */
   -1,                  /* number vars */
   NULL,                /* master indeces of incidente vars */
   (0x0)
};


static struct when_case *when_case_copy(const struct when_case *wc)
{
   struct when_case *newcase;
   newcase = (struct when_case *)ascmalloc( sizeof(struct when_case) );
   *newcase = *wc;
   return(newcase);
}


struct when_case *when_case_create(struct when_case *newcase)
{
  if (newcase==NULL) {
    newcase = when_case_copy(&g_case_defaults); /* malloc the case */
  } else {
    *newcase = g_case_defaults;    /* init the space we've been sent */
  }
  return(newcase);
}


void when_case_destroy(struct when_case *wc)
{
   if (wc->rels != NULL) {
     gl_destroy(wc->rels);
     wc->rels = NULL;
   }
   if (wc->logrels != NULL) {
     gl_destroy(wc->logrels);
     wc->logrels = NULL;
   }
   if (wc->whens != NULL ) {
     gl_destroy(wc->whens);
     wc->whens = NULL;
   }
   if (wc->ind_inc != NULL ) {
     ascfree(wc->ind_inc);
   }

   ascfree((POINTER)wc);
}


int32 *when_case_values_list( struct when_case *wc)
{
   assert(wc);
   return( &(wc->values[0]) );
}


void when_case_set_values_list( struct when_case *wc, int32 *vallist)
{
   int32 *value,index;
   assert(wc);
   value = &(wc->values[0]);
   for(index=0;index<MAX_VAR_IN_LIST;index++) {
      *value = *vallist;
      value++;
      vallist++;
   }
}


struct gl_list_t *when_case_rels_list( struct when_case *wc)
{
   assert(wc);
   return( wc->rels );
}


void when_case_set_rels_list( struct when_case *wc, struct gl_list_t *rlist)
{
   assert(wc);
   wc->rels = rlist;
}


struct gl_list_t *when_case_logrels_list( struct when_case *wc)
{
   assert(wc);
   return( wc->logrels );
}


void when_case_set_logrels_list(struct when_case *wc,
                                struct gl_list_t *lrlist)
{
   assert(wc);
   wc->logrels = lrlist;
}


struct gl_list_t *when_case_whens_list( struct when_case *wc)
{
   assert(wc);
   return( wc->whens );
}


void when_case_set_whens_list( struct when_case *wc, struct gl_list_t *wlist)
{
   assert(wc);
   wc->whens = wlist;
}


int32 when_case_case_number( struct when_case *wc)
{
  assert(wc);
  return wc->case_number;
}

void when_case_set_case_number(struct when_case *wc, int32 case_number)
{
  assert(wc);
  wc->case_number = case_number;
}

int32 when_case_num_rels( struct when_case *wc)
{
  assert(wc);
  return wc->num_rels;
}

void when_case_set_num_rels(struct when_case *wc, int32 num_rels)
{
  assert(wc);
  wc->num_rels = num_rels;
}

int32 when_case_num_inc_var( struct when_case *wc)
{
  assert(wc);
  return wc->num_inc_var;
}

void when_case_set_num_inc_var(struct when_case *wc, int32 num_inc_var)
{
  assert(wc);
  wc->num_inc_var = num_inc_var;
}

int32 *when_case_ind_inc( struct when_case *wc)
{
  assert(wc);
  return wc->ind_inc;
}

void when_case_set_ind_inc(struct when_case *wc, int32* ind_inc)
{
  assert(wc);
  wc->ind_inc = ind_inc;
}

int32 when_case_apply_filter(struct when_case *wc,
                           when_case_filter_t *filter)
{
  if (wc==NULL || filter==NULL) {
    FPRINTF(stderr,"when_case_apply_filter miscalled with NULL\n");
    return FALSE;
  }
  return ( (filter->matchbits & wc->flags) ==
           (filter->matchbits & filter->matchvalue) );
}

uint32 when_case_flags( struct when_case *wc)
{
  assert(wc);
  return wc->flags;
}

void when_case_set_flags(struct when_case *wc, uint32 flags)
{
  assert(wc);
  wc->flags = flags;
}

uint32 when_case_flagbit(struct when_case *wc, uint32 one)
{
  if (wc==NULL) {
    FPRINTF(stderr,"ERROR: when_case_flagbit called with bad case.\n");
    return 0;
  }
  return (wc->flags & one);
}

void when_case_set_flagbit(struct when_case *wc, uint32 field,
                   uint32 one)
{
  if (one) {
    wc->flags |= field;
  } else {
    wc->flags &= ~field;
  }
}


1	aw0a	1	/*
2			* Conditional Module
3			* by Vicente Rico-Ramirez
4			* Created: 09/96
5			* Version: $Revision: 1.10 $
6			* Version control file: $RCSfile: conditional.c,v $
7			* Date last modified: $Date: 1998/03/30 22:06:52 $
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			#include "utilities/ascConfig.h"
30			#include "utilities/ascMalloc.h"
31			#include "general/list.h"
32			#include "general/dstring.h"
33			#include "compiler/instance_enum.h"
34			#include "compiler/compiler.h"
35			#include "compiler/child.h"
36			#include "compiler/fractions.h"
37			#include "compiler/dimen.h"
38			#include "compiler/type_desc.h"
39			#include "compiler/atomvalue.h"
40			#include "compiler/parentchild.h"
41			#include "compiler/instquery.h"
42			#include "compiler/instance_io.h"
43			#include "solver/slv_types.h"
44			#include "solver/var.h"
45			#include "solver/rel.h"
46			#include "solver/discrete.h"
47			#include "solver/conditional.h"
48			#include "solver/logrel.h"
49			#include "solver/bnd.h"
50			#include "solver/slv_server.h"
51			#include "solver/analyze.h"
52
53
54			#ifndef IPTR
55			#define IPTR(i) ((struct Instance *)(i))
56			#endif
57			#define WHEN_DEBUG FALSE
58
59			/*
60			* When utility functions
61			*/
62
63			/* forward declaration */
64			void when_case_destroy(struct when_case *);
65
66			static const struct w_when g_when_defaults = {
67			NULL, /* instance */
68			NULL, /* variables */
69			NULL, /* cases */
70			-1, /* number of cases */
71			-1, /* mindex */
72			-1, /* sindex */
73			-1, /* model index */
74			(WHEN_INCLUDED) /* flags */
75			};
76
77
78			static struct w_when when_copy(const struct w_when when)
79			{
80			struct w_when *newwhen;
81			newwhen = (struct w_when *)ascmalloc( sizeof(struct w_when) );
82			newwhen = when;
83			return(newwhen);
84			}
85
86
87			struct w_when *when_create(SlvBackendToken instance,
88			struct w_when *newwhen)
89			{
90			if (newwhen==NULL) {
91			newwhen = when_copy(&g_when_defaults); /* malloc the when */
92			} else {
93			newwhen = g_when_defaults; / init the space we've been sent */
94			}
95			assert(newwhen!=NULL);
96			newwhen->instance = instance;
97			return(newwhen);
98			}
99
100
101			void when_destroy_cases(struct w_when *when)
102			{
103			int32 c,len;
104			struct when_case *cur_case;
105
106			len = gl_length(when->cases);
107			for(c=1;c<=len;c++){
108			cur_case = (struct when_case *)(gl_fetch(when->cases,c));
109			when_case_destroy(cur_case);
110			}
111			gl_destroy(when->cases);
112			}
113
114
115			void when_destroy(struct w_when *when)
116			{
117			struct Instance *inst;
118			if (when==NULL) return;
119			if (when->dvars != NULL) {
120			gl_destroy(when->dvars);
121			when->dvars = NULL;
122			}
123			if (when->cases != NULL) {
124			when_destroy_cases(when);
125			when->cases = NULL;
126			}
127			inst = IPTR(when->instance);
128			if (inst) {
129			if (GetInterfacePtr(inst)==when) {
130			SetInterfacePtr(inst,NULL);
131			}
132			}
133			}
134
135			SlvBackendToken when_instance(struct w_when *when)
136			{
137			if (when==NULL) return NULL;
138			return (SlvBackendToken) when->instance;
139			}
140
141
142			void when_write_name(slv_system_t sys,struct w_when *when,
143			FILE *fp)
144			{
145			if (when == NULL \|\| fp==NULL) return;
146			if (sys!=NULL) {
147			WriteInstanceName(fp,when_instance(when),slv_instance(sys));
148			} else {
149			WriteInstanceName(fp,when_instance(when),NULL);
150			}
151			}
152
153
154			struct gl_list_t when_dvars_list( struct w_when when)
155			{
156			assert(when);
157			return( when->dvars );
158			}
159
160
161			void when_set_dvars_list( struct w_when when, struct gl_list_t dvlist)
162			{
163			assert(when);
164			when->dvars = dvlist;
165			}
166
167
168			struct gl_list_t when_cases_list( struct w_when when)
169			{
170			assert(when);
171			return( when->cases );
172			}
173
174
175			void when_set_cases_list( struct w_when when, struct gl_list_t clist)
176			{
177			assert(when);
178			when->cases = clist;
179			}
180
181			int32 when_num_cases(struct w_when *when)
182			{
183			return( when->num_cases );
184			}
185
186			void when_set_num_cases( struct w_when *when, int32 num_cases)
187			{
188			when->num_cases = num_cases;
189			}
190
191			int32 when_mindex( struct w_when *when)
192			{
193			return( when->mindex );
194			}
195
196			void when_set_mindex( struct w_when *when, int32 index)
197			{
198			when->mindex = index;
199			}
200
201
202			int32 when_sindex( struct w_when *when)
203			{
204			return( when->sindex );
205			}
206
207			void when_set_sindex( struct w_when *when, int32 index)
208			{
209			when->sindex = index;
210			}
211
212			int32 when_model(const struct w_when *when)
213			{
214			return((const int32) when->model );
215			}
216
217			void when_set_model( struct w_when *when, int32 index)
218			{
219			when->model = index;
220			}
221
222			int32 when_apply_filter(struct w_when *w,
223			when_filter_t *filter)
224			{
225			if (w==NULL \|\| filter==NULL) {
226			FPRINTF(stderr,"when_apply_filter miscalled with NULL\n");
227			return FALSE;
228			}
229			return ( (filter->matchbits & w->flags) ==
230			(filter->matchbits & filter->matchvalue) );
231			}
232
233
234			uint32 when_flags( struct w_when *when)
235			{
236			return when->flags;
237			}
238
239			void when_set_flags(struct w_when *when, uint32 flags)
240			{
241			when->flags = flags;
242			}
243
244			uint32 when_flagbit(struct w_when *when, uint32 one)
245			{
246			if (when==NULL \|\| when->instance == NULL) {
247			FPRINTF(stderr,"ERROR: when_flagbit called with bad when.\n");
248			return 0;
249			}
250			return (when->flags & one);
251			}
252
253			void when_set_flagbit(struct w_when *when, uint32 field,
254			uint32 one)
255			{
256			if (one) {
257			when->flags \|= field;
258			} else {
259			when->flags &= ~field;
260			}
261			}
262
263
264			/*
265			* When Case utility functions
266			*/
267
268
269			/* we are depending on ansi initialization to 0 for the
270			* values field OF this struct.
271			*/
272			static
273			const struct when_case g_case_defaults = {
274			{0}, /* values */
275			NULL, /* relations */
276			NULL, /* logrelations */
277			NULL, /* whens */
278			-1, /* case number */
279			-1, /* number relations */
280			-1, /* number vars */
281			NULL, /* master indeces of incidente vars */
282			(0x0)
283			};
284
285
286			static struct when_case when_case_copy(const struct when_case wc)
287			{
288			struct when_case *newcase;
289			newcase = (struct when_case *)ascmalloc( sizeof(struct when_case) );
290			newcase = wc;
291			return(newcase);
292			}
293
294
295			struct when_case when_case_create(struct when_case newcase)
296			{
297			if (newcase==NULL) {
298			newcase = when_case_copy(&g_case_defaults); /* malloc the case */
299			} else {
300			newcase = g_case_defaults; / init the space we've been sent */
301			}
302			return(newcase);
303			}
304
305
306			void when_case_destroy(struct when_case *wc)
307			{
308			if (wc->rels != NULL) {
309			gl_destroy(wc->rels);
310			wc->rels = NULL;
311			}
312			if (wc->logrels != NULL) {
313			gl_destroy(wc->logrels);
314			wc->logrels = NULL;
315			}
316			if (wc->whens != NULL ) {
317			gl_destroy(wc->whens);
318			wc->whens = NULL;
319			}
320			if (wc->ind_inc != NULL ) {
321			ascfree(wc->ind_inc);
322			}
323
324			ascfree((POINTER)wc);
325			}
326
327
328			int32 when_case_values_list( struct when_case wc)
329			{
330			assert(wc);
331			return( &(wc->values[0]) );
332			}
333
334
335			void when_case_set_values_list( struct when_case wc, int32 vallist)
336			{
337			int32 *value,index;
338			assert(wc);
339			value = &(wc->values[0]);
340			for(index=0;index<MAX_VAR_IN_LIST;index++) {
341			value = vallist;
342			value++;
343			vallist++;
344			}
345			}
346
347
348			struct gl_list_t when_case_rels_list( struct when_case wc)
349			{
350			assert(wc);
351			return( wc->rels );
352			}
353
354
355			void when_case_set_rels_list( struct when_case wc, struct gl_list_t rlist)
356			{
357			assert(wc);
358			wc->rels = rlist;
359			}
360
361
362			struct gl_list_t when_case_logrels_list( struct when_case wc)
363			{
364			assert(wc);
365			return( wc->logrels );
366			}
367
368
369			void when_case_set_logrels_list(struct when_case *wc,
370			struct gl_list_t *lrlist)
371			{
372			assert(wc);
373			wc->logrels = lrlist;
374			}
375
376
377			struct gl_list_t when_case_whens_list( struct when_case wc)
378			{
379			assert(wc);
380			return( wc->whens );
381			}
382
383
384			void when_case_set_whens_list( struct when_case wc, struct gl_list_t wlist)
385			{
386			assert(wc);
387			wc->whens = wlist;
388			}
389
390
391			int32 when_case_case_number( struct when_case *wc)
392			{
393			assert(wc);
394			return wc->case_number;
395			}
396
397			void when_case_set_case_number(struct when_case *wc, int32 case_number)
398			{
399			assert(wc);
400			wc->case_number = case_number;
401			}
402
403			int32 when_case_num_rels( struct when_case *wc)
404			{
405			assert(wc);
406			return wc->num_rels;
407			}
408
409			void when_case_set_num_rels(struct when_case *wc, int32 num_rels)
410			{
411			assert(wc);
412			wc->num_rels = num_rels;
413			}
414
415			int32 when_case_num_inc_var( struct when_case *wc)
416			{
417			assert(wc);
418			return wc->num_inc_var;
419			}
420
421			void when_case_set_num_inc_var(struct when_case *wc, int32 num_inc_var)
422			{
423			assert(wc);
424			wc->num_inc_var = num_inc_var;
425			}
426
427			int32 when_case_ind_inc( struct when_case wc)
428			{
429			assert(wc);
430			return wc->ind_inc;
431			}
432
433			void when_case_set_ind_inc(struct when_case wc, int32 ind_inc)
434			{
435			assert(wc);
436			wc->ind_inc = ind_inc;
437			}
438
439			int32 when_case_apply_filter(struct when_case *wc,
440			when_case_filter_t *filter)
441			{
442			if (wc==NULL \|\| filter==NULL) {
443			FPRINTF(stderr,"when_case_apply_filter miscalled with NULL\n");
444			return FALSE;
445			}
446			return ( (filter->matchbits & wc->flags) ==
447			(filter->matchbits & filter->matchvalue) );
448			}
449
450			uint32 when_case_flags( struct when_case *wc)
451			{
452			assert(wc);
453			return wc->flags;
454			}
455
456			void when_case_set_flags(struct when_case *wc, uint32 flags)
457			{
458			assert(wc);
459			wc->flags = flags;
460			}
461
462			uint32 when_case_flagbit(struct when_case *wc, uint32 one)
463			{
464			if (wc==NULL) {
465			FPRINTF(stderr,"ERROR: when_case_flagbit called with bad case.\n");
466			return 0;
467			}
468			return (wc->flags & one);
469			}
470
471			void when_case_set_flagbit(struct when_case *wc, uint32 field,
472			uint32 one)
473			{
474			if (one) {
475			wc->flags \|= field;
476			} else {
477			wc->flags &= ~field;
478			}
479			}
480
481