Update copyright to LGPL on all files
[dyninst.git] / dyninstAPI / src / bitArray.C
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31 #include "dyninstAPI/src/inst.h"
32
33
34 #ifndef BITARRAY_HDR
35 #define BITARRAY_HDR
36
37
38 void bitArray::dispose()
39 {
40   free(data);
41   data = NULL;
42 }
43
44 bitArray::bitArray()
45 {
46   data = NULL;
47 }
48
49
50 void bitArray::bitarray_init(int size,bitArray* bitarray)
51 {
52         int bytesize;
53
54         bitarray->size = size;
55         if(!(size % 8))
56                 bytesize = size / 8;
57         else
58                 bytesize = (size / 8) + 1;
59
60         bitarray->data = (char*) malloc (sizeof(char)*bytesize);
61
62         memset(bitarray->data,'\0',bytesize);
63 }
64 void bitArray::bitarray_set(int location,bitArray* bitarray)
65 {
66   int pass,pos;
67   char* ptr;
68   unsigned char mask = 0x80;
69   
70   if(location > bitarray->size){
71     fprintf(stderr,"trying to set a bit more than the size\n");
72     return;
73   }
74   pass = location / 8;
75         pos = location % 8;
76
77         ptr = bitarray->data + pass;
78         mask = mask >> pos;
79
80         *ptr = (*ptr) | mask;
81 }
82 void bitArray::bitarray_unset(int location,bitArray* bitarray)
83 {
84         int pass,pos;
85         char* ptr;
86         unsigned char mask = 0x80;
87         
88         if(location > bitarray->size){
89                 fprintf(stderr,"trying to unset a bit more than the size\n");
90                 return;
91         }
92         pass = location / 8;
93         pos = location % 8;
94  
95         ptr = bitarray->data + pass;
96         mask = mask >> pos;
97  
98         *ptr = (*ptr) & (~mask);
99 }
100 int bitArray::bitarray_check(int location,bitArray* bitarray)
101 {
102         int pass,pos;
103         char* ptr;
104         char unsigned mask = 0x80;
105         
106         if(location < 0)
107                 return FALSE;
108
109         if(location > bitarray->size){
110                 fprintf(stderr,"trying to unset a bit more than the size\n");
111                 return FALSE;
112         }
113         pass = location / 8;
114         pos = location % 8;
115
116         ptr = bitarray->data + pass;
117         mask = mask >> pos;
118
119         if((*ptr) & mask)
120                 return TRUE;
121         return FALSE;
122 }
123
124 void bitArray::bitarray_and(bitArray* s1,bitArray* s2,bitArray* r)
125 {
126         int bytesize,i;
127
128         if(s1->size != s2->size){
129                 fprintf(stderr,"size do not match to and \n");
130                 return ;
131         }
132         if(s1->size % 8)
133                 bytesize = (s1->size / 8)+1;
134         else
135                 bytesize = s1->size / 8;
136         r->size = s1->size;
137         for(i=0;i<bytesize;i++)
138                 *((r->data)+i) = *((s1->data)+i) & *((s2->data)+i);
139 }
140 void bitArray::bitarray_or(bitArray* s1,bitArray* s2,bitArray* r)
141 {
142         int bytesize,i;
143
144         if(s1->size != s2->size){
145                 fprintf(stderr,"size do not match to and \n");
146                 return ;
147         }
148         if(s1->size % 8)
149                 bytesize = (s1->size / 8)+1;
150         else
151                 bytesize = s1->size / 8;
152         r->size = s1->size;
153         for(i=0;i<bytesize;i++)
154                 *((r->data)+i) = *((s1->data)+i) | *((s2->data)+i);
155 }
156 void bitArray::bitarray_copy(bitArray* s1,bitArray* s2)
157 {
158         int bytesize,i;
159
160         if(s1->size != s2->size){
161                 fprintf(stderr,"size do not match to and \n");
162                 return ;
163         }
164         if(s1->size % 8)
165                 bytesize = (s1->size / 8)+1;
166         else
167                 bytesize = s1->size / 8;
168
169         for(i=0;i<bytesize;i++)
170                 *((s1->data)+i) = *((s2->data)+i);
171 }
172 void bitArray::bitarray_comp(bitArray* s1,bitArray* s2)
173 {
174         int bytesize,i;
175
176         if(s1->size != s2->size){
177                 fprintf(stderr,"size do not match to and \n");
178                 return ;
179         }
180         if(s1->size % 8)
181                 bytesize = (s1->size / 8)+1;
182         else
183                 bytesize = s1->size / 8;
184
185         for(i=0;i<bytesize;i++)
186                 *((s1->data)+i) = ~(*((s2->data)+i));
187 }
188 int bitArray::bitarray_same(bitArray* s1,bitArray* s2)
189 {
190         int bytesize,i;
191
192         if(s1->size != s2->size){
193                 fprintf(stderr,"size do not match to and \n");
194                 return FALSE;
195         }
196         if(s1->size % 8)
197                 bytesize = (s1->size / 8)+1;
198         else
199                 bytesize = s1->size / 8;
200         for(i=0;i<bytesize;i++)
201                 if(*((s1->data)+i) ^ *((s2->data)+i))
202                         return FALSE;
203         return TRUE;
204 }
205         
206 void bitArray::bitarray_diff(bitArray* s1,bitArray* s2,bitArray* r)
207 {
208         int bytesize,i;
209  
210         if(s1->size != s2->size){
211                 fprintf(stderr,"size do not match to and \n");
212                 return ;
213         }
214         if(s1->size % 8)
215                 bytesize = (s1->size / 8)+1;
216         else
217                 bytesize = s1->size / 8;
218         r->size = s1->size;
219         for(i=0;i<bytesize;i++)
220                 *((r->data)+i) = *((s1->data)+i) & (~(*((s2->data)+i)));
221 }
222
223
224 #endif