abc-master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
vecAtt.h
Go to the documentation of this file.
1 /**CFile****************************************************************
2 
3  FileName [vecAtt.h]
4 
5  SystemName [ABC: Logic synthesis and verification system.]
6 
7  PackageName [Resizable arrays.]
8 
9  Synopsis [Array of user-specified attiributes.]
10 
11  Author [Alan Mishchenko]
12 
13  Affiliation [UC Berkeley]
14 
15  Date [Ver. 1.0. Started - June 20, 2005.]
16 
17  Revision [$Id: vecAtt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
18 
19 ***********************************************************************/
20 
21 #ifndef ABC__misc__vec__vecAtt_h
22 #define ABC__misc__vec__vecAtt_h
23 
24 
25 ////////////////////////////////////////////////////////////////////////
26 /// INCLUDES ///
27 ////////////////////////////////////////////////////////////////////////
28 
29 #include <stdio.h>
30 
31 ABC_NAMESPACE_HEADER_START
32 
33 
34 ////////////////////////////////////////////////////////////////////////
35 /// PARAMETERS ///
36 ////////////////////////////////////////////////////////////////////////
37 
38 // various attributes
39 typedef enum {
40  VEC_ATTR_NONE = 0, // 0
41  VEC_ATTR_COPY, // 1
42  VEC_ATTR_LOCAL_AIG, // 2
43  VEC_ATTR_LOCAL_SOP, // 3
44  VEC_ATTR_LOCAL_BDD, // 4
45  VEC_ATTR_GLOBAL_AIG, // 5
46  VEC_ATTR_GLOBAL_SOP, // 6
47  VEC_ATTR_GLOBAL_BDD, // 7
48  VEC_ATTR_LEVEL, // 8
49  VEC_ATTR_LEVEL_REV, // 9
50  VEC_ATTR_RETIME_LAG, // 10
51  VEC_ATTR_FRAIG, // 11
52  VEC_ATTR_MVVAR, // 12
53  VEC_ATTR_DATA1, // 13
54  VEC_ATTR_DATA2, // 14
55  VEC_ATTR_TOTAL_NUM // 15
56 } Vec_AttrType_t;
57 
58 ////////////////////////////////////////////////////////////////////////
59 /// BASIC TYPES ///
60 ////////////////////////////////////////////////////////////////////////
61 
62 typedef struct Vec_Att_t_ Vec_Att_t;
63 struct Vec_Att_t_
64 {
65  // storage for attributes
66  int nCap; // the size of array allocated
67  // Removed pArrayInt as it's not 64-bit safe, it generates compiler
68  // warnings, and it's unused.
69  void ** pArrayPtr; // the pointer attribute array
70  // attribute specific info
71  void * pMan; // the manager for this attribute
72  void (*pFuncFreeMan) (void *); // the procedure to free the manager
73  void*(*pFuncStartObj)(void *); // the procedure to start one attribute
74  void (*pFuncFreeObj) (void *, void *); // the procedure to free one attribute
75 };
76 
77 ////////////////////////////////////////////////////////////////////////
78 /// MACRO DEFINITIONS ///
79 ////////////////////////////////////////////////////////////////////////
80 
81 ////////////////////////////////////////////////////////////////////////
82 /// FUNCTION DEFINITIONS ///
83 ////////////////////////////////////////////////////////////////////////
84 
85 /**Function*************************************************************
86 
87  Synopsis [Allocates a vector with the given capacity.]
88 
89  Description []
90 
91  SideEffects []
92 
93  SeeAlso []
94 
95 ***********************************************************************/
96 static inline Vec_Att_t * Vec_AttAlloc(
97  int nSize, void * pMan,
98  void (*pFuncFreeMan) (void *),
99  void*(*pFuncStartObj)(void *),
100  void (*pFuncFreeObj) (void *, void *) )
101 {
102  Vec_Att_t * p;
103  p = ABC_ALLOC( Vec_Att_t, 1 );
104  memset( p, 0, sizeof(Vec_Att_t) );
105  p->pMan = pMan;
106  p->pFuncFreeMan = pFuncFreeMan;
107  p->pFuncStartObj = pFuncStartObj;
108  p->pFuncFreeObj = pFuncFreeObj;
109  p->nCap = nSize? nSize : 16;
110  p->pArrayPtr = ABC_ALLOC( void *, p->nCap );
111  memset( p->pArrayPtr, 0, sizeof(void *) * p->nCap );
112  return p;
113 }
114 
115 /**Function*************************************************************
116 
117  Synopsis [Frees the vector.]
118 
119  Description []
120 
121  SideEffects []
122 
123  SeeAlso []
124 
125 ***********************************************************************/
126 static inline void * Vec_AttFree( Vec_Att_t * p, int fFreeMan )
127 {
128  void * pMan;
129  if ( p == NULL )
130  return NULL;
131  // free the attributes of objects
132  if ( p->pFuncFreeObj )
133  {
134  int i;
135  for ( i = 0; i < p->nCap; i++ )
136  if ( p->pArrayPtr[i] )
137  p->pFuncFreeObj( p->pMan, p->pArrayPtr[i] );
138  }
139  // free the memory manager
140  pMan = fFreeMan? NULL : p->pMan;
141  if ( p->pMan && fFreeMan )
142  p->pFuncFreeMan( p->pMan );
143  ABC_FREE( p->pArrayPtr );
144  ABC_FREE( p );
145  return pMan;
146 }
147 
148 /**Function*************************************************************
149 
150  Synopsis [Clears the vector.]
151 
152  Description []
153 
154  SideEffects []
155 
156  SeeAlso []
157 
158 ***********************************************************************/
159 static inline void Vec_AttClear( Vec_Att_t * p )
160 {
161  // free the attributes of objects
162  if ( p->pFuncFreeObj )
163  {
164  int i;
165  if ( p->pFuncFreeObj )
166  for ( i = 0; i < p->nCap; i++ )
167  if ( p->pArrayPtr[i] )
168  p->pFuncFreeObj( p->pMan, p->pArrayPtr[i] );
169  }
170  memset( p->pArrayPtr, 0, sizeof(void *) * p->nCap );
171 }
172 
173 /**Function*************************************************************
174 
175  Synopsis [Deletes one entry from the attribute manager.]
176 
177  Description []
178 
179  SideEffects []
180 
181  SeeAlso []
182 
183 ***********************************************************************/
184 static inline void Vec_AttFreeEntry( Vec_Att_t * p, int i )
185 {
186  if ( i >= p->nCap )
187  return;
188  if ( p->pMan )
189  {
190  if ( p->pArrayPtr[i] && p->pFuncFreeObj )
191  p->pFuncFreeObj( p->pMan, (void *)p->pArrayPtr[i] );
192  }
193  p->pArrayPtr[i] = NULL;
194 }
195 
196 /**Function*************************************************************
197 
198  Synopsis [Resizes the vector to the given capacity.]
199 
200  Description []
201 
202  SideEffects []
203 
204  SeeAlso []
205 
206 ***********************************************************************/
207 static inline void Vec_AttGrow( Vec_Att_t * p, int nCapMin )
208 {
209  if ( p->nCap >= nCapMin )
210  return;
211  p->pArrayPtr = ABC_REALLOC( void *, p->pArrayPtr, nCapMin );
212  memset( p->pArrayPtr + p->nCap, 0, sizeof(void *) * (nCapMin - p->nCap) );
213  p->nCap = nCapMin;
214 }
215 
216 /**Function*************************************************************
217 
218  Synopsis [Writes the entry into its place.]
219 
220  Description [Only works if the manager is not defined.]
221 
222  SideEffects []
223 
224  SeeAlso []
225 
226 ***********************************************************************/
227 static inline void Vec_AttWriteEntry( Vec_Att_t * p, int i, void * pEntry )
228 {
229  assert( p->pArrayPtr );
230  assert( p->pFuncStartObj == NULL );
231  if ( i >= p->nCap )
232  Vec_AttGrow( p, (2 * p->nCap > i)? 2 * p->nCap : i + 10 );
233  p->pArrayPtr[i] = pEntry;
234 }
235 
236 /**Function*************************************************************
237 
238  Synopsis [Returns the entry.]
239 
240  Description []
241 
242  SideEffects []
243 
244  SeeAlso []
245 
246 ***********************************************************************/
247 static inline void * Vec_AttEntry( Vec_Att_t * p, int i )
248 {
249  assert( p->pArrayPtr );
250  if ( i >= p->nCap )
251  Vec_AttGrow( p, (2 * p->nCap > i)? 2 * p->nCap : i + 10 );
252  if ( p->pArrayPtr[i] == NULL && p->pFuncStartObj )
253  p->pArrayPtr[i] = p->pFuncStartObj( p->pMan );
254  return p->pArrayPtr[i];
255 }
256 
257 /**Function*************************************************************
258 
259  Synopsis [Returns the entry.]
260 
261  Description []
262 
263  SideEffects []
264 
265  SeeAlso []
266 
267 ***********************************************************************/
268 static inline void * Vec_AttMan( Vec_Att_t * p )
269 {
270  return p->pMan;
271 }
272 
273 /**Function*************************************************************
274 
275  Synopsis [Returns the array of attributes.]
276 
277  Description []
278 
279  SideEffects []
280 
281  SeeAlso []
282 
283 ***********************************************************************/
284 static inline void ** Vec_AttArray( Vec_Att_t * p )
285 {
286  return p->pArrayPtr;
287 }
288 
289 
290 
291 ABC_NAMESPACE_HEADER_END
292 
293 #endif
294 
295 ////////////////////////////////////////////////////////////////////////
296 /// END OF FILE ///
297 ////////////////////////////////////////////////////////////////////////
298 
memset
char * memset()
Vec_AttFreeEntry
static void Vec_AttFreeEntry(Vec_Att_t *p, int i)
Definition: vecAtt.h:184
Vec_AttEntry
static void * Vec_AttEntry(Vec_Att_t *p, int i)
Definition: vecAtt.h:247
p
static Llb_Mgr_t * p
Definition: llb3Image.c:950
ABC_REALLOC
#define ABC_REALLOC(type, obj, num)
Definition: abc_global.h:233
Vec_AttGrow
static void Vec_AttGrow(Vec_Att_t *p, int nCapMin)
Definition: vecAtt.h:207
ABC_ALLOC
#define ABC_ALLOC(type, num)
Definition: abc_global.h:229
Vec_Att_t_::pMan
void * pMan
Definition: vecAtt.h:71
Vec_Att_t_::pFuncFreeMan
void(* pFuncFreeMan)(void *)
Definition: vecAtt.h:72
Vec_AttrType_t
Vec_AttrType_t
INCLUDES ///.
Definition: vecAtt.h:39
Vec_Att_t_::pFuncFreeObj
void(* pFuncFreeObj)(void *, void *)
Definition: vecAtt.h:74
Vec_AttMan
static void * Vec_AttMan(Vec_Att_t *p)
Definition: vecAtt.h:268
Vec_Att_t_::nCap
int nCap
Definition: vecAtt.h:66
ABC_NAMESPACE_HEADER_START
#define ABC_NAMESPACE_HEADER_START
NAMESPACES ///.
Definition: abc_global.h:105
Vec_Att_t_::pFuncStartObj
void *(* pFuncStartObj)(void *)
Definition: vecAtt.h:73
Vec_AttFree
static void * Vec_AttFree(Vec_Att_t *p, int fFreeMan)
Definition: vecAtt.h:126
ABC_NAMESPACE_HEADER_END
#define ABC_NAMESPACE_HEADER_END
Definition: abc_global.h:106
Vec_AttArray
static void ** Vec_AttArray(Vec_Att_t *p)
Definition: vecAtt.h:284
Vec_Att_t_::pArrayPtr
void ** pArrayPtr
Definition: vecAtt.h:69
Vec_AttAlloc
static Vec_Att_t * Vec_AttAlloc(int nSize, void *pMan, void(*pFuncFreeMan)(void *), void *(*pFuncStartObj)(void *), void(*pFuncFreeObj)(void *, void *))
MACRO DEFINITIONS ///.
Definition: vecAtt.h:96
ABC_FREE
#define ABC_FREE(obj)
Definition: abc_global.h:232
Vec_AttClear
static void Vec_AttClear(Vec_Att_t *p)
Definition: vecAtt.h:159
Vec_AttWriteEntry
static void Vec_AttWriteEntry(Vec_Att_t *p, int i, void *pEntry)
Definition: vecAtt.h:227
assert
#define assert(ex)
Definition: util_old.h:213
Vec_Att_t_
Definition: vecAtt.h:63