shared_source/c_datd/cvxzone.c

//$Header$
//-------------------------------------------------------------------------------------------------
//This file is part of "David T. Ashley's Shared Source Code", a set of shared components
//integrated into many of David T. Ashley's projects.
//-------------------------------------------------------------------------------------------------
//This source code and any program in which it is compiled/used is provided under the MIT License,
//reproduced below.
//-------------------------------------------------------------------------------------------------
//Permission is hereby granted, free of charge, to any person obtaining a copy of
//this software and associated documentation files(the "Software"), to deal in the
//Software without restriction, including without limitation the rights to use,
//copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the
//Software, and to permit persons to whom the Software is furnished to do so,
//subject to the following conditions :
//
//The above copyright notice and this permission notice shall be included in all
//copies or substantial portions of the Software.
//
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//SOFTWARE.
//-------------------------------------------------------------------------------------------------
/* Convex zones for timed automata verification.
*/
//-------------------------------------------------------------------------------------------------
#define MODULE_CVXZONE

#include <assert.h>
#include <malloc.h>
#include <stdio.h>
#include <string.h>

#include "ccmalloc.h"
#include "cvxzone.h"


/**************************************************************************/
/***** ALLOCATION, DEALLOCATION, AND COPY FUNCTIONS
/**************************************************************************/
/* Returns the number of constraint slots in memory that should be 
** allocated as a function of those required.
*/
static int CVXZONE_cr_num_to_alloc(int crs_reqd_num)
   {
   int rv;

   assert(crs_reqd_num >= 0);

   rv = crs_reqd_num + CVXZONE_ZONE_CONST_ALLOC_INC - 1;

   rv = rv - (rv % CVXZONE_ZONE_CONST_ALLOC_INC);

   assert(rv >= crs_reqd_num);

   return(rv);
   }


void CVXZONE_new(CVXZONE_zone_ptr *arg)
   {
   /* Eyeball the inputs. */
   assert(arg  != NULL);
   assert(*arg == NULL);

   /* Allocate the space for the zone itself.
   */
   *arg = CCMALLOC_malloc(sizeof(CVXZONE_zone));

   /* Zero the space. */
   memset(*arg, 0, sizeof(CVXZONE_zone));

   /* Set any fields that take on non-zero initial values.
   */
   (*arg)->is_canonical = 1;
   }


void CVXZONE_delete(CVXZONE_zone_ptr *arg)
   {
   /* Check the input parameters. */
   assert(arg  != NULL);
   assert(*arg != NULL);

   /* Free any allocated constraint block.
   */
   if ((*arg)->constraints)
      CCMALLOC_free((*arg)->constraints);

   /* Free the record itself.
   */
   CCMALLOC_free(*arg);

   /* Set the caller's pointer to NULL.
   */
   *arg = NULL;
   }


void CVXZONE_copy(CVXZONE_zone_ptr *dst, CVXZONE_zone_ptr *src)
   {
   CVXZONE_constraint_ptr constraints;
   int n_allocd;

   /* Check the input parameters. */
   assert(dst  != NULL);
   assert(src  != NULL);
   assert(*dst != NULL);
   assert(*src != NULL);

   /* Save the victim's pointer to constraints and also the amount of
   ** space allocated.  These will be written over by the memory
   ** copy.
   */
   constraints = (*dst)->constraints;
   n_allocd    = (*dst)->n_allocd;

   /* Do a block copy from source to destination.  This catches
   ** everything except the constraints.
   */
   memcpy(*dst, *src, sizeof(CVXZONE_zone));

   /* Write the memory pointer and the amount allocd back.
   */
   (*dst)->constraints = constraints;
   (*dst)->n_allocd    = n_allocd;

   /* Reallocate the destination constraint block if there is not
   ** enough space to hold the constraints.
   */
   if ((*dst)->n_used > (*dst)->n_allocd)
      {
      if ((*dst)->constraints)
         {
         /* There was already a memory area involved, but not large
         ** enough.
         */
         CCMALLOC_realloc((*dst)->constraints, CVXZONE_cr_num_to_alloc((*dst)->n_used) * sizeof(CVXZONE_constraint));
         }
      else
         {
         /* No memory area had been allocated.  Need to allocate it for
         ** the first time.
         */
         CCMALLOC_malloc(CVXZONE_cr_num_to_alloc((*dst)->n_used) * sizeof(CVXZONE_constraint));
         }
      }

   /* Copy over the constraint block.
   */
   if ((*dst)->n_used)
      {
      memcpy((*dst)->constraints, (*src)->constraints, (*dst)->n_used * sizeof(CVXZONE_constraint));
      }
   }


void CVXZONE_clone(CVXZONE_zone_ptr *clone, CVXZONE_zone_ptr *orig)
   {
   /* Check the inputs. */
   assert(clone  != NULL);
   assert(orig   != NULL);
   assert(*clone == NULL);
   assert(*orig  != NULL);

   /* Allocate the clone.
   */
   CVXZONE_new(clone);

   /* Copy to the clone.
   */
   CVXZONE_copy(clone, orig);
   }


