#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include "libcob.h"
#include "coblocal.h"

Include dependency graph for strings.c:

Data Structures
struct	dlm_struct

Macros
#define	COB_LIB_EXPIMP

#define	INSPECT_ALL 0

#define	INSPECT_LEADING 1

#define	INSPECT_FIRST 2

#define	INSPECT_TRAILING 3

#define	DLM_DEFAULT_NUM 8U

Functions
static COB_INLINE int	cob_min_int (const int x, const int y)

static void	cob_str_memcpy (cob_field dst, unsigned char src, const int size)

static void	alloc_figurative (const cob_field f1, const cob_field f2)

static void	inspect_common (cob_field f1, cob_field f2, const int type)

void	cob_inspect_init (cob_field *var, const cob_u32_t replacing)

void	cob_inspect_start (void)

void	cob_inspect_before (const cob_field *str)

void	cob_inspect_after (const cob_field *str)

void	cob_inspect_characters (cob_field *f1)

void	cob_inspect_all (cob_field f1, cob_field f2)

void	cob_inspect_leading (cob_field f1, cob_field f2)

void	cob_inspect_first (cob_field f1, cob_field f2)

void	cob_inspect_trailing (cob_field f1, cob_field f2)

void	cob_inspect_converting (const cob_field f1, const cob_field f2)

void	cob_inspect_finish (void)

void	cob_string_init (cob_field dst, cob_field ptr)

void	cob_string_delimited (cob_field *dlm)

void	cob_string_append (cob_field *src)

void	cob_string_finish (void)

void	cob_unstring_init (cob_field src, cob_field ptr, const size_t num_dlm)

void	cob_unstring_delimited (cob_field *dlm, const cob_u32_t all)

void	cob_unstring_into (cob_field dst, cob_field dlm, cob_field *cnt)

void	cob_unstring_tallying (cob_field *f)

void	cob_unstring_finish (void)

void	cob_exit_strings (void)

void	cob_init_strings (void)

Variables
static const cob_field_attr	const_alpha_attr

static const cob_field_attr	const_strall_attr

static cob_field *	inspect_var

static unsigned char *	inspect_data

static unsigned char *	inspect_start

static unsigned char *	inspect_end

static int *	inspect_mark

static size_t	inspect_mark_size

static size_t	inspect_size

static cob_u32_t	inspect_replacing

static int	inspect_sign

static cob_field	inspect_var_copy

static cob_field *	string_dst

static cob_field *	string_ptr

static cob_field *	string_dlm

static cob_field	string_dst_copy

static cob_field	string_ptr_copy

static cob_field	string_dlm_copy

static int	string_offset

static struct dlm_struct *	dlm_list

static cob_field *	unstring_src

static cob_field *	unstring_ptr

static size_t	dlm_list_size

static cob_field	unstring_src_copy

static cob_field	unstring_ptr_copy

static int	unstring_offset

static int	unstring_count

static int	unstring_ndlms

static unsigned char *	figurative_ptr

static size_t	figurative_size

static cob_field	alpha_fld

static cob_field	str_cob_low

Macro Definition Documentation

#define COB_LIB_EXPIMP

#define DLM_DEFAULT_NUM 8U

Referenced by cob_init_strings().

#define INSPECT_ALL 0

Referenced by cob_inspect_all().

#define INSPECT_FIRST 2

Referenced by cob_inspect_first(), and inspect_common().

#define INSPECT_LEADING 1

Referenced by cob_inspect_leading(), and inspect_common().

#define INSPECT_TRAILING 3

Referenced by cob_inspect_trailing(), and inspect_common().

Function Documentation

static void alloc_figurative	(	const cob_field *	f1,
		const cob_field *	f2
	)

static

References cob_free(), cob_malloc(), cob_field::data, figurative_ptr, figurative_size, and cob_field::size.

