1 /* 2 copyright: Steve Dekorte, 2006. All rights reserved. 3 license: See _BSDLicense.txt. 4 description: A mutable array of same-sized values. 5 */ 6 7 8 #ifndef UARRAY_DEFINED 9 #define UARRAY_DEFINED 1 10 11 #include "Common.h" 12 #include <stdarg.h> 13 #include <stdio.h> 14 #include <stddef.h> 15 16 #ifdef __cplusplus 17 extern "C" { 18 #endif 19 20 #if !defined(float32_t) 21 typedef float float32_t; 22 typedef double float64_t; 23 #endif 24 25 typedef size_t PID_TYPE; 26 27 typedef enum 28 { 29 CTYPE_uint8_t, 30 CTYPE_uint16_t, 31 CTYPE_uint32_t, 32 CTYPE_uint64_t, 33 34 CTYPE_int8_t, 35 CTYPE_int16_t, 36 CTYPE_int32_t, 37 CTYPE_int64_t, 38 39 CTYPE_float32_t, 40 CTYPE_float64_t, 41 42 CTYPE_uintptr_t 43 } CTYPE; 44 45 typedef enum 46 { 47 CENCODING_ASCII, 48 CENCODING_UTF8, 49 CENCODING_UCS2, 50 CENCODING_UCS4, 51 CENCODING_NUMBER 52 } CENCODING; 53 54 typedef struct 55 { 56 uint8_t uint8; 57 uint16_t uint16; 58 uint32_t uint32; 59 uint64_t uint64; 60 int8_t int8; 61 int16_t int16; 62 int32_t int32; 63 int64_t int64; 64 float32_t float32; 65 float64_t float64; 66 uintptr_t uintptr; 67 } UArrayValueUnion; 68 69 #define UARRAY_DEBUG 1 70 71 typedef struct 72 { 73 uint8_t *data; // memory for items 74 size_t size; // number of items 75 CTYPE itemType; 76 int itemSize; 77 uintptr_t oddHash; 78 uintptr_t evenHash; 79 uint8_t encoding; 80 #ifdef UARRAY_DEBUG 81 int stackAllocated; 82 #endif 83 } UArray; 84 85 typedef UArray CharUArray; 86 typedef UArray PtrUArray; 87 typedef UArray FloatUArray; 88 89 BASEKIT_API const void *UArray_data(const UArray *self); 90 BASEKIT_API const uint8_t *UArray_bytes(const UArray *self); 91 BASEKIT_API uint8_t *UArray_mutableBytes(UArray *self); 92 BASEKIT_API const char *UArray_asCString(const UArray *self); 93 94 BASEKIT_API size_t UArray_SizeOfCtype(CTYPE type); 95 96 BASEKIT_API const char *CTYPE_name(CTYPE type); 97 BASEKIT_API int CTYPE_forName(const char *name); 98 BASEKIT_API int CTYPE_fixedWidthTextEncodingForType(CTYPE type); 99 100 BASEKIT_API const char *CENCODING_name(CENCODING encoding); 101 BASEKIT_API int CENCODING_forName(const char *name); 102 BASEKIT_API int CENCODING_isText(CENCODING encoding); 103 104 BASEKIT_API void UArray_unsupported_with_(const UArray *self, const char *methodName, const UArray *other); 105 BASEKIT_API void UArray_error_(const UArray *self, char *e); 106 107 BASEKIT_API UArray *UArray_new(void); 108 BASEKIT_API UArray *UArray_newWithData_type_size_copy_(void *data, CTYPE type, size_t size, int copy); 109 BASEKIT_API UArray *UArray_newWithData_type_encoding_size_copy_(void *bytes, CTYPE type, CENCODING encoding, size_t size, int copy); 110 BASEKIT_API UArray *UArray_newWithCString_copy_(char *s, int copy); 111 BASEKIT_API UArray *UArray_newWithCString_(const char *s); 112 BASEKIT_API void UArray_setCString_(UArray *self, const char *s); 113 BASEKIT_API void UArray_setData_type_size_copy_(UArray *self, void *data, CTYPE type, size_t size, int copy); 114 BASEKIT_API UArray *UArray_clone(const UArray *self); 115 BASEKIT_API void UArray_show(const UArray *self); 116 BASEKIT_API void UArray_print(const UArray *self); 117 118 BASEKIT_API UArray UArray_stackAllocedWithData_type_size_(void *data, CTYPE type, size_t size); 119 BASEKIT_API UArray UArray_stackAllocedWithCString_(char *s); 120 BASEKIT_API UArray UArray_stackAllocedEmptyUArray(void); 121 122 BASEKIT_API void UArray_stackFree(UArray *self); 123 BASEKIT_API void UArray_free(UArray *self); 124 125 BASEKIT_API CTYPE UArray_itemType(const UArray *self); 126 BASEKIT_API size_t UArray_itemSize(const UArray *self); 127 BASEKIT_API void UArray_setItemType_(UArray *self, CTYPE type); 128 BASEKIT_API CENCODING UArray_encoding(const UArray *self); 129 BASEKIT_API void UArray_setEncoding_(UArray *self, CENCODING encoding); 130 BASEKIT_API void UArray_convertToEncoding_(UArray *self, CENCODING encoding); 131 132 // copy 133 134 BASEKIT_API void UArray_copyItems_(UArray *self, const UArray *other); 135 BASEKIT_API void UArray_copy_(UArray *self, const UArray *other); 136 BASEKIT_API void UArray_copyData_(UArray *self, const UArray *other); 137 BASEKIT_API void UArray_convertToItemType_(UArray *self, CTYPE newItemType); 138 139 // size 140 141 #define UArray_minSizeWith_(self, other) self->size < other->size ? self->size : other->size 142 #define UArray_minSizeInBytesWith_(self, other) self->size * self->itemSize < other->size * other->itemSize ? self->size * self->itemSize : other->size * other->itemSize 143 144 BASEKIT_API void UArray_setSize_(UArray *self, size_t size); 145 BASEKIT_API size_t UArray_size(const UArray *self); 146 BASEKIT_API size_t UArray_sizeInBytes(const UArray *self); 147 148 BASEKIT_API void UArray_sizeTo_(UArray *self, size_t size); 149 150 // slice 151 152 BASEKIT_API UArray UArray_stackRange(const UArray *self, size_t start, size_t size); 153 BASEKIT_API UArray *UArray_range(const UArray *self, size_t start, size_t size); 154 BASEKIT_API UArray UArray_stackSlice(const UArray *self, long start, long end); 155 BASEKIT_API UArray *UArray_slice(const UArray *self, long start, long end); 156 157 // compare 158 159 BASEKIT_API int UArray_compare_(const UArray *self, const UArray *other); 160 BASEKIT_API int UArray_equals_(const UArray *self, const UArray *other); 161 BASEKIT_API int UArray_greaterThan_(const UArray *self, const UArray *other); 162 BASEKIT_API int UArray_lessThan_(const UArray *self, const UArray *other); 163 BASEKIT_API int UArray_greaterThanOrEqualTo_(const UArray *self, const UArray *other); 164 BASEKIT_API int UArray_lessThanOrEqualTo_(const UArray *self, const UArray *other); 165 BASEKIT_API int UArray_isZero(const UArray *self); 166 167 // contains 168 169 BASEKIT_API int UArray_contains_(const UArray *self, const UArray *other); 170 BASEKIT_API int UArray_containsAnyCase_(const UArray *self, const UArray *other); 171 BASEKIT_API int UArray_containsDouble_(const UArray *self, double other); 172 BASEKIT_API int UArray_containsLong_(const UArray *self, long other); 173 174 // find 175 176 BASEKIT_API long UArray_find_(const UArray *self, const UArray *other); 177 BASEKIT_API long UArray_findAnyCase_(const UArray *self, const UArray *other); 178 BASEKIT_API long UArray_find_from_(const UArray *self, const UArray *other, size_t from); 179 BASEKIT_API long UArray_rFind_from_(const UArray *self, const UArray *other, size_t from); 180 BASEKIT_API long UArray_rFind_(const UArray *self, const UArray *other); 181 BASEKIT_API long UArray_rFindAnyCase_(const UArray *self, const UArray *other); 182 BASEKIT_API long UArray_rFindAnyValue_(const UArray *self, const UArray *other); 183 184 // insert 185 186 BASEKIT_API void UArray_at_putLong_(UArray *self, size_t pos, long v); 187 BASEKIT_API void UArray_at_putDouble_(UArray *self, size_t pos, double v); 188 BASEKIT_API void UArray_at_putPointer_(UArray *self, size_t pos, void *v); 189 BASEKIT_API void UArray_at_putAll_(UArray *self, size_t pos, const UArray *other); 190 191 BASEKIT_API void UArray_appendLong_(UArray *self, long v); 192 BASEKIT_API void UArray_appendDouble_(UArray *self, double v); 193 BASEKIT_API void UArray_appendPointer_(UArray *self, void *v); 194 195 BASEKIT_API void UArray_appendBytes_size_(UArray *self, const uint8_t *bytes, size_t size); 196 //BASEKIT_API void UArray_appendByte_(UArray *self, uint8_t byte); 197 198 BASEKIT_API void UArray_insert_every_(UArray *self, UArray *other, size_t itemCount); 199 200 // remove 201 202 BASEKIT_API void UArray_removeRange(UArray *self, size_t start, size_t size); 203 BASEKIT_API void UArray_leave_thenRemove_(UArray *self, size_t itemsToLeave, size_t itemsToRemove); 204 BASEKIT_API void UArray_removeFirst(UArray *self); 205 BASEKIT_API void UArray_removeLast(UArray *self); 206 207 // at 208 209 #define UARRAY_RAWAT_(self, i) \ 210 switch (self->itemType)\ 211 {\ 212 case CTYPE_uint8_t: return ((uint8_t *)self->data)[i];\ 213 case CTYPE_uint16_t: return ((uint16_t *)self->data)[i];\ 214 case CTYPE_uint32_t: return ((uint32_t *)self->data)[i];\ 215 case CTYPE_uint64_t: return ((uint64_t *)self->data)[i];\ 216 case CTYPE_int8_t: return ((int8_t *)self->data)[i];\ 217 case CTYPE_int16_t: return ((int16_t *)self->data)[i];\ 218 case CTYPE_int32_t: return ((int32_t *)self->data)[i];\ 219 case CTYPE_int64_t: return ((int64_t *)self->data)[i];\ 220 case CTYPE_float32_t: return ((float32_t *)self->data)[i];\ 221 case CTYPE_float64_t: return ((float64_t *)self->data)[i];\ 222 case CTYPE_uintptr_t: return ((uintptr_t *)self->data)[i];\ 223 } 224 225 // at, without bounds check 226 227 BASEKIT_API void *UArray_rawPointerAt_(const UArray *self, size_t i); 228 BASEKIT_API long UArray_rawLongAt_(const UArray *self, size_t i); 229 BASEKIT_API double UArray_rawDoubleAt_(const UArray *self, size_t i); 230 231 // at, with bounds check 232 233 BASEKIT_API void *UArray_pointerAt_(const UArray *self, size_t i); 234 BASEKIT_API long UArray_longAt_(const UArray *self, size_t i); 235 BASEKIT_API double UArray_doubleAt_(const UArray *self, size_t i); 236 237 // at, extras 238 239 BASEKIT_API long UArray_lastLong(const UArray *self); 240 BASEKIT_API long UArray_firstLong(const UArray *self); 241 242 // types 243 244 BASEKIT_API int UArray_isFloatType(const UArray *self); 245 BASEKIT_API int UArray_isSignedType(const UArray *self); 246 247 BASEKIT_API size_t UArray_wrapPos_(const UArray *self, long pos); 248 249 // sort 250 251 BASEKIT_API void UArray_sort(UArray *self); 252 253 typedef int (UArraySortCallback)(const void *, const void *); 254 255 BASEKIT_API void UArray_sortBy_(UArray *self, UArraySortCallback *cmp); 256 257 // accessing 258 259 #define UARRAY_BYTEPOSAT_(self, n) (self->itemSize * n) 260 #define UARRAY_BYTESAT_(self, n) (self->data + (self->itemSize * n)) 261 262 // macros 263 264 #define DUARRAY_INTOTHER(MACRO, OP, TYPE1, self, other) \ 265 switch (other->itemType)\ 266 {\ 267 case CTYPE_uint8_t: MACRO(OP, TYPE1, self, uint8_t, other); break;\ 268 case CTYPE_uint16_t: MACRO(OP, TYPE1, self, uint16_t, other); break;\ 269 case CTYPE_uint32_t: MACRO(OP, TYPE1, self, uint32_t, other); break;\ 270 case CTYPE_int8_t: MACRO(OP, TYPE1, self, int8_t, other); break;\ 271 case CTYPE_int16_t: MACRO(OP, TYPE1, self, int16_t, other); break;\ 272 case CTYPE_int32_t: MACRO(OP, TYPE1, self, int32_t, other); break;\ 273 case CTYPE_uintptr_t: MACRO(OP, TYPE1, self, uintptr_t, other); break;\ 274 default: UArray_error_(self, "unsupported array op"); \ 275 } 276 277 #define DUARRAY_OTHER(MACRO, OP, TYPE1, self, other) \ 278 switch (other->itemType)\ 279 {\ 280 case CTYPE_uint8_t: MACRO(OP, TYPE1, self, uint8_t, other); break;\ 281 case CTYPE_uint16_t: MACRO(OP, TYPE1, self, uint16_t, other); break;\ 282 case CTYPE_uint32_t: MACRO(OP, TYPE1, self, uint32_t, other); break;\ 283 case CTYPE_uint64_t: MACRO(OP, TYPE1, self, uint64_t, other); break;\ 284 case CTYPE_int8_t: MACRO(OP, TYPE1, self, int8_t, other); break;\ 285 case CTYPE_int16_t: MACRO(OP, TYPE1, self, int16_t, other); break;\ 286 case CTYPE_int32_t: MACRO(OP, TYPE1, self, int32_t, other); break;\ 287 case CTYPE_int64_t: MACRO(OP, TYPE1, self, int64_t, other); break;\ 288 case CTYPE_float32_t: MACRO(OP, TYPE1, self, float32_t, other); break;\ 289 case CTYPE_float64_t: MACRO(OP, TYPE1, self, float64_t, other); break;\ 290 case CTYPE_uintptr_t: MACRO(OP, TYPE1, self, uintptr_t, other); break;\ 291 } 292 293 #define DUARRAY_INTSELF(MACRO, OP, self, other) \ 294 switch (self->itemType)\ 295 {\ 296 case CTYPE_uint8_t: DUARRAY_INTOTHER(MACRO, OP, uint8_t, self, other);\ 297 case CTYPE_uint16_t: DUARRAY_INTOTHER(MACRO, OP, uint16_t, self, other);\ 298 case CTYPE_uint32_t: DUARRAY_INTOTHER(MACRO, OP, uint32_t, self, other);\ 299 case CTYPE_int8_t: DUARRAY_INTOTHER(MACRO, OP, int8_t, self, other);\ 300 case CTYPE_int16_t: DUARRAY_INTOTHER(MACRO, OP, int16_t, self, other);\ 301 case CTYPE_int32_t: DUARRAY_INTOTHER(MACRO, OP, uint32_t, self, other);\ 302 default: UArray_error_(self, "unsupported array op"); \ 303 } 304 305 #define DUARRAY_SELF(MACRO, OP, self, other) \ 306 switch (self->itemType)\ 307 {\ 308 case CTYPE_uint8_t: DUARRAY_OTHER(MACRO, OP, uint8_t, self, other);\ 309 case CTYPE_uint16_t: DUARRAY_OTHER(MACRO, OP, uint16_t, self, other);\ 310 case CTYPE_uint32_t: DUARRAY_OTHER(MACRO, OP, uint32_t, self, other);\ 311 case CTYPE_uint64_t: DUARRAY_OTHER(MACRO, OP, uint64_t, self, other);\ 312 case CTYPE_int8_t: DUARRAY_OTHER(MACRO, OP, int8_t, self, other);\ 313 case CTYPE_int16_t: DUARRAY_OTHER(MACRO, OP, int16_t, self, other);\ 314 case CTYPE_int32_t: DUARRAY_OTHER(MACRO, OP, uint32_t, self, other);\ 315 case CTYPE_int64_t: DUARRAY_OTHER(MACRO, OP, uint64_t, self, other);\ 316 case CTYPE_float32_t: DUARRAY_OTHER(MACRO, OP, float32_t, self, other);\ 317 case CTYPE_float64_t: DUARRAY_OTHER(MACRO, OP, float64_t, self, other);\ 318 case CTYPE_uintptr_t: DUARRAY_OTHER(MACRO, OP, uintptr_t, self, other);\ 319 } 320 321 #define DUARRAY_OP(MACRO, OP, self, other)\ 322 DUARRAY_SELF(MACRO, OP, self, other);\ 323 UArray_unsupported_with_(self, #OP, other); 324 325 #define DUARRAY_INTOP(MACRO, OP, self, other)\ 326 DUARRAY_INTSELF(MACRO, OP, self, other);\ 327 UArray_unsupported_with_(self, #OP, other); 328 329 // two array primitive ops 330 331 #define UARRAY_BASICOP_TYPES(OP2, TYPE1, self, TYPE2, other)\ 332 {\ 333 size_t i, minSize = self->size < other->size ? self->size : other->size;\ 334 for(i = 0; i < minSize; i ++)\ 335 {\ 336 ((TYPE1 *)self->data)[i] OP2 (TYPE1)((TYPE2 *)other->data)[i];\ 337 }\ 338 return; \ 339 } 340 341 #define UARRAY_FUNCTION_TYPES(FUNCTION_NAME, TYPE1, self, TYPE2, other)\ 342 {\ 343 size_t i, minSize = self->size < other->size ? self->size : other->size;\ 344 for(i = 0; i < minSize; i ++)\ 345 {\ 346 ((TYPE1 *)self->data)[i] = FUNCTION_NAME(((TYPE1 *)self->data)[i], (TYPE1)((TYPE2 *)other->data)[i]);\ 347 }\ 348 return; \ 349 } 350 351 //printf("%i: " #TYPE1 " %f " #OP2 " " #TYPE2 " %i\n", i, ((TYPE1 *)self->data)[i], ((TYPE2 *)other->data)[i]); 352 353 // single array ops 354 355 // foreach -------------------------- 356 357 #define UARRAY_FOREACHTYPE(self, i, v, code, TYPE)\ 358 {\ 359 size_t i;\ 360 for(i = 0; i < self->size; i ++)\ 361 {\ 362 TYPE v = ((TYPE *)self->data)[i];\ 363 code;\ 364 }\ 365 } 366 367 #define UARRAY_FOREACH_CASETYPE_(self, i, v, code, TYPE)\ 368 case CTYPE_ ## TYPE: UARRAY_FOREACHTYPE(self, i, v, code, TYPE); break; 369 370 #define UARRAY_FOREACH(self, i, v, code)\ 371 switch(self->itemType)\ 372 {\ 373 UARRAY_FOREACH_CASETYPE_(self, i, v, code, uint8_t);\ 374 UARRAY_FOREACH_CASETYPE_(self, i, v, code, uint16_t);\ 375 UARRAY_FOREACH_CASETYPE_(self, i, v, code, uint32_t);\ 376 UARRAY_FOREACH_CASETYPE_(self, i, v, code, uint64_t);\ 377 UARRAY_FOREACH_CASETYPE_(self, i, v, code, int8_t);\ 378 UARRAY_FOREACH_CASETYPE_(self, i, v, code, int16_t);\ 379 UARRAY_FOREACH_CASETYPE_(self, i, v, code, int32_t);\ 380 UARRAY_FOREACH_CASETYPE_(self, i, v, code, int64_t);\ 381 UARRAY_FOREACH_CASETYPE_(self, i, v, code, float32_t);\ 382 UARRAY_FOREACH_CASETYPE_(self, i, v, code, float64_t);\ 383 UARRAY_FOREACH_CASETYPE_(self, i, v, code, uintptr_t);\ 384 } 385 386 #define UARRAY_INTFOREACH(self, i, v, code)\ 387 switch(self->itemType)\ 388 {\ 389 UARRAY_FOREACH_CASETYPE_(self, i, v, code, uint8_t);\ 390 UARRAY_FOREACH_CASETYPE_(self, i, v, code, uint16_t);\ 391 UARRAY_FOREACH_CASETYPE_(self, i, v, code, uint32_t);\ 392 UARRAY_FOREACH_CASETYPE_(self, i, v, code, uint64_t);\ 393 UARRAY_FOREACH_CASETYPE_(self, i, v, code, int8_t);\ 394 UARRAY_FOREACH_CASETYPE_(self, i, v, code, int16_t);\ 395 UARRAY_FOREACH_CASETYPE_(self, i, v, code, int32_t);\ 396 UARRAY_FOREACH_CASETYPE_(self, i, v, code, int64_t);\ 397 UARRAY_FOREACH_CASETYPE_(self, i, v, code, float32_t);\ 398 UARRAY_FOREACH_CASETYPE_(self, i, v, code, float64_t);\ 399 UARRAY_FOREACH_CASETYPE_(self, i, v, code, uintptr_t);\ 400 } 401 402 // rforeach -------------------------- 403 404 #define UARRAY_RFOREACHTYPE(self, i, v, code, TYPE)\ 405 {\ 406 size_t i;\ 407 for(i = self->size - 1; i >= 0; i --)\ 408 {\ 409 TYPE v = ((TYPE *)self->data)[i];\ 410 code;\ 411 }\ 412 } 413 414 #define UARRAY_RFOREACH_CASETYPE_(self, i, v, code, TYPE)\ 415 case CTYPE_ ## TYPE: UARRAY_RFOREACHTYPE(self, i, v, code, TYPE); break; 416 417 #define UARRAY_RFOREACH(self, i, v, code)\ 418 switch(self->itemType)\ 419 {\ 420 UARRAY_RFOREACH_CASETYPE_(self, i, v, code, uint8_t);\ 421 UARRAY_RFOREACH_CASETYPE_(self, i, v, code, uint16_t);\ 422 UARRAY_RFOREACH_CASETYPE_(self, i, v, code, uint32_t);\ 423 UARRAY_RFOREACH_CASETYPE_(self, i, v, code, uint64_t);\ 424 UARRAY_RFOREACH_CASETYPE_(self, i, v, code, int8_t);\ 425 UARRAY_RFOREACH_CASETYPE_(self, i, v, code, int16_t);\ 426 UARRAY_RFOREACH_CASETYPE_(self, i, v, code, int32_t);\ 427 UARRAY_RFOREACH_CASETYPE_(self, i, v, code, int64_t);\ 428 UARRAY_RFOREACH_CASETYPE_(self, i, v, code, float32_t);\ 429 UARRAY_RFOREACH_CASETYPE_(self, i, v, code, float64_t);\ 430 UARRAY_RFOREACH_CASETYPE_(self, i, v, code, uintptr_t);\ 431 } 432 433 // foreach assign -------------------------- 434 435 #define UARRAY_FOREACHTYPEASSIGN(self, i, v, code, TYPE)\ 436 {\ 437 size_t i;\ 438 for(i = 0; i < self->size; i ++)\ 439 {\ 440 TYPE v = ((TYPE *)self->data)[i];\ 441 ((TYPE *)self->data)[i] = (TYPE)(code);\ 442 }\ 443 } 444 445 #define UARRAY_FOREACHASSIGN(self, i, v, code)\ 446 switch(self->itemType)\ 447 {\ 448 case CTYPE_uint8_t: UARRAY_FOREACHTYPEASSIGN(self, i, v, code, uint8_t); break;\ 449 case CTYPE_uint16_t: UARRAY_FOREACHTYPEASSIGN(self, i, v, code, uint16_t); break;\ 450 case CTYPE_uint32_t: UARRAY_FOREACHTYPEASSIGN(self, i, v, code, uint32_t); break;\ 451 case CTYPE_uint64_t: UARRAY_FOREACHTYPEASSIGN(self, i, v, code, uint64_t); break;\ 452 case CTYPE_int8_t: UARRAY_FOREACHTYPEASSIGN(self, i, v, code, int8_t); break;\ 453 case CTYPE_int16_t: UARRAY_FOREACHTYPEASSIGN(self, i, v, code, int16_t); break;\ 454 case CTYPE_int32_t: UARRAY_FOREACHTYPEASSIGN(self, i, v, code, int32_t); break;\ 455 case CTYPE_int64_t: UARRAY_FOREACHTYPEASSIGN(self, i, v, code, int64_t); break;\ 456 case CTYPE_float32_t: UARRAY_FOREACHTYPEASSIGN(self, i, v, code, float32_t); break;\ 457 case CTYPE_float64_t: UARRAY_FOREACHTYPEASSIGN(self, i, v, code, float64_t); break;\ 458 case CTYPE_uintptr_t: UARRAY_FOREACHTYPEASSIGN(self, i, v, code, uintptr_t); break;\ 459 } 460 461 #define UARRAY_FOREACHTYPEASSIGN_VALUE_UNUSED(self, i, code, TYPE)\ 462 {\ 463 size_t i;\ 464 for(i = 0; i < self->size; i ++)\ 465 {\ 466 ((TYPE *)self->data)[i] = (TYPE)(code);\ 467 }\ 468 } 469 470 #define UARRAY_FOREACHASSIGN_VALUE_UNUSED(self, i, code)\ 471 switch(self->itemType)\ 472 {\ 473 case CTYPE_uint8_t: UARRAY_FOREACHTYPEASSIGN_VALUE_UNUSED(self, i, code, uint8_t); break;\ 474 case CTYPE_uint16_t: UARRAY_FOREACHTYPEASSIGN_VALUE_UNUSED(self, i, code, uint16_t); break;\ 475 case CTYPE_uint32_t: UARRAY_FOREACHTYPEASSIGN_VALUE_UNUSED(self, i, code, uint32_t); break;\ 476 case CTYPE_uint64_t: UARRAY_FOREACHTYPEASSIGN_VALUE_UNUSED(self, i, code, uint64_t); break;\ 477 case CTYPE_int8_t: UARRAY_FOREACHTYPEASSIGN_VALUE_UNUSED(self, i, code, int8_t); break;\ 478 case CTYPE_int16_t: UARRAY_FOREACHTYPEASSIGN_VALUE_UNUSED(self, i, code, int16_t); break;\ 479 case CTYPE_int32_t: UARRAY_FOREACHTYPEASSIGN_VALUE_UNUSED(self, i, code, int32_t); break;\ 480 case CTYPE_int64_t: UARRAY_FOREACHTYPEASSIGN_VALUE_UNUSED(self, i, code, int64_t); break;\ 481 case CTYPE_float32_t: UARRAY_FOREACHTYPEASSIGN_VALUE_UNUSED(self, i, code, float32_t); break;\ 482 case CTYPE_float64_t: UARRAY_FOREACHTYPEASSIGN_VALUE_UNUSED(self, i, code, float64_t); break;\ 483 case CTYPE_uintptr_t: UARRAY_FOREACHTYPEASSIGN_VALUE_UNUSED(self, i, code, uintptr_t); break;\ 484 } 485 486 // ---------------------------- 487 488 #include "UArray_character.h" 489 #include "UArray_format.h" 490 #include "UArray_math.h" 491 #include "UArray_path.h" 492 #include "UArray_stream.h" 493 #include "UArray_string.h" 494 #include "UArray_utf.h" 495 496 #ifdef __cplusplus 497 } 498 #endif 499 #endif 500