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);
}
}