Referenced by cob_inspect_converting(), and inspect_common().

 {
 
     unsigned char       *s;
     size_t          size1;
     size_t          size2;
     size_t          n;
 
     size2 = f2->size;
     if (size2 > figurative_size) {
         if (figurative_ptr) {
             cob_free (figurative_ptr);
         }
         figurative_ptr = cob_malloc (size2);
         figurative_size = size2;
     }
     size1 = 0;
     s = figurative_ptr;
     for (n = 0; n < size2; ++n, ++s) {
         *s = f1->data[size1];
         size1++;
         if (size1 >= f1->size) {
             size1 = 0;
         }
     }
     alpha_fld.size = size2;
     alpha_fld.data = figurative_ptr;
 }

void cob_exit_strings ( void )

References cob_free(), figurative_ptr, figurative_size, inspect_mark, and NULL.

Referenced by cob_terminate_routines().

 {
     if (inspect_mark) {
         cob_free (inspect_mark);
         inspect_mark = NULL;
     }
     if (dlm_list) {
         cob_free (dlm_list);
         dlm_list = NULL;
     }
     if (figurative_ptr) {
         cob_free (figurative_ptr);
         figurative_ptr = NULL;
     }
     figurative_size = 0;
 }

void cob_init_strings ( void )

References cob_field::attr, cob_malloc(), COB_NORMAL_BUFF, cob_u8_ptr, const_alpha_attr, const_strall_attr, cob_field::data, DLM_DEFAULT_NUM, dlm_list_size, figurative_ptr, figurative_size, inspect_mark, inspect_mark_size, NULL, and cob_field::size.

Referenced by cob_init().

 {
     inspect_mark = cob_malloc ((size_t)COB_NORMAL_BUFF);
     dlm_list = cob_malloc (DLM_DEFAULT_NUM * sizeof(struct dlm_struct));
     inspect_mark_size = COB_NORMAL_BUFF;
     dlm_list_size = DLM_DEFAULT_NUM;
     figurative_ptr = NULL;
     figurative_size = 0;
     alpha_fld.size = 0;
     alpha_fld.data = NULL;
     alpha_fld.attr = &const_alpha_attr;
     str_cob_low.size = 1;
     str_cob_low.data = (cob_u8_ptr)"\0";
     str_cob_low.attr = &const_strall_attr;
 }

void cob_inspect_after ( const cob_field * str )

References cob_field::data, inspect_end, inspect_start, p, and cob_field::size.

 {
     unsigned char   *p;
 
     for (p = inspect_start; p < inspect_end - str->size + 1; ++p) {
         if (memcmp (p, str->data, str->size) == 0) {
             inspect_start = p + str->size;
             return;
         }
     }
     inspect_start = inspect_end;
 }

void cob_inspect_all	(	cob_field *	f1,
		cob_field *	f2
	)

References INSPECT_ALL, and inspect_common().

 {
     inspect_common (f1, f2, INSPECT_ALL);
 }

void cob_inspect_before ( const cob_field * str )

References cob_field::data, inspect_end, inspect_start, p, and cob_field::size.

 {
     unsigned char   *p;
 
     for (p = inspect_start; p < inspect_end - str->size + 1; ++p) {
         if (memcmp (p, str->data, str->size) == 0) {
             inspect_end = p;
             return;
         }
     }
 }

void cob_inspect_characters ( cob_field * f1 )

References cob_add_int(), cob_field::data, inspect_data, inspect_end, inspect_mark, inspect_replacing, and inspect_start.

 {
     int *mark;
     int i;
     int n;
     int len;
 
     mark = &inspect_mark[inspect_start - inspect_data];
     len = (int)(inspect_end - inspect_start);
     if (inspect_replacing) {
         /* INSPECT REPLACING CHARACTERS f1 */
         for (i = 0; i < len; ++i) {
             if (mark[i] == -1) {
                 mark[i] = f1->data[0];
             }
         }
     } else {
         /* INSPECT TALLYING f1 CHARACTERS */
         n = 0;
         for (i = 0; i < len; ++i) {
             if (mark[i] == -1) {
                 mark[i] = 1;
                 n++;
             }
         }
         if (n > 0) {
             cob_add_int (f1, n, 0);
         }
     }
 }

