void cob_unstring_delimited (cob_field *dlm, const int all) { cob_field *add_dlm = NULL; if (COB_FIELD_TYPE (unstring_src) == COB_TYPE_NATIONAL || COB_FIELD_TYPE (unstring_src) == COB_TYPE_NATIONAL_EDITED) { if (dlm == &cob_quote) { dlm = &cob_zen_quote; } else if (dlm == &cob_space) { dlm = &cob_zen_space; add_dlm = &cob_zen_blank; } else if (dlm == &cob_zero) { dlm = &cob_zen_zero; } } dlm_list[unstring_ndlms].uns_dlm = *dlm; dlm_list[unstring_ndlms].uns_all = all; unstring_ndlms++; if (add_dlm) { dlm_list[unstring_ndlms].uns_dlm = *add_dlm; dlm_list[unstring_ndlms].uns_all = all; unstring_ndlms++; } }
void cob_string_init (cob_field *dst, cob_field *ptr) { 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_exception_code = 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); } } #ifdef I18N_UTF8 /* I18N_UTF8: No offset arrangement needed also in NATIONAL. */ #else /*!I18N_UTF8*/ if (COB_FIELD_TYPE (string_dst) == COB_TYPE_NATIONAL || COB_FIELD_TYPE (string_dst) == COB_TYPE_NATIONAL_EDITED) { string_offset *= 2; } #endif /*I18N_UTF8*/ }
static int cob_cmp_alnum (cob_field *f1, cob_field *f2) { const unsigned char *s; size_t min; int ret; int sign1; int sign2; sign1 = cob_get_sign (f1); sign2 = cob_get_sign (f2); min = (f1->size < f2->size) ? f1->size : f2->size; s = cob_current_module->collating_sequence; /* compare common substring */ if ((ret = common_cmps (f1->data, f2->data, min, s)) != 0) { goto end; } /* compare the rest (if any) with spaces */ if (f1->size > f2->size) { ret = common_cmpc (f1->data + min, ' ', f1->size - min); } else if (f1->size < f2->size) { ret = -common_cmpc (f2->data + min, ' ', f2->size - min); } end: if (COB_FIELD_TYPE (f1) != COB_TYPE_NUMERIC_PACKED) { cob_put_sign (f1, sign1); } if (COB_FIELD_TYPE (f2) != COB_TYPE_NUMERIC_PACKED) { cob_put_sign (f2, sign2); } return ret; }
static void display (cob_field *f, FILE *fp) { if (COB_FIELD_TYPE (f) == COB_TYPE_NUMERIC_DOUBLE) { double f1doub; memcpy ((char *)&f1doub, f->data, sizeof (double)); fprintf (fp, "%-.18lf", f1doub); } else if (COB_FIELD_TYPE (f) == COB_TYPE_NUMERIC_FLOAT) { float f1float; memcpy ((char *)&f1float, f->data, sizeof (float)); fprintf (fp, "%-.18lf", (double)f1float); } else if (COB_FIELD_TYPE(f) == COB_TYPE_NUMERIC_BINARY && !cob_current_module->flag_pretty_display) { cob_field_attr attr = *f->attr; cob_field temp = *f; attr.digits = bin_digits[f->size]; temp.attr = &attr; display_numeric (&temp, fp); } else if (COB_FIELD_IS_NUMERIC (f)) { if (cob_current_module->flag_pretty_display) { pretty_display_numeric (f, fp); } else { display_numeric (f, fp); } } else { display_alnum (f, fp); } }
int cob_cmp (cob_field *f1, cob_field *f2) { cob_field temp; cob_field_attr attr; unsigned char buff[48]; if (COB_FIELD_IS_NUMERIC (f1) && COB_FIELD_IS_NUMERIC (f2)) { return cob_numeric_cmp (f1, f2); } if (COB_FIELD_TYPE (f2) == COB_TYPE_ALPHANUMERIC_ALL) { if (f2 == &cob_zero && COB_FIELD_IS_NUMERIC (f1)) { return cob_cmp_int (f1, 0); } else if (f2->size == 1) { return cob_cmp_char (f1, f2->data[0]); } else { return cob_cmp_all (f1, f2); } } else if (COB_FIELD_TYPE (f1) == COB_TYPE_ALPHANUMERIC_ALL) { if (f1 == &cob_zero && COB_FIELD_IS_NUMERIC (f2)) { return -cob_cmp_int (f2, 0); } else if (f1->size == 1) { return -cob_cmp_char (f2, f1->data[0]); } else { return -cob_cmp_all (f2, f1); } } else { if (COB_FIELD_IS_NUMERIC (f1) && COB_FIELD_TYPE (f1) != COB_TYPE_NUMERIC_DISPLAY) { temp.size = COB_FIELD_DIGITS(f1); temp.data = buff; temp.attr = &attr; attr = *f1->attr; attr.type = COB_TYPE_NUMERIC_DISPLAY; attr.flags &= ~COB_FLAG_HAVE_SIGN; cob_move (f1, &temp); f1 = &temp; } if (COB_FIELD_IS_NUMERIC (f2) && COB_FIELD_TYPE (f2) != COB_TYPE_NUMERIC_DISPLAY) { temp.size = COB_FIELD_DIGITS(f2); temp.data = buff; temp.attr = &attr; attr = *f2->attr; attr.type = COB_TYPE_NUMERIC_DISPLAY; attr.flags &= ~COB_FLAG_HAVE_SIGN; cob_move (f2, &temp); f2 = &temp; } return cob_cmp_alnum (f1, f2); } }
void cob_unstring_init (cob_field *src, cob_field *ptr, const size_t num_dlm) { static size_t udlmcount = 0; 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_exception_code = 0; if (!dlm_list) { if (num_dlm <= DLM_DEFAULT_NUM) { dlm_list = cob_malloc (DLM_DEFAULT_NUM * sizeof(struct dlm_struct)); udlmcount = DLM_DEFAULT_NUM; } else { dlm_list = cob_malloc (num_dlm * sizeof(struct dlm_struct)); udlmcount = num_dlm; } } else { if (num_dlm > udlmcount) { free (dlm_list); dlm_list = cob_malloc (num_dlm * sizeof(struct dlm_struct)); udlmcount = 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); } } #ifdef I18N_UTF8 /* I18N_UTF8: No offset arrangement needed also in NATIONAL. */ #else /*!I18N_UTF8*/ if (COB_FIELD_TYPE (unstring_src) == COB_TYPE_NATIONAL || COB_FIELD_TYPE (unstring_src) == COB_TYPE_NATIONAL_EDITED) { unstring_offset *= 2; } #endif /*I18N_UTF8*/ }
void cob_string_finish (void) { #ifdef I18N_UTF8 /* I18N_UTF8: No offset arrangement needed also in NATIONAL. */ #else /*!I18N_UTF8*/ if (COB_FIELD_TYPE (string_dst) == COB_TYPE_NATIONAL || COB_FIELD_TYPE (string_dst) == COB_TYPE_NATIONAL_EDITED) { string_offset /= 2; } #endif /*I18N_UTF8*/ if (string_ptr) { cob_set_int (string_ptr, string_offset + 1); } }
void cob_inspect_converting (const cob_field *f1, const cob_field *f2) { 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; } } } }
static void display_numeric (cob_field *f, FILE *fp) { int i; int digits; int scale; int size; cob_field_attr attr; cob_field temp; unsigned char data[128]; digits = COB_FIELD_DIGITS (f); scale = COB_FIELD_SCALE (f); size = digits + (COB_FIELD_HAVE_SIGN (f) ? 1 : 0); COB_ATTR_INIT (COB_TYPE_NUMERIC_DISPLAY, digits, scale, 0, NULL); temp.size = size; temp.data = data; temp.attr = &attr; if (COB_FIELD_HAVE_SIGN (f)) { attr.flags = COB_FLAG_HAVE_SIGN | COB_FLAG_SIGN_SEPARATE; if (COB_FIELD_SIGN_LEADING (f) || COB_FIELD_TYPE (f) == COB_TYPE_NUMERIC_BINARY) { attr.flags |= COB_FLAG_SIGN_LEADING; } } cob_move (f, &temp); for (i = 0; i < size; i++) { putc (data[i], fp); } }
static int cob_cmp_all (cob_field *f1, cob_field *f2) { unsigned char *data; const unsigned char *s; size_t size; int ret; int sign; size = f1->size; data = f1->data; sign = cob_get_sign (f1); ret = 0; s = cob_current_module->collating_sequence; while (size >= f2->size) { if ((ret = common_cmps (data, f2->data, f2->size, s)) != 0) { goto end; } size -= f2->size; data += f2->size; } if (size > 0) { ret = common_cmps (data, f2->data, size, s); } end: if (COB_FIELD_TYPE (f1) != COB_TYPE_NUMERIC_PACKED) { cob_put_sign (f1, sign); } return ret; }
void cob_inspect_characters (cob_field *f1) { int *mark; int i; int j; 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) { for (j = 0; j < f1->size; j++) { mark[i+j] = f1->data[j]; } i += f1->size-1; } } } else { /* INSPECT TALLYING f1 CHARACTERS */ n = 0; for (i = 0; i < len; i++) { if (mark[i] == -1) { mark[i] = 1; n++; } } if (n > 0) { #ifdef I18N_UTF8 /* I18N_UTF8: count bytes also in NATIONAL. */ #else /*!I18N_UTF8*/ if (COB_FIELD_TYPE (inspect_var) == COB_TYPE_NATIONAL || COB_FIELD_TYPE (inspect_var) == COB_TYPE_NATIONAL_EDITED) { n = n / 2; } #endif /*I18N_UTF8*/ cob_add_int (f1, n); } } }
int cob_is_numeric (cob_field *f) { unsigned char *data; size_t size; size_t i; int sign; switch (COB_FIELD_TYPE (f)) { case COB_TYPE_NUMERIC_BINARY: case COB_TYPE_NUMERIC_FLOAT: case COB_TYPE_NUMERIC_DOUBLE: return 1; case COB_TYPE_NUMERIC_PACKED: /* check digits */ for (i = 0; i < f->size - 1; ++i) { if ((f->data[i] & 0xf0) > 0x90 || (f->data[i] & 0x0f) > 0x09) { return 0; } } if ((f->data[i] & 0xf0) > 0x90) { return 0; } /* check sign */ sign = f->data[i] & 0x0f; if (sign == 0x0f) { return 1; } if (COB_FIELD_HAVE_SIGN (f)) { if (sign == 0x0c || sign == 0x0d) { return 1; } } return 0; case COB_TYPE_NUMERIC_DISPLAY: data = COB_FIELD_DATA (f); size = COB_FIELD_SIZE (f); sign = cob_get_sign (f); for (i = 0; i < size; ++i) { if (!isdigit (data[i])) { cob_put_sign (f, sign); return 0; } } cob_put_sign (f, sign); return 1; default: for (i = 0; i < f->size; ++i) { if (!isdigit (f->data[i])) { return 0; } } return 1; } }
void cob_unstring_finish (void) { if (unstring_offset < (int)unstring_src->size) { cob_set_exception (COB_EC_OVERFLOW_UNSTRING); } #ifdef I18N_UTF8 /* I18N_UTF8: No offset arrangement needed also in NATIONAL. */ #else /*!I18N_UTF8*/ if (COB_FIELD_TYPE (unstring_src) == COB_TYPE_NATIONAL || COB_FIELD_TYPE (unstring_src) == COB_TYPE_NATIONAL_EDITED) { unstring_offset /= 2; } #endif /*I18N_UTF8*/ if (unstring_ptr) { cob_set_int (unstring_ptr, unstring_offset + 1); } }
void cob_string_delimited (cob_field *dlm) { if (COB_FIELD_TYPE (string_dst) == COB_TYPE_NATIONAL || COB_FIELD_TYPE (string_dst) == COB_TYPE_NATIONAL_EDITED) { if (dlm == &cob_quote) { dlm = &cob_zen_quote; } else if (dlm == &cob_space) { dlm = &cob_zen_space; } else if (dlm == &cob_zero) { dlm = &cob_zen_zero; } } string_dlm = NULL; if (dlm) { string_dlm_copy = *dlm; string_dlm = &string_dlm_copy; } }
static int cob_cmp_char (cob_field *f, const unsigned int c) { int sign; int ret; sign = cob_get_sign (f); ret = common_cmpc (f->data, c, f->size); if (COB_FIELD_TYPE (f) != COB_TYPE_NUMERIC_PACKED) { cob_put_sign (f, sign); } return ret; }
void cob_inspect_before (const cob_field *str) { unsigned char *p; unsigned char *data; size_t size; int sign; char *buf = NULL; unsigned char *p2; unsigned int n; int fig; switch (COB_FIELD_TYPE (str)) { case COB_TYPE_NUMERIC_DISPLAY: data = COB_FIELD_DATA (str); size = COB_FIELD_SIZE (str); sign = cob_get_sign ((cob_field *)str); n = 0; fig = 0; while (size > 1 && *data == '0') { size--; data++; } while (size--) { n = n * 10 + cob_d2i (*data++); fig++; } buf = cob_malloc (fig); sprintf (buf, "%d", n); p2 = (unsigned char *)buf; break; default: fig = str->size; p2 = str->data; break; } for (p = inspect_start; p < inspect_end - fig + 1; p++) { if (memcmp (p, p2, fig) == 0) { inspect_end = p; break; } } if (buf) { free (buf); } }
void cob_real_put_sign (cob_field *f, const int sign) { unsigned char *p; int c; switch (COB_FIELD_TYPE (f)) { case COB_TYPE_NUMERIC_DISPLAY: /* locate sign */ if (unlikely(COB_FIELD_SIGN_LEADING (f))) { p = f->data; } else { p = f->data + f->size - 1; } /* put sign */ if (unlikely(COB_FIELD_SIGN_SEPARATE (f))) { c = (sign < 0) ? '-' : '+'; if (*p != c) { *p = c; } } else if (unlikely(cob_current_module->display_sign)) { cob_put_sign_ebcdic (p, sign); } else if (sign < 0) { #ifdef COB_EBCDIC_MACHINE cob_put_sign_ascii (p); #else PUT_SIGN_ASCII (*p); #endif } return; case COB_TYPE_NUMERIC_PACKED: p = f->data + f->size - 1; if (sign < 0) { *p = (*p & 0xf0) | 0x0d; } else { *p = (*p & 0xf0) | 0x0c; } return; default: return; } }
int cob_real_get_sign (cob_field *f) { unsigned char *p; switch (COB_FIELD_TYPE (f)) { case COB_TYPE_NUMERIC_DISPLAY: /* locate sign */ if (unlikely(COB_FIELD_SIGN_LEADING (f))) { p = f->data; } else { p = f->data + f->size - 1; } /* get sign */ if (unlikely(COB_FIELD_SIGN_SEPARATE (f))) { return (*p == '+') ? 1 : -1; } else { if (*p >= '0' && *p <= '9') { return 1; } if (*p == ' ') { *p = (unsigned char)'0'; return 1; } if (unlikely(cob_current_module->display_sign)) { return cob_get_sign_ebcdic (p); } else { #ifdef COB_EBCDIC_MACHINE cob_get_sign_ascii (p); #else GET_SIGN_ASCII (*p); #endif return -1; } } case COB_TYPE_NUMERIC_PACKED: p = f->data + f->size - 1; return ((*p & 0x0f) == 0x0d) ? -1 : 1; default: return 0; } }
static void COB_NOINLINE cob_check_pos_status (int fret) { cob_field *f; int sline; int scolumn; char datbuf[8]; if (fret) { cob_set_exception (COB_EC_IMP_ACCEPT); } if (cob_current_module->crt_status) { if (COB_FIELD_IS_NUMERIC (cob_current_module->crt_status)) { cob_set_int (cob_current_module->crt_status, fret); } else { sprintf(datbuf, "%4.4d", fret); memcpy (cob_current_module->crt_status->data, datbuf, 4); } } if (cob_current_module->cursor_pos) { getyx (stdscr, sline, scolumn); f = cob_current_module->cursor_pos; if (COB_FIELD_IS_NUMERIC (f) && COB_FIELD_TYPE (f) != COB_TYPE_NUMERIC_DISPLAY) { sline *= 1000; sline += scolumn; cob_set_int (f, sline); } else { if (f->size < 6) { sline *= 100; sline += scolumn; sprintf(datbuf, "%4.4d", sline); memcpy (f->data, datbuf, 4); } else { sline *= 1000; sline += scolumn; sprintf(datbuf, "%6.6d", sline); memcpy (f->data, datbuf, 6); } } } }
static void inspect_common (cob_field *f1, cob_field *f2, const int type) { 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); } }
void cob_inspect_converting (const cob_field *f1, const cob_field *f2) { size_t i; size_t j; size_t len; #ifdef I18N_UTF8 const int mark_wait[6] = {-1, -1, -1, -1, -1, -1}; const int mark_done[6] = { 1, 1, 1, 1, 1, 1}; size_t nc1; size_t nc2; size_t nc3; const cob_field *fig_const = NULL; const cob_field *fig_constw = NULL; unsigned char *pdata; char buf1[8]; /* for error message */ char buf2[8]; /* for error message */ #endif /*!I18N_UTF8*/ len = (size_t)(inspect_end - inspect_start); #ifdef I18N_UTF8 if (f2 == &cob_quote) { fig_const = &cob_quote; fig_constw = &cob_zen_quote; } else if (f2 == &cob_space) { fig_const = &cob_space; fig_constw = &cob_zen_space; } else if (f2 == &cob_zero) { fig_const = &cob_zero; fig_constw = &cob_zen_zero; } for (j = 0; j < f1->size; j += nc1) { if (!(nc1 = COB_U8BYTE_1 (f1->data[j]))) { cob_runtime_error ( "Unexpected char X(%02X) in INSPECT CONVERTING (value before)", f1->data[j]); cob_stop_run (1); } else if (fig_const) { /* iteratively map to figurative */ } else if (!(nc2 = COB_U8BYTE_1 (f2->data[j]))) { cob_runtime_error ( "Unexpected char X(%02X) in INSPECT CONVERTING (value after)", f2->data[j]); cob_stop_run (1); } else if (nc1 != nc2) { memset (buf1, 0, sizeof (buf1)); memset (buf2, 0, sizeof (buf2)); memcpy (buf1, &(f1->data[j]), nc1); memcpy (buf2, &(f2->data[j]), nc2); cob_runtime_error ( "'%s' char width (%d) to '%s' char width (%d) mismatch", buf1, nc1, buf2, nc2); cob_stop_run (1); } for (i = 0; i < len; i += nc3) { if (!(nc3 = COB_U8BYTE_1 (inspect_start[i]))) { cob_runtime_error ( "Unexpected char X(%02X) in INSPECT field", inspect_start[i]); cob_stop_run (1); } if (nc1 == nc3 && !memcmp (&(inspect_mark[i]), mark_wait, nc1) && !memcmp (&(inspect_start[i]), &(f1->data[j]), nc1)) { if (!fig_const) { pdata = &(f2->data[j]); } else if (nc1 == 1) { pdata = fig_const->data; } else if (nc1 == COB_U8CSIZ) { pdata = fig_constw->data; } else { memset (buf1, 0, sizeof (buf1)); memcpy (buf1, &(f1->data[j]), nc1); cob_runtime_error ( "'%s' char width (%d) mismatch", buf1, nc1); cob_stop_run (1); } memcpy (&(inspect_start[i]), pdata, nc1); memcpy (&(inspect_mark[i]), mark_done, nc1); } } } #else /*!I18N_UTF8*/ if (COB_FIELD_TYPE (f1) == COB_TYPE_NATIONAL || COB_FIELD_TYPE (f1) == COB_TYPE_NATIONAL_EDITED) { if (f2 == &cob_quote) { f2 = &cob_zen_quote; } else if (f2 == &cob_space) { f2 = &cob_zen_space; } else if (f2 == &cob_zero) { f2 = &cob_zen_zero; } for (j = 0; j < f1->size; j += 2) { for (i = 0; i < len; i += 2) { if (inspect_mark[i] == -1 && inspect_mark[i+1] == -1 && memcmp (&inspect_start[i], &(f1->data[j]), 2) == 0) { if (f2 == &cob_zen_quote || f2 == &cob_zen_space || f2 == &cob_zen_zero) { inspect_start[i] = f2->data[0]; inspect_start[i+1] = f2->data[1]; } else { inspect_start[i] = f2->data[j]; inspect_start[i+1] = f2->data[j+1]; } inspect_mark[i] = 1; inspect_mark[i+1] = 1; } } } } else { for (j = 0; j < f1->size; j++) { for (i = 0; i < len; i++) { if (inspect_mark[i] == -1 && inspect_start[i] == f1->data[j]) { if (f2 == &cob_quote || f2 == &cob_space || f2 == &cob_zero) { inspect_start[i] = f2->data[0]; } else { inspect_start[i] = f2->data[j]; } inspect_mark[i] = 1; } } } } #endif /*I18N_UTF8*/ }
void cob_unstring_into (cob_field *dst, cob_field *dlm, cob_field *cnt) { 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_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_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)) { match_size = (int)(p - start); cob_memcpy (dst, start, match_size); unstring_offset += match_size + dlsize; dlm_data = dp; dlm_size = dlsize; if (dlm_list[i].uns_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; } } #ifdef I18N_UTF8 /* I18N_UTF8: No offset arrangement needed also in NATIONAL. */ #else /*!I18N_UTF8*/ if (COB_FIELD_TYPE (unstring_src) == COB_TYPE_NATIONAL || COB_FIELD_TYPE (unstring_src) == COB_TYPE_NATIONAL_EDITED) { p++; } #endif /*I18N_UTF8*/ if (brkpt) { break; } } if (!brkpt) { /* no match */ match_size = (int)(unstring_src->size - unstring_offset); cob_memcpy (dst, start, match_size); unstring_offset = (int) unstring_src->size; dlm_data = NULL; } } unstring_count++; if (dlm) { if (dlm_data) { cob_memcpy (dlm, dlm_data, (int) dlm_size); } else if (COB_FIELD_IS_NUMERIC (dlm)) { cob_move (&cob_zero, dlm); } else { cob_move (&cob_space, dlm); } } #ifdef I18N_UTF8 /* I18N_UTF8: No offset arrangement needed also in NATIONAL. */ #else /*!I18N_UTF8*/ if (COB_FIELD_TYPE (unstring_src) == COB_TYPE_NATIONAL || COB_FIELD_TYPE (unstring_src) == COB_TYPE_NATIONAL_EDITED) { match_size /= 2; } #endif /*I18N_UTF8*/ if (cnt) { cob_set_int (cnt, match_size); } }