Line data    Source code

       1              : #include "testitall.h"
       2              : #include <stdio.h>
       3              : #include <stdarg.h>
       4              : 
       5              : /**
       6              :  * @brief Append formatted text to a memory descriptor.
       7              :  * @param buffer Target descriptor that stores the growing string.
       8              :  * @param format printf-style format string.
       9              :  * @param ... Values consumed by the format string.
      10              :  */
      11          162 : void echo(
      12              :         memory     *buffer,
      13              :         const char *format,
      14              :         ...)
      15              : {
      16          162 :         if(buffer == NULL || format == NULL)
      17              :         {
      18            0 :                 return;
      19              :         }
      20              : 
      21              :         va_list args;
      22          162 :         va_start(args,format);
      23              : 
      24              :         va_list args_copy;
      25          162 :         va_copy(args_copy,args);
      26          162 :         int characters = vsnprintf(NULL,0,format,args_copy);
      27          162 :         va_end(args_copy);
      28              : 
      29          162 :         if(characters < 0)
      30              :         {
      31            0 :                 va_end(args);
      32            0 :                 return;
      33              :         }
      34              : 
      35          162 :         size_t former_length = buffer->length;
      36          162 :         size_t shift = former_length;
      37          162 :         size_t new_size = former_length + (size_t)characters + 1U;
      38              : 
      39          162 :         if(former_length > 0U)
      40              :         {
      41            0 :                 shift -= 1U;
      42              : 
      43            0 :                 if(new_size > 0U)
      44              :                 {
      45            0 :                         new_size -= 1U;
      46              :                 }
      47              :         }
      48              : 
      49          162 :         if(SUCCESS == resize(buffer,new_size))
      50              :         {
      51          162 :                 if(buffer->length > 0U)
      52              :                 {
      53          162 :                         char *buffer_data = data(char,buffer);
      54              : 
      55          162 :                         if(buffer_data == NULL)
      56              :                         {
      57            0 :                                 va_end(args);
      58            0 :                                 return;
      59              :                         }
      60              : 
      61          162 :                         const size_t writable_capacity = buffer->length - shift;
      62          162 :                         int written = vsnprintf(
      63              :                                 buffer_data + shift,
      64              :                                 writable_capacity,
      65              :                                 format,
      66              :                                 args);
      67              : 
      68          162 :                         if(written < 0 || (size_t)written >= writable_capacity)
      69              :                         {
      70            0 :                                 report("Formatting failed while writing into buffer");
      71              :                         } else {
      72          162 :                                 buffer_data[buffer->length - 1U] = '\0';
      73              :                         }
      74              :                 }
      75              :         } else {
      76            0 :                 report("Memory allocation failed, requested size: %zu bytes",new_size);
      77              :         }
      78              : 
      79          162 :         va_end(args);
      80              : }