void cob_inspect_converting	(	const cob_field *	f1,
		const cob_field *	f2
	)

References alloc_figurative(), alpha_fld, COB_FIELD_TYPE, cob_set_exception(), COB_TYPE_ALPHANUMERIC_ALL, cob_field::data, inspect_end, inspect_mark, inspect_start, cob_field::size, str_cob_low, and unlikely.

 {
     size_t  i;
     size_t  j;
     size_t  len;
 
     if (unlikely(!f1)) {
         f1 = &str_cob_low;
     }
     if (unlikely(!f2)) {
         f2 = &str_cob_low;
     }
     if (f1->size != f2->size) {
         if (COB_FIELD_TYPE (f2) == COB_TYPE_ALPHANUMERIC_ALL) {
             alloc_figurative (f2, f1);
             f2 = &alpha_fld;
         } else {
             cob_set_exception (COB_EC_RANGE_INSPECT_SIZE);
             return;
         }
     }
 
     len = (size_t)(inspect_end - inspect_start);
     for (j = 0; j < f1->size; ++j) {
         for (i = 0; i < len; ++i) {
             if (inspect_mark[i] == -1 &&
                 inspect_start[i] == f1->data[j]) {
                 inspect_start[i] = f2->data[j];
                 inspect_mark[i] = 1;
             }
         }
     }
 }

void cob_inspect_finish ( void )

References COB_PUT_SIGN, inspect_data, inspect_mark, inspect_replacing, inspect_sign, inspect_size, and unlikely.

 {
     size_t  i;
 
     if (inspect_replacing) {
         for (i = 0; i < inspect_size; ++i) {
             if (inspect_mark[i] != -1) {
                 inspect_data[i] = inspect_mark[i];
             }
         }
     }
 
     if (unlikely(inspect_var)) {
         COB_PUT_SIGN (inspect_var, inspect_sign);
     }
 }

void cob_inspect_first	(	cob_field *	f1,
		cob_field *	f2
	)

References inspect_common(), and INSPECT_FIRST.

 {
     inspect_common (f1, f2, INSPECT_FIRST);
 }

void cob_inspect_init	(	cob_field *	var,
		const cob_u32_t	replacing
	)

References cob_fast_malloc(), COB_FIELD_DATA, COB_FIELD_IS_NUMDISP, COB_FIELD_SIZE, cob_free(), COB_GET_SIGN, cob_set_exception(), inspect_data, inspect_end, inspect_mark, inspect_mark_size, inspect_replacing, inspect_sign, inspect_size, inspect_start, inspect_var_copy, NULL, and unlikely.

 {
     size_t      i;
     size_t      digcount;
 
     if (unlikely(COB_FIELD_IS_NUMDISP (var))) {
         inspect_var_copy = *var;
         inspect_var = &inspect_var_copy;
         inspect_sign = COB_GET_SIGN (var);
     } else {
         inspect_var = NULL;
     }
     inspect_size = COB_FIELD_SIZE (var);
     inspect_data = COB_FIELD_DATA (var);
     inspect_replacing = replacing;
     inspect_start = NULL;
     inspect_end = NULL;
     digcount = inspect_size * sizeof (int);
     if (digcount > inspect_mark_size) {
         if (inspect_mark) {
             cob_free (inspect_mark);
         }
         inspect_mark = cob_fast_malloc (digcount);
         inspect_mark_size = digcount;
     }
     for (i = 0; i < inspect_size; ++i) {
         inspect_mark[i] = -1;
     }
     cob_set_exception (0);
 }

void cob_inspect_leading	(	cob_field *	f1,
		cob_field *	f2
	)

References inspect_common(), and INSPECT_LEADING.

 {
     inspect_common (f1, f2, INSPECT_LEADING);
 }

