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);
}
}
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);
}
}
}
}
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);
}
}
static int
sort_compare (const void *data1, const void *data2)
{
size_t i;
int cmp;
cob_field f1;
cob_field f2;
for (i = 0; i < sort_nkeys; ++i) {
f1 = f2 = *sort_keys[i].field;
f1.data = (unsigned char *)data1 + sort_keys[i].offset;
f2.data = (unsigned char *)data2 + sort_keys[i].offset;
if (COB_FIELD_IS_NUMERIC(&f1)) {
cmp = cob_numeric_cmp (&f1, &f2);
} else {
cmp = common_cmps (f1.data, f2.data, f1.size, sort_collate);
}
if (cmp != 0) {
return (sort_keys[i].flag == COB_ASCENDING) ? cmp : -cmp;
}
}
return 0;
}
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_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)) {
match_size = (int)(p - start);
cob_str_memcpy (dst, start, match_size);
unstring_offset += match_size + dlsize;
dlm_data = dp;
dlm_size = dlsize;
if (dlm_list[i].uns_all) {
for (p++ ; p < s; ++p) {
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_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);
}
}
void
cob_field_accept (cob_field *f, cob_field *line, cob_field *column,
cob_field *fgc, cob_field *bgc, cob_field *scroll,
const int attr)
{
unsigned char *p;
unsigned char *p2;
size_t count;
int keyp;
int fret;
int sline;
int scolumn;
int cline;
int ccolumn;
int rightpos;
int ateof;
int move_char;
int prompt_char;
/* Initialize the screen. */
if (!cob_screen_initialized) {
cob_screen_init ();
}
if (scroll) {
keyp = cob_get_int (scroll);
if (attr & COB_SCREEN_SCROLL_DOWN) {
keyp = -keyp;
}
scrollok (stdscr, 1);
scrl (keyp);
scrollok (stdscr, 0);
refresh ();
}
cob_exception_code = 0;
/* Start line and column. */
get_line_column (line, column, &sline, &scolumn);
move (sline, scolumn);
cob_screen_attr (fgc, bgc, attr);
/* Prompt characters. */
p = f->data;
for (count = 0; count < f->size; count++) {
if (attr & COB_SCREEN_SECURE) {
addch ('*');
} else if (attr & COB_SCREEN_UPDATE) {
fret = *p++;
addch ((unsigned int)fret);
} else if (COB_FIELD_IS_NUMERIC (f)) {
addch ('0');
} else if (attr & COB_SCREEN_PROMPT) {
addch ('_');
} else {
addch (' ');
}
}
move (sline, scolumn);
/* Initialize field. */
if (!(attr & COB_SCREEN_UPDATE)) {
if (COB_FIELD_IS_NUMERIC (f)) {
cob_move (&cob_zero, f);
} else {
memset (f->data, ' ', f->size);
}
}
fret = 0;
ateof = 0;
rightpos = scolumn + f->size - 1;
p = f->data;
/* Get characters from keyboard, processing each one. */
for (; ;) {
/* Get current line, column. */
getyx (stdscr, cline, ccolumn);
/* Trailing prompts. */
if (COB_FIELD_IS_NUMERIC (f)) {
prompt_char = '0';
} else if (attr & COB_SCREEN_PROMPT) {
prompt_char = '_';
} else {
prompt_char = ' ';
}
for (count = rightpos; count > scolumn - 1; count--) {
/* Get character */
p2 = f->data + count - scolumn;
move_char = *p2;
/* Field prompts. */
if (COB_FIELD_IS_NUMERIC (f)) {
/* Numeric prompt zeros. */
if (move_char == '0') {
move (cline, count);
addch (prompt_char);
} else {
/* Switch to remove prompts from within field. */
if (attr & COB_SCREEN_SECURE) {
prompt_char = '*';
} else {
prompt_char = '0';
}
}
} else {
/* Alpha prompts. */
if (move_char == ' ') {
move (cline, count);
addch (prompt_char);
} else {
/* Switch to remove prompts from within field. */
if (attr & COB_SCREEN_SECURE) {
prompt_char = '*';
} else {
prompt_char = ' ';
}
}
}
}
/* Cursor to current column. */
move (cline, ccolumn);
/* Refresh screen. */
refresh ();
errno = 0;
/* Get a character. */
keyp = getch ();
/* Key error. */
if (keyp == ERR) {
fret = 8001;
goto field_return;
}
/* Function keys F1 through F64 */
if (keyp > KEY_F0 && keyp < KEY_F(65)) {
fret = 1000 + keyp - KEY_F0;
goto field_return;
}
cob_convert_key (&keyp, 1U);
if (keyp <= 0) {
(void)flushinp ();
beep ();
continue;
}
switch (keyp) {
case KEY_ENTER:
goto field_return;
case KEY_PPAGE:
/* Page up. */
fret = 2001;
goto field_return;
case KEY_NPAGE:
/* Page down. */
fret = 2002;
goto field_return;
case KEY_UP:
/* Up arrow. */
fret = 2003;
goto field_return;
case KEY_DOWN:
/* Down arrow. */
fret = 2004;
goto field_return;
case KEY_PRINT:
/* Print key. */
/* pdcurses not returning this ? */
fret = 2006;
goto field_return;
case 033:
/* Escape key. */
fret = 2005;
goto field_return;
case KEY_STAB:
/* Tab key. */
fret = 2007;
goto field_return;
case KEY_BTAB:
/* Back tab key. */
fret = 2008;
goto field_return;
default:
break;
}
getyx (stdscr, cline, ccolumn);
switch (keyp) {
case KEY_IC:
/* Insert key toggle. If off turn on, if on turn off. */
if (insert_mode == 0) {
insert_mode = 1; /* on */
/* to do, needs vertical bar cursor */
/* this doesn't seem to work */
count = curs_set(1);
} else {
insert_mode = 0; /* off */
/* to do, needs square cursor */
/* this doesn't seem to work */
count = curs_set(2);
}
continue;
case KEY_DC:
/* Delete key. */
/* Delete character, move remainder left. */
for (count = ccolumn; count < rightpos; count++) {
/* Get character one position to right. */
p2 = f->data + count - scolumn + 1;
move_char = *p2;
/* Move the character left. */
p2 = f->data + count - scolumn;
*p2 = move_char;
/* Update screen with moved character. */
move (cline, count);
if (attr & COB_SCREEN_SECURE) {
addch ('*');
} else {
addch (move_char);
}
}
/* Put space as the right most character. */
p2 = f->data + f->size - 1;
if (COB_FIELD_IS_NUMERIC (f)) {
*p2 = '0';
} else {
*p2 = ' ';
}
/* Put cursor back to original position. */
move (cline, ccolumn);
continue;
case KEY_BACKSPACE:
/* Backspace key. */
if (ccolumn > scolumn) {
/* Shift remainder left with cursor. */
for (count = ccolumn; count < rightpos + 1; count++) {
/* Get character. */
p2 = f->data + count - scolumn ;
move_char = *p2;
/* Move the character left. */
p2 = f->data + count - scolumn - 1;
*p2 = move_char;
/* Update screen with moved character. */
move (cline, count - 1);
if (attr & COB_SCREEN_SECURE) {
addch ('*');
} else {
addch (move_char);
}
}
/* Put space as the right most character. */
p2 = f->data + f->size - 1;
if (COB_FIELD_IS_NUMERIC (f)) {
*p2 = '0';
} else {
*p2 = ' ';
}
/* Move cursor left one from current. */
ccolumn--;
move (cline, ccolumn);
p--;
}
ateof = 0;
continue;
case KEY_HOME:
/* Home key, move to start of field. */
move (sline, scolumn);
p = f->data;
ateof = 0;
continue;
case KEY_END:
/* End key. */
/* Prepare for empty field. */
ccolumn = scolumn;
move_char = ' ';
/* Find non blank from right. */
for (count = rightpos; count >= scolumn; count--) {
/* Get character */
p2 = f->data + count - scolumn;
move_char = *p2;
/* Non blank stop. */
if (move_char != ' ') {
ccolumn = count;
count = scolumn;
}
}
/* Cursor to first blank after. */
if (move_char != ' ' && ccolumn != rightpos) {
ccolumn++;
}
move (cline, ccolumn);
p = f->data + ccolumn - scolumn;
ateof = 0;
continue;
case KEY_LEFT:
/* Left arrow. */
if (ccolumn > scolumn) {
ccolumn--;
move (cline, ccolumn);
p = f->data + ccolumn - scolumn;
continue;
}
continue;
case KEY_RIGHT:
/* Right arrow. */
if (ccolumn < rightpos) {
ccolumn++;
move (cline, ccolumn);
p = f->data + ccolumn - scolumn;
continue;
}
continue;
default:
break;
}
/* Printable character. */
if (keyp > 037 && keyp < (int)A_CHARTEXT) {
/* Numeric field check. */
if (COB_FIELD_IS_NUMERIC (f)) {
if (keyp < '0' || keyp > '9') {
beep ();
continue;
}
}
/* Insert character. */
if (insert_mode == 1) {
/* Move remainder to the right. */
for (count = rightpos; count > ccolumn - 1; count--) {
/* Get character */
p2 = f->data + count - scolumn - 1;
move_char = *p2;
/* Move character one right. */
p2 = f->data + count - scolumn;
*p2 = move_char;
/* Update screen with moved character. */
if (count > scolumn) {
move (cline, count);
if (move_char != ' ') {
if (attr & COB_SCREEN_SECURE) {
addch ('*');
} else {
addch (move_char);
}
}
}
}
move (cline, ccolumn);
}
*p = (unsigned char)keyp;
/* Display character or '*' if secure. */
if (attr & COB_SCREEN_SECURE) {
addch ('*');
} else {
addch ((unsigned int)keyp);
}
if (ccolumn == rightpos) {
/* Auto-skip at end of field. */
if (attr & COB_SCREEN_AUTO) {
break;
}
move (cline, ccolumn);
if (ateof) {
beep ();
} else {
ateof = 1;
}
} else {
p++;
}
continue;
}
beep ();
}
field_return:
refresh ();
cob_check_pos_status (fret);
}
static void
cob_screen_get_all (void)
{
struct cob_inp_struct *sptr;
cob_screen *s;
unsigned char *p;
int keyp;
int sline;
int scolumn;
int cline;
int ccolumn;
int rightpos;
int ateof;
int gotbacksp;
int ungetched;
sptr = cob_base_inp;
s = sptr->scr;
sline = sptr->this_y;
scolumn = sptr->this_x;
move (sline, scolumn);
cob_screen_attr (s->foreg, s->backg, s->attr);
/* RXW
p = s->field->data;
for (count = 0; count < s->field->size; count++) {
if (s->attr & COB_SCREEN_UPDATE) {
keyp = *p++;
addch (keyp);
} else if (s->attr & COB_SCREEN_PROMPT) {
addch ('_');
} else {
addch (' ');
}
}
move (sline, scolumn);
*/
ateof = 0;
gotbacksp = 0;
ungetched = 0;
rightpos = scolumn + s->field->size - 1;
p = s->field->data;
for (; ;) {
refresh ();
errno = 0;
keyp = getch ();
if (keyp == ERR) {
global_return = 8001;
goto screen_return;
}
if (keyp > KEY_F0 && keyp < KEY_F(65)) {
global_return = 1000 + keyp - KEY_F0;
goto screen_return;
}
cob_convert_key (&keyp, 0);
if (keyp <= 0) {
(void)flushinp ();
beep ();
continue;
}
getyx (stdscr, cline, ccolumn);
switch (keyp) {
case KEY_ENTER:
goto screen_return;
case KEY_PPAGE:
global_return = 2001;
goto screen_return;
case KEY_NPAGE:
global_return = 2002;
goto screen_return;
case KEY_PRINT:
global_return = 2006;
goto screen_return;
case '\033':
global_return = 2005;
goto screen_return;
case KEY_STAB:
if (curr_index < totl_index - 1) {
curr_index++;
} else {
curr_index = 0;
}
sptr = cob_base_inp + curr_index;
s = sptr->scr;
sline = sptr->this_y;
scolumn = sptr->this_x;
ateof = 0;
gotbacksp = 0;
rightpos = scolumn + s->field->size - 1;
p = s->field->data;
move (sline, scolumn);
cob_screen_attr (s->foreg, s->backg, s->attr);
continue;
case KEY_BTAB:
if (curr_index > 0) {
curr_index--;
} else {
curr_index = totl_index - 1;
}
sptr = cob_base_inp + curr_index;
s = sptr->scr;
sline = sptr->this_y;
scolumn = sptr->this_x;
ateof = 0;
gotbacksp = 0;
rightpos = scolumn + s->field->size - 1;
if (ungetched) {
ungetched = 0;
p = s->field->data + rightpos;
move (sline, rightpos);
} else {
p = s->field->data;
move (sline, scolumn);
}
cob_screen_attr (s->foreg, s->backg, s->attr);
continue;
case KEY_UP:
curr_index = sptr->up_index;
sptr = cob_base_inp + curr_index;
s = sptr->scr;
sline = sptr->this_y;
scolumn = sptr->this_x;
ateof = 0;
gotbacksp = 0;
rightpos = scolumn + s->field->size - 1;
p = s->field->data;
move (sline, scolumn);
cob_screen_attr (s->foreg, s->backg, s->attr);
continue;
case KEY_DOWN:
curr_index = sptr->down_index;
sptr = cob_base_inp + curr_index;
s = sptr->scr;
sline = sptr->this_y;
scolumn = sptr->this_x;
ateof = 0;
gotbacksp = 0;
rightpos = scolumn + s->field->size - 1;
p = s->field->data;
move (sline, scolumn);
cob_screen_attr (s->foreg, s->backg, s->attr);
continue;
case KEY_HOME:
curr_index = 0;
sptr = cob_base_inp;
s = sptr->scr;
sline = sptr->this_y;
scolumn = sptr->this_x;
ateof = 0;
gotbacksp = 0;
rightpos = scolumn + s->field->size - 1;
p = s->field->data;
move (sline, scolumn);
cob_screen_attr (s->foreg, s->backg, s->attr);
continue;
case KEY_END:
curr_index = totl_index - 1;
sptr = cob_base_inp + curr_index;
s = sptr->scr;
sline = sptr->this_y;
scolumn = sptr->this_x;
ateof = 0;
gotbacksp = 0;
rightpos = scolumn + s->field->size - 1;
p = s->field->data;
move (sline, scolumn);
cob_screen_attr (s->foreg, s->backg, s->attr);
continue;
case KEY_BACKSPACE:
if (ccolumn > scolumn) {
if (gotbacksp || ccolumn != rightpos) {
ccolumn--;
} else {
ateof = 0;
}
gotbacksp = 1;
move (cline, ccolumn);
if (s->attr & COB_SCREEN_SECURE) {
addch ('*');
} else {
addch ('_');
}
move (cline, ccolumn);
p = s->field->data + ccolumn - scolumn;
*p = ' ';
} else {
ungetched = 1;
gotbacksp = 0;
ungetch (KEY_BACKSPACE);
ungetch (KEY_BTAB);
}
continue;
case KEY_LEFT:
gotbacksp = 0;
if (ccolumn > scolumn) {
ccolumn--;
move (cline, ccolumn);
p = s->field->data + ccolumn - scolumn;
} else {
ungetched = 1;
ungetch (KEY_BTAB);
}
continue;
case KEY_RIGHT:
gotbacksp = 0;
if (ccolumn < rightpos) {
ccolumn++;
move (cline, ccolumn);
p = s->field->data + ccolumn - scolumn;
} else {
ungetch ('\t');
}
continue;
default:
break;
}
if (keyp > 037 && keyp < (int)A_CHARTEXT) {
if (COB_FIELD_IS_NUMERIC (s->field)) {
if (keyp < '0' || keyp > '9') {
beep ();
continue;
}
}
gotbacksp = 0;
*p = keyp;
if (s->attr & COB_SCREEN_SECURE) {
addch ('*');
} else {
addch ((unsigned int)keyp);
}
if (ccolumn == rightpos) {
if (s->attr & COB_SCREEN_AUTO) {
if (curr_index == totl_index - 1) {
goto screen_return;
} else {
ungetch (011);
}
}
move (cline, ccolumn);
if (ateof) {
beep ();
} else {
ateof = 1;
}
} else {
p++;
}
continue;
}
gotbacksp = 0;
(void)flushinp ();
beep ();
}
screen_return:
refresh ();
}
