luke
/
ngspice
mirror of https://git.code.sf.net/p/ngspice/ngspice
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ngspice/src/misc/dstring.c

545 lines
17 KiB
C
Raw Blame History

/* -----------------------------------------------------------------
FILE: dstring.c
DESCRIPTION:This file contains the routines for manipulating dynamic strings.
Copyright 2020 The ngspice team
3 - Clause BSD license
(see COPYING or https://opensource.org/licenses/BSD-3-Clause)
Author: Jim Monte
----------------------------------------------------------------- */
#include <ctype.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "ngspice/dstring.h"
static int ds_reserve_internal(DSTRING *p_ds,
size_t n_byte_alloc_opt, size_t n_byte_alloc_min);
/* Instantiations of dstring functions */
extern inline int ds_cat_str(DSTRING *p_ds, const char *sz);
extern inline int ds_cat_char(DSTRING *p_ds, char c);
extern inline int ds_cat_ds(DSTRING *p_ds_dst, const DSTRING *p_ds_src);
extern inline int ds_cat_mem(DSTRING *p_ds, const char *p_src, size_t n_char);
extern inline int ds_set_length(DSTRING *p_ds, size_t length);
extern inline void ds_clear(DSTRING *p_ds);
extern inline char *ds_free_move(DSTRING *p_ds, unsigned int opt);
extern inline char *ds_get_buf(DSTRING *p_ds);
extern inline size_t ds_get_length(const DSTRING *p_ds);
extern inline size_t ds_get_buf_size(const DSTRING *p_ds);
/* This function initalizes a dstring using *p_buf as the initial backing
*
* Parameters
* p_buf: Inital buffer backing the dstring
* length_string: Length of string in the initial buffer
* n_byte_data: Length of initial buffer. Must be at least 1
* type_buffer: Type of buffer providing initial backing
*
* Return codes
* DS_E_OK: Init OK
* DS_E_INVALID: n_byte_data = 0 length_string too long,
* or unknown buffer type
*/
int ds_init(DSTRING *p_ds, char *p_buf, size_t length_string,
size_t n_byte_buf, ds_buf_type_t type_buffer)
{
/* Validate buffer size */
if (n_byte_buf == 0) {
return DS_E_INVALID;
}
/* Set current buffer */
p_ds->p_buf = p_buf;
/* Set size of current string >= rather than > because this function
* adds a terminating null */
if (length_string >= n_byte_buf) {
return DS_E_INVALID;
}
p_ds->n_byte_alloc = n_byte_buf;
p_ds->length = length_string;
p_ds->p_buf[length_string] = '\0';
/* Set stack buffer */
if (type_buffer == ds_buf_type_stack) {
p_ds->p_stack_buf = p_buf;
p_ds->n_byte_stack_buf = n_byte_buf;
}
else if (type_buffer == ds_buf_type_heap) {
p_ds->p_stack_buf = (char *) NULL;
p_ds->n_byte_stack_buf = 0;
}
else { /* unknown buffer type */
return DS_E_INVALID;
}
return DS_E_OK;
} /* end of function ds_init */
/* This function frees all memory used by the dstring. After calling this
* function, the dstring should not be used again. */
void ds_free(DSTRING *p_ds)
{
if (p_ds->p_buf != p_ds->p_stack_buf) {
txfree((void *) p_ds->p_buf);
}
} /* end of function ds_free */
/* Concatenate string */
int ds_cat_str_case(DSTRING *p_ds, const char *sz, ds_case_t case_type)
{
return ds_cat_mem_case(p_ds, sz, strlen(sz), case_type);
} /* end of function ds_cat_str_case */
/* Concatenate character */
int ds_cat_char_case(DSTRING *p_ds, char c, ds_case_t case_type)
{
return ds_cat_mem_case(p_ds, &c, 1, case_type);
} /* end of function ds_cat_char_case */
/* Concatenate another dstring */
int ds_cat_ds_case(DSTRING *p_ds_dst, const DSTRING *p_ds_src,
ds_case_t case_type)
{
return ds_cat_mem_case(p_ds_dst, p_ds_src->p_buf, p_ds_src->length,
case_type);
} /* end of function ds_cat_ds_case */
/* General concatenation of a memory buffer. A terminating null is added. */
int ds_cat_mem_case(DSTRING *p_ds, const char *p_src, size_t n_char,
ds_case_t type_case)
{
/* Resize buffer if necessary. Double required size, if available,
* to reduce the number of allocations */
const size_t length_new = p_ds->length + n_char;
const size_t n_byte_needed = length_new + 1;
if (n_byte_needed > p_ds->n_byte_alloc) {
if (ds_reserve_internal(p_ds,
2 * n_byte_needed, n_byte_needed) == DS_E_NO_MEMORY) {
return DS_E_NO_MEMORY;
}
}
/* For "as-is" can simply memcpy */
if (type_case == ds_case_as_is) {
char *p_dst = p_ds->p_buf + p_ds->length;
(void) memcpy(p_dst, p_src, n_char);
p_dst += n_char;
*p_dst = '\0';
p_ds->length = length_new;
return DS_E_OK;
}
/* For lowercasing, work char by char */
if (type_case == ds_case_lower) {
char *p_dst = p_ds->p_buf + p_ds->length;
char *p_dst_end = p_dst + n_char;
for ( ; p_dst < p_dst_end; p_dst++, p_src++) {
*p_dst = (char) tolower(*p_src);
}
*p_dst_end = '\0';
p_ds->length = length_new;
return DS_E_OK;
}
/* Uppercasing done like lowercasing. Note that it would be possible to
* use a function pointer and select either tolower() or toupper() based
* on type_case, but doing so may degrade performance by inhibiting
* inlining. */
if (type_case == ds_case_upper) {
char *p_dst = p_ds->p_buf + p_ds->length;
char *p_dst_end = p_dst + n_char;
for ( ; p_dst < p_dst_end; p_dst++, p_src++) {
*p_dst = (char) toupper(*p_src);
}
*p_dst_end = '\0';
p_ds->length = length_new;
return DS_E_OK;
}
return DS_E_INVALID; /* unknown case type */
} /* end of function ds_cat_mem_case */
/* Ensure minimum internal buffer size */
int ds_reserve(DSTRING *p_ds, size_t n_byte_alloc)
{
/* Return if buffer already large enough */
if (p_ds->n_byte_alloc >= n_byte_alloc) {
return DS_E_OK;
}
return ds_reserve_internal(p_ds, n_byte_alloc, 0);
} /* end of function ds_reserve */
/* This function resizes the buffer for the string and handles freeing
* the original alloction, if necessary. It is assumed that the requested
* size or sizes are larger than the current size.
*
* Parameters
* p_ds: Dstring pointer
* n_byte_alloc_opt: Optimal alloction amount
* n_byte_alloc_min: Absolute minimum allocation amount or 0 if no
* smaller amount can be allocated
*
* Return codes
* DS_E_OK: At least the minimum allocation was performed
* DS_E_NO_MEMORY: Unable to resize the buffer */
static int ds_reserve_internal(DSTRING *p_ds,
size_t n_byte_alloc_opt, size_t n_byte_alloc_min)
{
size_t n_byte_alloc = n_byte_alloc_opt;
/* Allocate. First try (larger) optimal size, and gradually fall back
* to min size if that fails and one was provided. */
char * p_buf_new;
if (n_byte_alloc_min == 0) {
n_byte_alloc_min = n_byte_alloc_opt;
}
for ( ; ; ) {
if ((p_buf_new = (char *) malloc(n_byte_alloc)) != (char *) NULL) {
break; /* Allocated OK */
}
if (n_byte_alloc == n_byte_alloc_min) { /* min alloc failed */
return DS_E_NO_MEMORY;
}
if ((n_byte_alloc /= 2) < n_byte_alloc_min) { /* last try */
n_byte_alloc = n_byte_alloc_min;
}
} /* end of loop trying smaller allocations */
/* Copy to the new buffer */
(void) memcpy(p_buf_new, p_ds->p_buf, p_ds->length + 1);
/* If there already was a dynamic allocation, free it */
if (p_ds->p_buf != p_ds->p_stack_buf) {
txfree((void *) p_ds->p_buf);
}
/* Assign new active buffer and its size */
p_ds->p_buf = p_buf_new;
p_ds->n_byte_alloc = n_byte_alloc;
return DS_E_OK;
} /* end of function ds_reserve_nocheck */
/* Concatenate the result of a printf-style format
*
* Return codes as for ds_cat_vprintf */
int ds_cat_printf(DSTRING *p_ds, const char *sz_fmt, ...)
{
va_list p_arg;
va_start(p_arg, sz_fmt);
const int xrc = ds_cat_vprintf(p_ds, sz_fmt, p_arg);
va_end(p_arg);
return xrc;
} /* end of function ds_cat_printf */
/* Concatenate the result of a printf-style format using va_list
*
* Return codes
* DS_E_OK: Formatted OK
* DS_E_NO_MEMORY: Unable to allocate memory to resize buffer
* DS_E_INVALID: Invalid formatter / data
*/
int ds_cat_vprintf(DSTRING *p_ds, const char *sz_fmt, va_list p_arg)
{
/* Make a copy of the argument list in case need to format more than
* once */
va_list p_arg2;
va_copy(p_arg2, p_arg);
const size_t n_byte_free = p_ds->n_byte_alloc - p_ds->length;
char * const p_dst = p_ds->p_buf + p_ds->length;
const int rc = vsnprintf(p_dst, n_byte_free, sz_fmt, p_arg);
if (rc < 0) { /* Check for formatting error */
return DS_E_INVALID;
}
/* Else check for buffer large enough and set length if it is */
if ((size_t) rc < n_byte_free) {
p_ds->length += (size_t) rc;
return DS_E_OK;
}
/* Else buffer too small, so resize and format again */
{
/* Double required size to avoid excessive allocations +1 for
* null, which is not included in the count returned by snprintf */
const size_t n_byte_alloc_min =
p_ds->length + (size_t) rc + (size_t) 1;
if (ds_reserve_internal(p_ds,
2 * n_byte_alloc_min, n_byte_alloc_min) == DS_E_NO_MEMORY) {
/* vsnprintf may have written bytes to the buffer.
* Ensure that dstring in a consistent state by writing
* a null at the length of the string */
p_ds->p_buf[p_ds->length] = '\0';
return DS_E_NO_MEMORY;
}
const size_t n_byte_free2 = p_ds->n_byte_alloc - p_ds->length;
char * const p_dst2 = p_ds->p_buf + p_ds->length;
const int rc2 = vsnprintf(p_dst2, n_byte_free2, sz_fmt, p_arg2);
if (rc2 < 0) { /* Check for formatting error */
/* vsnprintf may have written bytes to the buffer.
* Ensure that dstring in a consistent state by writing
* a null at the length of the string */
p_ds->p_buf[p_ds->length] = '\0';
return DS_E_INVALID;
}
/* Else update length. No need to check buffer size since it was
* sized to fit the string. */
p_ds->length += (size_t) rc2;
return DS_E_OK;
}
} /* end of function ds_cat_vprintf */
/* Reallocate/free to eliminate unused buffer space.
*
* Return codes
* DS_E_OK: Compacted OK
* DS_E_NO_MEMORY: Compaction failed, but dstring still valid */
int ds_compact(DSTRING *p_ds)
{
const size_t n_byte_alloc_min = p_ds->length + 1;
/* If the string is in the stack buffer, there is nothing to do */
if (p_ds->p_stack_buf == p_ds->p_buf) {
return DS_E_OK;
}
/* Else if the string will fit in the stack buffer, copy it there and
* free the allocation. */
if (p_ds->n_byte_stack_buf >= n_byte_alloc_min) {
(void) memcpy(p_ds->p_stack_buf, p_ds->p_buf, n_byte_alloc_min);
txfree((void *) p_ds->p_buf);
p_ds->p_buf = p_ds->p_stack_buf;
p_ds->n_byte_alloc = p_ds->n_byte_stack_buf;
return DS_E_OK;
}
/* Else if the heap buffer is the minimum size, there is nothng to do */
if (n_byte_alloc_min == p_ds->n_byte_alloc) {
return DS_E_OK;
}
/* Else realloc the heap buffer */
{
void *p = TREALLOC(char, p_ds->p_buf, n_byte_alloc_min);
if (p == NULL) {
return DS_E_NO_MEMORY;
}
p_ds->p_buf = (char *) p;
p_ds->n_byte_alloc = n_byte_alloc_min;
return DS_E_OK;
}
} /* end of function ds_compact */
#ifdef DSTRING_UNIT_TEST
#if defined (_WIN32) && !defined(CONSOLE)
#include "ngspice/wstdio.h"
#endif
static void ds_print_info(DSTRING *p_ds, FILE *fp, const char *sz_id);
static int ds_test_from_macro(FILE *fp);
static int ds_test_from_stack(FILE *fp);
static int ds_test_from_heap(FILE *fp);
static int ds_test1(DSTRING *p_ds, FILE *fp);
int ds_test(FILE *fp)
{
if (ds_test_from_macro(fp) != 0) { /* create from macro and run test */
return -1;
}
if (ds_test_from_stack(fp) != 0) { /* create from stack */
return -1;
}
if (ds_test_from_heap(fp) != 0) { /* create from heap */
return -1;
}
return 0;
} /* end of function ds_test */
/* Run tests from a macro-created dstring */
static int ds_test_from_macro(FILE *fp)
{
DS_CREATE(ds, 10);
(void) fprintf(fp, "Macro initialization\n");
return ds_test1(&ds, fp);
} /* end of function ds_test_from_macro */
/* Run tests from a manually created stack-backed dstring */
static int ds_test_from_stack(FILE *fp)
{
static char p_buf[30] = "Hello World";
DSTRING ds;
(void) fprintf(fp, "Stack initialization\n");
(void) ds_init(&ds, p_buf, 11, sizeof p_buf, ds_buf_type_stack);
return ds_test1(&ds, fp);
} /* end of function ds_test_from_stack */
/* Run tests from a heap-backed dstring */
static int ds_test_from_heap(FILE *fp)
{
char *p_buf = (char *) malloc(25);
if (p_buf == (char *) NULL) {
return -1;
}
(void) memcpy(p_buf, "Heap", 4);
DSTRING ds;
(void) ds_init(&ds, p_buf, 4, 25, ds_buf_type_heap);
(void) fprintf(fp, "Heap initialization\n");
return ds_test1(&ds, fp);
} /* end of function ds_test_from_heap */
static int ds_test1(DSTRING *p_ds, FILE *fp)
{
/* Print info on entry */
ds_print_info(p_ds, fp, "On entry to ds_test1\n");
int i;
for (i = 0; i < 10; i++) {
if (ds_cat_str(p_ds, "Abc") != 0) {
(void) fprintf(fp, "Unable to cat string %d.\n", i);
return -1;
}
if (ds_cat_str_case(p_ds, "Abc", ds_case_as_is) != 0) {
(void) fprintf(fp, "Unable to cat string as-is %d.\n", i);
return -1;
}
if (ds_cat_str_case(p_ds, "Abc", ds_case_upper) != 0) {
(void) fprintf(fp, "Unable to cat string upper %d.\n", i);
return -1;
}
if (ds_cat_str_case(p_ds, "Abc", ds_case_lower) != 0) {
(void) fprintf(fp, "Unable to cat string lower %d.\n", i);
return -1;
}
if (ds_cat_char(p_ds, 'z') != 0) {
(void) fprintf(fp, "Unable to cat char %d.\n", i);
return -1;
}
if (ds_cat_char_case(p_ds, 'z', ds_case_as_is) != 0) {
(void) fprintf(fp, "Unable to cat char as-is %d.\n", i);
return -1;
}
if (ds_cat_char_case(p_ds, 'z', ds_case_upper) != 0) {
(void) fprintf(fp, "Unable to cat char upper %d.\n", i);
return -1;
}
if (ds_cat_char_case(p_ds, 'Z', ds_case_lower) != 0) {
(void) fprintf(fp, "Unable to cat char lower %d.\n", i);
return -1;
}
if (ds_cat_mem(p_ds, "Zyxw", 4) != 0) {
(void) fprintf(fp, "Unable to cat string %d.\n", i);
return -1;
}
if (ds_cat_mem_case(p_ds, "Zyxw", 4, ds_case_as_is) != 0) {
(void) fprintf(fp, "Unable to cat string as-is %d.\n", i);
return -1;
}
if (ds_cat_mem_case(p_ds, "Zyxw", 4, ds_case_upper) != 0) {
(void) fprintf(fp, "Unable to cat string upper %d.\n", i);
return -1;
}
if (ds_cat_mem_case(p_ds, "Zyxw", 4, ds_case_lower) != 0) {
(void) fprintf(fp, "Unable to cat string lower %d.\n", i);
return -1;
}
if (ds_cat_printf(p_ds, "--- And finally a formatted %s (%d)",
"string", i) != 0) {
(void) fprintf(fp, "Unable to cat formatted string %d.\n", i);
return -1;
}
/* Print info after cats */
ds_print_info(p_ds, fp, "After appending strings");
/* Truncate the string */
if (ds_set_length(p_ds, i * (size_t) 10) != 0) {
(void) fprintf(fp, "Unable to set size %d.\n", i);
return -1;
}
/* Print info after truncation */
ds_print_info(p_ds, fp, "After setting length");
/* Compact the string */
if (ds_compact(p_ds) != 0) {
(void) fprintf(fp, "Unable to compact %d.\n", i);
return -1;
}
/* Print info after compaction */
ds_print_info(p_ds, fp, "After compacting the string");
} /* end of loop over tests */
ds_free(p_ds); /* free buffer if allocated */
return 0;
} /* end of funtion ds_test */
/* Print some info about the DSTRING */
static void ds_print_info(DSTRING *p_ds, FILE *fp, const char *sz_id)
{
(void) fprintf(fp, "%s: length = %zu; "
"allocated buffer size = %zu; value = \"%s\"; "
"address of active buffer = %p; "
"address of stack buffer = %p; "
"size of stack buffer = %zu\n",
sz_id,
ds_get_length(p_ds), ds_get_buf_size(p_ds),
ds_get_buf(p_ds), ds_get_buf(p_ds),
p_ds->p_stack_buf, p_ds->n_byte_stack_buf);
} /* end of function ds_print_info */
#endif /* DSTRING_UNIT_TEST */
Reference in New Issue View Git Blame Copy Permalink