Lines Matching refs:T
129 #define VEC_length(T,V) (VEC_OP(T,length)(V)) argument
137 #define VEC_empty(T,V) (VEC_length (T,V) == 0) argument
147 #define VEC_last(T,V) (VEC_OP(T,last)(V VEC_ASSERT_INFO)) argument
156 #define VEC_index(T,V,I) (VEC_OP(T,index)(V,I VEC_ASSERT_INFO)) argument
170 #define VEC_iterate(T,V,I,P) (VEC_OP(T,iterate)(V,I,&(P))) argument
178 #define VEC_alloc(T,N) (VEC_OP(T,alloc)(N)) argument
185 #define VEC_free(T,V) (VEC_OP(T,free)(&V)) argument
192 #define VEC_cleanup(T) (VEC_OP(T,cleanup)) argument
202 #define VEC_embedded_size(T,N) (VEC_OP(T,embedded_size)(N)) argument
203 #define VEC_embedded_init(T,O,N) (VEC_OP(T,embedded_init)(VEC_BASE(O),N)) argument
211 #define VEC_copy(T,V) (VEC_OP(T,copy)(V)) argument
218 #define VEC_merge(T,V1,V2) (VEC_OP(T,merge)(V1, V2)) argument
230 #define VEC_space(T,V,R) (VEC_OP(T,space)(V,R VEC_ASSERT_INFO)) argument
242 #define VEC_reserve(T,V,R) (VEC_OP(T,reserve)(&(V),R VEC_ASSERT_INFO)) argument
254 #define VEC_quick_push(T,V,O) (VEC_OP(T,quick_push)(V,O VEC_ASSERT_INFO)) argument
265 #define VEC_safe_push(T,V,O) (VEC_OP(T,safe_push)(&(V),O VEC_ASSERT_INFO)) argument
275 #define VEC_pop(T,V) (VEC_OP(T,pop)(V VEC_ASSERT_INFO)) argument
283 #define VEC_truncate(T,V,I) \ argument
284 (VEC_OP(T,truncate)(V,I VEC_ASSERT_INFO))
293 #define VEC_safe_grow(T,V,I) \ argument
294 (VEC_OP(T,safe_grow)(&(V),I VEC_ASSERT_INFO))
307 #define VEC_replace(T,V,I,O) (VEC_OP(T,replace)(V,I,O VEC_ASSERT_INFO)) argument
319 #define VEC_quick_insert(T,V,I,O) \ argument
320 (VEC_OP(T,quick_insert)(V,I,O VEC_ASSERT_INFO))
332 #define VEC_safe_insert(T,V,I,O) \ argument
333 (VEC_OP(T,safe_insert)(&(V),I,O VEC_ASSERT_INFO))
344 #define VEC_ordered_remove(T,V,I) \ argument
345 (VEC_OP(T,ordered_remove)(V,I VEC_ASSERT_INFO))
356 #define VEC_unordered_remove(T,V,I) \ argument
357 (VEC_OP(T,unordered_remove)(V,I VEC_ASSERT_INFO))
365 #define VEC_block_remove(T,V,I,L) \ argument
366 (VEC_OP(T,block_remove)(V,I,L VEC_ASSERT_INFO))
374 #define VEC_address(T,V) (VEC_OP(T,address)(V)) argument
388 #define VEC_lower_bound(T,V,O,LT) \ argument
389 (VEC_OP(T,lower_bound)(V,O,LT VEC_ASSERT_INFO))
403 #define VEC(T) VEC_##T argument
404 #define VEC_OP(T,OP) VEC_##T##_##OP argument
406 #define VEC_T(T) \ argument
407 typedef struct VEC(T) \
411 T vec[1]; \
412 } VEC(T)
415 #define DEF_VEC_I(T) \ argument
416 static inline void VEC_OP (T,must_be_integral_type) (void) \
418 (void)~(T)0; \
421 VEC_T(T); \
422 DEF_VEC_FUNC_P(T) \
423 DEF_VEC_ALLOC_FUNC_I(T) \
427 #define DEF_VEC_P(T) \ argument
428 static inline void VEC_OP (T,must_be_pointer_type) (void) \
430 (void)((T)1 == (void *)1); \
433 VEC_T(T); \
434 DEF_VEC_FUNC_P(T) \
435 DEF_VEC_ALLOC_FUNC_P(T) \
439 #define DEF_VEC_O(T) \ argument
440 VEC_T(T); \
441 DEF_VEC_FUNC_O(T) \
442 DEF_VEC_ALLOC_FUNC_O(T) \
445 #define DEF_VEC_ALLOC_FUNC_I(T) \ argument
446 static inline VEC(T) *VEC_OP (T,alloc) \
450 return (VEC(T) *) vec_o_reserve (NULL, -alloc_, \
451 offsetof (VEC(T),vec), sizeof (T)); \
454 static inline VEC(T) *VEC_OP (T,copy) (VEC(T) *vec_) \
457 VEC (T) *new_vec_ = NULL; \
462 new_vec_ = (VEC (T) *) \
463 vec_o_reserve (NULL, -len_, offsetof (VEC(T),vec), sizeof (T)); \
466 memcpy (new_vec_->vec, vec_->vec, sizeof (T) * len_); \
471 static inline VEC(T) *VEC_OP (T,merge) (VEC(T) *vec1_, VEC(T) *vec2_) \
476 VEC (T) *new_vec_ = NULL; \
479 new_vec_ = (VEC (T) *) \
480 vec_o_reserve (NULL, -len_, offsetof (VEC(T),vec), sizeof (T)); \
483 memcpy (new_vec_->vec, vec1_->vec, sizeof (T) * vec1_->num); \
485 sizeof (T) * vec2_->num); \
490 return VEC_copy (T, vec1_ ? vec1_ : vec2_); \
493 static inline void VEC_OP (T,free) \
494 (VEC(T) **vec_) \
501 static inline void VEC_OP (T,cleanup) \
504 VEC(T) **vec_ = arg_; \
510 static inline int VEC_OP (T,reserve) \
511 (VEC(T) **vec_, int alloc_ VEC_ASSERT_DECL) \
513 int extend = !VEC_OP (T,space) \
517 *vec_ = (VEC(T) *) vec_o_reserve (*vec_, alloc_, \
518 offsetof (VEC(T),vec), sizeof (T)); \
523 static inline void VEC_OP (T,safe_grow) \
524 (VEC(T) **vec_, int size_ VEC_ASSERT_DECL) \
526 vec_assert (size_ >= 0 && VEC_OP(T,length) (*vec_) <= (unsigned)size_, \
528 VEC_OP (T,reserve) (vec_, (int)(*vec_ ? (*vec_)->num : 0) - size_ \
533 static inline T *VEC_OP (T,safe_push) \
534 (VEC(T) **vec_, const T obj_ VEC_ASSERT_DECL) \
536 VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS); \
538 return VEC_OP (T,quick_push) (*vec_, obj_ VEC_ASSERT_PASS); \
541 static inline T *VEC_OP (T,safe_insert) \
542 (VEC(T) **vec_, unsigned ix_, const T obj_ VEC_ASSERT_DECL) \
544 VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS); \
546 return VEC_OP (T,quick_insert) (*vec_, ix_, obj_ VEC_ASSERT_PASS); \
549 #define DEF_VEC_FUNC_P(T) \ argument
550 static inline unsigned VEC_OP (T,length) (const VEC(T) *vec_) \
555 static inline T VEC_OP (T,last) \
556 (const VEC(T) *vec_ VEC_ASSERT_DECL) \
563 static inline T VEC_OP (T,index) \
564 (const VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL) \
571 static inline int VEC_OP (T,iterate) \
572 (const VEC(T) *vec_, unsigned ix_, T *ptr) \
586 static inline size_t VEC_OP (T,embedded_size) \
589 return offsetof (VEC(T),vec) + alloc_ * sizeof(T); \
592 static inline void VEC_OP (T,embedded_init) \
593 (VEC(T) *vec_, int alloc_) \
599 static inline int VEC_OP (T,space) \
600 (VEC(T) *vec_, int alloc_ VEC_ASSERT_DECL) \
606 static inline T *VEC_OP (T,quick_push) \
607 (VEC(T) *vec_, T obj_ VEC_ASSERT_DECL) \
609 T *slot_; \
618 static inline T VEC_OP (T,pop) (VEC(T) *vec_ VEC_ASSERT_DECL) \
620 T obj_; \
628 static inline void VEC_OP (T,truncate) \
629 (VEC(T) *vec_, unsigned size_ VEC_ASSERT_DECL) \
636 static inline T VEC_OP (T,replace) \
637 (VEC(T) *vec_, unsigned ix_, T obj_ VEC_ASSERT_DECL) \
639 T old_obj_; \
648 static inline T *VEC_OP (T,quick_insert) \
649 (VEC(T) *vec_, unsigned ix_, T obj_ VEC_ASSERT_DECL) \
651 T *slot_; \
655 memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T)); \
661 static inline T VEC_OP (T,ordered_remove) \
662 (VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL) \
664 T *slot_; \
665 T obj_; \
670 memmove (slot_, slot_ + 1, (--vec_->num - ix_) * sizeof (T)); \
675 static inline T VEC_OP (T,unordered_remove) \
676 (VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL) \
678 T *slot_; \
679 T obj_; \
689 static inline void VEC_OP (T,block_remove) \
690 (VEC(T) *vec_, unsigned ix_, unsigned len_ VEC_ASSERT_DECL) \
692 T *slot_; \
697 memmove (slot_, slot_ + len_, (vec_->num - ix_) * sizeof (T)); \
700 static inline T *VEC_OP (T,address) \
701 (VEC(T) *vec_) \
706 static inline unsigned VEC_OP (T,lower_bound) \
707 (VEC(T) *vec_, const T obj_, \
708 int (*lessthan_)(const T, const T) VEC_ASSERT_DECL) \
710 unsigned int len_ = VEC_OP (T, length) (vec_); \
715 T middle_elem_; \
719 middle_elem_ = VEC_OP (T,index) (vec_, middle_ VEC_ASSERT_PASS); \
732 #define DEF_VEC_ALLOC_FUNC_P(T) \ argument
733 static inline VEC(T) *VEC_OP (T,alloc) \
737 return (VEC(T) *) vec_p_reserve (NULL, -alloc_); \
740 static inline void VEC_OP (T,free) \
741 (VEC(T) **vec_) \
748 static inline void VEC_OP (T,cleanup) \
751 VEC(T) **vec_ = arg_; \
757 static inline VEC(T) *VEC_OP (T,copy) (VEC(T) *vec_) \
760 VEC (T) *new_vec_ = NULL; \
765 new_vec_ = (VEC (T) *)(vec_p_reserve (NULL, -len_)); \
768 memcpy (new_vec_->vec, vec_->vec, sizeof (T) * len_); \
773 static inline VEC(T) *VEC_OP (T,merge) (VEC(T) *vec1_, VEC(T) *vec2_) \
778 VEC (T) *new_vec_ = NULL; \
781 new_vec_ = (VEC (T) *)(vec_p_reserve (NULL, -len_)); \
784 memcpy (new_vec_->vec, vec1_->vec, sizeof (T) * vec1_->num); \
786 sizeof (T) * vec2_->num); \
791 return VEC_copy (T, vec1_ ? vec1_ : vec2_); \
794 static inline int VEC_OP (T,reserve) \
795 (VEC(T) **vec_, int alloc_ VEC_ASSERT_DECL) \
797 int extend = !VEC_OP (T,space) \
801 *vec_ = (VEC(T) *) vec_p_reserve (*vec_, alloc_); \
806 static inline void VEC_OP (T,safe_grow) \
807 (VEC(T) **vec_, int size_ VEC_ASSERT_DECL) \
809 vec_assert (size_ >= 0 && VEC_OP(T,length) (*vec_) <= (unsigned)size_, \
811 VEC_OP (T,reserve) \
816 static inline T *VEC_OP (T,safe_push) \
817 (VEC(T) **vec_, T obj_ VEC_ASSERT_DECL) \
819 VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS); \
821 return VEC_OP (T,quick_push) (*vec_, obj_ VEC_ASSERT_PASS); \
824 static inline T *VEC_OP (T,safe_insert) \
825 (VEC(T) **vec_, unsigned ix_, T obj_ VEC_ASSERT_DECL) \
827 VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS); \
829 return VEC_OP (T,quick_insert) (*vec_, ix_, obj_ VEC_ASSERT_PASS); \
832 #define DEF_VEC_FUNC_O(T) \ argument
833 static inline unsigned VEC_OP (T,length) (const VEC(T) *vec_) \
838 static inline T *VEC_OP (T,last) (VEC(T) *vec_ VEC_ASSERT_DECL) \
845 static inline T *VEC_OP (T,index) \
846 (VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL) \
853 static inline int VEC_OP (T,iterate) \
854 (VEC(T) *vec_, unsigned ix_, T **ptr) \
868 static inline size_t VEC_OP (T,embedded_size) \
871 return offsetof (VEC(T),vec) + alloc_ * sizeof(T); \
874 static inline void VEC_OP (T,embedded_init) \
875 (VEC(T) *vec_, int alloc_) \
881 static inline int VEC_OP (T,space) \
882 (VEC(T) *vec_, int alloc_ VEC_ASSERT_DECL) \
888 static inline T *VEC_OP (T,quick_push) \
889 (VEC(T) *vec_, const T *obj_ VEC_ASSERT_DECL) \
891 T *slot_; \
901 static inline void VEC_OP (T,pop) (VEC(T) *vec_ VEC_ASSERT_DECL) \
907 static inline void VEC_OP (T,truncate) \
908 (VEC(T) *vec_, unsigned size_ VEC_ASSERT_DECL) \
915 static inline T *VEC_OP (T,replace) \
916 (VEC(T) *vec_, unsigned ix_, const T *obj_ VEC_ASSERT_DECL) \
918 T *slot_; \
928 static inline T *VEC_OP (T,quick_insert) \
929 (VEC(T) *vec_, unsigned ix_, const T *obj_ VEC_ASSERT_DECL) \
931 T *slot_; \
935 memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T)); \
942 static inline void VEC_OP (T,ordered_remove) \
943 (VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL) \
945 T *slot_; \
949 memmove (slot_, slot_ + 1, (--vec_->num - ix_) * sizeof (T)); \
952 static inline void VEC_OP (T,unordered_remove) \
953 (VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL) \
959 static inline void VEC_OP (T,block_remove) \
960 (VEC(T) *vec_, unsigned ix_, unsigned len_ VEC_ASSERT_DECL) \
962 T *slot_; \
967 memmove (slot_, slot_ + len_, (vec_->num - ix_) * sizeof (T)); \
970 static inline T *VEC_OP (T,address) \
971 (VEC(T) *vec_) \
976 static inline unsigned VEC_OP (T,lower_bound) \
977 (VEC(T) *vec_, const T *obj_, \
978 int (*lessthan_)(const T *, const T *) VEC_ASSERT_DECL) \
980 unsigned int len_ = VEC_OP (T, length) (vec_); \
985 T *middle_elem_; \
989 middle_elem_ = VEC_OP (T,index) (vec_, middle_ VEC_ASSERT_PASS); \
1002 #define DEF_VEC_ALLOC_FUNC_O(T) \ argument
1003 static inline VEC(T) *VEC_OP (T,alloc) \
1007 return (VEC(T) *) vec_o_reserve (NULL, -alloc_, \
1008 offsetof (VEC(T),vec), sizeof (T)); \
1011 static inline VEC(T) *VEC_OP (T,copy) (VEC(T) *vec_) \
1014 VEC (T) *new_vec_ = NULL; \
1019 new_vec_ = (VEC (T) *) \
1020 vec_o_reserve (NULL, -len_, offsetof (VEC(T),vec), sizeof (T)); \
1023 memcpy (new_vec_->vec, vec_->vec, sizeof (T) * len_); \
1028 static inline VEC(T) *VEC_OP (T,merge) (VEC(T) *vec1_, VEC(T) *vec2_) \
1033 VEC (T) *new_vec_ = NULL; \
1036 new_vec_ = (VEC (T) *) \
1037 vec_o_reserve (NULL, -len_, offsetof (VEC(T),vec), sizeof (T)); \
1040 memcpy (new_vec_->vec, vec1_->vec, sizeof (T) * vec1_->num); \
1042 sizeof (T) * vec2_->num); \
1047 return VEC_copy (T, vec1_ ? vec1_ : vec2_); \
1050 static inline void VEC_OP (T,free) \
1051 (VEC(T) **vec_) \
1058 static inline void VEC_OP (T,cleanup) \
1061 VEC(T) **vec_ = arg_; \
1067 static inline int VEC_OP (T,reserve) \
1068 (VEC(T) **vec_, int alloc_ VEC_ASSERT_DECL) \
1070 int extend = !VEC_OP (T,space) (*vec_, alloc_ < 0 ? -alloc_ : alloc_ \
1074 *vec_ = (VEC(T) *) \
1075 vec_o_reserve (*vec_, alloc_, offsetof (VEC(T),vec), sizeof (T)); \
1080 static inline void VEC_OP (T,safe_grow) \
1081 (VEC(T) **vec_, int size_ VEC_ASSERT_DECL) \
1083 vec_assert (size_ >= 0 && VEC_OP(T,length) (*vec_) <= (unsigned)size_, \
1085 VEC_OP (T,reserve) \
1090 static inline T *VEC_OP (T,safe_push) \
1091 (VEC(T) **vec_, const T *obj_ VEC_ASSERT_DECL) \
1093 VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS); \
1095 return VEC_OP (T,quick_push) (*vec_, obj_ VEC_ASSERT_PASS); \
1098 static inline T *VEC_OP (T,safe_insert) \
1099 (VEC(T) **vec_, unsigned ix_, const T *obj_ VEC_ASSERT_DECL) \
1101 VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS); \
1103 return VEC_OP (T,quick_insert) (*vec_, ix_, obj_ VEC_ASSERT_PASS); \