/**************************************************************************/
/***** MAINTENANCE FUNCTIONS                        
/**************************************************************************/
/* Removes (i.e. compresses out) all the unused constraints, i.e. those with
** the valid flag not set.  This simply makes the existing constraints contiguous.
** This function does this unconditionally, i.e. the is_canonical flag is not
** considered.
*/
static void CVXZONE_compress_constraints(CVXZONE_zone_ptr *arg)
   {
   int src_idx, dst_idx;

   assert(arg  != NULL);
   assert(*arg != NULL);

   dst_idx = 0;

   for (src_idx = 0; src_idx < (int)((*arg)->n_used); src_idx++)
      {
      if ((*arg)->constraints[src_idx].valid)
         {
         if (src_idx != dst_idx)  /* No sense copying something onto itself. */
            {
            memcpy((*arg)->constraints + dst_idx, 
                   (*arg)->constraints + src_idx,
                   sizeof(CVXZONE_constraint));
            }
         dst_idx++;
         }
      }

   /* The copy cycle is complete.  We can infer how many slots were *actually* used.
   */
   (*arg)->n_used = dst_idx;
   }


void CVXZONE_maintain_memory_trim(CVXZONE_zone_ptr *arg)
   {
   assert(arg  != NULL);
   assert(*arg != NULL);

   /* First, compact the array of constraints.
   */
   CVXZONE_compress_constraints(arg);

   /* Now, realloc the array to be the exact right size.
   */
   if ((*arg)->n_used)
      {
      assert((*arg)->constraints != NULL);

      CCMALLOC_realloc((*arg)->constraints,
                       (*arg)->n_used * sizeof(CVXZONE_constraint));
      }
   else
      {
      if ((*arg)->constraints)
         {
         CCMALLOC_free((*arg)->constraints);
         (*arg)->constraints = NULL;
         }
      }
   }


DECMOD_CVXZONE void CVXZONE_maintain_canonize(CVXZONE_zone_ptr *arg)
   {
   assert(arg  != NULL);
   assert(*arg != NULL);


   }

