OLD | NEW |
| (Empty) |
1 /***************************************************************************/ | |
2 /* */ | |
3 /* cf2arrst.c */ | |
4 /* */ | |
5 /* Adobe's code for Array Stacks (body). */ | |
6 /* */ | |
7 /* Copyright 2007-2013 Adobe Systems Incorporated. */ | |
8 /* */ | |
9 /* This software, and all works of authorship, whether in source or */ | |
10 /* object code form as indicated by the copyright notice(s) included */ | |
11 /* herein (collectively, the "Work") is made available, and may only be */ | |
12 /* used, modified, and distributed under the FreeType Project License, */ | |
13 /* LICENSE.TXT. Additionally, subject to the terms and conditions of the */ | |
14 /* FreeType Project License, each contributor to the Work hereby grants */ | |
15 /* to any individual or legal entity exercising permissions granted by */ | |
16 /* the FreeType Project License and this section (hereafter, "You" or */ | |
17 /* "Your") a perpetual, worldwide, non-exclusive, no-charge, */ | |
18 /* royalty-free, irrevocable (except as stated in this section) patent */ | |
19 /* license to make, have made, use, offer to sell, sell, import, and */ | |
20 /* otherwise transfer the Work, where such license applies only to those */ | |
21 /* patent claims licensable by such contributor that are necessarily */ | |
22 /* infringed by their contribution(s) alone or by combination of their */ | |
23 /* contribution(s) with the Work to which such contribution(s) was */ | |
24 /* submitted. If You institute patent litigation against any entity */ | |
25 /* (including a cross-claim or counterclaim in a lawsuit) alleging that */ | |
26 /* the Work or a contribution incorporated within the Work constitutes */ | |
27 /* direct or contributory patent infringement, then any patent licenses */ | |
28 /* granted to You under this License for that Work shall terminate as of */ | |
29 /* the date such litigation is filed. */ | |
30 /* */ | |
31 /* By using, modifying, or distributing the Work you indicate that you */ | |
32 /* have read and understood the terms and conditions of the */ | |
33 /* FreeType Project License as well as those provided in this section, */ | |
34 /* and you accept them fully. */ | |
35 /* */ | |
36 /***************************************************************************/ | |
37 | |
38 | |
39 #include "cf2ft.h" | |
40 #include "../../include/freetype/internal/ftdebug.h" | |
41 | |
42 #include "cf2glue.h" | |
43 #include "cf2arrst.h" | |
44 | |
45 #include "cf2error.h" | |
46 | |
47 | |
48 /* | |
49 * CF2_ArrStack uses an error pointer, to enable shared errors. | |
50 * Shared errors are necessary when multiple objects allow the program | |
51 * to continue after detecting errors. Only the first error should be | |
52 * recorded. | |
53 */ | |
54 | |
55 FT_LOCAL_DEF( void ) | |
56 cf2_arrstack_init( CF2_ArrStack arrstack, | |
57 FT_Memory memory, | |
58 FT_Error* error, | |
59 size_t sizeItem ) | |
60 { | |
61 FT_ASSERT( arrstack != NULL ); | |
62 | |
63 /* initialize the structure */ | |
64 arrstack->memory = memory; | |
65 arrstack->error = error; | |
66 arrstack->sizeItem = sizeItem; | |
67 arrstack->allocated = 0; | |
68 arrstack->chunk = 10; /* chunks of 10 items */ | |
69 arrstack->count = 0; | |
70 arrstack->totalSize = 0; | |
71 arrstack->ptr = NULL; | |
72 } | |
73 | |
74 | |
75 FT_LOCAL_DEF( void ) | |
76 cf2_arrstack_finalize( CF2_ArrStack arrstack ) | |
77 { | |
78 FT_Memory memory = arrstack->memory; /* for FT_FREE */ | |
79 | |
80 | |
81 FT_ASSERT( arrstack != NULL ); | |
82 | |
83 arrstack->allocated = 0; | |
84 arrstack->count = 0; | |
85 arrstack->totalSize = 0; | |
86 | |
87 /* free the data buffer */ | |
88 FT_FREE( arrstack->ptr ); | |
89 } | |
90 | |
91 | |
92 /* allocate or reallocate the buffer size; */ | |
93 /* return false on memory error */ | |
94 static FT_Bool | |
95 cf2_arrstack_setNumElements( CF2_ArrStack arrstack, | |
96 size_t numElements ) | |
97 { | |
98 FT_ASSERT( arrstack != NULL ); | |
99 | |
100 { | |
101 FT_Error error = FT_Err_Ok; /* for FT_REALLOC */ | |
102 FT_Memory memory = arrstack->memory; /* for FT_REALLOC */ | |
103 | |
104 FT_Long newSize = (FT_Long)( numElements * arrstack->sizeItem ); | |
105 | |
106 | |
107 if ( numElements > LONG_MAX / arrstack->sizeItem ) | |
108 goto exit; | |
109 | |
110 | |
111 FT_ASSERT( newSize > 0 ); /* avoid realloc with zero size */ | |
112 | |
113 if ( !FT_REALLOC( arrstack->ptr, arrstack->totalSize, newSize ) ) | |
114 { | |
115 arrstack->allocated = numElements; | |
116 arrstack->totalSize = newSize; | |
117 | |
118 if ( arrstack->count > numElements ) | |
119 { | |
120 /* we truncated the list! */ | |
121 CF2_SET_ERROR( arrstack->error, Stack_Overflow ); | |
122 arrstack->count = numElements; | |
123 return FALSE; | |
124 } | |
125 | |
126 return TRUE; /* success */ | |
127 } | |
128 } | |
129 | |
130 exit: | |
131 /* if there's not already an error, store this one */ | |
132 CF2_SET_ERROR( arrstack->error, Out_Of_Memory ); | |
133 | |
134 return FALSE; | |
135 } | |
136 | |
137 | |
138 /* set the count, ensuring allocation is sufficient */ | |
139 FT_LOCAL_DEF( void ) | |
140 cf2_arrstack_setCount( CF2_ArrStack arrstack, | |
141 size_t numElements ) | |
142 { | |
143 FT_ASSERT( arrstack != NULL ); | |
144 | |
145 if ( numElements > arrstack->allocated ) | |
146 { | |
147 /* expand the allocation first */ | |
148 if ( !cf2_arrstack_setNumElements( arrstack, numElements ) ) | |
149 return; | |
150 } | |
151 | |
152 arrstack->count = numElements; | |
153 } | |
154 | |
155 | |
156 /* clear the count */ | |
157 FT_LOCAL_DEF( void ) | |
158 cf2_arrstack_clear( CF2_ArrStack arrstack ) | |
159 { | |
160 FT_ASSERT( arrstack != NULL ); | |
161 | |
162 arrstack->count = 0; | |
163 } | |
164 | |
165 | |
166 /* current number of items */ | |
167 FT_LOCAL_DEF( size_t ) | |
168 cf2_arrstack_size( const CF2_ArrStack arrstack ) | |
169 { | |
170 FT_ASSERT( arrstack != NULL ); | |
171 | |
172 return arrstack->count; | |
173 } | |
174 | |
175 | |
176 FT_LOCAL_DEF( void* ) | |
177 cf2_arrstack_getBuffer( const CF2_ArrStack arrstack ) | |
178 { | |
179 FT_ASSERT( arrstack != NULL ); | |
180 | |
181 return arrstack->ptr; | |
182 } | |
183 | |
184 | |
185 /* return pointer to the given element */ | |
186 FT_LOCAL_DEF( void* ) | |
187 cf2_arrstack_getPointer( const CF2_ArrStack arrstack, | |
188 size_t idx ) | |
189 { | |
190 void* newPtr; | |
191 | |
192 | |
193 FT_ASSERT( arrstack != NULL ); | |
194 | |
195 if ( idx >= arrstack->count ) | |
196 { | |
197 /* overflow */ | |
198 CF2_SET_ERROR( arrstack->error, Stack_Overflow ); | |
199 idx = 0; /* choose safe default */ | |
200 } | |
201 | |
202 newPtr = (FT_Byte*)arrstack->ptr + idx * arrstack->sizeItem; | |
203 | |
204 return newPtr; | |
205 } | |
206 | |
207 | |
208 /* push (append) an element at the end of the list; */ | |
209 /* return false on memory error */ | |
210 /* TODO: should there be a length param for extra checking? */ | |
211 FT_LOCAL_DEF( void ) | |
212 cf2_arrstack_push( CF2_ArrStack arrstack, | |
213 const void* ptr ) | |
214 { | |
215 FT_ASSERT( arrstack != NULL ); | |
216 | |
217 if ( arrstack->count == arrstack->allocated ) | |
218 { | |
219 /* grow the buffer by one chunk */ | |
220 if ( !cf2_arrstack_setNumElements( | |
221 arrstack, arrstack->allocated + arrstack->chunk ) ) | |
222 { | |
223 /* on error, ignore the push */ | |
224 return; | |
225 } | |
226 } | |
227 | |
228 FT_ASSERT( ptr != NULL ); | |
229 | |
230 { | |
231 size_t offset = arrstack->count * arrstack->sizeItem; | |
232 void* newPtr = (FT_Byte*)arrstack->ptr + offset; | |
233 | |
234 | |
235 FT_MEM_COPY( newPtr, ptr, arrstack->sizeItem ); | |
236 arrstack->count += 1; | |
237 } | |
238 } | |
239 | |
240 | |
241 /* END */ | |
OLD | NEW |