commit chck for openSUSE:Factory

Hello community, here is the log from the commit of package chck for openSUSE:Factory checked in at 2017-02-16 17:05:44 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/chck (Old) and /work/SRC/openSUSE:Factory/.chck.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "chck" Changes: -------- --- /work/SRC/openSUSE:Factory/chck/chck.changes 2016-05-08 10:46:16.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.chck.new/chck.changes 2017-02-16 17:05:45.861790820 +0100 @@ -1,0 +2,5 @@ +Wed Feb 8 19:58:27 UTC 2017 - callumjfarmer13@gmail.com + +- update to 0.0.20161208 + +------------------------------------------------------------------- Old: ---- chck-0.0.20160429.tar.xz New: ---- chck-0.0.20161208.tar.xz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ chck.spec ++++++ --- /var/tmp/diff_new_pack.pLq3uk/_old 2017-02-16 17:05:46.233738192 +0100 +++ /var/tmp/diff_new_pack.pLq3uk/_new 2017-02-16 17:05:46.237737626 +0100 @@ -17,7 +17,7 @@ Name: chck -Version: 0.0.20160429 +Version: 0.0.20161208 Release: 0 Summary: C utilities collection library License: MIT ++++++ chck-0.0.20160429.tar.xz -> chck-0.0.20161208.tar.xz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/atlas/atlas.h new/chck-0.0.20161208/chck/atlas/atlas.h --- old/chck-0.0.20160429/chck/atlas/atlas.h 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/atlas/atlas.h 2016-12-08 16:14:10.000000000 +0100 @@ -42,13 +42,13 @@ uint32_t total_area; }; -CHCK_NONULL bool chck_atlas(struct chck_atlas *atlas); +bool chck_atlas(struct chck_atlas *atlas); void chck_atlas_release(struct chck_atlas *atlas); -CHCK_NONULL uint32_t chck_atlas_push(struct chck_atlas *atlas, uint32_t width, uint32_t height); -CHCK_NONULL uint32_t chck_atlas_pop(struct chck_atlas *atlas); -CHCK_NONULLV(1) const struct chck_atlas_texture* chck_atlas_get(const struct chck_atlas *atlas, uint32_t index, struct chck_atlas_rect *out_transformed); +uint32_t chck_atlas_push(struct chck_atlas *atlas, uint32_t width, uint32_t height); +uint32_t chck_atlas_pop(struct chck_atlas *atlas); +const struct chck_atlas_texture* chck_atlas_get(const struct chck_atlas *atlas, uint32_t index, struct chck_atlas_rect *out_transformed); // returns total unused area -CHCK_NONULLV(1) uint32_t chck_atlas_pack(struct chck_atlas *atlas, bool force_pot, bool one_px_border, uint32_t *out_w, uint32_t *out_h); +uint32_t chck_atlas_pack(struct chck_atlas *atlas, bool force_pot, bool one_px_border, uint32_t *out_w, uint32_t *out_h); #endif /* __chck_atlas_h__ */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/buffer/buffer.c new/chck-0.0.20161208/chck/buffer/buffer.c --- old/chck-0.0.20160429/chck/buffer/buffer.c 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/buffer/buffer.c 2016-12-08 16:14:10.000000000 +0100 @@ -10,7 +10,18 @@ # define HAS_ZLIB 0 #endif -static inline bool +struct chck_variant { + union { + uint64_t u64; + uint32_t u32; + uint16_t u16; + uint8_t u8; + uint8_t b[sizeof(uint64_t)]; + }; + enum chck_bits bits; +}; + +CHCK_CONST static inline bool valid_bits(enum chck_bits bits) { return (bits == CHCK_BUFFER_B8 || @@ -19,6 +30,46 @@ bits == CHCK_BUFFER_B64); } +CHCK_CONST static inline enum chck_bits +smallest_bits_for_value(uintmax_t v) +{ + static const struct { + uintmax_t off; + enum chck_bits bits; + } map[3] = { + { ~(uint32_t)0, CHCK_BUFFER_B64 }, + { ~(uint16_t)0, CHCK_BUFFER_B32 }, + { ~(uint8_t)0, CHCK_BUFFER_B16 }, + }; + + for (size_t i = 0; i < sizeof(map) / sizeof(map[0]); ++i) { + if (v <= map[i].off) + continue; + + return map[i].bits; + } + + return CHCK_BUFFER_B8; +} + +CHCK_PURE static inline uintmax_t +variant_get_value(struct chck_variant v) +{ + switch (v.bits) { + case CHCK_BUFFER_B8: + return v.u8; + case CHCK_BUFFER_B16: + return v.u16; + case CHCK_BUFFER_B32: + return v.u32; + case CHCK_BUFFER_B64: + return v.u64; + } + + assert(0 && "should not happen"); + return 0; +} + void chck_buffer_flush(struct chck_buffer *buf) { @@ -257,10 +308,12 @@ if (out_len) *out_len = 0; - size_t len = 0; - if (unlikely(!chck_buffer_read_int(&len, bits, buf))) + struct chck_variant v = { .bits = bits }; + if (unlikely(!chck_buffer_read_int(v.b, bits, buf))) return false; + const size_t len = variant_get_value(v); + if (out_len) *out_len = len; @@ -288,7 +341,7 @@ *len = 0; uint8_t bits; - if (unlikely(!chck_buffer_read_int(&bits, sizeof(uint8_t), buf))) + if (unlikely(!chck_buffer_read_int(&bits, sizeof(bits), buf))) return false; return likely(chck_buffer_read_string_of_type(str, len, bits, buf)); @@ -344,11 +397,24 @@ { assert(buf); - if (unlikely(!chck_buffer_write_int(&len, bits, buf))) - return false; + bool ret = false; + switch (bits) { + case CHCK_BUFFER_B8: + ret = chck_buffer_write_int((uint8_t[]){len}, bits, buf); + break; + case CHCK_BUFFER_B16: + ret = chck_buffer_write_int((uint16_t[]){len}, bits, buf); + break; + case CHCK_BUFFER_B32: + ret = chck_buffer_write_int((uint32_t[]){len}, bits, buf); + break; + case CHCK_BUFFER_B64: + ret = chck_buffer_write_int((uint64_t[]){len}, bits, buf); + break; + } - if (len <= 0) - return true; + if (unlikely(!ret)) + return false; return likely(chck_buffer_write(str, 1, len, buf) == len); } @@ -357,9 +423,9 @@ chck_buffer_write_string(const char *str, size_t len, struct chck_buffer *buf) { assert(buf); - const enum chck_bits bits = (len > 0xffff ? sizeof(uint32_t) : (len > 0xff ? sizeof(uint16_t) : sizeof(uint8_t))); - if (unlikely(!chck_buffer_write_int(&bits, sizeof(uint8_t), buf))) + const uint8_t bits = smallest_bits_for_value(len); + if (unlikely(!chck_buffer_write_int(&bits, sizeof(bits), buf))) return false; return likely(chck_buffer_write_string_of_type(str, len, bits, buf)); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/buffer/buffer.h new/chck-0.0.20161208/chck/buffer/buffer.h --- old/chck-0.0.20160429/chck/buffer/buffer.h 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/buffer/buffer.h 2016-12-08 16:14:10.000000000 +0100 @@ -32,44 +32,44 @@ bool copied; }; -CHCK_NONULL static inline bool +static inline bool chck_buffer_native_endianess(const struct chck_buffer *buf) { return (chck_endianess() == buf->endianess); } void chck_buffer_release(struct chck_buffer *buf); -CHCK_NONULL void chck_buffer_flush(struct chck_buffer *buf); -CHCK_NONULLV(1) bool chck_buffer_from_pointer(struct chck_buffer *buf, void *ptr, size_t size, enum chck_endianess endianess); -CHCK_NONULL bool chck_buffer(struct chck_buffer *buf, size_t size, enum chck_endianess endianess); -CHCK_NONULLV(1) void chck_buffer_set_pointer(struct chck_buffer *buf, void *ptr, size_t size, enum chck_endianess endianess); - -CHCK_NONULLV(4) size_t chck_buffer_fill(const void *src, size_t size, size_t memb, struct chck_buffer *buf); -CHCK_NONULL size_t chck_buffer_fill_from_file(FILE *src, size_t size, size_t memb, struct chck_buffer *buf); -CHCK_NONULL size_t chck_buffer_fill_from_fd(int fd, size_t size, size_t memb, struct chck_buffer *buf); - -CHCK_NONULLV(4) size_t chck_buffer_write(const void *src, size_t size, size_t nmemb, struct chck_buffer *buf); -CHCK_NONULL size_t chck_buffer_write_from_file(FILE *src, size_t size, size_t nmemb, struct chck_buffer *buf); -CHCK_NONULL size_t chck_buffer_write_from_fd(int fd, size_t size, size_t nmemb, struct chck_buffer *buf); - -CHCK_NONULL size_t chck_buffer_read(void *dst, size_t size, size_t memb, struct chck_buffer *buf); -CHCK_NONULL bool chck_buffer_read_int(void *i, enum chck_bits bits, struct chck_buffer *buf); -CHCK_NONULLV(1, 3) bool chck_buffer_read_string(char **str, size_t *len, struct chck_buffer *buf); -CHCK_NONULLV(1, 4) bool chck_buffer_read_string_of_type(char **str, size_t *len, enum chck_bits bits, struct chck_buffer *buf); - -CHCK_NONULL bool chck_buffer_write_int(const void *i, enum chck_bits bits, struct chck_buffer *buf); -CHCK_NONULLV(3) bool chck_buffer_write_string(const char *str, size_t len, struct chck_buffer *buf); -CHCK_NONULLV(4) bool chck_buffer_write_string_of_type(const char *str, size_t len, enum chck_bits bits, struct chck_buffer *buf); +void chck_buffer_flush(struct chck_buffer *buf); +bool chck_buffer_from_pointer(struct chck_buffer *buf, void *ptr, size_t size, enum chck_endianess endianess); +bool chck_buffer(struct chck_buffer *buf, size_t size, enum chck_endianess endianess); +void chck_buffer_set_pointer(struct chck_buffer *buf, void *ptr, size_t size, enum chck_endianess endianess); + +size_t chck_buffer_fill(const void *src, size_t size, size_t memb, struct chck_buffer *buf); +size_t chck_buffer_fill_from_file(FILE *src, size_t size, size_t memb, struct chck_buffer *buf); +size_t chck_buffer_fill_from_fd(int fd, size_t size, size_t memb, struct chck_buffer *buf); + +size_t chck_buffer_write(const void *src, size_t size, size_t nmemb, struct chck_buffer *buf); +size_t chck_buffer_write_from_file(FILE *src, size_t size, size_t nmemb, struct chck_buffer *buf); +size_t chck_buffer_write_from_fd(int fd, size_t size, size_t nmemb, struct chck_buffer *buf); + +size_t chck_buffer_read(void *dst, size_t size, size_t memb, struct chck_buffer *buf); +bool chck_buffer_read_int(void *i, enum chck_bits bits, struct chck_buffer *buf); +bool chck_buffer_read_string(char **str, size_t *len, struct chck_buffer *buf); +bool chck_buffer_read_string_of_type(char **str, size_t *len, enum chck_bits bits, struct chck_buffer *buf); + +bool chck_buffer_write_int(const void *i, enum chck_bits bits, struct chck_buffer *buf); +bool chck_buffer_write_string(const char *str, size_t len, struct chck_buffer *buf); +bool chck_buffer_write_string_of_type(const char *str, size_t len, enum chck_bits bits, struct chck_buffer *buf); -CHCK_NONULL CHCK_FORMAT(printf, 2, 3) size_t chck_buffer_write_format(struct chck_buffer *buf, const char *fmt, ...); -CHCK_NONULL size_t chck_buffer_write_varg(struct chck_buffer *buf, const char *fmt, va_list args); +CHCK_FORMAT(printf, 2, 3) size_t chck_buffer_write_format(struct chck_buffer *buf, const char *fmt, ...); +size_t chck_buffer_write_varg(struct chck_buffer *buf, const char *fmt, va_list args); -CHCK_NONULL ptrdiff_t chck_buffer_seek(struct chck_buffer *buf, long offset, int whence); -CHCK_NONULL bool chck_buffer_resize(struct chck_buffer *buf, size_t size); +ptrdiff_t chck_buffer_seek(struct chck_buffer *buf, long offset, int whence); +bool chck_buffer_resize(struct chck_buffer *buf, size_t size); /* -DHAS_ZLIB=1 -lz */ CHCK_CONST bool chck_buffer_has_zlib(void); -CHCK_NONULL bool chck_buffer_compress_zlib(struct chck_buffer *buf); -CHCK_NONULL bool chck_buffer_decompress_zlib(struct chck_buffer *buf); +bool chck_buffer_compress_zlib(struct chck_buffer *buf); +bool chck_buffer_decompress_zlib(struct chck_buffer *buf); #endif /* __chck_buffer__ */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/buffer/endianess.h new/chck-0.0.20161208/chck/buffer/endianess.h --- old/chck-0.0.20160429/chck/buffer/endianess.h 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/buffer/endianess.h 2016-12-08 16:14:10.000000000 +0100 @@ -56,7 +56,7 @@ # define chck_endianess() CHCK_ENDIANESS_LITTLE #else // runtime endianess check -static inline enum +CHCK_CONST static inline enum chck_endianess chck_endianess(void) { union { @@ -67,16 +67,21 @@ }; #endif -CHCK_NONULL static inline void +static inline void chck_bswap_generic(void *p, size_t size) { - size_t s; - uint8_t b[size]; + if (size <= sizeof(uint8_t)) + return; + + assert(size <= sizeof(intmax_t)); + uint8_t b[sizeof(intmax_t)]; memcpy(b, p, size); - for (s = 0; s < size; ++s) memset((uint8_t*)p + s, b[size - s - 1], 1); + + for (size_t s = 0; s < size; ++s) + memset((uint8_t*)p + s, b[size - s - 1], 1); } -CHCK_NONULL static inline void +static inline void chck_bswap_single(void *p, size_t size) { #if HAS_BYTESWAP @@ -100,12 +105,12 @@ #endif } -CHCK_NONULL static inline void +static inline void chck_bswap(void *v, size_t size, size_t memb) { assert(v); - for (uint8_t *p = v; p < (uint8_t*)v + (memb * size); p += size) + for (uint8_t *p = v; size > sizeof(uint8_t) && p < (uint8_t*)v + (memb * size); p += size) chck_bswap_single(p, size); } @@ -113,10 +118,10 @@ #if HAS_BYTESWAP # define generic_swap(T, n) \ - CHCK_NONULL static inline T chck_bswap##n(T v) { return bswap##n(v); } + static inline T chck_bswap##n(T v) { return bswap##n(v); } #else # define generic_swap(T, n) \ - CHCK_NONULL static inline T chck_bswap##n(T v) { chck_bswap_generic(&v, sizeof(v)); return v; } + static inline T chck_bswap##n(T v) { chck_bswap_generic(&v, sizeof(v)); return v; } #endif generic_swap(uint16_t, 16) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/dl/dl.h new/chck-0.0.20161208/chck/dl/dl.h --- old/chck-0.0.20160429/chck/dl/dl.h 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/dl/dl.h 2016-12-08 16:14:10.000000000 +0100 @@ -3,8 +3,8 @@ #include -CHCK_NONULLV(1) void* chck_dl_load(const char *file, const char **out_error); -CHCK_NONULLV(1,2) void* chck_dl_load_symbol(void *handle, const char *name, const char **out_error); -CHCK_NONULL void chck_dl_unload(void *handle); +void* chck_dl_load(const char *file, const char **out_error); +void* chck_dl_load_symbol(void *handle, const char *name, const char **out_error); +void chck_dl_unload(void *handle); #endif /* __chck_cdl__ */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/fs/fs.c new/chck-0.0.20161208/chck/fs/fs.c --- old/chck-0.0.20160429/chck/fs/fs.c 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/fs/fs.c 2016-12-08 16:14:10.000000000 +0100 @@ -14,7 +14,7 @@ # include #endif -#if defined(BSD) +#if defined(BSD) || defined(__FreeBSD__) # include # include #endif @@ -121,7 +121,7 @@ #elif defined(_WIN32) || defined(_WIN64) if (_pgmptr && !(exepath = ccopy(_pgmptr))) return NULL; if (exepath) return exepath; -#elif defined(BSD) /* works on all BSD's? */ +#elif defined(BSD) || defined(__FreeBSD__) /* works on all BSD's? */ int mib[4]; mib[0] = CTL_KERN; mib[1] = KERN_PROC; @@ -140,7 +140,7 @@ path = "/proc/self/exe"; #elif defined(__NetBSD__) path = "/proc/curproc/exe"; -#elif defined(BSD) +#elif defined(BSD) || defined(__FreeBSD__) path = "/proc/curproc/file"; #elif defined(__sun) path = "/proc/self/path/a.out"; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/fs/fs.h new/chck-0.0.20161208/chck/fs/fs.h --- old/chck-0.0.20160429/chck/fs/fs.h 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/fs/fs.h 2016-12-08 16:14:10.000000000 +0100 @@ -7,7 +7,7 @@ #include #include -CHCK_PURE CHCK_NONULL static inline const char* +CHCK_PURE static inline const char* chck_basename(const char *path) { assert(path); @@ -15,7 +15,7 @@ return (base ? base + 1 : path); } -CHCK_NONULL static inline bool +static inline bool chck_filename_is_safe(const char *name) { if (!name || !*name) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/lut/lut.h new/chck-0.0.20161208/chck/lut/lut.h --- old/chck-0.0.20160429/chck/lut/lut.h 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/lut/lut.h 2016-12-08 16:14:10.000000000 +0100 @@ -53,7 +53,7 @@ } // default simple string hash -CHCK_NONULL CHCK_CONST static inline uint32_t +CHCK_CONST static inline uint32_t chck_default_str_hash(const char *str, size_t len) { (void)len; @@ -78,16 +78,16 @@ #define chck_lut_for_each(lut, pos) \ for (size_t _I = 0; (pos = chck_lut_iter(lut, &_I));) -CHCK_NONULL bool chck_lut(struct chck_lut *lut, int set, size_t count, size_t member); -CHCK_NONULL void chck_lut_uint_algorithm(struct chck_lut *lut, uint32_t (*hashuint)(uint32_t uint)); -CHCK_NONULL void chck_lut_str_algorithm(struct chck_lut *lut, uint32_t (*hashstr)(const char *str, size_t len)); +bool chck_lut(struct chck_lut *lut, int set, size_t count, size_t member); +void chck_lut_uint_algorithm(struct chck_lut *lut, uint32_t (*hashuint)(uint32_t uint)); +void chck_lut_str_algorithm(struct chck_lut *lut, uint32_t (*hashstr)(const char *str, size_t len)); void chck_lut_release(struct chck_lut *lut); -CHCK_NONULL void chck_lut_flush(struct chck_lut *lut); -CHCK_NONULLV(1) bool chck_lut_set(struct chck_lut *lut, uint32_t lookup, const void *data); -CHCK_NONULL void* chck_lut_get(struct chck_lut *lut, uint32_t lookup); -CHCK_NONULLV(1, 2) bool chck_lut_str_set(struct chck_lut *lut, const char *str, size_t len, const void *data); -CHCK_NONULL void* chck_lut_str_get(struct chck_lut *lut, const char *str, size_t len); -CHCK_NONULL void* chck_lut_iter(struct chck_lut *lut, size_t *iter); +void chck_lut_flush(struct chck_lut *lut); +bool chck_lut_set(struct chck_lut *lut, uint32_t lookup, const void *data); +void* chck_lut_get(struct chck_lut *lut, uint32_t lookup); +bool chck_lut_str_set(struct chck_lut *lut, const char *str, size_t len, const void *data); +void* chck_lut_str_get(struct chck_lut *lut, const char *str, size_t len); +void* chck_lut_iter(struct chck_lut *lut, size_t *iter); /** * Hash tables are wrappers around LUTs that does not have collisions. @@ -104,16 +104,16 @@ #define chck_hash_table_for_each(table, pos) \ for (struct chck_hash_table_iterator _I = { table, 0, NULL, 0 }; (pos = chck_hash_table_iter(&_I));) -CHCK_NONULL bool chck_hash_table(struct chck_hash_table *table, int set, size_t count, size_t member); -CHCK_NONULL void chck_hash_table_uint_algorithm(struct chck_hash_table *table, uint32_t (*hashuint)(uint32_t uint)); -CHCK_NONULL void chck_hash_table_str_algorithm(struct chck_hash_table *table, uint32_t (*hashstr)(const char *str, size_t len)); +bool chck_hash_table(struct chck_hash_table *table, int set, size_t count, size_t member); +void chck_hash_table_uint_algorithm(struct chck_hash_table *table, uint32_t (*hashuint)(uint32_t uint)); +void chck_hash_table_str_algorithm(struct chck_hash_table *table, uint32_t (*hashstr)(const char *str, size_t len)); void chck_hash_table_release(struct chck_hash_table *table); -CHCK_NONULL void chck_hash_table_flush(struct chck_hash_table *table); -CHCK_NONULL uint32_t chck_hash_table_collisions(struct chck_hash_table *table); -CHCK_NONULLV(1) bool chck_hash_table_set(struct chck_hash_table *table, uint32_t key, const void *data); -CHCK_NONULLV(1) void* chck_hash_table_get(struct chck_hash_table *table, uint32_t key); -CHCK_NONULLV(1, 2) bool chck_hash_table_str_set(struct chck_hash_table *table, const char *str, size_t len, const void *data); -CHCK_NONULLV(1, 2) void* chck_hash_table_str_get(struct chck_hash_table *table, const char *str, size_t len); -CHCK_NONULL void* chck_hash_table_iter(struct chck_hash_table_iterator *iter); +void chck_hash_table_flush(struct chck_hash_table *table); +uint32_t chck_hash_table_collisions(struct chck_hash_table *table); +bool chck_hash_table_set(struct chck_hash_table *table, uint32_t key, const void *data); +void* chck_hash_table_get(struct chck_hash_table *table, uint32_t key); +bool chck_hash_table_str_set(struct chck_hash_table *table, const char *str, size_t len, const void *data); +void* chck_hash_table_str_get(struct chck_hash_table *table, const char *str, size_t len); +void* chck_hash_table_iter(struct chck_hash_table_iterator *iter); #endif /* __chck_lut__ */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/macros.h new/chck-0.0.20161208/chck/macros.h --- old/chck-0.0.20160429/chck/macros.h 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/macros.h 2016-12-08 16:14:10.000000000 +0100 @@ -7,8 +7,6 @@ # define unlikely(x) __builtin_expect(!!(x), 0) # endif # define CHCK_FORMAT(f, x, y) __attribute__((format(f, x, y))) -# define CHCK_NONULL __attribute__((nonnull)) -# define CHCK_NONULLV(...) __attribute__((nonnull(__VA_ARGS__))) # define CHCK_CONST __attribute__((const)) # define CHCK_PURE __attribute__((pure)) # define CHCK_MALLOC __attribute__((malloc)) @@ -18,8 +16,6 @@ # define unlikely(x) !!(x) # endif # define CHCK_FORMAT(f, x, y) -# define CHCK_NONULL -# define CHCK_NONULLV # define CHCK_CONST # define CHCK_PURE # define CHCK_MALLOC diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/math/test.c new/chck-0.0.20161208/chck/math/test.c --- old/chck-0.0.20160429/chck/math/test.c 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/math/test.c 2016-12-08 16:14:10.000000000 +0100 @@ -8,12 +8,12 @@ int main(void) { - assert(chck_equalld(10.0, 10.000000000001l, 1000000.0l)); - assert(!chck_equalld(10.0, 10.000000000001l, 1.0l)); - assert(chck_equal(10.0, 10.000000000001, 1000.0)); - assert(!chck_equal(10.0, 10.000000000001, 1.0)); - assert(chck_equalf(10.0f, 10.00001f, 10.0f)); - assert(!chck_equalf(10.0f, 10.00001f, 1.0f)); + assert(chck_equalld(LDBL_MIN, LDBL_MIN + LDBL_MIN, LDBL_DIG / LDBL_EPSILON)); + assert(!chck_equalld(LDBL_MIN, LDBL_MIN + LDBL_MIN, 1.0l)); + assert(chck_equal(DBL_MIN, DBL_MIN + DBL_MIN, DBL_DIG / DBL_EPSILON)); + assert(!chck_equal(DBL_MIN, DBL_MIN + DBL_MIN, 1.0)); + assert(chck_equalf(FLT_MIN, FLT_MIN + FLT_MIN, FLT_DIG / FLT_EPSILON)); + assert(!chck_equalf(FLT_MIN, FLT_MIN + FLT_MIN, 1.0f)); for (uint32_t i = 0xFFFF; i < 0xFFFFFF; ++i) { assert(chck_minu32(i, i - 20) == i - 20); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/overflow/overflow.h new/chck-0.0.20161208/chck/overflow/overflow.h --- old/chck-0.0.20160429/chck/overflow/overflow.h 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/overflow/overflow.h 2016-12-08 16:14:10.000000000 +0100 @@ -38,9 +38,9 @@ // T = type name, n = function suffix, s = is type signed? #define decl_generics_for_type(T, n, s) \ - of_attr CHCK_NONULL static inline bool chck_add_of##n(T a, T b, T *r) { assert((!s || b >= 0) && r); return add_of(a, b, r); } \ - of_attr CHCK_NONULL static inline bool chck_sub_of##n(T a, T b, T *r) { assert((!s || b >= 0) && r); return sub_of(a, b, r); } \ - of_attr CHCK_NONULL static inline bool chck_mul_of##n(T a, T b, T *r) { assert(r); return mul_of(a, b, r); } + of_attr static inline bool chck_add_of##n(T a, T b, T *r) { assert((!s || b >= 0) && r); return add_of(a, b, r); } \ + of_attr static inline bool chck_sub_of##n(T a, T b, T *r) { assert((!s || b >= 0) && r); return sub_of(a, b, r); } \ + of_attr static inline bool chck_mul_of##n(T a, T b, T *r) { assert(r); return mul_of(a, b, r); } // UT = unsigned type, un = unsigned function suffix // T = signed type, n = signed function suffix diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/pool/pool.c new/chck-0.0.20161208/chck/pool/pool.c --- old/chck-0.0.20160429/chck/pool/pool.c 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/pool/pool.c 2016-12-08 16:14:10.000000000 +0100 @@ -545,109 +545,3 @@ assert(pool); return pool_buffer_to_c_array(&pool->items, out_memb); } - -bool -chck_ring_pool(struct chck_ring_pool *pool, size_t grow, size_t capacity, size_t member_size) -{ - assert(pool && member_size > 0); - - if (unlikely(!member_size)) - return false; - - *pool = (struct chck_ring_pool){0}; - return pool_buffer(&pool->items, grow, capacity, member_size); -} - -bool -chck_ring_pool_from_c_array(struct chck_ring_pool *pool, const void *items, size_t memb, size_t grow, size_t member_size) -{ - return (!chck_ring_pool(pool, grow, 0, member_size) && !chck_ring_pool_set_c_array(pool, items, memb)); -} - -void -chck_ring_pool_release(struct chck_ring_pool *pool) -{ - if (!pool) - return; - - pool_buffer_release(&pool->items); - free(pool->popped); - pool->popped = NULL; -} - -void -chck_ring_pool_flush(struct chck_ring_pool *pool) -{ - assert(pool); - pool_buffer_flush(&pool->items, true); - free(pool->popped); - pool->popped = NULL; -} - -void* -chck_ring_pool_push_front(struct chck_ring_pool *pool, const void *data) -{ - assert(pool); - return pool_buffer_add_move(&pool->items, data, 0, NULL); -} - -void* -chck_ring_pool_push_back(struct chck_ring_pool *pool, const void *data) -{ - assert(pool); - return pool_buffer_add(&pool->items, data, pool->items.used, NULL); -} - -void* -chck_ring_pool_pop_first(struct chck_ring_pool *pool) -{ - assert(pool); - - if (unlikely(pool->items.count <= 0)) - return NULL; - - if (!pool->popped && !(pool->popped = malloc(pool->items.member))) - return NULL; - - memcpy(pool->popped, pool->items.buffer, pool->items.member); - pool_buffer_remove_move(&pool->items, 0); - return pool->popped; -} - -void* -chck_ring_pool_pop_last(struct chck_ring_pool *pool) -{ - assert(pool); - - if (unlikely(pool->items.count <= 0)) - return NULL; - - const void *ptr = pool_buffer_get(&pool->items, pool->items.count - 1); - if (!ptr || (!pool->popped && !(pool->popped = malloc(pool->items.member)))) - return NULL; - - memcpy(pool->popped, ptr, pool->items.member); - pool_buffer_remove_move(&pool->items, pool->items.count - 1); - return pool->popped; -} - -void* -chck_ring_pool_iter(const struct chck_ring_pool *pool, size_t *iter, bool reverse) -{ - assert(pool && iter); - return pool_buffer_iter(&pool->items, iter, reverse); -} - -bool -chck_ring_pool_set_c_array(struct chck_ring_pool *pool, const void *items, size_t memb) -{ - assert(pool); - return pool_buffer_set_c_array(&pool->items, items, memb); -} - -void* -chck_ring_pool_to_c_array(struct chck_ring_pool *pool, size_t *out_memb) -{ - assert(pool); - return pool_buffer_to_c_array(&pool->items, out_memb); -} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/pool/pool.h new/chck-0.0.20161208/chck/pool/pool.h --- old/chck-0.0.20160429/chck/pool/pool.h 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/pool/pool.h 2016-12-08 16:14:10.000000000 +0100 @@ -59,18 +59,18 @@ #define chck_pool_for_each_reverse(pool, pos) \ for (size_t _I = (pool)->items.count - 1; (pos = chck_pool_iter(pool, &_I, true));) -CHCK_NONULL bool chck_pool(struct chck_pool *pool, size_t grow, size_t capacity, size_t member_size); -CHCK_NONULL bool chck_pool_from_c_array(struct chck_pool *pool, const void *items, size_t memb, size_t grow, size_t member_size); +bool chck_pool(struct chck_pool *pool, size_t grow, size_t capacity, size_t member_size); +bool chck_pool_from_c_array(struct chck_pool *pool, const void *items, size_t memb, size_t grow, size_t member_size); void chck_pool_release(struct chck_pool *pool); -CHCK_NONULL void chck_pool_flush(struct chck_pool *pool); -CHCK_NONULL void chck_pool_print(const struct chck_pool *pool, FILE *out); -CHCK_PURE CHCK_NONULL void* chck_pool_get(const struct chck_pool *pool, size_t index); -CHCK_PURE CHCK_NONULL void* chck_pool_get_last(const struct chck_pool *pool); -CHCK_NONULLV(1) void* chck_pool_add(struct chck_pool *pool, const void *data, size_t *out_index); -CHCK_NONULL void chck_pool_remove(struct chck_pool *pool, size_t index); -CHCK_NONULL void* chck_pool_iter(const struct chck_pool *pool, size_t *iter, bool reverse); -CHCK_NONULLV(1) bool chck_pool_set_c_array(struct chck_pool *pool, const void *items, size_t memb); /* struct item *c_array; */ -CHCK_NONULLV(1) void* chck_pool_to_c_array(struct chck_pool *pool, size_t *memb); /* struct item *c_array; (contains holes) */ +void chck_pool_flush(struct chck_pool *pool); +void chck_pool_print(const struct chck_pool *pool, FILE *out); +CHCK_PURE void* chck_pool_get(const struct chck_pool *pool, size_t index); +CHCK_PURE void* chck_pool_get_last(const struct chck_pool *pool); +void* chck_pool_add(struct chck_pool *pool, const void *data, size_t *out_index); +void chck_pool_remove(struct chck_pool *pool, size_t index); +void* chck_pool_iter(const struct chck_pool *pool, size_t *iter, bool reverse); +bool chck_pool_set_c_array(struct chck_pool *pool, const void *items, size_t memb); /* struct item *c_array; */ +void* chck_pool_to_c_array(struct chck_pool *pool, size_t *memb); /* struct item *c_array; (contains holes) */ /** * IterPools don't have holes in buffer. @@ -92,49 +92,19 @@ #define chck_iter_pool_for_each_reverse(pool, pos) \ for (size_t _I = (pool)->items.count - 1; (pos = chck_iter_pool_iter(pool, &_I, true));) -CHCK_NONULL bool chck_iter_pool(struct chck_iter_pool *pool, size_t grow, size_t capacity, size_t member_size); -CHCK_NONULL bool chck_iter_pool_from_c_array(struct chck_iter_pool *pool, const void *items, size_t memb, size_t grow_step, size_t member_size); +bool chck_iter_pool(struct chck_iter_pool *pool, size_t grow, size_t capacity, size_t member_size); +bool chck_iter_pool_from_c_array(struct chck_iter_pool *pool, const void *items, size_t memb, size_t grow_step, size_t member_size); void chck_iter_pool_release(struct chck_iter_pool *pool); -CHCK_NONULL void chck_iter_pool_flush(struct chck_iter_pool *pool); -CHCK_NONULL void chck_iter_pool_empty(struct chck_iter_pool *pool); -CHCK_PURE CHCK_NONULL void* chck_iter_pool_get(const struct chck_iter_pool *pool, size_t index); -CHCK_PURE CHCK_NONULL void* chck_iter_pool_get_last(const struct chck_iter_pool *pool); -CHCK_NONULLV(1) void* chck_iter_pool_push_front(struct chck_iter_pool *pool, const void *data); -CHCK_NONULLV(1) void* chck_iter_pool_push_back(struct chck_iter_pool *pool, const void *data); -CHCK_NONULLV(1) void* chck_iter_pool_insert(struct chck_iter_pool *pool, size_t index, const void *data); -CHCK_NONULL void chck_iter_pool_remove(struct chck_iter_pool *pool, size_t index); -CHCK_NONULL void* chck_iter_pool_iter(const struct chck_iter_pool *pool, size_t *iter, bool reverse); -CHCK_NONULLV(1) bool chck_iter_pool_set_c_array(struct chck_iter_pool *pool, const void *items, size_t memb); /* struct item *c_array; */ -CHCK_NONULLV(1) void* chck_iter_pool_to_c_array(struct chck_iter_pool *pool, size_t *memb); /* struct item *c_array; */ - -/** - * RingPools are circular pools. - * You push items to them and the pool grows as needed. - * You can push and pop to/from both sides. - */ - -#define chck_ring_pool_for_each_call(pool, function, ...) \ -{ void *_P; for (size_t _I = 0; (_P = chck_ring_pool_iter(pool, &_I, false));) function(_P, ##__VA_ARGS__); } - -#define chck_ring_pool_for_each_call_reverse(pool, function, ...) \ -{ void *_P; for (size_t _I = (pool)->items.count - 1; (_P = chck_ring_pool_iter(pool, &_I, true));) function(_P, ##__VA_ARGS__); } - -#define chck_ring_pool_for_each(pool, pos) \ - for (size_t _I = 0; (pos = chck_ring_pool_iter(pool, &_I, false));) - -#define chck_ring_pool_for_each_reverse(pool, pos) \ - for (size_t _I = (pool)->items.count - 1; (pos = chck_ring_pool_iter(pool, &_I, true));) - -CHCK_NONULL bool chck_ring_pool(struct chck_ring_pool *pool, size_t grow, size_t capacity, size_t member_size); -CHCK_NONULL bool chck_ring_pool_from_c_array(struct chck_ring_pool *pool, const void *items, size_t memb, size_t growStep, size_t memberSize); -void chck_ring_pool_release(struct chck_ring_pool *pool); -CHCK_NONULL void chck_ring_pool_flush(struct chck_ring_pool *pool); -CHCK_NONULLV(1) void* chck_ring_pool_push_front(struct chck_ring_pool *pool, const void *data); -CHCK_NONULLV(1) void* chck_ring_pool_push_back(struct chck_ring_pool *pool, const void *data); -CHCK_NONULL void* chck_ring_pool_pop_first(struct chck_ring_pool *pool); -CHCK_NONULL void* chck_ring_pool_pop_last(struct chck_ring_pool *pool); -CHCK_NONULL void* chck_ring_pool_iter(const struct chck_ring_pool *pool, size_t *iter, bool reverse); -CHCK_NONULLV(1) bool chck_ring_pool_set_c_array(struct chck_ring_pool *pool, const void *items, size_t memb); /* struct item *c_array; */ -CHCK_NONULLV(1) void* chck_ring_pool_to_c_array(struct chck_ring_pool *pool, size_t *memb); /* struct item *c_array; */ +void chck_iter_pool_flush(struct chck_iter_pool *pool); +void chck_iter_pool_empty(struct chck_iter_pool *pool); +CHCK_PURE void* chck_iter_pool_get(const struct chck_iter_pool *pool, size_t index); +CHCK_PURE void* chck_iter_pool_get_last(const struct chck_iter_pool *pool); +void* chck_iter_pool_push_front(struct chck_iter_pool *pool, const void *data); +void* chck_iter_pool_push_back(struct chck_iter_pool *pool, const void *data); +void* chck_iter_pool_insert(struct chck_iter_pool *pool, size_t index, const void *data); +void chck_iter_pool_remove(struct chck_iter_pool *pool, size_t index); +void* chck_iter_pool_iter(const struct chck_iter_pool *pool, size_t *iter, bool reverse); +bool chck_iter_pool_set_c_array(struct chck_iter_pool *pool, const void *items, size_t memb); /* struct item *c_array; */ +void* chck_iter_pool_to_c_array(struct chck_iter_pool *pool, size_t *memb); /* struct item *c_array; */ #endif /* __chck_pool__ */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/pool/test.c new/chck-0.0.20161208/chck/pool/test.c --- old/chck-0.0.20160429/chck/pool/test.c 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/pool/test.c 2016-12-08 16:14:10.000000000 +0100 @@ -349,143 +349,6 @@ assert(pool.items.used == 0); } - /* TEST: ring pool */ - { - struct chck_ring_pool pool = {0}; - - { - size_t iter = 0; - assert(!chck_ring_pool_iter(&pool, &iter, false)); - assert(!iter); - assert(!chck_ring_pool_iter(&pool, &iter, true)); - assert(!iter); - } - - assert(chck_ring_pool(&pool, 32, 0, sizeof(struct item))); - assert(pool.items.step == 32 * sizeof(struct item)); - assert(pool.items.member == sizeof(struct item)); - assert(pool.items.allocated == 0); - assert(pool.items.used == 0); - assert(pool.items.count == 0); - assert(!pool.items.buffer); - - void *a, *b, *c; - a = chck_ring_pool_push_back(&pool, (&(struct item){1, NULL})); - b = chck_ring_pool_push_back(&pool, (&(struct item){2, NULL})); - c = chck_ring_pool_push_back(&pool, (&(struct item){3, NULL})); - - assert(a != NULL && b != NULL && c != NULL); - assert(a != b && b != c && a != c); - - { - size_t iter = 0; - struct item *current; - while ((current = chck_ring_pool_iter(&pool, &iter, false))) - assert(current != NULL); - - assert(pool.items.count == 3); - assert(pool.items.used == 3 * sizeof(struct item)); - assert(pool.items.allocated == 32 * sizeof(struct item)); - assert(iter == 3); - } - - assert(((struct item*)chck_ring_pool_pop_first(&pool))->a == 1); - - { - size_t iter = 0; - struct item *current; - while ((current = chck_ring_pool_iter(&pool, &iter, true))) - assert(current != NULL); - - assert(pool.items.count == 2); - assert(pool.items.used == 2 * sizeof(struct item)); - assert(pool.items.allocated == 32 * sizeof(struct item)); - assert(iter == (size_t)-1); - } - - assert(chck_ring_pool_push_front(&pool, NULL)); - - { - size_t iter = 0; - struct item *current; - while ((current = chck_ring_pool_iter(&pool, &iter, false))) - assert(current != NULL); - - assert(pool.items.count == 3); - assert(pool.items.used == 3 * sizeof(struct item)); - assert(pool.items.allocated == 32 * sizeof(struct item)); - assert(iter == 3); - } - - assert(((struct item*)chck_ring_pool_pop_last(&pool))->a == 3); - - { - size_t iter = 0; - struct item *current; - while ((current = chck_ring_pool_iter(&pool, &iter, false))) - assert(current != NULL); - - assert(pool.items.count == 2); - assert(pool.items.used == 2 * sizeof(struct item)); - assert(pool.items.allocated == 32 * sizeof(struct item)); - assert(iter == 2); - } - - chck_ring_pool_push_back(&pool, NULL); - - { - size_t iter = 0; - struct item *current; - while ((current = chck_ring_pool_iter(&pool, &iter, false))) - assert(current != NULL); - - assert(pool.items.count == 3); - assert(pool.items.used == 3 * sizeof(struct item)); - assert(pool.items.allocated == 32 * sizeof(struct item)); - assert(iter == 3); - } - - chck_ring_pool_flush(&pool); - - chck_ring_pool_push_back(&pool, (&(struct item){1, NULL})); - chck_ring_pool_push_front(&pool, (&(struct item){3, NULL})); - chck_ring_pool_push_back(&pool, (&(struct item){2, NULL})); - - assert(((struct item*)chck_ring_pool_to_c_array(&pool, NULL))[0].a == 3); - assert(((struct item*)chck_ring_pool_to_c_array(&pool, NULL))[1].a == 1); - assert(((struct item*)chck_ring_pool_to_c_array(&pool, NULL))[2].a == 2); - chck_ring_pool_for_each_call(&pool, printa); - - assert(((struct item*)chck_ring_pool_pop_last(&pool))->a == 2); - assert(((struct item*)chck_ring_pool_pop_first(&pool))->a == 3); - assert(((struct item*)chck_ring_pool_pop_last(&pool))->a == 1); - assert(pool.items.used == 0); - - { - for (uint32_t i = 0; i < 33; ++i) - chck_ring_pool_push_back(&pool, NULL); - - assert(pool.items.used == 33 * sizeof(struct item)); - assert(pool.items.allocated == 64 * sizeof(struct item)); - - for (uint32_t i = 0; i < 32; ++i) - chck_ring_pool_pop_last(&pool); - - assert(pool.items.used == 1 * sizeof(struct item)); - assert(pool.items.allocated == 32 * sizeof(struct item)); - } - - struct item bars[4] = {{.a = 1}}; - assert(chck_ring_pool_set_c_array(&pool, &bars, 4)); - assert(pool.items.allocated == 4 * sizeof(struct item)); - assert(pool.items.used == 4 * sizeof(struct item)); - assert(!memcmp(pool.items.buffer, bars, sizeof(bars))); - - chck_ring_pool_release(&pool); - assert(pool.items.allocated == 0); - assert(pool.items.used == 0); - } - /* TEST: benchmark (many insertions, and removal expanding from center) */ { const uint32_t iters = 0xFFFFF; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/sjis/sjis.h new/chck-0.0.20161208/chck/sjis/sjis.h --- old/chck-0.0.20160429/chck/sjis/sjis.h 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/sjis/sjis.h 2016-12-08 16:14:10.000000000 +0100 @@ -6,7 +6,7 @@ #include #include -CHCK_NONULLV(1) char* chck_sjis_to_utf8(const unsigned char *sjis, size_t size, size_t *out_size, bool terminate); -CHCK_NONULLV(1) uint8_t* chck_utf8_to_sjis(const char *input, size_t size, size_t *out_size, bool terminate); +char* chck_sjis_to_utf8(const unsigned char *sjis, size_t size, size_t *out_size, bool terminate); +uint8_t* chck_utf8_to_sjis(const char *input, size_t size, size_t *out_size, bool terminate); #endif /* __sjis_h__ */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/string/string.h new/chck-0.0.20161208/chck/string/string.h --- old/chck-0.0.20160429/chck/string/string.h 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/string/string.h 2016-12-08 16:14:10.000000000 +0100 @@ -170,16 +170,16 @@ } void chck_string_release(struct chck_string *string); -CHCK_NONULLV(1) bool chck_string_set_cstr(struct chck_string *string, const char *data, bool is_heap); -CHCK_NONULLV(1) bool chck_string_set_cstr_with_length(struct chck_string *string, const char *data, size_t len, bool is_heap); -CHCK_NONULL bool chck_string_set(struct chck_string *string, const struct chck_string *other, bool is_heap); -CHCK_NONULLV(1,2) CHCK_FORMAT(printf, 2, 3) bool chck_string_set_format(struct chck_string *string, const char *fmt, ...); -CHCK_NONULL bool chck_string_set_varg(struct chck_string *string, const char *fmt, va_list args); +bool chck_string_set_cstr(struct chck_string *string, const char *data, bool is_heap); +bool chck_string_set_cstr_with_length(struct chck_string *string, const char *data, size_t len, bool is_heap); +bool chck_string_set(struct chck_string *string, const struct chck_string *other, bool is_heap); +CHCK_FORMAT(printf, 2, 3) bool chck_string_set_format(struct chck_string *string, const char *fmt, ...); +bool chck_string_set_varg(struct chck_string *string, const char *fmt, va_list args); -CHCK_NONULL char* chck_cstr_strip(char *cstr); /* modifies inplace */ -CHCK_NONULL char* chck_cstr_remove_chars(char *cstr, const char *bad); /* modifies inplace */ -CHCK_NONULL char* chck_cstr_replace_char(char *cstr, char replace, char with); /* modifies inplace */ -CHCK_NONULLV(2,3,5) const char* chck_cstr_tokenize(const char *cstr, size_t *out_len, const char *separator, bool skip_whitespace, const char **state); -CHCK_NONULLV(2,3,5) const char* chck_cstr_tokenize_quoted(const char *cstr, size_t *out_len, const char *separator, const char *quotes, const char **state); +char* chck_cstr_strip(char *cstr); /* modifies inplace */ +char* chck_cstr_remove_chars(char *cstr, const char *bad); /* modifies inplace */ +char* chck_cstr_replace_char(char *cstr, char replace, char with); /* modifies inplace */ +const char* chck_cstr_tokenize(const char *cstr, size_t *out_len, const char *separator, bool skip_whitespace, const char **state); +const char* chck_cstr_tokenize_quoted(const char *cstr, size_t *out_len, const char *separator, const char *quotes, const char **state); #endif /* __chck_string_h__ */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/thread/queue/queue.h new/chck-0.0.20161208/chck/thread/queue/queue.h --- old/chck-0.0.20160429/chck/thread/queue/queue.h 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/thread/queue/queue.h 2016-12-08 16:14:10.000000000 +0100 @@ -32,13 +32,13 @@ } threads; }; -CHCK_NONULL bool chck_tqueue_add_task(struct chck_tqueue *tqueue, void *data, useconds_t block); -CHCK_NONULL size_t chck_tqueue_collect(struct chck_tqueue *tqueue); -CHCK_NONULL void chck_tqueue_set_fd(struct chck_tqueue *tqueue, int fd); -CHCK_PURE CHCK_NONULL int chck_tqueue_get_fd(struct chck_tqueue *tqueue); -CHCK_NONULL void chck_tqueue_set_keep_alive(struct chck_tqueue *tqueue, bool keep_alive); -CHCK_PURE CHCK_NONULL bool chck_tqueue_get_keep_alive(struct chck_tqueue *tqueue); +bool chck_tqueue_add_task(struct chck_tqueue *tqueue, void *data, useconds_t block); +size_t chck_tqueue_collect(struct chck_tqueue *tqueue); +void chck_tqueue_set_fd(struct chck_tqueue *tqueue, int fd); +CHCK_PURE int chck_tqueue_get_fd(struct chck_tqueue *tqueue); +void chck_tqueue_set_keep_alive(struct chck_tqueue *tqueue, bool keep_alive); +CHCK_PURE bool chck_tqueue_get_keep_alive(struct chck_tqueue *tqueue); void chck_tqueue_release(struct chck_tqueue *tqueue); -CHCK_NONULLV(1, 5) bool chck_tqueue(struct chck_tqueue *tqueue, size_t nthreads, size_t qsize, size_t msize, void (*work)(), void (*callback)(), void (*destructor)()); +bool chck_tqueue(struct chck_tqueue *tqueue, size_t nthreads, size_t qsize, size_t msize, void (*work)(), void (*callback)(), void (*destructor)()); #endif /* __chck_dispatch_h__ */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/unicode/unicode.h new/chck-0.0.20161208/chck/unicode/unicode.h --- old/chck-0.0.20160429/chck/unicode/unicode.h 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/unicode/unicode.h 2016-12-08 16:14:10.000000000 +0100 @@ -18,12 +18,12 @@ CHCK_UTF16_UNEXPECTED_LOW, }; -CHCK_NONULL uint8_t chck_utf32_encode(uint32_t dec, char out[4]); -CHCK_NONULLV(2,3) uint8_t chck_utf16_encode(uint16_t dec, char out[4], uint16_t *in_out_hi, enum chck_utf16_error *out_error); -CHCK_NONULL uint32_t chck_utf8_decode(uint32_t *state /* accept, reject */, uint32_t *codep, uint8_t byte); -CHCK_PURE CHCK_NONULL uint8_t chck_utf8_mblen(const char u8[4]); -CHCK_NONULL bool chck_utf8_validate(const char u8[4]); -CHCK_NONULL uint32_t chck_utf8_codepoint(const char u8[4]); -CHCK_NONULL bool chck_utf8_strlen(const char *u8, size_t len, size_t *out_len); +uint8_t chck_utf32_encode(uint32_t dec, char out[4]); +uint8_t chck_utf16_encode(uint16_t dec, char out[4], uint16_t *in_out_hi, enum chck_utf16_error *out_error); +uint32_t chck_utf8_decode(uint32_t *state /* accept, reject */, uint32_t *codep, uint8_t byte); +CHCK_PURE uint8_t chck_utf8_mblen(const char u8[4]); +bool chck_utf8_validate(const char u8[4]); +uint32_t chck_utf8_codepoint(const char u8[4]); +bool chck_utf8_strlen(const char *u8, size_t len, size_t *out_len); #endif /* __chck_unicode_h__ */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/chck-0.0.20160429/chck/xdg/xdg.h new/chck-0.0.20161208/chck/xdg/xdg.h --- old/chck-0.0.20160429/chck/xdg/xdg.h 2016-05-05 14:21:04.000000000 +0200 +++ new/chck-0.0.20161208/chck/xdg/xdg.h 2016-12-08 16:14:10.000000000 +0100 @@ -10,7 +10,7 @@ uint32_t iter; }; -CHCK_NONULL char* xdg_get_path(const char *xdg_env, const char *default_path); -CHCK_NONULL const char* xdg_get_paths(const char *xdg_env, const char *default_paths, struct xdg_paths *state, uint32_t max_iter); +char* xdg_get_path(const char *xdg_env, const char *default_path); +const char* xdg_get_paths(const char *xdg_env, const char *default_paths, struct xdg_paths *state, uint32_t max_iter); #endif /* __chck_xdg__ */