text: /*
    ***** BEGIN LICENSE BLOCK *****
   
    Copyright (C) 2001-2022 Olof Hagsand
  
    This file is part of CLIgen.
  
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
  
      http://www.apache.org/licenses/LICENSE-2.0
  
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
  
    Alternatively, the contents of this file may be used under the terms of
    the GNU General Public License Version 2 or later (the "GPL"),
    in which case the provisions of the GPL are applicable instead
    of those above. If you wish to allow use of your version of this file only
    under the terms of the GPL, and not to allow others to
    use your version of this file under the terms of Apache License version 2, indicate
    your decision by deleting the provisions above and replace them with the 
    notice and other provisions required by the GPL. If you do not delete
    the provisions above, a recipient may use your version of this file under
    the terms of any one of the Apache License version 2 or the GPL.
  
    ***** END LICENSE BLOCK *****
  
   * CLIgen dynamic buffers 
   * @code
   *   cbuf *cb;
   *   if ((cb = cbuf_new()) == NULL)
   *      err();
   *   cprintf(cb, "content %d", 42);
   *   if (write(f, cbuf_get(cb), cbuf_len(cb)) < 0)
   *      err();
   *   cbuf_free(cb);
   * @endcode
   */
  
  /*
   * Constants
   */
  /* Initial alloc mem length of a cbuf, then grows exponentially, with 2*, 4*, etc
   * 1K could be a bit much for large syntaxes and small entries 
   * @see cbuf_alloc_set
   */
  #define CBUFLEN_START 1024
  #define CBUFLEN_THRESHOLD 65536
  
  #include <stdio.h>
  #include <stdlib.h>
  #include <stdint.h>
  #include <string.h>
  #include <errno.h>
  
  #include "cligen_buf.h"              /* External API */
  #include "cligen_buf_internal.h"            
  
  /*
   * Variables
   */
  /* This is how large an initial cbuf is after calling cbuf_new. Note that the cbuf 
   * may grow after calls to cprintf or cbuf_alloc 
   */
  static size_t cbuflen_start     = CBUFLEN_START;
  
  /* Threshold to where a cbuf grows exponentially, thereafter it grows linearly
   * If 0 continue with exponential growth
   */
  static size_t cbuflen_threshold = CBUFLEN_THRESHOLD;
  
  /*! Get global cbuf initial memory allocation size
   * This is how large a cbuf is after calling cbuf_new. Note that the cbuf 
   * may grow after calls to cprintf or cbuf_alloc
   * @param[out]  default   Initial default cbuf size
   * @param[out]  threshold Threshold where cbuf grows linearly instead of exponentially
   */
  int
  cbuf_alloc_get(size_t *start,
  	       size_t *threshold)
  {
      *start = cbuflen_start;
      *threshold = cbuflen_threshold;
      return 0;
  }
  
  /*! Set global cbuf initial memory allocation size
   * This is how large a cbuf is after calling cbuf_new. Note that the cbuf 
   * may grow after calls to cprintf or cbuf_alloc
   * If 0 continue with exponential growth
   */
  int
  cbuf_alloc_set(size_t start,
  	       size_t threshold)
  {
      cbuflen_start = start;
      cbuflen_threshold = threshold;
      return 0;
  }
  
  /*! Allocate cligen buffer. Returned handle can be used in sprintf calls
   * which dynamically print a string.
   * The handle should be freed by cbuf_free()
   * @param[in]   How much buffer space for initial allocation
   * @retval cb   The allocated objecyt handle on success.
   * @retval NULL Error.
   * @see cbuf_new  with auto buffer allocation
   */
  cbuf *
  cbuf_new_alloc(size_t sz)
  {
      cbuf *cb;
  
      if ((cb = (cbuf*)malloc(sizeof(*cb))) == NULL)
  	return NULL;
      memset(cb, 0, sizeof(*cb));
      cb->cb_buflen = sz;
      if ((cb->cb_buffer = malloc(cb->cb_buflen)) == NULL){
  	free(cb);
  	return NULL;
      }
      memset(cb->cb_buffer, 0, cb->cb_buflen);
      cb->cb_strlen = 0;
      return cb;
  }
  
  /*! Allocate cligen buffer with auto buffer allocation. Returned handle can be used in sprintf calls
   * which dynamically print a string.
   * The handle should be freed by cbuf_free()
   * @retval cb   The allocated objecyt handle on success.
   * @retval NULL Error.
   * @see cbuf_new_alloc  with explicit buffer allocation
   */
  cbuf *
  cbuf_new(void)
  {
      return cbuf_new_alloc(cbuflen_start);
  }
  
  /*! Free cligen buffer previously allocated with cbuf_new
   * @param[in]   cb  Cligen buffer
   */
  void
  cbuf_free(cbuf *cb)
  {
      if (cb) {
  	if (cb->cb_buffer)
  	    free(cb->cb_buffer);
  	free(cb);
      }
  }
  
  /*! Return actual byte buffer of cligen buffer
   * @param[in]   cb  Cligen buffer
   */
  char*
  cbuf_get(cbuf *cb)
  {
      return cb->cb_buffer;
  }
  
  /*! Return length of string in cligen buffer (not buffer length itself)
   * @param[in]   cb  Cligen buffer
   * @see cbuf_buflen
   */
  size_t
  cbuf_len(cbuf *cb)
  {
      return cb->cb_strlen;
  }
  
  /*! Return length of buffer itself, ie allocated bytes
   * @param[in]   cb  Cligen buffer
   * @see cbuf_len
   */
  size_t
  cbuf_buflen(cbuf *cb)
  {
      return cb->cb_buflen;
  }
  
  /*! Reset a cligen buffer. That is, restart it from scratch.
   * @param[in]   cb  Cligen buffer
   */
  void
  cbuf_reset(cbuf *cb)
  {
      cb->cb_strlen    = 0; 
      cb->cb_buffer[0] = '\0'; 
  }
  
  /*! Internal buffer reallocator, Ensure buffer is large enough
   * use quadratic expansion (2* size)
   * @param[in] cb   CLIgen buffer
   * @param[in] len  Extra length added
   */
  static int
  cbuf_realloc(cbuf  *cb,
  	     size_t sz)
  {
      int retval = -1;
      int diff;
      
      diff = cb->cb_buflen - (cb->cb_strlen + sz + 1);
      if (diff <= 0){
  	while (diff <= 0){
  	    if (cbuflen_threshold == 0 || cb->cb_buflen < cbuflen_threshold)
  		cb->cb_buflen *= 2; /* Double the space - exponential */
  	    else
  		cb->cb_buflen += cbuflen_threshold; /* Add - linear growth*/
  	    diff = cb->cb_buflen - (cb->cb_strlen + sz + 1);
  	}
  	if ((cb->cb_buffer = realloc(cb->cb_buffer, cb->cb_buflen)) == NULL)
  	    goto done;
      }
      retval = 0;
   done:
      return retval;
  }
  
  /*! Append a cligen buf by printf like semantics
   * 
   * @param [in]  cb      cligen buffer allocated by cbuf_new(), may be reallocated.
   * @param [in]  format  arguments uses printf syntax.
   * @retval      See printf
   * @see cbuf_append_str for the optimized special case of string append
   * @note cprintf assume null-terminated string as %s, use cbuf_memcp for a raw interface
   */
  int
  cprintf(cbuf       *cb, 
  	const char *format, ...)
  {
      int     retval = -1;
      va_list ap;
      int     len;
      int     ret;
  
      if (cb == NULL)
  	goto ok;
      va_start(ap, format); /* dryrun */
      if ((len = vsnprintf(NULL, 0, format, ap)) < 0) /* dryrun, just get len */
  	goto done;
      va_end(ap);
      /* Ensure buffer is large enough */
      if (cbuf_realloc(cb, len) < 0)
      	goto done;
      va_start(ap, format); /* real */
      if ((ret = vsnprintf(cb->cb_buffer+cb->cb_strlen, /* str */
  			 cb->cb_buflen-cb->cb_strlen, /* size */
  			 format, ap)) < 0)
  	goto done;
      va_end(ap);
      cb->cb_strlen += ret;
   ok:
      retval = 0;
   done:
      return retval;
  }
  
  /*! Append a string to a cbuf
    *
    * An optimized special case of cprintf
    * @param [in]  cb  cligen buffer allocated by cbuf_new(), may be reallocated.
    * @param [in]  str string
    * @retval 0    OK
    * @retval -1   Error
    * @see cprintf for the generic function
    */
  int
  cbuf_append_str(cbuf       *cb,
  		char       *str)
  {
      size_t  len0;
      size_t  len;
  
      if (str == NULL){
  	errno = EINVAL;
  	return -1;
      }
      len0 = strlen(str);
      len = cb->cb_strlen + len0;
      /* Ensure buffer is large enough */
      if (cbuf_realloc(cb, len) < 0)
  	return -1;
      strncpy(cb->cb_buffer+cb->cb_strlen, str, len0+1);
      cb->cb_strlen = len;
      return 0;
  }
  
  /*! Append a character to a cbuf
    *
    * @param [in]  cb  cligen buffer allocated by cbuf_new(), may be reallocated.
    * @param [in]  c   character to append
    * @retval 0    OK
    * @retval -1   Error
    * @see cbuf_append_str, use that function instead
    */
  int
  cbuf_append(cbuf       *cb,
              int        c)
  {
      char str[2] = {0,};
  
      str[0] = c;
      return cbuf_append_str(cb, str);
  }
  
  /*! Append a raw memory buffer and add null-termination
    *
    * A raw buffer handler to cprintf
    * @param [in]  cb  cligen buffer allocated by cbuf_new(), may be reallocated.
    * @param [in]  src Source buffer
    * @param [in]  n   Number of bytes to copy, add a null
    * @retval 0    OK
    * @retval -1   Error
    * @see cprintf for the generic function
    */
  int
  cbuf_append_buf(cbuf  *cb,
  		void  *src,
  		size_t n)
  {
      size_t  len0;
      size_t  len;
  
      if (src == NULL){
  	errno = EINVAL;
  	return -1;
      }
      len0 = cb->cb_strlen;
      len = cb->cb_strlen + n;
      /* Ensure buffer is large enough */
      if (cbuf_realloc(cb, len+1) < 0)
  	return -1;
      memcpy(cb->cb_buffer+len0, src, n);
      cb->cb_buffer[len] = '\0'; /* Add a null byte */
      cb->cb_strlen = len;
      return 0;
  }
  
  /*! Truncate cligen buf to a shorther length
    * @param [in]  cb  cligen buffer allocated by cbuf_new(), may be reallocated.
    * @param [in]  i   Truncate string to this length
    * @retval 0    OK
    * @retval -1   Error
   */
  int
  cbuf_trunc(cbuf  *cb,
  	   size_t i)
  {
      if (i > cb->cb_strlen){
  	errno = EINVAL;
  	return -1;
      }
      cb->cb_strlen = i;
      cb->cb_buffer[i] = '\0'; /* Add a null byte */
      return 0;
  }
  