//End of cvxzone.c.
1	dashley	71	//$Header$
2			//-------------------------------------------------------------------------------------------------
3			//This file is part of "David T. Ashley's Shared Source Code", a set of shared components
4			//integrated into many of David T. Ashley's projects.
5			//-------------------------------------------------------------------------------------------------
6			//This source code and any program in which it is compiled/used is provided under the MIT License,
7			//reproduced below.
8			//-------------------------------------------------------------------------------------------------
9			//Permission is hereby granted, free of charge, to any person obtaining a copy of
10			//this software and associated documentation files(the "Software"), to deal in the
11			//Software without restriction, including without limitation the rights to use,
12			//copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the
13			//Software, and to permit persons to whom the Software is furnished to do so,
14			//subject to the following conditions :
15			//
16			//The above copyright notice and this permission notice shall be included in all
17			//copies or substantial portions of the Software.
18			//
19			//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20			//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21			//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
22			//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23			//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24			//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25			//SOFTWARE.
26			//-------------------------------------------------------------------------------------------------
27			/* Convex zones for timed automata verification.
28			*/
29			//-------------------------------------------------------------------------------------------------
30			#define MODULE_CVXZONE
31
32			#include <assert.h>
33			#include <malloc.h>
34			#include <stdio.h>
35			#include <string.h>
36
37			#include "ccmalloc.h"
38			#include "cvxzone.h"
39
40
41			/**************************************************************************/
42			/***** ALLOCATION, DEALLOCATION, AND COPY FUNCTIONS
43			/**************************************************************************/
44			/* Returns the number of constraint slots in memory that should be
45			** allocated as a function of those required.
46			*/
47			static int CVXZONE_cr_num_to_alloc(int crs_reqd_num)
48			{
49			int rv;
50
51			assert(crs_reqd_num >= 0);
52
53			rv = crs_reqd_num + CVXZONE_ZONE_CONST_ALLOC_INC - 1;
54
55			rv = rv - (rv % CVXZONE_ZONE_CONST_ALLOC_INC);
56
57			assert(rv >= crs_reqd_num);
58
59			return(rv);
60			}
61
62
63			void CVXZONE_new(CVXZONE_zone_ptr *arg)
64			{
65			/* Eyeball the inputs. */
66			assert(arg != NULL);
67			assert(*arg == NULL);
68
69			/* Allocate the space for the zone itself.
70			*/
71			*arg = CCMALLOC_malloc(sizeof(CVXZONE_zone));
72
73			/* Zero the space. */
74			memset(*arg, 0, sizeof(CVXZONE_zone));
75
76			/* Set any fields that take on non-zero initial values.
77			*/
78			(*arg)->is_canonical = 1;
79			}
80
81
82			void CVXZONE_delete(CVXZONE_zone_ptr *arg)
83			{
84			/* Check the input parameters. */
85			assert(arg != NULL);
86			assert(*arg != NULL);
87
88			/* Free any allocated constraint block.
89			*/
90			if ((*arg)->constraints)
91			CCMALLOC_free((*arg)->constraints);
92
93			/* Free the record itself.
94			*/
95			CCMALLOC_free(*arg);
96
97			/* Set the caller's pointer to NULL.
98			*/
99			*arg = NULL;
100			}
101
102
103			void CVXZONE_copy(CVXZONE_zone_ptr dst, CVXZONE_zone_ptr src)
104			{
105			CVXZONE_constraint_ptr constraints;
106			int n_allocd;
107
108			/* Check the input parameters. */
109			assert(dst != NULL);
110			assert(src != NULL);
111			assert(*dst != NULL);
112			assert(*src != NULL);
113
114			/* Save the victim's pointer to constraints and also the amount of
115			** space allocated. These will be written over by the memory
116			** copy.
117			*/
118			constraints = (*dst)->constraints;
119			n_allocd = (*dst)->n_allocd;
120
121			/* Do a block copy from source to destination. This catches
122			** everything except the constraints.
123			*/
124			memcpy(dst, src, sizeof(CVXZONE_zone));
125
126			/* Write the memory pointer and the amount allocd back.
127			*/
128			(*dst)->constraints = constraints;
129			(*dst)->n_allocd = n_allocd;
130
131			/* Reallocate the destination constraint block if there is not
132			** enough space to hold the constraints.
133			*/
134			if ((dst)->n_used > (dst)->n_allocd)
135			{
136			if ((*dst)->constraints)
137			{
138			/* There was already a memory area involved, but not large
139			** enough.
140			*/
141			CCMALLOC_realloc((dst)->constraints, CVXZONE_cr_num_to_alloc((dst)->n_used) * sizeof(CVXZONE_constraint));
142			}
143			else
144			{
145			/* No memory area had been allocated. Need to allocate it for
146			** the first time.
147			*/
148			CCMALLOC_malloc(CVXZONE_cr_num_to_alloc((dst)->n_used) sizeof(CVXZONE_constraint));
149			}
150			}
151
152			/* Copy over the constraint block.
153			*/
154			if ((*dst)->n_used)
155			{
156			memcpy((dst)->constraints, (src)->constraints, (dst)->n_used sizeof(CVXZONE_constraint));
157			}
158			}
159
160
161			void CVXZONE_clone(CVXZONE_zone_ptr clone, CVXZONE_zone_ptr orig)
162			{
163			/* Check the inputs. */
164			assert(clone != NULL);
165			assert(orig != NULL);
166			assert(*clone == NULL);
167			assert(*orig != NULL);
168
169			/* Allocate the clone.
170			*/
171			CVXZONE_new(clone);
172
173			/* Copy to the clone.
174			*/
175			CVXZONE_copy(clone, orig);
176			}
177
178
179			/**************************************************************************/
180			/***** MAINTENANCE FUNCTIONS
181			/**************************************************************************/
182			/* Removes (i.e. compresses out) all the unused constraints, i.e. those with
183			** the valid flag not set. This simply makes the existing constraints contiguous.
184			** This function does this unconditionally, i.e. the is_canonical flag is not
185			** considered.
186			*/
187			static void CVXZONE_compress_constraints(CVXZONE_zone_ptr *arg)
188			{
189			int src_idx, dst_idx;
190
191			assert(arg != NULL);
192			assert(*arg != NULL);
193
194			dst_idx = 0;
195
196			for (src_idx = 0; src_idx < (int)((*arg)->n_used); src_idx++)
197			{
198			if ((*arg)->constraints[src_idx].valid)
199			{
200			if (src_idx != dst_idx) /* No sense copying something onto itself. */
201			{
202			memcpy((*arg)->constraints + dst_idx,
203			(*arg)->constraints + src_idx,
204			sizeof(CVXZONE_constraint));
205			}
206			dst_idx++;
207			}
208			}
209
210			/* The copy cycle is complete. We can infer how many slots were actually used.
211			*/
212			(*arg)->n_used = dst_idx;
213			}
214
215
216			void CVXZONE_maintain_memory_trim(CVXZONE_zone_ptr *arg)
217			{
218			assert(arg != NULL);
219			assert(*arg != NULL);
220
221			/* First, compact the array of constraints.
222			*/
223			CVXZONE_compress_constraints(arg);
224
225			/* Now, realloc the array to be the exact right size.
226			*/
227			if ((*arg)->n_used)
228			{
229			assert((*arg)->constraints != NULL);
230
231			CCMALLOC_realloc((*arg)->constraints,
232			(arg)->n_used sizeof(CVXZONE_constraint));
233			}
234			else
235			{
236			if ((*arg)->constraints)
237			{
238			CCMALLOC_free((*arg)->constraints);
239			(*arg)->constraints = NULL;
240			}
241			}
242			}
243
244
245			DECMOD_CVXZONE void CVXZONE_maintain_canonize(CVXZONE_zone_ptr *arg)
246			{
247			assert(arg != NULL);
248			assert(*arg != NULL);
249
250
251			}
252
253			//End of cvxzone.c.