Mercurial > hg > ucx / changeset

     1.1 --- a/docs/src/modules-ucx2.md	Sun Nov 20 17:48:42 2022 +0100
     1.2 +++ b/docs/src/modules-ucx2.md	Sun Nov 20 21:08:36 2022 +0100
     1.3 @@ -75,20 +75,20 @@
     1.4      return result;
     1.5  }
     1.6  
     1.7 -/* ... */
     1.8 +// ... 
     1.9  
    1.10 -sstr_t* array = /* some standard array of strings */
    1.11 -size_t arrlen = /* the length of the array */
    1.12 +sstr_t* array = // some standard array of strings 
    1.13 +size_t arrlen = // the length of the array 
    1.14  
    1.15  UcxArray* result = create_unique(array,arrlen);
    1.16  
    1.17 -/* Iterate over the array and print the elements */
    1.18 +// Iterate over the array and print the elements 
    1.19  sstr_t* unique = result->data;
    1.20  for (size_t i = 0 ; i < result->size ; i++) {
    1.21      printf("%" PRIsstr "\n", SFMT(unique[i]));
    1.22  }
    1.23  
    1.24 -/* Free the array. */
    1.25 +// Free the array. 
    1.26  ucx_array_free(result);
    1.27  ```
    1.28  ### Preventing out of bounds writes
    1.29 @@ -128,23 +128,18 @@
    1.30  is to find all items within a time window `[t_start, t_end]`.
    1.31  With AVL Trees this is easy:
    1.32  ```C
    1.33 -/* ---------------------
    1.34 - * Somewhere in a header
    1.35 - */
    1.36 +// Somewhere in a header
    1.37  typedef struct {
    1.38      time_t ts;
    1.39 -    /* other important data */
    1.40 +    // other important data 
    1.41  } MyObject;
    1.42  
    1.43 -/* -----------
    1.44 - * Source code
    1.45 - */
    1.46 +// Source code
    1.47 +UcxAVLTree* tree = ucx_avl_new(ucx_cmp_longint);
    1.48 +// ... populate tree with objects, use '& MyObject.ts' as key ... 
    1.49  
    1.50 -UcxAVLTree* tree = ucx_avl_new(ucx_cmp_longint);
    1.51 -/* ... populate tree with objects, use '& MyObject.ts' as key ... */
    1.52  
    1.53 -
    1.54 -/* Now find every item, with 30 <= ts <= 70 */
    1.55 +// Now find every item, with 30 <= ts <= 70 
    1.56  time_t ts_start = 30;
    1.57  time_t ts_end = 70;
    1.58  
    1.59 @@ -212,18 +207,18 @@
    1.60  
    1.61      UcxBuffer* linebuf =
    1.62          ucx_buffer_new(
    1.63 -            NULL,       /* the buffer should manage the memory area for us */
    1.64 -            2*chunksize,  /* initial size should be twice the chunk size */
    1.65 -            UCX_BUFFER_AUTOEXTEND); /* the buffer will grow when necessary */
    1.66 +            NULL,       // the buffer should manage the memory area for us 
    1.67 +            2*chunksize,  // initial size should be twice the chunk size 
    1.68 +            UCX_BUFFER_AUTOEXTEND); // the buffer will grow when necessary 
    1.69  
    1.70      size_t lineno = 1;
    1.71      do {
    1.72 -        /* read line chunk */
    1.73 +        // read line chunk 
    1.74          size_t read = ucx_stream_ncopy(
    1.75                  input, linebuf, fread, ucx_buffer_write, chunksize);
    1.76          if (read == 0) break;
    1.77          
    1.78 -        /* handle line endings */
    1.79 +        // handle line endings 
    1.80          do {
    1.81              sstr_t bufstr = ucx_buffer_to_sstr(linebuf);
    1.82              sstr_t nl = sstrchr(bufstr, '\n');
    1.83 @@ -234,13 +229,13 @@
    1.84  
    1.85              printf("%zu: %" PRIsstr "\n", lineno++, SFMT(linestr));
    1.86  
    1.87 -            /* shift the buffer to the next line */
    1.88 +            // shift the buffer to the next line 
    1.89              ucx_buffer_shift_left(linebuf, linelen+1);
    1.90          } while(1);
    1.91  
    1.92      } while(1);
    1.93  
    1.94 -    /* print the 'noeol' line, if any */
    1.95 +    // print the 'noeol' line, if any 
    1.96      sstr_t lastline = ucx_buffer_to_sstr(linebuf);
    1.97      if (lastline.length > 0) {
    1.98          printf("%zu: %" PRIsstr, lineno, SFMT(lastline));
    1.99 @@ -286,27 +281,27 @@
   1.100      return list;
   1.101  }
   1.102  
   1.103 -/* we will need this function to clean up the list contents later */
   1.104 +// we will need this function to clean up the list contents later 
   1.105  void free_sstr(void* ptr) {
   1.106      sstr_t* s = ptr;
   1.107      free(s->ptr);
   1.108      free(s);
   1.109  }
   1.110  
   1.111 -/* ... */
   1.112 +// ... 
   1.113  
   1.114 -sstr_t* array = /* some array of strings */
   1.115 -size_t arrlen = /* the length of the array */
   1.116 +sstr_t* array = // some array of strings 
   1.117 +size_t arrlen = // the length of the array 
   1.118  
   1.119  UcxList* list = remove_duplicates(array,arrlen);
   1.120  
   1.121 -/* Iterate over the list and print the elements */
   1.122 +// Iterate over the list and print the elements 
   1.123  UCX_FOREACH(elem, list) {
   1.124      sstr_t s = *((sstr_t*)elem->data);
   1.125      printf("%" PRIsstr "\n", SFMT(s));
   1.126  }
   1.127  
   1.128 -/* Use our free function to free the duplicated strings. */
   1.129 +// Use our free function to free the duplicated strings. 
   1.130  ucx_list_free_content(list, free_sstr);
   1.131  ucx_list_free(list);
   1.132  ```
   1.133 @@ -392,7 +387,7 @@
   1.134              ucx_map_cstr_put(options, option, arg);
   1.135              option = NULL;
   1.136          } else {
   1.137 -            /* ... handle argument that is not an option ... */
   1.138 +            // ... handle argument that is not an option ... 
   1.139          }
   1.140      }
   1.141      if(option) {
   1.142 @@ -463,20 +458,20 @@
   1.143          perror("Cannot open file");
   1.144          return 1;
   1.145      }
   1.146 -    /* close the file automatically at pool destruction*/
   1.147 +    // close the file automatically at pool destruction
   1.148      ucx_mempool_reg_destr(pool, f, (ucx_destructor) fclose);
   1.149  
   1.150 -    /* create a buffer and register it at the memory pool for destruction */
   1.151 +    // create a buffer and register it at the memory pool for destruction 
   1.152      UcxBuffer* content = ucx_buffer_new(NULL, 256, UCX_BUFFER_AUTOEXTEND);
   1.153      ucx_mempool_reg_destr(pool, content, (ucx_destructor) ucx_buffer_free);
   1.154  
   1.155 -    /* read the file and split it by lines first */
   1.156 +    // read the file and split it by lines first 
   1.157      ucx_stream_copy(f, content, fread, ucx_buffer_write);
   1.158      sstr_t contentstr = ucx_buffer_to_sstr(content);
   1.159      ssize_t lc = 0;
   1.160      sstr_t* lines = sstrsplit_a(pool->allocator, contentstr, S("\n"), &lc);
   1.161  
   1.162 -    /* skip the header and parse the remaining data */
   1.163 +    // skip the header and parse the remaining data 
   1.164      UcxList* datalist = NULL;
   1.165      for (size_t i = 1 ; i < lc ; i++) {
   1.166          if (lines[i].length == 0) continue;
   1.167 @@ -494,7 +489,7 @@
   1.168          datalist = ucx_list_append_a(pool->allocator, datalist, data);
   1.169      }
   1.170  
   1.171 -    /* control output */
   1.172 +    // control output 
   1.173      UCX_FOREACH(elem, datalist) {
   1.174          CSVData* data = elem->data;
   1.175          printf("Column A: %" PRIsstr " | "
   1.176 @@ -504,7 +499,7 @@
   1.177          );
   1.178      }
   1.179  
   1.180 -    /* cleanup everything, no manual free() needed */
   1.181 +    // cleanup everything, no manual free() needed 
   1.182      ucx_mempool_destroy(pool);
   1.183  
   1.184      return 0;
   1.185 @@ -519,10 +514,10 @@
   1.186  ```C
   1.187      MyObject* obj = ucx_mempool_malloc(pool, sizeof(MyObject));
   1.188  
   1.189 -    /* some special initialization with own resource management */
   1.190 +    // some special initialization with own resource management 
   1.191      my_object_init(obj);
   1.192  
   1.193 -    /* register destructor function */
   1.194 +    // register destructor function 
   1.195      ucx_mempool_set_destr(obj, (ucx_destructor) my_object_destroy);
   1.196  ```
   1.197  Be aware, that your destructor function should not free any memory, that is
   1.198 @@ -544,30 +539,30 @@
   1.199  ### Example: Loading properties from a file
   1.200  
   1.201  ```C
   1.202 -/* Open the file as usual */
   1.203 +// Open the file as usual 
   1.204  FILE* file = fopen("myprops.properties", "r");
   1.205  if (!file) {
   1.206      // error handling
   1.207      return 1;
   1.208  }
   1.209  
   1.210 -/* Load the properties from the file */
   1.211 +// Load the properties from the file 
   1.212  UcxMap* myprops = ucx_map_new(16);
   1.213  if (ucx_properties_load(myprops, file)) {
   1.214 -    /* ... error handling ... */
   1.215 +    // ... error handling ... 
   1.216      fclose(file);
   1.217      ucx_map_free(myprops);
   1.218      return 1;
   1.219  }
   1.220  
   1.221 -/* Print out the key/value pairs */
   1.222 +// Print out the key/value pairs 
   1.223  char* propval;
   1.224  UcxMapIterator propiter = ucx_map_iterator(myprops);
   1.225  UCX_MAP_FOREACH(key, propval, propiter) {
   1.226      printf("%s = %s\n", (char*)key.data, propval);
   1.227  }
   1.228  
   1.229 -/* Don't forget to free the values before freeing the map */
   1.230 +// Don't forget to free the values before freeing the map 
   1.231  ucx_map_free_content(myprops, NULL);
   1.232  ucx_map_free(myprops);
   1.233  fclose(file);
   1.234 @@ -599,30 +594,30 @@
   1.235      const char* str = "Hello!";
   1.236      size_t strn = 7;
   1.237  
   1.238 -    /* push the integer */
   1.239 +    // push the integer 
   1.240      ucx_stack_push(&stack, sizeof(int), &i);
   1.241  
   1.242 -    /* push the float and rember the address */
   1.243 +    // push the float and rember the address 
   1.244      float* remember = ucx_stack_push(&stack, sizeof(float), &f);
   1.245  
   1.246 -    /* push the string with zero terminator */
   1.247 +    // push the string with zero terminator 
   1.248      ucx_stack_push(&stack, strn, str);
   1.249  
   1.250 -    /* if we forget, how big an element was, we can ask the stack */
   1.251 +    // if we forget, how big an element was, we can ask the stack 
   1.252      printf("Length of string: %zu\n", ucx_stack_topsize(&stack)-1);
   1.253  
   1.254 -    /* retrieve the string as sstr_t, without zero terminator! */
   1.255 +    // retrieve the string as sstr_t, without zero terminator! 
   1.256      sstr_t s;
   1.257      s.length = ucx_stack_topsize(&stack)-1;
   1.258      s.ptr = malloc(s.length);
   1.259      ucx_stack_popn(&stack, s.ptr, s.length);
   1.260      printf("%" PRIsstr "\n", SFMT(s));
   1.261  
   1.262 -    /* print the float directly from the stack and free it */
   1.263 +    // print the float directly from the stack and free it 
   1.264      printf("Float: %f\n", *remember);
   1.265      ucx_stack_free(&stack, remember);
   1.266  
   1.267 -    /* the last element is the integer */
   1.268 +    // the last element is the integer 
   1.269      int j;
   1.270      ucx_stack_pop(&stack, &j);
   1.271      printf("Integer: %d\n", j);
   1.272 @@ -647,21 +642,21 @@
   1.273  There are several ways to create an `sstr_t`:
   1.274  
   1.275  ```C
   1.276 -/* (1) sstr() uses strlen() internally, hence cstr MUST be zero-terminated */
   1.277 +// (1) sstr() uses strlen() internally, hence cstr MUST be zero-terminated 
   1.278  sstr_t a = sstr(cstr);
   1.279  
   1.280 -/* (2) cstr does not need to be zero-terminated, if length is specified */
   1.281 +// (2) cstr does not need to be zero-terminated, if length is specified 
   1.282  sstr_t b = sstrn(cstr, len);
   1.283  
   1.284 -/* (3) S() macro creates sstr_t from a string using sizeof() and using sstrn().
   1.285 -       This version is especially useful for function arguments */
   1.286 +// (3) S() macro creates sstr_t from a string using sizeof() and using sstrn().
   1.287 +//     This version is especially useful for function arguments
   1.288  sstr_t c = S("hello");
   1.289  
   1.290 -/* (4) SC() macro works like S(), but makes the string immutable using scstr_t.
   1.291 -       (available since UCX 2.0) */
   1.292 +// (4) SC() macro works like S(), but makes the string immutable using scstr_t.
   1.293 +//     (available since UCX 2.0)
   1.294  scstr_t d = SC("hello");
   1.295  
   1.296 -/* (5) ST() macro creates sstr_t struct literal using sizeof() */
   1.297 +// (5) ST() macro creates sstr_t struct literal using sizeof() 
   1.298  sstr_t e = ST("hello");
   1.299  ```
   1.300  
   1.301 @@ -716,12 +711,12 @@
   1.302  sstr_t test = ST("here::are::some::strings");
   1.303  sstr_t delim = ST("::");
   1.304  
   1.305 -ssize_t count = 0; /* no limit */
   1.306 +ssize_t count = 0; // no limit 
   1.307  UcxMempool* pool = ucx_mempool_new_default();
   1.308  
   1.309  sstr_t* result = sstrsplit_a(pool->allocator, test, delim, &count);
   1.310  for (ssize_t i = 0 ; i < count ; i++) {
   1.311 -    /* don't forget to specify the length via the %*s format specifier */
   1.312 +    // don't forget to specify the length via the %*s format specifier 
   1.313      printf("%*s\n", result[i].length, result[i].ptr);
   1.314  }
   1.315  
   1.316 @@ -762,32 +757,30 @@
   1.317  You should declare test cases and subroutines in a header file per test unit
   1.318  and implement them as you would implement normal functions.
   1.319  ```C
   1.320 -    /* myunit.h */
   1.321 +    // myunit.h 
   1.322      UCX_TEST(function_name);
   1.323 -    UCX_TEST_SUBROUTINE(subroutine_name, paramlist); /* optional */
   1.324 +    UCX_TEST_SUBROUTINE(subroutine_name, paramlist); // optional 
   1.325  
   1.326  
   1.327 -    /* myunit.c */
   1.328 +    // myunit.c 
   1.329      UCX_TEST_SUBROUTINE(subroutine_name, paramlist) {
   1.330 -        /* ... reusable tests with UCX_TEST_ASSERT() ... */
   1.331 +        // ... reusable tests with UCX_TEST_ASSERT() ... 
   1.332      }
   1.333  
   1.334      UCX_TEST(function_name) {
   1.335 -        /* ... resource allocation and other test preparation ... */
   1.336 +        // ... resource allocation and other test preparation ... 
   1.337  
   1.338 -        /* mandatory marker for the start of the tests */
   1.339 +        // mandatory marker for the start of the tests 
   1.340          UCX_TEST_BEGIN
   1.341  
   1.342 -        /*  ... verifications with UCX_TEST_ASSERT() ...
   1.343 -         * (and/or calls with UCX_TEST_CALL_SUBROUTINE())
   1.344 -         */
   1.345 +        //  ... verifications with UCX_TEST_ASSERT() ...
   1.346 +        // (and/or calls with UCX_TEST_CALL_SUBROUTINE())
   1.347  
   1.348 -        /* mandatory marker for the end of the tests */
   1.349 +        // mandatory marker for the end of the tests 
   1.350          UCX_TEST_END
   1.351  
   1.352 -        /* ... resource cleanup ...
   1.353 -         * (all code after UCX_TEST_END is always executed)
   1.354 -         */
   1.355 +        // ... resource cleanup ...
   1.356 +        // (all code after UCX_TEST_END is always executed)
   1.357      }
   1.358  ```
   1.359  If you want to use the `UCX_TEST_ASSERT()` macro in a function, you are
   1.360 @@ -800,8 +793,8 @@
   1.361      UcxTestSuite* suite = ucx_test_suite_new();
   1.362      ucx_test_register(suite, testMyTestCase01);
   1.363      ucx_test_register(suite, testMyTestCase02);
   1.364 -    /* ... */
   1.365 -    ucx_test_run(suite, stdout); /* stdout, or any other FILE stream */
   1.366 +    // ... 
   1.367 +    ucx_test_run(suite, stdout); // stdout, or any other FILE stream 
   1.368  ```
   1.369  
   1.370  ## Utilities
   1.371 @@ -831,7 +824,7 @@
   1.372          return 1;
   1.373      }
   1.374  
   1.375 -    FILE *srcf = fopen(argv[1], "r");   /* insert error handling on your own */
   1.376 +    FILE *srcf = fopen(argv[1], "r");   // insert error handling on your own 
   1.377      FILE *destf = fopen(argv[2], "w");
   1.378      
   1.379      size_t n =  ucx_stream_copy(srcf, destf, fread, fwrite);
   1.380 @@ -866,7 +859,7 @@
   1.381                          i, prime(i) ? "prime" : "not prime");
   1.382  }
   1.383  
   1.384 -/* print the result to stdout */
   1.385 +// print the result to stdout 
   1.386  printf("%s", (char*)strbuffer->space);
   1.387  
   1.388  ucx_buffer_free(strbuffer);

     2.1 --- a/src/allocator.c	Sun Nov 20 17:48:42 2022 +0100
     2.2 +++ b/src/allocator.c	Sun Nov 20 21:08:36 2022 +0100
     2.3 @@ -77,7 +77,7 @@
     2.4  };
     2.5  CxAllocator *cxDefaultAllocator = &cx_default_allocator;
     2.6  
     2.7 -/* IMPLEMENTATION OF HIGH LEVEL API */
     2.8 +// IMPLEMENTATION OF HIGH LEVEL API
     2.9  
    2.10  void *cxMalloc(
    2.11          CxAllocator const *allocator,

     3.1 --- a/src/array_list.c	Sun Nov 20 17:48:42 2022 +0100
     3.2 +++ b/src/array_list.c	Sun Nov 20 21:08:36 2022 +0100
     3.3 @@ -31,7 +31,7 @@
     3.4  #include <string.h>
     3.5  #include <stdint.h>
     3.6  
     3.7 -/* LOW LEVEL ARRAY LIST FUNCTIONS */
     3.8 +// LOW LEVEL ARRAY LIST FUNCTIONS
     3.9  
    3.10  enum cx_array_copy_result cx_array_copy(
    3.11          void **target,
    3.12 @@ -43,37 +43,37 @@
    3.13          size_t elem_count,
    3.14          struct cx_array_reallocator_s *reallocator
    3.15  ) {
    3.16 -    /* assert pointers */
    3.17 +    // assert pointers
    3.18      assert(target != NULL);
    3.19      assert(size != NULL);
    3.20      assert(src != NULL);
    3.21  
    3.22 -    /* determine capacity */
    3.23 +    // determine capacity
    3.24      size_t cap = capacity == NULL ? *size : *capacity;
    3.25  
    3.26 -    /* check if resize is required */
    3.27 +    // check if resize is required
    3.28      size_t minsize = index + elem_count;
    3.29      size_t newsize = *size < minsize ? minsize : *size;
    3.30      bool needrealloc = newsize > cap;
    3.31  
    3.32 -    /* reallocate if possible */
    3.33 +    // reallocate if possible
    3.34      if (needrealloc) {
    3.35 -        /* a reallocator and a capacity variable must be available */
    3.36 +        // a reallocator and a capacity variable must be available
    3.37          if (reallocator == NULL || capacity == NULL) {
    3.38              return CX_ARRAY_COPY_REALLOC_NOT_SUPPORTED;
    3.39          }
    3.40  
    3.41 -        /* check, if we need to repair the src pointer */
    3.42 +        // check, if we need to repair the src pointer
    3.43          uintptr_t targetaddr = (uintptr_t) *target;
    3.44          uintptr_t srcaddr = (uintptr_t) src;
    3.45          bool repairsrc = targetaddr <= srcaddr
    3.46                           && srcaddr < targetaddr + cap * elem_size;
    3.47  
    3.48 -        /* calculate new capacity (next number divisible by 16) */
    3.49 +        // calculate new capacity (next number divisible by 16)
    3.50          cap = newsize - (newsize % 16) + 16;
    3.51          assert(cap > newsize);
    3.52  
    3.53 -        /* perform reallocation */
    3.54 +        // perform reallocation
    3.55          void *newmem = reallocator->realloc(
    3.56                  *target, cap, elem_size, reallocator
    3.57          );
    3.58 @@ -81,25 +81,25 @@
    3.59              return CX_ARRAY_COPY_REALLOC_FAILED;
    3.60          }
    3.61  
    3.62 -        /* repair src pointer, if necessary */
    3.63 +        // repair src pointer, if necessary
    3.64          if (repairsrc) {
    3.65              src = ((char *) newmem) + (srcaddr - targetaddr);
    3.66          }
    3.67  
    3.68 -        /* store new pointer and capacity */
    3.69 +        // store new pointer and capacity
    3.70          *target = newmem;
    3.71          *capacity = cap;
    3.72      }
    3.73  
    3.74 -    /* determine target pointer */
    3.75 +    // determine target pointer
    3.76      char *start = *target;
    3.77      start += index * elem_size;
    3.78  
    3.79 -    /* copy elements and set new size */
    3.80 +    // copy elements and set new size
    3.81      memmove(start, src, elem_count * elem_size);
    3.82      *size = newsize;
    3.83  
    3.84 -    /* return successfully */
    3.85 +    // return successfully
    3.86      return CX_ARRAY_COPY_SUCCESS;
    3.87  }
    3.88  
    3.89 @@ -111,38 +111,38 @@
    3.90          size_t idx1,
    3.91          size_t idx2
    3.92  ) {
    3.93 -    /* short circuit */
    3.94 +    // short circuit
    3.95      if (idx1 == idx2) return;
    3.96  
    3.97      char sbo_mem[CX_ARRAY_SWAP_SBO_SIZE];
    3.98      void *tmp;
    3.99  
   3.100 -    /* decide if we can use the local buffer */
   3.101 +    // decide if we can use the local buffer
   3.102      if (elem_size > CX_ARRAY_SWAP_SBO_SIZE) {
   3.103          tmp = malloc(elem_size);
   3.104 -        /* we don't want to enforce error handling */
   3.105 +        // we don't want to enforce error handling
   3.106          if (tmp == NULL) abort();
   3.107      } else {
   3.108          tmp = sbo_mem;
   3.109      }
   3.110  
   3.111 -    /* calculate memory locations */
   3.112 +    // calculate memory locations
   3.113      char *left = arr, *right = arr;
   3.114      left += idx1 * elem_size;
   3.115      right += idx2 * elem_size;
   3.116  
   3.117 -    /* three-way swap */
   3.118 +    // three-way swap
   3.119      memcpy(tmp, left, elem_size);
   3.120      memcpy(left, right, elem_size);
   3.121      memcpy(right, tmp, elem_size);
   3.122  
   3.123 -    /* free dynamic memory, if it was needed */
   3.124 +    // free dynamic memory, if it was needed
   3.125      if (tmp != sbo_mem) {
   3.126          free(tmp);
   3.127      }
   3.128  }
   3.129  
   3.130 -/* HIGH LEVEL ARRAY LIST FUNCTIONS */
   3.131 +// HIGH LEVEL ARRAY LIST FUNCTIONS
   3.132  
   3.133  typedef struct {
   3.134      struct cx_list_s base;
   3.135 @@ -156,10 +156,10 @@
   3.136          size_t elem_size,
   3.137          struct cx_array_reallocator_s *alloc
   3.138  ) {
   3.139 -    /* retrieve the pointer to the list allocator */
   3.140 +    // retrieve the pointer to the list allocator
   3.141      CxAllocator const *al = alloc->ptr1;
   3.142  
   3.143 -    /* use the list allocator to reallocate the memory */
   3.144 +    // use the list allocator to reallocate the memory
   3.145      return cxRealloc(al, array, capacity * elem_size);
   3.146  }
   3.147  
   3.148 @@ -197,7 +197,7 @@
   3.149      } else {
   3.150          cx_array_list *arl = (cx_array_list *) list;
   3.151  
   3.152 -        /* move elements starting at index to the right */
   3.153 +        // move elements starting at index to the right
   3.154          if (cx_array_copy(
   3.155                  &arl->data,
   3.156                  &list->size,
   3.157 @@ -211,7 +211,7 @@
   3.158              return 1;
   3.159          }
   3.160  
   3.161 -        /* place the element */
   3.162 +        // place the element
   3.163          memcpy(((char *) arl->data) + index * list->itemsize,
   3.164                 elem, list->itemsize);
   3.165  
   3.166 @@ -247,18 +247,18 @@
   3.167          struct cx_list_s *list,
   3.168          size_t index
   3.169  ) {
   3.170 -    /* out-of-bounds check */
   3.171 +    // out-of-bounds check
   3.172      if (index >= list->size) {
   3.173          return 1;
   3.174      }
   3.175  
   3.176 -    /* short-circuit removal of last element */
   3.177 +    // short-circuit removal of last element
   3.178      if (index == list->size - 1) {
   3.179          list->size--;
   3.180          return 0;
   3.181      }
   3.182  
   3.183 -    /* just move the elements starting at index to the left */
   3.184 +    // just move the elements starting at index to the left
   3.185      cx_array_list *arl = (cx_array_list *) list;
   3.186      int result = cx_array_copy(
   3.187              &arl->data,
   3.188 @@ -271,7 +271,7 @@
   3.189              &arl->reallocator
   3.190      );
   3.191      if (result == 0) {
   3.192 -        /* decrease the size */
   3.193 +        // decrease the size
   3.194          list->size--;
   3.195      }
   3.196      return result;
   3.197 @@ -417,7 +417,7 @@
   3.198      list->base.itemsize = item_size;
   3.199      list->base.capacity = initial_capacity;
   3.200  
   3.201 -    /* configure the reallocator */
   3.202 +    // configure the reallocator
   3.203      list->reallocator.realloc = cx_arl_realloc;
   3.204      list->reallocator.ptr1 = (void *) allocator;
   3.205  

     4.1 --- a/src/cx/allocator.h	Sun Nov 20 17:48:42 2022 +0100
     4.2 +++ b/src/cx/allocator.h	Sun Nov 20 21:08:36 2022 +0100
     4.3 @@ -254,7 +254,7 @@
     4.4  __attribute__((__nonnull__));
     4.5  
     4.6  #ifdef __cplusplus
     4.7 -} /* extern "C" */
     4.8 +} // extern "C"
     4.9  #endif
    4.10  
    4.11 -#endif /* UCX_ALLOCATOR_H */
    4.12 +#endif // UCX_ALLOCATOR_H

     5.1 --- a/src/cx/array_list.h	Sun Nov 20 17:48:42 2022 +0100
     5.2 +++ b/src/cx/array_list.h	Sun Nov 20 21:08:36 2022 +0100
     5.3 @@ -166,7 +166,7 @@
     5.4  
     5.5  
     5.6  #ifdef __cplusplus
     5.7 -} /* extern "C" */
     5.8 +} // extern "C"
     5.9  #endif
    5.10  
    5.11 -#endif /* UCX_ARRAY_LIST_H */
    5.12 +#endif // UCX_ARRAY_LIST_H

     6.1 --- a/src/cx/buffer.h	Sun Nov 20 17:48:42 2022 +0100
     6.2 +++ b/src/cx/buffer.h	Sun Nov 20 21:08:36 2022 +0100
     6.3 @@ -411,4 +411,4 @@
     6.4  }
     6.5  #endif
     6.6  
     6.7 -#endif /* UCX_BUFFER_H */
     6.8 +#endif // UCX_BUFFER_H

     7.1 --- a/src/cx/common.h	Sun Nov 20 17:48:42 2022 +0100
     7.2 +++ b/src/cx/common.h	Sun Nov 20 21:08:36 2022 +0100
     7.3 @@ -110,12 +110,12 @@
     7.4  #else
     7.5  #define __WORDSIZE 32
     7.6  #endif
     7.7 -#endif /* __WORDSIZE */
     7.8 -#else /* !_WIN32 */
     7.9 +#endif // __WORDSIZE
    7.10 +#else // !_WIN32
    7.11  
    7.12  #include <sys/types.h>
    7.13  
    7.14 -#endif /* _WIN32 */
    7.15 +#endif // _WIN32
    7.16  
    7.17  #ifndef __GNUC__
    7.18  /**
    7.19 @@ -124,4 +124,4 @@
    7.20  #define __attribute__(x)
    7.21  #endif
    7.22  
    7.23 -#endif /* UCX_COMMON_H */
    7.24 +#endif // UCX_COMMON_H

     8.1 --- a/src/cx/hash_key.h	Sun Nov 20 17:48:42 2022 +0100
     8.2 +++ b/src/cx/hash_key.h	Sun Nov 20 21:08:36 2022 +0100
     8.3 @@ -125,4 +125,4 @@
     8.4  } // extern "C"
     8.5  #endif
     8.6  
     8.7 -#endif /* UCX_HASH_KEY_H */
     8.8 +#endif // UCX_HASH_KEY_H

     9.1 --- a/src/cx/iterator.h	Sun Nov 20 17:48:42 2022 +0100
     9.2 +++ b/src/cx/iterator.h	Sun Nov 20 21:08:36 2022 +0100
     9.3 @@ -164,4 +164,4 @@
     9.4  #define cx_foreach(type, elem, iter) \
     9.5  for (type elem; cxIteratorValid(&iter) && (elem = (type)cxIteratorCurrent(&iter)) != NULL ; cxIteratorNext(&iter)) // NOLINT(bugprone-macro-parentheses)
     9.6  
     9.7 -#endif /* UCX_ITERATOR_H */
     9.8 +#endif // UCX_ITERATOR_H

    10.1 --- a/src/cx/linked_list.h	Sun Nov 20 17:48:42 2022 +0100
    10.2 +++ b/src/cx/linked_list.h	Sun Nov 20 21:08:36 2022 +0100
    10.3 @@ -444,7 +444,7 @@
    10.4  ) __attribute__((__nonnull__(1)));
    10.5  
    10.6  #ifdef __cplusplus
    10.7 -} /* extern "C" */
    10.8 +} // extern "C"
    10.9  #endif
   10.10  
   10.11 -#endif /* UCX_LINKED_LIST_H */
   10.12 +#endif // UCX_LINKED_LIST_H

    11.1 --- a/src/cx/list.h	Sun Nov 20 17:48:42 2022 +0100
    11.2 +++ b/src/cx/list.h	Sun Nov 20 21:08:36 2022 +0100
    11.3 @@ -419,7 +419,7 @@
    11.4  void cxListDestroy(CxList *list);
    11.5  
    11.6  #ifdef __cplusplus
    11.7 -} /* extern "C" */
    11.8 +} // extern "C"
    11.9  #endif
   11.10  
   11.11 -#endif /* UCX_LIST_H */
   11.12 +#endif // UCX_LIST_H

    12.1 --- a/src/cx/tree.h	Sun Nov 20 17:48:42 2022 +0100
    12.2 +++ b/src/cx/tree.h	Sun Nov 20 21:08:36 2022 +0100
    12.3 @@ -129,8 +129,8 @@
    12.4  
    12.5  
    12.6  #ifdef __cplusplus
    12.7 -} /* extern "C" */
    12.8 +} // extern "C"
    12.9  #endif
   12.10  
   12.11 -#endif /* UCX_TREE_H */
   12.12 +#endif // UCX_TREE_H
   12.13  

    13.1 --- a/src/cx/utils.h	Sun Nov 20 17:48:42 2022 +0100
    13.2 +++ b/src/cx/utils.h	Sun Nov 20 21:08:36 2022 +0100
    13.3 @@ -51,9 +51,7 @@
    13.4   */
    13.5  #define cx_for_n(varname, n) for (size_t varname = 0 ; (varname) < (n) ; (varname)++)
    13.6  
    13.7 -/* ----------------------
    13.8 - * cx_szmul() definition.
    13.9 - * ---------------------- */
   13.10 +// cx_szmul() definition
   13.11  
   13.12  #if (__GNUC__ >= 5 || defined(__clang__)) && !defined(CX_NO_SZMUL_BUILTIN)
   13.13  #define CX_SZMUL_BUILTIN
   13.14 @@ -72,7 +70,7 @@
   13.15   * otherwise
   13.16   */
   13.17  #define cx_szmul(a, b, result) __builtin_umul_overflow(a, b, result)
   13.18 -#else /* __WORDSIZE != 32 */
   13.19 +#else // __WORDSIZE != 32
   13.20  /**
   13.21   * Alias for \c __builtin_umull_overflow.
   13.22   *
   13.23 @@ -86,9 +84,9 @@
   13.24   * otherwise
   13.25   */
   13.26  #define cx_szmul(a, b, result) __builtin_umull_overflow(a, b, result)
   13.27 -#endif /* __WORDSIZE */
   13.28 +#endif // __WORDSIZE
   13.29  
   13.30 -#else /* no GNUC or clang bultin */
   13.31 +#else // no GNUC or clang bultin
   13.32  
   13.33  /**
   13.34   * Performs a multiplication of size_t values and checks for overflow.
   13.35 @@ -122,4 +120,4 @@
   13.36  }
   13.37  #endif
   13.38  
   13.39 -#endif /* UCX_UTILS_H */
   13.40 +#endif // UCX_UTILS_H

    14.1 --- a/src/hash_key.c	Sun Nov 20 17:48:42 2022 +0100
    14.2 +++ b/src/hash_key.c	Sun Nov 20 21:08:36 2022 +0100
    14.3 @@ -32,7 +32,7 @@
    14.4  void cx_hash_murmur(CxHashKey *key) {
    14.5      unsigned char const *data = key->data.cbytes;
    14.6      if (data == NULL) {
    14.7 -        /* extension: special value for NULL */
    14.8 +        // extension: special value for NULL
    14.9          key->hash = 1574210520u;
   14.10          return;
   14.11      }
   14.12 @@ -70,8 +70,8 @@
   14.13              h ^= (data[i + 0] & 0xFF);
   14.14              h *= m;
   14.15                      __attribute__((__fallthrough__));
   14.16 -        default:
   14.17 -            /* do nothing */;
   14.18 +        default: // do nothing
   14.19 +        ;
   14.20      }
   14.21  
   14.22      h ^= h >> 13;

    15.1 --- a/src/linked_list.c	Sun Nov 20 17:48:42 2022 +0100
    15.2 +++ b/src/linked_list.c	Sun Nov 20 21:08:36 2022 +0100
    15.3 @@ -32,7 +32,7 @@
    15.4  #include <string.h>
    15.5  #include <assert.h>
    15.6  
    15.7 -/* LOW LEVEL LINKED LIST FUNCTIONS */
    15.8 +// LOW LEVEL LINKED LIST FUNCTIONS
    15.9  
   15.10  #define CX_LL_PTR(cur, off) (*(void**)(((char*)(cur))+(off)))
   15.11  #define ll_prev(node) CX_LL_PTR(node, loc_prev)
   15.12 @@ -337,7 +337,7 @@
   15.13      return ret;
   15.14  }
   15.15  
   15.16 -void cx_linked_list_sort( /* NOLINT(misc-no-recursion) - purposely recursive function */
   15.17 +void cx_linked_list_sort( // NOLINT(misc-no-recursion) - purposely recursive function
   15.18          void **begin,
   15.19          void **end,
   15.20          ptrdiff_t loc_prev,
   15.21 @@ -455,7 +455,7 @@
   15.22      *begin = prev;
   15.23  }
   15.24  
   15.25 -/* HIGH LEVEL LINKED LIST IMPLEMENTATION */
   15.26 +// HIGH LEVEL LINKED LIST IMPLEMENTATION
   15.27  
   15.28  typedef struct cx_linked_list_node cx_linked_list_node;
   15.29  struct cx_linked_list_node {

    16.1 --- a/src/list.c	Sun Nov 20 17:48:42 2022 +0100
    16.2 +++ b/src/list.c	Sun Nov 20 21:08:36 2022 +0100
    16.3 @@ -57,10 +57,10 @@
    16.4          CxList const *other
    16.5  ) {
    16.6      if (list->cl->compare == other->cl->compare) {
    16.7 -        /* same compare function, lists are compatible */
    16.8 +        // same compare function, lists are compatible
    16.9          return list->cl->compare(list, other);
   16.10      } else {
   16.11 -        /* different compare functions, use iterator */
   16.12 +        // different compare functions, use iterator
   16.13          if (list->size == other->size) {
   16.14              // TODO: we would need a const iterator
   16.15              CxIterator left = cxListBegin(list);

    17.1 --- a/src/string.c	Sun Nov 20 17:48:42 2022 +0100
    17.2 +++ b/src/string.c	Sun Nov 20 21:08:36 2022 +0100
    17.3 @@ -35,9 +35,9 @@
    17.4  
    17.5  #ifndef _WIN32
    17.6  
    17.7 -#include <strings.h> /* for strncasecmp() */
    17.8 +#include <strings.h> // for strncasecmp()
    17.9  
   17.10 -#endif /* _WIN32 */
   17.11 +#endif // _WIN32
   17.12  
   17.13  cxmutstr cx_mutstr(char *cstring) {
   17.14      return (cxmutstr) {cstring, strlen(cstring)};
   17.15 @@ -236,7 +236,7 @@
   17.16          return haystack;
   17.17      }
   17.18  
   17.19 -    /* optimize for single-char needles */
   17.20 +    // optimize for single-char needles
   17.21      if (needle.length == 1) {
   17.22          return cx_strchr(haystack, *needle.ptr);
   17.23      }
   17.24 @@ -249,19 +249,19 @@
   17.25       * and we want to avoid that.
   17.26       */
   17.27  
   17.28 -    /* local prefix table */
   17.29 +    // local prefix table
   17.30      size_t s_prefix_table[STRSTR_SBO_BUFLEN];
   17.31  
   17.32 -    /* check needle length and use appropriate prefix table */
   17.33 -    /* if the pattern exceeds static prefix table, allocate on the heap */
   17.34 +    // check needle length and use appropriate prefix table
   17.35 +    // if the pattern exceeds static prefix table, allocate on the heap
   17.36      bool useheap = needle.length >= STRSTR_SBO_BUFLEN;
   17.37      register size_t *ptable = useheap ? calloc(needle.length + 1,
   17.38                                                 sizeof(size_t)) : s_prefix_table;
   17.39  
   17.40 -    /* keep counter in registers */
   17.41 +    // keep counter in registers
   17.42      register size_t i, j;
   17.43  
   17.44 -    /* fill prefix table */
   17.45 +    // fill prefix table
   17.46      i = 0;
   17.47      j = 0;
   17.48      ptable[i] = j;
   17.49 @@ -274,7 +274,7 @@
   17.50          ptable[i] = j;
   17.51      }
   17.52  
   17.53 -    /* search */
   17.54 +    // search
   17.55      cxstring result = {NULL, 0};
   17.56      i = 0;
   17.57      j = 1;
   17.58 @@ -292,7 +292,7 @@
   17.59          }
   17.60      }
   17.61  
   17.62 -    /* if prefix table was allocated on the heap, free it */
   17.63 +    // if prefix table was allocated on the heap, free it
   17.64      if (ptable != s_prefix_table) {
   17.65          free(ptable);
   17.66      }
   17.67 @@ -314,23 +314,24 @@
   17.68          size_t limit,
   17.69          cxstring *output
   17.70  ) {
   17.71 -    /* special case: output limit is zero */
   17.72 +    // special case: output limit is zero
   17.73      if (limit == 0) return 0;
   17.74  
   17.75 -    /* special case: delimiter is empty */
   17.76 +    // special case: delimiter is empty
   17.77      if (delim.length == 0) {
   17.78          output[0] = string;
   17.79          return 1;
   17.80      }
   17.81  
   17.82 -    /* special cases: delimiter is at least as large as the string */
   17.83 +    // special cases: delimiter is at least as large as the string
   17.84      if (delim.length >= string.length) {
   17.85 -        /* exact match */
   17.86 +        // exact match
   17.87          if (cx_strcmp(string, delim) == 0) {
   17.88              output[0] = cx_strn(string.ptr, 0);
   17.89              output[1] = cx_strn(string.ptr + string.length, 0);
   17.90              return 2;
   17.91 -        } else /* no match possible */ {
   17.92 +        } else {
   17.93 +            // no match possible
   17.94              output[0] = string;
   17.95              return 1;
   17.96          }
   17.97 @@ -342,21 +343,21 @@
   17.98          ++n;
   17.99          cxstring match = cx_strstr(curpos, delim);
  17.100          if (match.length > 0) {
  17.101 -            /* is the limit reached? */
  17.102 +            // is the limit reached?
  17.103              if (n < limit) {
  17.104 -                /* copy the current string to the array */
  17.105 +                // copy the current string to the array
  17.106                  cxstring item = cx_strn(curpos.ptr, match.ptr - curpos.ptr);
  17.107                  output[n - 1] = item;
  17.108                  size_t processed = item.length + delim.length;
  17.109                  curpos.ptr += processed;
  17.110                  curpos.length -= processed;
  17.111              } else {
  17.112 -                /* limit reached, copy the _full_ remaining string */
  17.113 +                // limit reached, copy the _full_ remaining string
  17.114                  output[n - 1] = curpos;
  17.115                  break;
  17.116              }
  17.117          } else {
  17.118 -            /* no more matches, copy last string */
  17.119 +            // no more matches, copy last string
  17.120              output[n - 1] = curpos;
  17.121              break;
  17.122          }
  17.123 @@ -372,24 +373,24 @@
  17.124          size_t limit,
  17.125          cxstring **output
  17.126  ) {
  17.127 -    /* find out how many splits we're going to make and allocate memory */
  17.128 +    // find out how many splits we're going to make and allocate memory
  17.129      size_t n = 0;
  17.130      cxstring curpos = string;
  17.131      while (1) {
  17.132          ++n;
  17.133          cxstring match = cx_strstr(curpos, delim);
  17.134          if (match.length > 0) {
  17.135 -            /* is the limit reached? */
  17.136 +            // is the limit reached?
  17.137              if (n < limit) {
  17.138                  size_t processed = match.ptr - curpos.ptr + delim.length;
  17.139                  curpos.ptr += processed;
  17.140                  curpos.length -= processed;
  17.141              } else {
  17.142 -                /* limit reached */
  17.143 +                // limit reached
  17.144                  break;
  17.145              }
  17.146          } else {
  17.147 -            /* no more matches */
  17.148 +            // no more matches
  17.149              break;
  17.150          }
  17.151      }
  17.152 @@ -566,14 +567,14 @@
  17.153      if (pattern.length == 0 || pattern.length > str.length || replmax == 0)
  17.154          return cx_strdup_a(allocator, str);
  17.155  
  17.156 -    /* Compute expected buffer length */
  17.157 +    // Compute expected buffer length
  17.158      size_t ibufmax = str.length / pattern.length;
  17.159      size_t ibuflen = replmax < ibufmax ? replmax : ibufmax;
  17.160      if (ibuflen > REPLACE_INDEX_BUFFER_MAX) {
  17.161          ibuflen = REPLACE_INDEX_BUFFER_MAX;
  17.162      }
  17.163  
  17.164 -    /* Allocate first index buffer */
  17.165 +    // Allocate first index buffer
  17.166      struct cx_strreplace_ibuf *firstbuf, *curbuf;
  17.167      firstbuf = curbuf = calloc(1, sizeof(struct cx_strreplace_ibuf));
  17.168      if (!firstbuf) return cx_mutstrn(NULL, 0);
  17.169 @@ -583,13 +584,13 @@
  17.170          return cx_mutstrn(NULL, 0);
  17.171      }
  17.172  
  17.173 -    /* Search occurrences */
  17.174 +    // Search occurrences
  17.175      cxstring searchstr = str;
  17.176      size_t found = 0;
  17.177      do {
  17.178          cxstring match = cx_strstr(searchstr, pattern);
  17.179          if (match.length > 0) {
  17.180 -            /* Allocate next buffer in chain, if required */
  17.181 +            // Allocate next buffer in chain, if required
  17.182              if (curbuf->len == ibuflen) {
  17.183                  struct cx_strreplace_ibuf *nextbuf =
  17.184                          calloc(1, sizeof(struct cx_strreplace_ibuf));
  17.185 @@ -607,7 +608,7 @@
  17.186                  curbuf = nextbuf;
  17.187              }
  17.188  
  17.189 -            /* Record match index */
  17.190 +            // Record match index
  17.191              found++;
  17.192              size_t idx = match.ptr - str.ptr;
  17.193              curbuf->buf[curbuf->len++] = idx;
  17.194 @@ -618,7 +619,7 @@
  17.195          }
  17.196      } while (searchstr.length > 0 && found < replmax);
  17.197  
  17.198 -    /* Allocate result string */
  17.199 +    // Allocate result string
  17.200      cxmutstr result;
  17.201      {
  17.202          ssize_t adjlen = (ssize_t) replacement.length - (ssize_t) pattern.length;
  17.203 @@ -636,13 +637,13 @@
  17.204          }
  17.205      }
  17.206  
  17.207 -    /* Build result string */
  17.208 +    // Build result string
  17.209      curbuf = firstbuf;
  17.210      size_t srcidx = 0;
  17.211      char *destptr = result.ptr;
  17.212      do {
  17.213          for (size_t i = 0; i < curbuf->len; i++) {
  17.214 -            /* Copy source part up to next match*/
  17.215 +            // Copy source part up to next match
  17.216              size_t idx = curbuf->buf[i];
  17.217              size_t srclen = idx - srcidx;
  17.218              if (srclen > 0) {
  17.219 @@ -651,7 +652,7 @@
  17.220                  srcidx += srclen;
  17.221              }
  17.222  
  17.223 -            /* Copy the replacement and skip the source pattern */
  17.224 +            // Copy the replacement and skip the source pattern
  17.225              srcidx += pattern.length;
  17.226              memcpy(destptr, replacement.ptr, replacement.length);
  17.227              destptr += replacement.length;
  17.228 @@ -660,10 +661,10 @@
  17.229      } while (curbuf);
  17.230      memcpy(destptr, str.ptr + srcidx, str.length - srcidx);
  17.231  
  17.232 -    /* Result is guaranteed to be zero-terminated */
  17.233 +    // Result is guaranteed to be zero-terminated
  17.234      result.ptr[result.length] = '\0';
  17.235  
  17.236 -    /* Free index buffer */
  17.237 +    // Free index buffer
  17.238      cx_strrepl_free_ibuf(firstbuf);
  17.239  
  17.240      return result;

    18.1 --- a/test/test_string.cpp	Sun Nov 20 17:48:42 2022 +0100
    18.2 +++ b/test/test_string.cpp	Sun Nov 20 21:08:36 2022 +0100
    18.3 @@ -272,22 +272,22 @@
    18.4      cxstring list[8];
    18.5      size_t n;
    18.6  
    18.7 -    /* special case: empty string */
    18.8 +    // special case: empty string
    18.9      n = cx_strsplit(test, cx_str(""), capa, list);
   18.10      ASSERT_EQ(n, 1);
   18.11      EXPECT_EQ(cx_strcmp(list[0], test), 0);
   18.12  
   18.13 -    /* no delimiter occurrence */
   18.14 +    // no delimiter occurrence
   18.15      n = cx_strsplit(test, cx_str("z"), capa, list);
   18.16      ASSERT_EQ(n, 1);
   18.17      EXPECT_EQ(cx_strcmp(list[0], test), 0);
   18.18  
   18.19 -    /* partially matching delimiter */
   18.20 +    // partially matching delimiter
   18.21      n = cx_strsplit(test, cx_str("is,not"), capa, list);
   18.22      ASSERT_EQ(n, 1);
   18.23      EXPECT_EQ(cx_strcmp(list[0], test), 0);
   18.24  
   18.25 -    /* matching single-char delimiter */
   18.26 +    // matching single-char delimiter
   18.27      n = cx_strsplit(test, cx_str(","), capa, list);
   18.28      ASSERT_EQ(n, 5);
   18.29      EXPECT_EQ(cx_strcmp(list[0], cx_str("this")), 0);
   18.30 @@ -296,65 +296,65 @@
   18.31      EXPECT_EQ(cx_strcmp(list[3], cx_str("csv")), 0);
   18.32      EXPECT_EQ(cx_strcmp(list[4], cx_str("string")), 0);
   18.33  
   18.34 -    /* matching multi-char delimiter */
   18.35 +    // matching multi-char delimiter
   18.36      n = cx_strsplit(test, cx_str("is"), capa, list);
   18.37      ASSERT_EQ(n, 3);
   18.38      EXPECT_EQ(cx_strcmp(list[0], cx_str("th")), 0);
   18.39      EXPECT_EQ(cx_strcmp(list[1], cx_str(",")), 0);
   18.40      EXPECT_EQ(cx_strcmp(list[2], cx_str(",a,csv,string")), 0);
   18.41  
   18.42 -    /* bounded list using single-char delimiter */
   18.43 +    // bounded list using single-char delimiter
   18.44      n = cx_strsplit(test, cx_str(","), 3, list);
   18.45      ASSERT_EQ(n, 3);
   18.46      EXPECT_EQ(cx_strcmp(list[0], cx_str("this")), 0);
   18.47      EXPECT_EQ(cx_strcmp(list[1], cx_str("is")), 0);
   18.48      EXPECT_EQ(cx_strcmp(list[2], cx_str("a,csv,string")), 0);
   18.49  
   18.50 -    /* bounded list using multi-char delimiter */
   18.51 +    // bounded list using multi-char delimiter
   18.52      n = cx_strsplit(test, cx_str("is"), 2, list);
   18.53      ASSERT_EQ(n, 2);
   18.54      EXPECT_EQ(cx_strcmp(list[0], cx_str("th")), 0);
   18.55      EXPECT_EQ(cx_strcmp(list[1], cx_str(",is,a,csv,string")), 0);
   18.56  
   18.57 -    /* start with delimiter */
   18.58 +    // start with delimiter
   18.59      n = cx_strsplit(test, cx_str("this"), capa, list);
   18.60      ASSERT_EQ(n, 2);
   18.61      EXPECT_EQ(cx_strcmp(list[0], cx_str("")), 0);
   18.62      EXPECT_EQ(cx_strcmp(list[1], cx_str(",is,a,csv,string")), 0);
   18.63  
   18.64 -    /* end with delimiter */
   18.65 +    // end with delimiter
   18.66      n = cx_strsplit(test, cx_str("string"), capa, list);
   18.67      ASSERT_EQ(n, 2);
   18.68      EXPECT_EQ(cx_strcmp(list[0], cx_str("this,is,a,csv,")), 0);
   18.69      EXPECT_EQ(cx_strcmp(list[1], cx_str("")), 0);
   18.70  
   18.71  
   18.72 -    /* end with delimiter exceed bound */
   18.73 +    // end with delimiter exceed bound
   18.74      n = cx_strsplit(cx_str("a,b,c,"), cx_str(","), 3, list);
   18.75      ASSERT_EQ(n, 3);
   18.76      EXPECT_EQ(cx_strcmp(list[0], cx_str("a")), 0);
   18.77      EXPECT_EQ(cx_strcmp(list[1], cx_str("b")), 0);
   18.78      EXPECT_EQ(cx_strcmp(list[2], cx_str("c,")), 0);
   18.79  
   18.80 -    /* exact match */
   18.81 +    // exact match
   18.82      n = cx_strsplit(test, cx_str("this,is,a,csv,string"), capa, list);
   18.83      ASSERT_EQ(n, 2);
   18.84      EXPECT_EQ(cx_strcmp(list[0], cx_str("")), 0);
   18.85      EXPECT_EQ(cx_strcmp(list[1], cx_str("")), 0);
   18.86  
   18.87 -    /* string to be split is only substring */
   18.88 +    // string to be split is only substring
   18.89      n = cx_strsplit(test, cx_str("this,is,a,csv,string,with,extension"), capa, list);
   18.90      ASSERT_EQ(n, 1);
   18.91      EXPECT_EQ(cx_strcmp(list[0], test), 0);
   18.92  
   18.93 -    /* subsequent encounter of delimiter (the string between is empty) */
   18.94 +    // subsequent encounter of delimiter (the string between is empty)
   18.95      n = cx_strsplit(test, cx_str("is,"), capa, list);
   18.96      ASSERT_EQ(n, 3);
   18.97      EXPECT_EQ(cx_strcmp(list[0], cx_str("th")), 0);
   18.98      EXPECT_EQ(cx_strcmp(list[1], cx_str("")), 0);
   18.99      EXPECT_EQ(cx_strcmp(list[2], cx_str("a,csv,string")), 0);
  18.100  
  18.101 -    /* call the _m variant just for coverage */
  18.102 +    // call the _m variant just for coverage
  18.103      auto mtest = cx_strdup(test);
  18.104      cxmutstr mlist[4];
  18.105      n = cx_strsplit_m(mtest, cx_str("is,"), 4, mlist);
  18.106 @@ -373,25 +373,25 @@
  18.107      cxstring *list;
  18.108      size_t n;
  18.109  
  18.110 -    /* special case: empty string */
  18.111 +    // special case: empty string
  18.112      n = cx_strsplit_a(&alloc, test, cx_str(""), capa, &list);
  18.113      ASSERT_EQ(n, 1);
  18.114      EXPECT_EQ(cx_strcmp(list[0], test), 0);
  18.115      cxFree(&alloc, list);
  18.116  
  18.117 -    /* no delimiter occurrence */
  18.118 +    // no delimiter occurrence
  18.119      n = cx_strsplit_a(&alloc, test, cx_str("z"), capa, &list);
  18.120      ASSERT_EQ(n, 1);
  18.121      EXPECT_EQ(cx_strcmp(list[0], test), 0);
  18.122      cxFree(&alloc, list);
  18.123  
  18.124 -    /* partially matching delimiter */
  18.125 +    // partially matching delimiter
  18.126      n = cx_strsplit_a(&alloc, test, cx_str("is,not"), capa, &list);
  18.127      ASSERT_EQ(n, 1);
  18.128      EXPECT_EQ(cx_strcmp(list[0], test), 0);
  18.129      cxFree(&alloc, list);
  18.130  
  18.131 -    /* matching single-char delimiter */
  18.132 +    // matching single-char delimiter
  18.133      n = cx_strsplit_a(&alloc, test, cx_str(","), capa, &list);
  18.134      ASSERT_EQ(n, 5);
  18.135      EXPECT_EQ(cx_strcmp(list[0], cx_str("this")), 0);
  18.136 @@ -401,7 +401,7 @@
  18.137      EXPECT_EQ(cx_strcmp(list[4], cx_str("string")), 0);
  18.138      cxFree(&alloc, list);
  18.139  
  18.140 -    /* matching multi-char delimiter */
  18.141 +    // matching multi-char delimiter
  18.142      n = cx_strsplit_a(&alloc, test, cx_str("is"), capa, &list);
  18.143      ASSERT_EQ(n, 3);
  18.144      EXPECT_EQ(cx_strcmp(list[0], cx_str("th")), 0);
  18.145 @@ -409,7 +409,7 @@
  18.146      EXPECT_EQ(cx_strcmp(list[2], cx_str(",a,csv,string")), 0);
  18.147      cxFree(&alloc, list);
  18.148  
  18.149 -    /* bounded list using single-char delimiter */
  18.150 +    // bounded list using single-char delimiter
  18.151      n = cx_strsplit_a(&alloc, test, cx_str(","), 3, &list);
  18.152      ASSERT_EQ(n, 3);
  18.153      EXPECT_EQ(cx_strcmp(list[0], cx_str("this")), 0);
  18.154 @@ -417,28 +417,28 @@
  18.155      EXPECT_EQ(cx_strcmp(list[2], cx_str("a,csv,string")), 0);
  18.156      cxFree(&alloc, list);
  18.157  
  18.158 -    /* bounded list using multi-char delimiter */
  18.159 +    // bounded list using multi-char delimiter
  18.160      n = cx_strsplit_a(&alloc, test, cx_str("is"), 2, &list);
  18.161      ASSERT_EQ(n, 2);
  18.162      EXPECT_EQ(cx_strcmp(list[0], cx_str("th")), 0);
  18.163      EXPECT_EQ(cx_strcmp(list[1], cx_str(",is,a,csv,string")), 0);
  18.164      cxFree(&alloc, list);
  18.165  
  18.166 -    /* start with delimiter */
  18.167 +    // start with delimiter
  18.168      n = cx_strsplit_a(&alloc, test, cx_str("this"), capa, &list);
  18.169      ASSERT_EQ(n, 2);
  18.170      EXPECT_EQ(cx_strcmp(list[0], cx_str("")), 0);
  18.171      EXPECT_EQ(cx_strcmp(list[1], cx_str(",is,a,csv,string")), 0);
  18.172      cxFree(&alloc, list);
  18.173  
  18.174 -    /* end with delimiter */
  18.175 +    // end with delimiter
  18.176      n = cx_strsplit_a(&alloc, test, cx_str("string"), capa, &list);
  18.177      ASSERT_EQ(n, 2);
  18.178      EXPECT_EQ(cx_strcmp(list[0], cx_str("this,is,a,csv,")), 0);
  18.179      EXPECT_EQ(cx_strcmp(list[1], cx_str("")), 0);
  18.180      cxFree(&alloc, list);
  18.181  
  18.182 -    /* end with delimiter exceed bound */
  18.183 +    // end with delimiter exceed bound
  18.184      n = cx_strsplit_a(&alloc, cx_str("a,b,c,"), cx_str(","), 3, &list);
  18.185      ASSERT_EQ(n, 3);
  18.186      EXPECT_EQ(cx_strcmp(list[0], cx_str("a")), 0);
  18.187 @@ -446,20 +446,20 @@
  18.188      EXPECT_EQ(cx_strcmp(list[2], cx_str("c,")), 0);
  18.189      cxFree(&alloc, list);
  18.190  
  18.191 -    /* exact match */
  18.192 +    // exact match
  18.193      n = cx_strsplit_a(&alloc, test, cx_str("this,is,a,csv,string"), capa, &list);
  18.194      ASSERT_EQ(n, 2);
  18.195      EXPECT_EQ(cx_strcmp(list[0], cx_str("")), 0);
  18.196      EXPECT_EQ(cx_strcmp(list[1], cx_str("")), 0);
  18.197      cxFree(&alloc, list);
  18.198  
  18.199 -    /* string to be split is only substring */
  18.200 +    // string to be split is only substring
  18.201      n = cx_strsplit_a(&alloc, test, cx_str("this,is,a,csv,string,with,extension"), capa, &list);
  18.202      ASSERT_EQ(n, 1);
  18.203      EXPECT_EQ(cx_strcmp(list[0], test), 0);
  18.204      cxFree(&alloc, list);
  18.205  
  18.206 -    /* subsequent encounter of delimiter (the string between is empty) */
  18.207 +    // subsequent encounter of delimiter (the string between is empty)
  18.208      n = cx_strsplit_a(&alloc, test, cx_str("is,"), capa, &list);
  18.209      ASSERT_EQ(n, 3);
  18.210      EXPECT_EQ(cx_strcmp(list[0], cx_str("th")), 0);
  18.211 @@ -467,7 +467,7 @@
  18.212      EXPECT_EQ(cx_strcmp(list[2], cx_str("a,csv,string")), 0);
  18.213      cxFree(&alloc, list);
  18.214  
  18.215 -    /* call the _m variant just for coverage */
  18.216 +    // call the _m variant just for coverage
  18.217      auto mtest = cx_strdup(test);
  18.218      cxmutstr *mlist;
  18.219      n = cx_strsplit_ma(&alloc, mtest, cx_str("is,"), 4, &mlist);
  18.220 @@ -496,7 +496,7 @@
  18.221      EXPECT_EQ(cx_strcmp(t5, cx_str("")), 0);
  18.222      EXPECT_EQ(cx_strcmp(empty, cx_str("")), 0);
  18.223  
  18.224 -    /* call the _m variant just for coverage */
  18.225 +    // call the _m variant just for coverage
  18.226      cxmutstr m1 = cx_strtrim_m(cx_mutstr((char *) "  ein test  \t "));
  18.227      EXPECT_EQ(cx_strcmp(cx_strcast(m1), cx_str("ein test")), 0);
  18.228  }

    19.1 --- a/test/util_allocator.h	Sun Nov 20 17:48:42 2022 +0100
    19.2 +++ b/test/util_allocator.h	Sun Nov 20 21:08:36 2022 +0100
    19.3 @@ -78,4 +78,4 @@
    19.4      [[nodiscard]] bool verify() const;
    19.5  };
    19.6  
    19.7 -#endif /* UCX_UTIL_ALLOCATOR_H */
    19.8 +#endif // UCX_UTIL_ALLOCATOR_H