void cob_inspect_start ( void )

References inspect_data, inspect_end, inspect_size, and inspect_start.

 {
     inspect_start = inspect_data;
     inspect_end = inspect_data + inspect_size;
 }

void cob_inspect_trailing	(	cob_field *	f1,
		cob_field *	f2
	)

References inspect_common(), and INSPECT_TRAILING.

 {
     inspect_common (f1, f2, INSPECT_TRAILING);
 }

static COB_INLINE int cob_min_int	(	const int	x,
		const int	y
	)

static

Referenced by cob_unstring_into().

 {
     if (x < y) {
         return x;
     }
     return y;
 }

static void cob_str_memcpy	(	cob_field *	dst,
		unsigned char *	src,
		const int	size
	)

static

References cob_field::attr, cob_move(), const_alpha_attr, cob_field::data, and cob_field::size.

Referenced by cob_unstring_into().

 {
     cob_field   temp;
 
     temp.size = size;
     temp.data = src;
     temp.attr = &const_alpha_attr;
     cob_move (&temp, dst);
 }

void cob_string_append ( cob_field * src )

References COB_EC_OVERFLOW_STRING, cob_get_exception_code(), cob_set_exception(), cob_field::data, cob_field::size, and string_offset.

 {
     size_t  src_size;
     int i;
     int size;
 
     if (cob_get_exception_code ()) {
         return;
     }
 
     src_size = src->size;
     if (!src_size) {
         return;
     }
     if (string_dlm) {
         size = (int)(src_size - string_dlm->size + 1);
         for (i = 0; i < size; ++i) {
             if (memcmp (src->data + i, string_dlm->data,
                     string_dlm->size) == 0) {
                 src_size = i;
                 break;
             }
         }
     }
 
     if (src_size <= string_dst->size - string_offset) {
         memcpy (string_dst->data + string_offset, src->data, src_size);
         string_offset += (int) src_size;
     } else {
         size = (int)(string_dst->size - string_offset);
         memcpy (string_dst->data + string_offset, src->data, (size_t)size);
         string_offset += size;
         cob_set_exception (COB_EC_OVERFLOW_STRING);
     }
 }

void cob_string_delimited ( cob_field * dlm )

References NULL, and string_dlm_copy.

 {
     string_dlm = NULL;
     if (dlm) {
         string_dlm_copy = *dlm;
         string_dlm = &string_dlm_copy;
     }
 }

void cob_string_finish ( void )

References cob_set_int(), and string_offset.

 {
     if (string_ptr) {
         cob_set_int (string_ptr, string_offset + 1);
     }
 }

void cob_string_init	(	cob_field *	dst,
		cob_field *	ptr
	)

References COB_EC_OVERFLOW_STRING, cob_get_int(), cob_set_exception(), NULL, cob_field::size, string_dst_copy, string_offset, and string_ptr_copy.

 {
     string_dst_copy = *dst;
     string_dst = &string_dst_copy;
     string_ptr = NULL;
     if (ptr) {
         string_ptr_copy = *ptr;
         string_ptr = &string_ptr_copy;
     }
     string_offset = 0;
     cob_set_exception (0);
 
     if (string_ptr) {
         string_offset = cob_get_int (string_ptr) - 1;
         if (string_offset < 0 ||
             string_offset >= (int)string_dst->size) {
             cob_set_exception (COB_EC_OVERFLOW_STRING);
         }
     }
 }

void cob_unstring_delimited	(	cob_field *	dlm,
		const cob_u32_t	all
	)

References dlm_struct::uns_all, dlm_struct::uns_dlm, and unstring_ndlms.

 {
     dlm_list[unstring_ndlms].uns_dlm = *dlm;
     dlm_list[unstring_ndlms].uns_all = all;
     unstring_ndlms++;
 }

void cob_unstring_finish ( void )

