?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* config/i860/i860-protos.h (i860_va_arg): Remove.
[official-gcc.git] / gcc / vec.h
blob84b8dbf978b90f30e00cffeeea971f94e05f03e0
1 /* Vector API for GNU compiler.
2 Copyright (C) 2004 Free Software Foundation, Inc.
3 Contributed by Nathan Sidwell <nathan@codesourcery.com>
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
21
22 #ifndef GCC_VEC_H
23 #define GCC_VEC_H
24
25 /* The macros here implement a set of templated vector types and
26 associated interfaces. These templates are implemented with
27 macros, as we're not in C++ land. The interface functions are
28 typesafe and use static inline functions, sometimes backed by
29 out-of-line generic functions. The vectors are designed to
30 interoperate with the GTY machinery.
31
32 Because of the different behaviour of objects and of pointers to
33 objects, there are two flavours. One to deal with a vector of
34 pointers to objects, and one to deal with a vector of objects
35 themselves. Both of these pass pointers to objects around -- in
36 the former case the pointers are stored into the vector and in the
37 latter case the pointers are dereferenced and the objects copied
38 into the vector. Therefore, when using a vector of pointers, the
39 objects pointed to must be long lived, but when dealing with a
40 vector of objects, the source objects need not be.
41
42 The vectors are implemented using the trailing array idiom, thus
43 they are not resizeable without changing the address of the vector
44 object itself. This means you cannot have variables or fields of
45 vector type -- always use a pointer to a vector. The one exception
46 is the final field of a structure, which could be a vector type.
47 You will have to use the embedded_size & embedded_init calls to
48 create such objects, and they will probably not be resizeable (so
49 don't use the 'safe' allocation variants). The trailing array
50 idiom is used (rather than a pointer to an array of data), because,
51 if we allow NULL to also represent an empty vector, empty vectors
52 occupy minimal space in the structure containing them.
53
54 Each operation that increases the number of active elements is
55 available in 'quick' and 'safe' variants. The former presumes that
56 there is sufficient allocated space for the operation to succeed
57 (it aborts if there is not). The latter will reallocate the
58 vector, if needed. Reallocation causes an exponential increase in
59 vector size. If you know you will be adding N elements, it would
60 be more efficient to use the reserve operation before adding the
61 elements with the 'quick' operation. You may also use the reserve
62 operation with a -1 operand, to gain control over exactly when
63 reallocation occurs.
64
65 You should prefer the push and pop operations, as they append and
66 remove from the end of the vector. If you need to remove several
67 items in one go, use the truncate operation. The insert and remove
68 operations allow you to change elements in the middle of the
69 vector. There are two remove operations, one which preserves the
70 element ordering 'ordered_remove', and one which does not
71 'unordered_remove'. The latter function copies the end element
72 into the removed slot, rather than invoke a memmove operation.
73
74 Vector types are defined using a DEF_VEC_x(TYPEDEF) macro, and
75 variables of vector type are declared using a VEC(TYPEDEF)
76 macro. The 'x' letter indicates whether TYPEDEF is a pointer (P) or
77 object (O) type.
78
79 An example of their use would be,
80
81 DEF_VEC_P(tree); // define a vector of tree pointers. This must
82 // appear at file scope.
83
84 struct my_struct {
85 VEC(tree) *v; // A (pointer to) a vector of tree pointers.
86 };
87
88 struct my_struct *s;
89
90 if (VEC_length(tree,s->v)) { we have some contents }
91 VEC_safe_push(tree,s->v,decl); // append some decl onto the end
92 for (ix = 0; (t = VEC_iterate(tree,s->v,ix)); ix++)
93 { do something with t }
94
95 */
96
97 /* Macros to invoke API calls. A single macro works for both pointer
98 and object vectors, but the argument and return types might well be
99 different. In each macro, TDEF is the typedef of the vector
100 elements. Some of these macros pass the vector, V, by reference
101 (by taking its address), this is noted in the descriptions. */
102
103 /* Length of vector
104 size_t VEC_T_length(const VEC(T) *v);
105
106 Return the number of active elements in V. V can be NULL, in which
107 case zero is returned. */
108 #define VEC_length(TDEF,V) (VEC_OP(TDEF,length)(V))
109
110 /* Get the final element of the vector.
111 T VEC_T_last(VEC(T) *v); // Pointer
112 T *VEC_T_last(VEC(T) *v); // Object
113
114 Return the final element. If V is empty, abort. */
115 #define VEC_last(TDEF,V) (VEC_OP(TDEF,last)(V))
116
117 /* Index into vector
118 T VEC_T_index(VEC(T) *v, size_t ix); // Pointer
119 T *VEC_T_index(VEC(T) *v, size_t ix); // Object
120
121 Return the IX'th element. If IX is outside the domain of V,
122 abort. */
123 #define VEC_index(TDEF,V,I) (VEC_OP(TDEF,index)(V,I))
124
125 /* Iterate over vector
126 T VEC_T_index(VEC(T) *v, size_t ix); // Pointer
127 T *VEC_T_index(VEC(T) *v, size_t ix); // Object
128
129 Return the IX'th element or NULL. Use this to iterate over the
130 elements of a vector as follows,
131
132 for (ix = 0; (ptr = VEC_iterate(T,v,ix)); ix++)
133 continue; */
134 #define VEC_iterate(TDEF,V,I) (VEC_OP(TDEF,iterate)(V,I))
135
136 /* Allocate new vector.
137 VEC(T) *VEC_T_alloc(int reserve);
138
139 Allocate a new vector with space for RESERVE objects. If RESERVE
140 is <= 0, a default number of slots are created. */
141 #define VEC_alloc(TDEF,A) (VEC_OP(TDEF,alloc)(A MEM_STAT_INFO))
142
143 /* Use these to determine the required size and initialization of a
144 vector embedded within another structure (as the final member).
145
146 size_t VEC_T_embedded_size(int reserve);
147 void VEC_T_embedded_init(VEC(T) *v, int reserve);
148
149 These allow the caller to perform the memory allocation. */
150 #define VEC_embedded_size(TDEF,A) (VEC_OP(TDEF,embedded_size)(A))
151 #define VEC_embedded_init(TDEF,O,A) (VEC_OP(TDEF,embedded_init)(O,A))
152
153 /* Reserve space.
154 int VEC_T_reserve(VEC(T) *&v, int reserve);
155
156 Ensure that V has at least RESERVE slots available, if RESERVE is
157 >= 0. If RESERVE < 0, ensure that there is at least one spare
158 slot. These differ in their reallocation behaviour, the first will
159 not create additionsl headroom, but the second mechanism will
160 perform the usual exponential headroom increase. Note this can
161 cause V to be reallocated. Returns non-zero iff reallocation
162 actually occurred. */
163 #define VEC_reserve(TDEF,V,R) (VEC_OP(TDEF,reserve)(&(V),R MEM_STAT_INFO))
164
165 /* Push object with no reallocation
166 T *VEC_T_quick_push (VEC(T) *v, T obj); // Pointer
167 T *VEC_T_quick_push (VEC(T) *v, T *obj); // Object
168
169 Push a new element onto the end, returns a pointer to the slot
170 filled in. For object vectors, the new value can be NULL, in which
171 case NO initialization is performed. Aborts if there is
172 insufficient space in the vector. */
173 #define VEC_quick_push(TDEF,V,O) (VEC_OP(TDEF,quick_push)(V,O))
174
175 /* Push object with reallocation
176 T *VEC_T_safe_push (VEC(T) *&v, T obj); // Pointer
177 T *VEC_T_safe_push (VEC(T) *&v, T *obj); // Object
178
179 Push a new element onto the end, returns a pointer to the slot
180 filled in. For object vectors, the new value can be NULL, in which
181 case NO initialization is performed. Reallocates V, if needed. */
182 #define VEC_safe_push(TDEF,V,O) (VEC_OP(TDEF,safe_push)(&(V),O MEM_STAT_INFO))
183
184 /* Pop element off end
185 T VEC_T_pop (VEC(T) *v); // Pointer
186 void VEC_T_pop (VEC(T) *v); // Object
187
188 Pop the last element off the end. Returns the element popped, for
189 pointer vectors. */
190 #define VEC_pop(TDEF,V) (VEC_OP(TDEF,pop)(V))
191
192 /* Truncate to specific length
193 void VEC_T_truncate (VEC(T) *v, size_t len);
194
195 Set the length as specified. This is an O(1) operation. */
196 #define VEC_truncate(TDEF,V,I) (VEC_OP(TDEF,truncate)(V,I))
197
198 /* Replace element
199 T VEC_T_replace (VEC(T) *v, size_t ix, T val); // Pointer
200 T *VEC_T_replace (VEC(T) *v, size_t ix, T *val); // Object
201
202 Replace the IXth element of V with a new value, VAL. For pointer
203 vectors returns the original value. For object vectors returns a
204 pointer to the new value. For object vectors the new value can be
205 NULL, in which case no overwriting of the slot is actually
206 performed. */
207 #define VEC_replace(TDEF,V,I,O) (VEC_OP(TDEF,replace)(V,I,O))
208
209 /* Insert object with no reallocation
210 T *VEC_T_quick_insert (VEC(T) *v, size_t ix, T val); // Pointer
211 T *VEC_T_quick_insert (VEC(T) *v, size_t ix, T *val); // Object
212
213 Insert an element, VAL, at the IXth position of V. Return a pointer
214 to the slot created. For vectors of object, the new value can be
215 NULL, in which case no initialization of the inserted slot takes
216 place. Aborts if there is insufficient space. */
217 #define VEC_quick_insert(TDEF,V,I,O) (VEC_OP(TDEF,quick_insert)(V,I,O))
218
219 /* Insert object with reallocation
220 T *VEC_T_safe_insert (VEC(T) *&v, size_t ix, T val); // Pointer
221 T *VEC_T_safe_insert (VEC(T) *&v, size_t ix, T *val); // Object
222
223 Insert an element, VAL, at the IXth position of V. Return a pointer
224 to the slot created. For vectors of object, the new value can be
225 NULL, in which case no initialization of the inserted slot takes
226 place. Reallocate V, if necessary. */
227 #define VEC_safe_insert(TDEF,V,I,O) (VEC_OP(TDEF,safe_insert)(&(V),I,O MEM_STAT_INFO))
228
229 /* Remove element retaining order
230 T VEC_T_ordered_remove (VEC(T) *v, size_t ix); // Pointer
231 void VEC_T_ordered_remove (VEC(T) *v, size_t ix); // Object
232
233 Remove an element from the IXth position of V. Ordering of
234 remaining elements is preserverd. For pointer vectors returns the
235 removed object. This is an O(N) operation due to a memmove. */
236 #define VEC_ordered_remove(TDEF,V,I) (VEC_OP(TDEF,ordered_remove)(V,I))
237
238 /* Remove element destroying order
239 T VEC_T_unordered_remove (VEC(T) *v, size_t ix); // Pointer
240 void VEC_T_unordered_remove (VEC(T) *v, size_t ix); // Object
241
242 Remove an element from the IXth position of V. Ordering of
243 remaining elements is destroyed. For pointer vectors returns the
244 removed object. This is an O(1) operation. */
245 #define VEC_unordered_remove(TDEF,V,I) (VEC_OP(TDEF,unordered_remove)(V,I))
246
247 #if !IN_GENGTYPE
248 /* Reallocate an array of elements with prefix. */
249 extern void *vec_p_reserve (void *, int MEM_STAT_DECL);
250 extern void *vec_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL);
251
252 #if ENABLE_CHECKING
253 extern void vec_assert_fail (const char *, const char *,
254 const char *, size_t, const char *)
255 ATTRIBUTE_NORETURN;
256 #define VEC_ASSERT_FAIL(OP,VEC) \
257 vec_assert_fail (OP,#VEC,__FILE__,__LINE__,__FUNCTION__)
258
259 #define VEC_ASSERT(EXPR,OP,TDEF) \
260 (void)((EXPR) ? 0 : (VEC_ASSERT_FAIL(OP,VEC(TDEF)), 0))
261 #else
262 #define VEC_ASSERT(EXPR,OP,TYPE) (void)(EXPR)
263 #endif
264
265 #define VEC(TDEF) VEC_##TDEF
266 #define VEC_OP(TDEF,OP) VEC_OP_(VEC(TDEF),OP)
267 #define VEC_OP_(VEC,OP) VEC_OP__(VEC,OP)
268 #define VEC_OP__(VEC,OP) VEC ## _ ## OP
269 #else /* IN_GENGTYPE */
270 #define VEC(TDEF) VEC_ TDEF
271 #define VEC_STRINGIFY(X) VEC_STRINGIFY_(X)
272 #define VEC_STRINGIFY_(X) #X
273 #undef GTY
274 #endif /* IN_GENGTYPE */
275
276 #define VEC_TDEF(TDEF) \
277 typedef struct VEC (TDEF) GTY(()) \
278 { \
279 size_t num; \
280 size_t alloc; \
281 TDEF GTY ((length ("%h.num"))) vec[1]; \
282 } VEC (TDEF)
283
284 /* Vector of pointer to object. */
285 #if IN_GENGTYPE
286 {"DEF_VEC_P", VEC_STRINGIFY (VEC_TDEF (#)) ";", NULL},
287 #else
288
289 #define DEF_VEC_P(TDEF) \
290 VEC_TDEF (TDEF); \
291 \
292 static inline size_t VEC_OP (TDEF,length) \
293 (const VEC (TDEF) *vec_) \
294 { \
295 return vec_ ? vec_->num : 0; \
296 } \
297 \
298 static inline TDEF VEC_OP (TDEF,last) \
299 (const VEC (TDEF) *vec_) \
300 { \
301 VEC_ASSERT (vec_ && vec_->num, "last", TDEF); \
302 \
303 return vec_->vec[vec_->num - 1]; \
304 } \
305 \
306 static inline TDEF VEC_OP (TDEF,index) \
307 (const VEC (TDEF) *vec_, size_t ix_) \
308 { \
309 VEC_ASSERT (vec_ && ix_ < vec_->num, "index", TDEF); \
310 \
311 return vec_->vec[ix_]; \
312 } \
313 \
314 static inline TDEF VEC_OP (TDEF,iterate) \
315 (const VEC (TDEF) *vec_, size_t ix_) \
316 { \
317 return vec_ && ix_ < vec_->num ? vec_->vec[ix_] : NULL; \
318 } \
319 \
320 static inline VEC (TDEF) *VEC_OP (TDEF,alloc MEM_STAT_DECL) \
321 (int alloc_) \
322 { \
323 return vec_p_reserve (NULL, alloc_ - !alloc_ PASS_MEM_STAT); \
324 } \
325 \
326 static inline size_t VEC_OP (TDEF,embedded_size) \
327 (int alloc_) \
328 { \
329 return offsetof (VEC(TDEF),vec) + alloc_ * sizeof(TDEF); \
330 } \
331 \
332 static inline void VEC_OP (TDEF,embedded_init) \
333 (VEC (TDEF) *vec_, int alloc_) \
334 { \
335 vec_->num = 0; \
336 vec_->alloc = alloc_; \
337 } \
338 \
339 static inline int VEC_OP (TDEF,reserve) \
340 (VEC (TDEF) **vec_, int alloc_ MEM_STAT_DECL) \
341 { \
342 int extend = !*vec_ || ((*vec_)->alloc - (*vec_)->num \
343 < (size_t)(alloc_ < 0 ? 1 : alloc_)); \
344 \
345 if (extend) \
346 *vec_ = vec_p_reserve (*vec_, alloc_ PASS_MEM_STAT); \
347 \
348 return extend; \
349 } \
350 \
351 static inline TDEF *VEC_OP (TDEF,quick_push) \
352 (VEC (TDEF) *vec_, TDEF obj_) \
353 { \
354 TDEF *slot_; \
355 \
356 VEC_ASSERT (vec_->num < vec_->alloc, "push", TDEF); \
357 slot_ = &vec_->vec[vec_->num++]; \
358 *slot_ = obj_; \
359 \
360 return slot_; \
361 } \
362 \
363 static inline TDEF *VEC_OP (TDEF,safe_push) \
364 (VEC (TDEF) **vec_, TDEF obj_ MEM_STAT_DECL) \
365 { \
366 VEC_OP (TDEF,reserve) (vec_, -1 PASS_MEM_STAT); \
367 \
368 return VEC_OP (TDEF,quick_push) (*vec_, obj_); \
369 } \
370 \
371 static inline TDEF VEC_OP (TDEF,pop) \
372 (VEC (TDEF) *vec_) \
373 { \
374 TDEF obj_; \
375 \
376 VEC_ASSERT (vec_->num, "pop", TDEF); \
377 obj_ = vec_->vec[--vec_->num]; \
378 \
379 return obj_; \
380 } \
381 \
382 static inline void VEC_OP (TDEF,truncate) \
383 (VEC (TDEF) *vec_, size_t size_) \
384 { \
385 VEC_ASSERT (vec_->num >= size_, "truncate", TDEF); \
386 vec_->num = size_; \
387 } \
388 \
389 static inline TDEF VEC_OP (TDEF,replace) \
390 (VEC (TDEF) *vec_, size_t ix_, TDEF obj_) \
391 { \
392 TDEF old_obj_; \
393 \
394 VEC_ASSERT (ix_ < vec_->num, "replace", TDEF); \
395 old_obj_ = vec_->vec[ix_]; \
396 vec_->vec[ix_] = obj_; \
397 \
398 return old_obj_; \
399 } \
400 \
401 static inline TDEF *VEC_OP (TDEF,quick_insert) \
402 (VEC (TDEF) *vec_, size_t ix_, TDEF obj_) \
403 { \
404 TDEF *slot_; \
405 \
406 VEC_ASSERT (vec_->num < vec_->alloc, "insert", TDEF); \
407 VEC_ASSERT (ix_ <= vec_->num, "insert", TDEF); \
408 slot_ = &vec_->vec[ix_]; \
409 memmove (slot_ + 1, slot_, vec_->num++ - ix_); \
410 *slot_ = obj_; \
411 \
412 return slot_; \
413 } \
414 \
415 static inline TDEF *VEC_OP (TDEF,safe_insert) \
416 (VEC (TDEF) **vec_, size_t ix_, TDEF obj_ MEM_STAT_DECL) \
417 { \
418 VEC_OP (TDEF,reserve) (vec_, -1 PASS_MEM_STAT); \
419 \
420 return VEC_OP (TDEF,quick_insert) (*vec_, ix_, obj_); \
421 } \
422 \
423 static inline TDEF VEC_OP (TDEF,ordered_remove) \
424 (VEC (TDEF) *vec_, size_t ix_) \
425 { \
426 TDEF *slot_; \
427 TDEF obj_; \
428 \
429 VEC_ASSERT (ix_ < vec_->num, "remove", TDEF); \
430 slot_ = &vec_->vec[ix_]; \
431 obj_ = *slot_; \
432 memmove (slot_, slot_ + 1, --vec_->num - ix_); \
433 \
434 return obj_; \
435 } \
436 \
437 static inline TDEF VEC_OP (TDEF,unordered_remove) \
438 (VEC (TDEF) *vec_, size_t ix_) \
439 { \
440 TDEF *slot_; \
441 TDEF obj_; \
442 \
443 VEC_ASSERT (ix_ < vec_->num, "remove", TDEF); \
444 slot_ = &vec_->vec[ix_]; \
445 obj_ = *slot_; \
446 *slot_ = vec_->vec[--vec_->num]; \
447 \
448 return obj_; \
449 } \
450 \
451 struct vec_swallow_trailing_semi
452 #endif
453
454 /* Vector of object. */
455 #if IN_GENGTYPE
456 {"DEF_VEC_O", VEC_STRINGIFY (VEC_TDEF (#)) ";", NULL},
457 #else
458
459 #define DEF_VEC_O(TDEF) \
460 VEC_TDEF (TDEF); \
461 \
462 static inline size_t VEC_OP (TDEF,length) \
463 (const VEC (TDEF) *vec_) \
464 { \
465 return vec_ ? vec_->num : 0; \
466 } \
467 \
468 static inline TDEF *VEC_OP (TDEF,last) \
469 (VEC (TDEF) *vec_) \
470 { \
471 VEC_ASSERT (vec_ && vec_->num, "last", TDEF); \
472 \
473 return &vec_->vec[vec_->num - 1]; \
474 } \
475 \
476 static inline TDEF *VEC_OP (TDEF,index) \
477 (VEC (TDEF) *vec_, size_t ix_) \
478 { \
479 VEC_ASSERT (vec_ && ix_ < vec_->num, "index", TDEF); \
480 \
481 return &vec_->vec[ix_]; \
482 } \
483 \
484 static inline TDEF *VEC_OP (TDEF,iterate) \
485 (VEC (TDEF) *vec_, size_t ix_) \
486 { \
487 return vec_ && ix_ < vec_->num ? &vec_->vec[ix_] : NULL; \
488 } \
489 \
490 static inline VEC (TDEF) *VEC_OP (TDEF,alloc) \
491 (int alloc_ MEM_STAT_DECL) \
492 { \
493 return vec_o_reserve (NULL, alloc_ - !alloc_, \
494 offsetof (VEC(TDEF),vec), sizeof (TDEF) \
495 PASS_MEM_STAT); \
496 } \
497 \
498 static inline size_t VEC_OP (TDEF,embedded_size) \
499 (int alloc_) \
500 { \
501 return offsetof (VEC(TDEF),vec) + alloc_ * sizeof(TDEF); \
502 } \
503 \
504 static inline void VEC_OP (TDEF,embedded_init) \
505 (VEC (TDEF) *vec_, int alloc_) \
506 { \
507 vec_->num = 0; \
508 vec_->alloc = alloc_; \
509 } \
510 \
511 static inline int VEC_OP (TDEF,reserve) \
512 (VEC (TDEF) **vec_, int alloc_ MEM_STAT_DECL) \
513 { \
514 int extend = !*vec_ || ((*vec_)->alloc - (*vec_)->num \
515 < (size_t)(alloc_ < 0 ? 1 : alloc_)); \
516 \
517 if (extend) \
518 *vec_ = vec_o_reserve (*vec_, alloc_, \
519 offsetof (VEC(TDEF),vec), sizeof (TDEF) \
520 PASS_MEM_STAT); \
521 \
522 return extend; \
523 } \
524 \
525 static inline TDEF *VEC_OP (TDEF,quick_push) \
526 (VEC (TDEF) *vec_, const TDEF *obj_) \
527 { \
528 TDEF *slot_; \
529 \
530 VEC_ASSERT (vec_->num < vec_->alloc, "push", TDEF); \
531 slot_ = &vec_->vec[vec_->num++]; \
532 if (obj_) \
533 *slot_ = *obj_; \
534 \
535 return slot_; \
536 } \
537 \
538 static inline TDEF *VEC_OP (TDEF,safe_push) \
539 (VEC (TDEF) **vec_, const TDEF *obj_ MEM_STAT_DECL) \
540 { \
541 VEC_OP (TDEF,reserve) (vec_, -1 PASS_MEM_STAT); \
542 \
543 return VEC_OP (TDEF,quick_push) (*vec_, obj_); \
544 } \
545 \
546 static inline void VEC_OP (TDEF,pop) \
547 (VEC (TDEF) *vec_) \
548 { \
549 VEC_ASSERT (vec_->num, "pop", TDEF); \
550 --vec_->num; \
551 } \
552 \
553 static inline void VEC_OP (TDEF,truncate) \
554 (VEC (TDEF) *vec_, size_t size_) \
555 { \
556 VEC_ASSERT (vec_->num >= size_, "truncate", TDEF); \
557 vec_->num = size_; \
558 } \
559 \
560 static inline TDEF *VEC_OP (TDEF,replace) \
561 (VEC (TDEF) *vec_, size_t ix_, const TDEF *obj_) \
562 { \
563 TDEF *slot_; \
564 \
565 VEC_ASSERT (ix_ < vec_->num, "replace", TDEF); \
566 slot_ = &vec_->vec[ix_]; \
567 if (obj_) \
568 *slot_ = *obj_; \
569 \
570 return slot_; \
571 } \
572 \
573 static inline TDEF *VEC_OP (TDEF,quick_insert) \
574 (VEC (TDEF) *vec_, size_t ix_, const TDEF *obj_) \
575 { \
576 TDEF *slot_; \
577 \
578 VEC_ASSERT (vec_->num < vec_->alloc, "insert", TDEF); \
579 VEC_ASSERT (ix_ <= vec_->num, "insert", TDEF); \
580 slot_ = &vec_->vec[ix_]; \
581 memmove (slot_ + 1, slot_, vec_->num++ - ix_); \
582 if (obj_) \
583 *slot_ = *obj_; \
584 \
585 return slot_; \
586 } \
587 \
588 static inline TDEF *VEC_OP (TDEF,safe_insert) \
589 (VEC (TDEF) **vec_, size_t ix_, const TDEF *obj_ MEM_STAT_DECL) \
590 { \
591 VEC_OP (TDEF,reserve) (vec_, -1 PASS_MEM_STAT); \
592 \
593 return VEC_OP (TDEF,quick_insert) (*vec_, ix_, obj_); \
594 } \
595 \
596 static inline void VEC_OP (TDEF,ordered_remove) \
597 (VEC (TDEF) *vec_, size_t ix_) \
598 { \
599 TDEF *slot_; \
600 \
601 VEC_ASSERT (ix_ < vec_->num, "remove", TDEF); \
602 slot_ = &vec_->vec[ix_]; \
603 memmove (slot_, slot_ + 1, --vec_->num - ix_); \
604 } \
605 \
606 static inline void VEC_OP (TDEF,unordered_remove) \
607 (VEC (TDEF) *vec_, size_t ix_) \
608 { \
609 VEC_ASSERT (ix_ < vec_->num, "remove", TDEF); \
610 vec_->vec[ix_] = vec_->vec[--vec_->num]; \
611 } \
612 \
613 struct vec_swallow_trailing_semi
614 #endif
615
616 #endif /* GCC_VEC_H */
Mirror of the offical gcc git repository hosted at gcc.gnu.org