References cob_set_exception(), cob_set_int(), cob_field::size, and unstring_offset.

 {
     if (unstring_offset < (int)unstring_src->size) {
         cob_set_exception (COB_EC_OVERFLOW_UNSTRING);
     }
 
     if (unstring_ptr) {
         cob_set_int (unstring_ptr, unstring_offset + 1);
     }
 }

void cob_unstring_init	(	cob_field *	src,
		cob_field *	ptr,
		const size_t	num_dlm
	)

References cob_free(), cob_get_int(), cob_malloc(), cob_set_exception(), dlm_list_size, NULL, cob_field::size, unstring_count, unstring_ndlms, unstring_offset, unstring_ptr_copy, and unstring_src_copy.

 {
     unstring_src_copy = *src;
     unstring_src = &unstring_src_copy;
     unstring_ptr = NULL;
     if (ptr) {
         unstring_ptr_copy = *ptr;
         unstring_ptr = &unstring_ptr_copy;
     }
 
     unstring_offset = 0;
     unstring_count = 0;
     unstring_ndlms = 0;
     cob_set_exception (0);
     if (num_dlm > dlm_list_size) {
         cob_free (dlm_list);
         dlm_list = cob_malloc (num_dlm * sizeof(struct dlm_struct));
         dlm_list_size = num_dlm;
     }
 
     if (unstring_ptr) {
         unstring_offset = cob_get_int (unstring_ptr) - 1;
         if (unstring_offset < 0 || unstring_offset >= (int)unstring_src->size) {
             cob_set_exception (COB_EC_OVERFLOW_UNSTRING);
         }
     }
 }

void cob_unstring_into	(	cob_field *	dst,
		cob_field *	dlm,
		cob_field *	cnt
	)

References COB_FIELD_IS_NUMERIC, COB_FIELD_SIZE, cob_get_exception_code(), cob_min_int(), cob_set_int(), cob_str_memcpy(), cob_field::data, if(), NULL, p, cob_field::size, dlm_struct::uns_all, dlm_struct::uns_dlm, unstring_count, unstring_ndlms, and unstring_offset.

 {
     unsigned char   *p;
     unsigned char   *dp;
     unsigned char   *s;
     unsigned char   *dlm_data;
     unsigned char   *start;
     size_t      dlm_size = 0;
     int     i;
     int     srsize;
     int     dlsize;
     int     match_size = 0;
     int     brkpt = 0;
 
     if (cob_get_exception_code ()) {
         return;
     }
 
     if (unstring_offset >= (int)unstring_src->size) {
         return;
     }
 
     start = unstring_src->data + unstring_offset;
     dlm_data = NULL;
     if (unstring_ndlms == 0) {
         match_size = cob_min_int ((int)COB_FIELD_SIZE (dst),
                       (int)unstring_src->size - unstring_offset);
         cob_str_memcpy (dst, start, match_size);
         unstring_offset += match_size;
     } else {
         srsize = (int) unstring_src->size;
         s = unstring_src->data + srsize;
         for (p = start; p < s; ++p) {
             for (i = 0; i < unstring_ndlms; ++i) {
                 dlsize = (int) dlm_list[i].uns_dlm.size;
                 dp = dlm_list[i].uns_dlm.data;
                 if (p + dlsize > s) {
                     continue;
                 }
                 if (!memcmp (p, dp, (size_t)dlsize)) {             /* delimiter equal */         
                     match_size = (int)(p - start);             /* count in */
                     cob_str_memcpy (dst, start, match_size);   /* into */
                     unstring_offset += match_size + dlsize;    /* with pointer */
                     dlm_data = dp;
                     dlm_size = dlsize;
                     if (dlm_list[i].uns_all) {                 /* delimited by all */
                         for (p += dlsize ; p < s; p += dlsize) { 
                             if (p + dlsize > s) {
                                 break;
                             }
                             if (memcmp (p, dp, (size_t)dlsize)) {
                                 break;
                             }
                             unstring_offset += dlsize;
                         }
                     }
                     brkpt = 1;
                     break;
                 }
             }
             if (brkpt) {
                 break;
             }
         }
         if (!brkpt) {
             /* No match */
             match_size = (int)(unstring_src->size - unstring_offset);
             cob_str_memcpy (dst, start, match_size);
             unstring_offset = (int) unstring_src->size;
             dlm_data = NULL;
         }
     }
     unstring_count++;
 
     if (dlm) {
         if (dlm_data) {
             cob_str_memcpy (dlm, dlm_data, (int) dlm_size);
         } else if (COB_FIELD_IS_NUMERIC (dlm)) {
             cob_set_int (dlm, 0);
         } else {
             memset (dlm->data, ' ', dlm->size);
         }
     }
 
     if (cnt) {
         cob_set_int (cnt, match_size);
     }
 }

void cob_unstring_tallying ( cob_field * f )

References cob_add_int(), and unstring_count.

 {
     cob_add_int (f, unstring_count, 0);
 }

static void inspect_common	(	cob_field *	f1,
		cob_field *	f2,
		const int	type
	)

static

References alloc_figurative(), alpha_fld, cob_add_int(), COB_FIELD_TYPE, cob_set_exception(), COB_TYPE_ALPHANUMERIC_ALL, cob_field::data, inspect_data, inspect_end, INSPECT_FIRST, INSPECT_LEADING, inspect_mark, inspect_replacing, inspect_start, INSPECT_TRAILING, cob_field::size, str_cob_low, and unlikely.

Referenced by cob_inspect_all(), cob_inspect_first(), cob_inspect_leading(), and cob_inspect_trailing().

 {
     int     *mark;
     size_t      n = 0;
     size_t      j;
     int     i;
     int     len;
 
     if (unlikely(!f1)) {
         f1 = &str_cob_low;
     }
     if (unlikely(!f2)) {
         f2 = &str_cob_low;
     }
 
     if (inspect_replacing && f1->size != f2->size) {
         if (COB_FIELD_TYPE (f1) == COB_TYPE_ALPHANUMERIC_ALL) {
             alloc_figurative (f1, f2);
             f1 = &alpha_fld;
         } else {
             cob_set_exception (COB_EC_RANGE_INSPECT_SIZE);
             return;
         }
     }
 
     mark = &inspect_mark[inspect_start - inspect_data];
     len = (int)(inspect_end - inspect_start);
     if (type == INSPECT_TRAILING) {
         for (i = len - (int)f2->size; i >= 0; --i) {
             /* Find matching substring */
             if (memcmp (inspect_start + i, f2->data, f2->size) == 0) {
                 /* Check if it is already marked */
                 for (j = 0; j < f2->size; ++j) {
                     if (mark[i + j] != -1) {
                         break;
                     }
                 }
                 /* If not, mark and count it */
                 if (j == f2->size) {
                     for (j = 0; j < f2->size; ++j) {
                         mark[i + j] = inspect_replacing ? f1->data[j] : 1;
                     }
                     i -= f2->size - 1;
                     n++;
                 }
             } else {
                 break;
             }
         }
     } else {
         for (i = 0; i < (int)(len - f2->size + 1); ++i) {
             /* Find matching substring */
             if (memcmp (inspect_start + i, f2->data, f2->size) == 0) {
                 /* Check if it is already marked */
                 for (j = 0; j < f2->size; ++j) {
                     if (mark[i + j] != -1) {
                         break;
                     }
                 }
                 /* If not, mark and count it */
                 if (j == f2->size) {
                     for (j = 0; j < f2->size; ++j) {
                         mark[i + j] = inspect_replacing ? f1->data[j] : 1;
                     }
                     i += f2->size - 1;
                     n++;
                     if (type == INSPECT_FIRST) {
                         break;
                     }
                 }
             } else if (type == INSPECT_LEADING) {
                 break;
             }
         }
     }
 
     if (n > 0 && !inspect_replacing) {
         cob_add_int (f1, (int) n, 0);
     }
 }