#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include "libcob.h"
#include "coblocal.h"

Include dependency graph for screenio.c:

Go to the source code of this file.

Data Structures
struct	cob_inp_struct

Macros
#define	COB_LIB_EXPIMP

#define	COB_INP_FLD_MAX 512U

#define	COB_INP_SIZE (COB_INP_FLD_MAX * sizeof(struct cob_inp_struct))

#define	COB_CH_UL ((const chtype)'_')

#define	COB_CH_SP ((const chtype)' ')

#define	COB_CH_AS ((const chtype)'*')

#define	UPDATE_CLAUSE_FUNC(clause_name_upper, clause_name_lower)

Enumerations
enum	screen_statement { ACCEPT_STATEMENT, DISPLAY_STATEMENT }

Functions
static void	cob_speaker_beep (void)

static void	cob_beep (void)

static void	cob_convert_key (int *keyp, const cob_u32_t field_accept)

static void	get_line_column (cob_field fline, cob_field fcol, int line, int col)

static void	raise_ec_on_invalid_line_or_col (const int line, const int column)

static void	cob_move_cursor (const int line, const int column)

static void	cob_move_to_beg_of_last_line (void)

static void	cob_screen_attr (cob_field fgc, cob_field bgc, const int attr, const enum screen_statement stmt)

static void	cob_screen_init (void)

static void	cob_check_pos_status (const int fret)

static void	raise_ec_on_truncation (const int item_size)

static void	cob_addnstr (const char *data, const int size)

static void	cob_addch (const chtype c)

static void	cob_addch_no_trunc_check (const chtype c)

static void	cob_addnch (const int n, const chtype c)

static int	is_first_screen_item (cob_screen *s)

static cob_screen *	get_last_child (cob_screen *const s)

static cob_screen *	get_prev_screen_item (cob_screen *const s)

static void	update_line (cob_screen s, int const count, int *const found_clause)

static void	update_column (cob_screen s, int const count, int *const found_clause)

static size_t	get_size (cob_screen *s)

static void	get_screen_item_line_and_col (cob_screen s, int const line, int *const col)

static void	cob_screen_puts (cob_screen s, cob_field f, const cob_u32_t is_input, const enum screen_statement stmt)

static COB_INLINE COB_A_INLINE int	cob_field_is_numeric_or_numeric_edited (cob_field *field)

static int	field_is_empty (cob_screen *s)

static int	field_is_zero (cob_screen *s)

static int	pic_has_zero_suppression (const char *pic)

static int	get_num_int_digits_for_no_zero_sup (const char *pic)

static int	field_is_zero_or_no_zero_suppression (cob_screen *s)

static int	field_is_full (cob_screen *s)

static int	satisfied_full_clause (cob_screen *s)

static int	satisfied_required_clause (cob_screen *s)

static int	valid_field_data (cob_field *field)

static void	refresh_field (cob_screen *s)

static void	format_field (cob_screen *s)

static int	finalize_field_input (cob_screen *s)

static int	finalize_all_fields (struct cob_inp_struct *sptr, const size_t total_idx)

static void	cob_screen_get_all (const int initial_curs, const int gettimeout)

static int	compare_yx (const void m1, const void m2)

static void	cob_screen_moveyx (cob_screen *s)

static size_t	cob_prep_input (cob_screen *s)

static void	cob_screen_iterate (cob_screen *s)

static COB_INLINE COB_A_INLINE void	set_default_line_column (const int is_screen, int sline, int scolumn)

static void	pos_to_line_column (cob_field pos, int line, int *column)

static void	extract_line_and_col_vals (const int is_screen, cob_field line, cob_field column, int sline, int scolumn)

static COB_INLINE COB_A_INLINE void	init_cob_screen_if_needed (void)

static void	screen_display (cob_screen *s, const int line, const int column)

static void	screen_accept (cob_screen s, const int line, const int column, cob_field ftimeout)

static void	field_display (cob_field f, const int line, const int column, cob_field fgc, cob_field bgc, cob_field fscroll, cob_field *size_is, const int fattr)

static void	field_accept (cob_field f, const int sline, const int scolumn, cob_field fgc, cob_field bgc, cob_field fscroll, cob_field ftimeout, cob_field prompt, cob_field *size_is, const int fattr)

void	cob_screen_display (cob_screen s, cob_field line, cob_field *column)

void	cob_screen_accept (cob_screen s, cob_field line, cob_field column, cob_field ftimeout)

void	cob_field_display (cob_field f, cob_field line, cob_field column, cob_field fgc, cob_field bgc, cob_field fscroll, cob_field *size_is, const int fattr)

void	cob_field_accept (cob_field f, cob_field line, cob_field column, cob_field fgc, cob_field bgc, cob_field fscroll, cob_field ftimeout, cob_field prompt, cob_field *size_is, const int fattr)

void	cob_screen_line_col (cob_field *f, const int l_or_c)

int	cob_sys_clear_screen (void)

void	cob_screen_set_mode (const cob_u32_t smode)

void	cob_exit_screen (void)

int	cob_sys_sound_bell (void)

void	cob_accept_escape_key (cob_field *f)

int	cob_sys_get_csr_pos (unsigned char *fld)

int	cob_sys_get_scr_size (unsigned char line, unsigned char col)

void	cob_init_screenio (cob_global lptr, cob_settings sptr)

Variables
static cob_global *	cobglobptr

static cob_settings *	cobsetptr

static const cob_field_attr	const_alpha_attr

static struct cob_inp_struct *	cob_base_inp

static size_t	totl_index

static size_t	cob_has_color

static int	global_return

static int	cob_current_y

static int	cob_current_x

static short	fore_color

static short	back_color

static int	origin_y

static int	origin_x

Macro Definition Documentation

#define COB_CH_AS ((const chtype)'*')

Definition at line 88 of file screenio.c.

Referenced by cob_screen_get_all(), cob_screen_puts(), and field_accept().

#define COB_CH_SP ((const chtype)' ')

Definition at line 87 of file screenio.c.

Referenced by cob_screen_get_all(), field_accept(), and field_display().

#define COB_CH_UL ((const chtype)'_')

Definition at line 86 of file screenio.c.

Referenced by cob_screen_get_all(), cob_screen_puts(), and field_accept().

#define COB_INP_FLD_MAX 512U

Definition at line 82 of file screenio.c.

Referenced by cob_prep_input().

#define COB_INP_SIZE (COB_INP_FLD_MAX * sizeof(struct cob_inp_struct))

Definition at line 84 of file screenio.c.

Referenced by screen_accept().

#define COB_LIB_EXPIMP

Definition at line 65 of file screenio.c.

#define UPDATE_CLAUSE_FUNC	(	clause_name_upper,
		clause_name_lower
	)

Value:

static void                         \
    update_##clause_name_lower (cob_screen *s, int * const count,   \
                    int * const found_clause)       \
    {                               \
        if (s->attr & COB_SCREEN_##clause_name_upper##_PLUS) {  \
            *count += cob_get_int (s->clause_name_lower);   \
        } else if (s->attr & COB_SCREEN_##clause_name_upper##_MINUS) { \
            *count -= cob_get_int (s->clause_name_lower);   \
        } else {                        \
            *count += cob_get_int (s->clause_name_lower) - 1; \
            *found_clause = 1;              \
        }                           \
    }

Definition at line 717 of file screenio.c.

Enumeration Type Documentation

enum screen_statement

Enumerator
ACCEPT_STATEMENT
DISPLAY_STATEMENT

Definition at line 339 of file screenio.c.

                       {
     ACCEPT_STATEMENT,
     DISPLAY_STATEMENT
 };

Function Documentation

void cob_accept_escape_key ( cob_field * f )

Definition at line 2524 of file screenio.c.

References COB_ACCEPT_STATUS, and cob_set_int().

 {
     cob_set_int (f, COB_ACCEPT_STATUS);
 }

Here is the call graph for this function:

static void cob_addch ( const chtype c )

static

Definition at line 649 of file screenio.c.

References raise_ec_on_truncation().

Referenced by cob_screen_get_all(), and field_accept().

 {
     raise_ec_on_truncation (1);
     addch (c);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void cob_addch_no_trunc_check ( const chtype c )

static

Definition at line 657 of file screenio.c.

Referenced by cob_addnch(), cob_screen_puts(), and field_accept().

 {
     addch (c);
 }

Here is the caller graph for this function:

static void cob_addnch	(	const int	n,
		const chtype	c
	)

static

Definition at line 663 of file screenio.c.

References cob_addch_no_trunc_check(), and raise_ec_on_truncation().

Referenced by field_accept(), and field_display().

 {
     int count;
 
     raise_ec_on_truncation (n);
     for (count = 0; count < n; count++) {
         cob_addch_no_trunc_check (c);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void cob_addnstr	(	const char *	data,
		const int	size
	)

static

Definition at line 642 of file screenio.c.

References raise_ec_on_truncation().

Referenced by cob_screen_puts().

 {
     raise_ec_on_truncation (size);
     addnstr (data, size);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void cob_beep ( void )

static

Definition at line 128 of file screenio.c.

References COB_BEEP_VALUE, and cob_speaker_beep().

Referenced by cob_screen_attr(), cob_screen_get_all(), cob_sys_sound_bell(), and field_accept().

 {
     switch (COB_BEEP_VALUE) {
     case 1:
         (void)flash ();
         return;
     case 2:
         cob_speaker_beep ();
         return;
     case 9:
         return;
     default:
         (void)beep ();
         return;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void cob_check_pos_status ( const int fret )

static

Definition at line 578 of file screenio.c.

References COB_ACCEPT_STATUS, COB_EC_IMP_ACCEPT, COB_FIELD_IS_NUMERIC, COB_FIELD_TYPE, COB_MODULE_PTR, cob_set_exception(), cob_set_int(), COB_TYPE_NUMERIC_DISPLAY, cob_field::data, and cob_field::size.

Referenced by field_accept(), and screen_accept().

 {
     cob_field   *f;
     int     sline;
     int     scolumn;
     char        datbuf[8];
 
     if (fret) {
         cob_set_exception (COB_EC_IMP_ACCEPT);
     }
     COB_ACCEPT_STATUS = fret;
     if (COB_MODULE_PTR->crt_status) {
         if (COB_FIELD_IS_NUMERIC (COB_MODULE_PTR->crt_status)) {
             cob_set_int (COB_MODULE_PTR->crt_status, fret);
         } else {
             sprintf(datbuf, "%4.4d", fret);
             memcpy (COB_MODULE_PTR->crt_status->data, datbuf,
                 (size_t)4);
         }
     }
     if (COB_MODULE_PTR->cursor_pos) {
         getyx (stdscr, sline, scolumn);
         f = COB_MODULE_PTR->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, (size_t)4);
             } else {
                 sline *= 1000;
                 sline += scolumn;
                 sprintf(datbuf, "%6.6d", sline);
                 memcpy (f->data, datbuf, (size_t)6);
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void cob_convert_key	(	int *	keyp,
		const cob_u32_t	field_accept
	)

static

Definition at line 146 of file screenio.c.

References COB_EXTENDED_STATUS, and COB_USE_ESC.

Referenced by cob_screen_get_all(), and field_accept().

 {
     /* Map key to KEY_xxx value */
     switch (*keyp) {
     case '\n':
     case '\r':
     case '\004':
     case '\032':
         *keyp = KEY_ENTER;
         break;
     case '\t':
         *keyp = KEY_STAB;
         break;
     case '\b':
     case 0177:
         *keyp = KEY_BACKSPACE;
         break;
     case 01005:
         *keyp = KEY_EOL;    /* Alt-Delete */
         break;
     case 01040:
         *keyp = KEY_CLOSE;  /* Alt-left-arrow */
         break;
     case 01062:
         *keyp = KEY_PREVIOUS;   /* Alt-right-arrow */
         break;
 
 #ifdef  KEY_A1
     /* A1, A3, C1, C3 must be present */
     case KEY_A1:
         *keyp = KEY_HOME;
         break;
     case KEY_A3:
         *keyp = KEY_PPAGE;
         break;
     case KEY_C1:
         *keyp = KEY_END;
         break;
     case KEY_C3:
         *keyp = KEY_NPAGE;
         break;
     /* Any or all of A2, B1-3, C2 MAY be present */
     /* Note B2 ignored */
 #ifdef  KEY_A2
     case KEY_A2:
         *keyp = KEY_UP;
         break;
 #endif
 #ifdef  KEY_B1
     case KEY_B1:
         *keyp = KEY_LEFT;
         break;
 #endif
 #ifdef  KEY_B3
     case KEY_B3:
         *keyp = KEY_RIGHT;
         break;
 #endif
 #ifdef  KEY_C2
     case KEY_C2:
         *keyp = KEY_DOWN;
         break;
 #endif
 
 #if defined(__PDCURSES__) && defined(PADSLASH)
     case PADSLASH:
         *keyp = '/';
         break;
     case PADSTAR:
         *keyp = '*';
         break;
     case PADMINUS:
         *keyp = '-';
         break;
     case PADPLUS:
         *keyp = '+';
         break;
     case PADENTER:
         *keyp = KEY_ENTER;
         break;
 #ifdef  PAD0
     case PAD0:
         *keyp = KEY_IC;
         break;
     case PADSTOP:
         *keyp = KEY_DC;
         break;
 #endif  /* PAD0 */
 #endif  /* __PDCURSES__ */
 #endif  /* KEY_A1 */
     default:
         break;
     }
 
     /* Check if key should be ignored */
     switch (*keyp) {
     /* 2012/08/30 removed to allow Tab key in extended Accept.
     case KEY_STAB:
         if (field_accept) {
             *keyp = 0;
         }
         break;
     */
     case '\033':
         if (!COB_EXTENDED_STATUS || !COB_USE_ESC) {
             *keyp = 0;
         }
         break;
     case KEY_PPAGE:
     case KEY_NPAGE:
     case KEY_PRINT:
         if (!COB_EXTENDED_STATUS) {
             *keyp = 0;
         }
         break;
     case KEY_UP:
     case KEY_DOWN:
         if (field_accept && !COB_EXTENDED_STATUS) {
             *keyp = 0;
         }
         break;
     default:
         break;
     }
 }

Here is the caller graph for this function:

void cob_exit_screen ( void )

Definition at line 2401 of file screenio.c.

References COB_ACCEPT_STATUS, cob_free(), cob_move_to_beg_of_last_line(), __cob_global::cob_screen_initialized, and NULL.

Referenced by cob_runtime_error(), and cob_terminate_routines().

 {
     if (!cobglobptr) {
         return;
     }
     if (cobglobptr->cob_screen_initialized) {
         cobglobptr->cob_screen_initialized = 0;
         clear ();
         cob_move_to_beg_of_last_line ();
         delwin (stdscr);
         endwin ();
 #ifdef  HAVE_CURSES_FREEALL
         _nc_freeall ();
 #endif
         if (cob_base_inp) {
             cob_free (cob_base_inp);
             cob_base_inp = NULL;
         }
     }
     COB_ACCEPT_STATUS = 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void cob_field_accept	(	cob_field *	f,
		cob_field *	line,
		cob_field *	column,
		cob_field *	fgc,
		cob_field *	bgc,
		cob_field *	fscroll,
		cob_field *	ftimeout,
		cob_field *	prompt,
		cob_field *	size_is,
		const int	fattr
	)

Definition at line 2353 of file screenio.c.

References extract_line_and_col_vals(), and field_accept().

Referenced by cob_accept(), and GCic_().

 {
     int sline;
     int scolumn;
 
     extract_line_and_col_vals (0, line, column, &sline, &scolumn);
     field_accept (f, sline, scolumn, fgc, bgc, fscroll, ftimeout, prompt, size_is, fattr);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void cob_field_display	(	cob_field *	f,
		cob_field *	line,
		cob_field *	column,
		cob_field *	fgc,
		cob_field *	bgc,
		cob_field *	fscroll,
		cob_field *	size_is,
		const int	fattr
	)

Definition at line 2341 of file screenio.c.

References extract_line_and_col_vals(), and field_display().

Referenced by cob_display().

 {
     int sline;
     int scolumn;
 
     extract_line_and_col_vals (0, line, column, &sline, &scolumn);
     field_display (f, sline, scolumn, fgc, bgc, fscroll, size_is, fattr);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static COB_INLINE COB_A_INLINE int cob_field_is_numeric_or_numeric_edited ( cob_field * field )

static

Definition at line 847 of file screenio.c.

References COB_FIELD_IS_NUMERIC, COB_FIELD_TYPE, and COB_TYPE_NUMERIC_EDITED.

Referenced by cob_screen_get_all(), field_accept(), finalize_field_input(), and satisfied_required_clause().

 {
     return (COB_FIELD_IS_NUMERIC (field)
         || COB_FIELD_TYPE (field) == COB_TYPE_NUMERIC_EDITED);
 }

Here is the caller graph for this function:

void cob_init_screenio	(	cob_global *	lptr,
		cob_settings *	sptr
	)

Definition at line 2567 of file screenio.c.

Referenced by cob_init().

 {
     cobglobptr = lptr;
     cobsetptr  = sptr;
 }

Here is the caller graph for this function:

static void cob_move_cursor	(	const int	line,
		const int	column
	)

static

Definition at line 317 of file screenio.c.

References raise_ec_on_invalid_line_or_col().

Referenced by cob_screen_attr(), cob_screen_get_all(), cob_screen_moveyx(), cob_screen_puts(), field_accept(), field_display(), refresh_field(), screen_accept(), and screen_display().

 {
     int status = move (line, column);
 
     if (status == ERR) {
         raise_ec_on_invalid_line_or_col (line, column);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void cob_move_to_beg_of_last_line ( void )

static

Definition at line 327 of file screenio.c.

References COB_UNUSED.

Referenced by cob_exit_screen().

 {
     int max_y;
     int max_x;
 
     COB_UNUSED (max_x);
 
     getmaxyx (stdscr, max_y, max_x);
     /* We don't need to check for exceptions here; it will always be fine */
     move (max_y, 0);
 }

Here is the caller graph for this function:

static size_t cob_prep_input ( cob_screen * s )

static

Definition at line 1442 of file screenio.c.

References ACCEPT_STATEMENT, __cob_screen::attr, __cob_screen::backg, __cob_screen::child, cob_current_x, cob_current_y, COB_INP_FLD_MAX, __cob_settings::cob_legacy, cob_screen_attr(), COB_SCREEN_INPUT, cob_screen_moveyx(), cob_screen_puts(), COB_SCREEN_TYPE_ATTRIBUTE, COB_SCREEN_TYPE_FIELD, COB_SCREEN_TYPE_GROUP, COB_SCREEN_TYPE_VALUE, __cob_screen::field, __cob_screen::foreg, __cob_screen::next, __cob_screen::occurs, cob_inp_struct::scr, cob_inp_struct::this_x, cob_inp_struct::this_y, totl_index, __cob_screen::type, and __cob_screen::value.

Referenced by screen_accept().

 {
     struct cob_inp_struct   *sptr;
     int         n;
 
     switch (s->type) {
     case COB_SCREEN_TYPE_GROUP:
         cob_screen_moveyx (s);
         for (s = s->child; s; s = s->next) {
             cob_prep_input (s);
         }
         break;
     case COB_SCREEN_TYPE_FIELD:
         cob_screen_puts (s, s->field, cobsetptr->cob_legacy,
                  ACCEPT_STATEMENT);
         if (s->attr & COB_SCREEN_INPUT) {
             if (totl_index >= COB_INP_FLD_MAX) {
                 return 1;
             }
             sptr = cob_base_inp + totl_index;
             sptr->scr = s;
             sptr->this_y = cob_current_y;
             sptr->this_x = cob_current_x;
             totl_index++;
         }
         break;
     case COB_SCREEN_TYPE_VALUE:
         cob_screen_puts (s, s->value, cobsetptr->cob_legacy,
                  ACCEPT_STATEMENT);
         if (s->occurs) {
             for (n = 1; n < s->occurs; ++n) {
                 cob_screen_puts (s, s->value, cobsetptr->cob_legacy,
                          ACCEPT_STATEMENT);
             }
         }
         break;
     case COB_SCREEN_TYPE_ATTRIBUTE:
 #if 0   /* RXWRXW - Attr */
         cob_screen_attr (s->foreg, s->backg, s->attr);
 #endif
         break;
     default:
         break;
     }
     return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void cob_screen_accept	(	cob_screen *	s,
		cob_field *	line,
		cob_field *	column,
		cob_field *	ftimeout
	)

Definition at line 2330 of file screenio.c.

References extract_line_and_col_vals(), and screen_accept().

Referenced by GCic_().

 {
     int sline;
     int scolumn;
 
     extract_line_and_col_vals (1, line, column, &sline, &scolumn);
     screen_accept (s, sline, scolumn, ftimeout);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void cob_screen_attr	(	cob_field *	fgc,
		cob_field *	bgc,
		const int	attr,
		const enum screen_statement	stmt
	)

static

Definition at line 345 of file screenio.c.

References back_color, cob_beep(), cob_get_int(), cob_has_color, cob_move_cursor(), COB_SCREEN_BELL, COB_SCREEN_BLACK, COB_SCREEN_BLANK_LINE, COB_SCREEN_BLANK_SCREEN, COB_SCREEN_BLINK, COB_SCREEN_BLUE, COB_SCREEN_CYAN, COB_SCREEN_ERASE_EOL, COB_SCREEN_ERASE_EOS, COB_SCREEN_GREEN, COB_SCREEN_HIGHLIGHT, COB_SCREEN_LOWLIGHT, COB_SCREEN_MAGENTA, COB_SCREEN_RED, COB_SCREEN_REVERSE, COB_SCREEN_UNDERLINE, COB_SCREEN_WHITE, COB_SCREEN_YELLOW, DISPLAY_STATEMENT, fore_color, line, and NULL.

Referenced by cob_prep_input(), cob_screen_get_all(), cob_screen_iterate(), cob_screen_puts(), field_accept(), and field_display().

 {
     int     i;
     int     styles = 0;
     int     line;
     int     column;
     short       fgcolor;
     short       bgcolor;
     short       fgdef;
     short       bgdef;
 
     attrset (A_NORMAL);
     if (attr & COB_SCREEN_BELL) {
         cob_beep ();
     }
     if (attr & COB_SCREEN_REVERSE) {
         styles |= A_REVERSE;
     }
     if (attr & COB_SCREEN_HIGHLIGHT) {
         styles |= A_BOLD;
     }
     if (attr & COB_SCREEN_LOWLIGHT) {
         styles |= A_DIM;
     }
     if (attr & COB_SCREEN_BLINK) {
         styles |= A_BLINK;
     }
     if (attr & COB_SCREEN_UNDERLINE) {
         styles |= A_UNDERLINE;
     }
     if (styles) {
         attron (styles);
     }
     if (cob_has_color) {
         fgcolor = fore_color;
         bgcolor = back_color;
         if (fgc) {
             switch (cob_get_int (fgc)) {
             case COB_SCREEN_BLACK:
                 fgcolor = COLOR_BLACK;
                 break;
             case COB_SCREEN_BLUE:
                 fgcolor = COLOR_BLUE;
                 break;
             case COB_SCREEN_GREEN:
                 fgcolor = COLOR_GREEN;
                 break;
             case COB_SCREEN_CYAN:
                 fgcolor = COLOR_CYAN;
                 break;
             case COB_SCREEN_RED:
                 fgcolor = COLOR_RED;
                 break;
             case COB_SCREEN_MAGENTA:
                 fgcolor = COLOR_MAGENTA;
                 break;
             case COB_SCREEN_YELLOW:
                 fgcolor = COLOR_YELLOW;
                 break;
             case COB_SCREEN_WHITE:
                 fgcolor = COLOR_WHITE;
                 break;
             default:
                 break;
             }
         }
         if (bgc) {
             switch (cob_get_int (bgc)) {
             case COB_SCREEN_BLACK:
                 bgcolor = COLOR_BLACK;
                 break;
             case COB_SCREEN_BLUE:
                 bgcolor = COLOR_BLUE;
                 break;
             case COB_SCREEN_GREEN:
                 bgcolor = COLOR_GREEN;
                 break;
             case COB_SCREEN_CYAN:
                 bgcolor = COLOR_CYAN;
                 break;
             case COB_SCREEN_RED:
                 bgcolor = COLOR_RED;
                 break;
             case COB_SCREEN_MAGENTA:
                 bgcolor = COLOR_MAGENTA;
                 break;
             case COB_SCREEN_YELLOW:
                 bgcolor = COLOR_YELLOW;
                 break;
             case COB_SCREEN_WHITE:
                 bgcolor = COLOR_WHITE;
                 break;
             default:
                 break;
             }
         }
         for (i = 0; i < (int)COLOR_PAIRS; i++) {
             pair_content ((short)i, &fgdef, &bgdef);
             if (fgdef == fgcolor && bgdef == bgcolor) {
                 break;
             }
             if (fgdef == 0 && bgdef == 0) {
                 init_pair ((short)i, fgcolor, bgcolor);
                 break;
             }
         }
         if (i != (int)COLOR_PAIRS) {
 #ifdef  HAVE_COLOR_SET
             color_set ((short)COLOR_PAIR(i), NULL);
 #else
             attrset (COLOR_PAIR(i));
 #endif
             bkgdset (COLOR_PAIR(i));
         } else {
             if (!styles) {
                 attrset (A_NORMAL);
             }
         }
     }
     /* BLANK SCREEN colors the whole screen. */
     if (attr & COB_SCREEN_BLANK_SCREEN) {
         getyx (stdscr, line, column);
         clear ();
         cob_move_cursor (line, column);
     }
 
     if (stmt == DISPLAY_STATEMENT) {
         /* BLANK LINE colors the whole line. */
         if (attr & COB_SCREEN_BLANK_LINE) {
             getyx (stdscr, line, column);
             cob_move_cursor (line, 0);
             clrtoeol ();
             cob_move_cursor (line, column);
         }
         if (attr & COB_SCREEN_ERASE_EOL) {
             clrtoeol ();
         }
         if (attr & COB_SCREEN_ERASE_EOS) {
             clrtobot ();
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void cob_screen_display	(	cob_screen *	s,
		cob_field *	line,
		cob_field *	column
	)

Definition at line 2321 of file screenio.c.

References extract_line_and_col_vals(), and screen_display().

Referenced by GCic_().

 {
     int sline;
     int scolumn;
 
     extract_line_and_col_vals (1, line, column, &sline, &scolumn);
     screen_display (s, sline, scolumn);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void cob_screen_get_all	(	const int	initial_curs,
		const int	gettimeout
	)

static

Definition at line 1085 of file screenio.c.

References ACCEPT_STATEMENT, __cob_screen::attr, __cob_screen::backg, cob_addch(), cob_base_inp, cob_beep(), COB_CH_AS, COB_CH_SP, COB_CH_UL, cob_convert_key(), cob_field_is_numeric_or_numeric_edited(), cob_move_cursor(), cob_screen_attr(), COB_SCREEN_AUTO, COB_SCREEN_LOWER, COB_SCREEN_NO_ECHO, COB_SCREEN_SECURE, COB_SCREEN_UPPER, cob_field::data, cob_inp_struct::down_index, __cob_screen::field, finalize_all_fields(), finalize_field_input(), __cob_screen::foreg, global_return, __cob_screen::prompt, cob_inp_struct::scr, cob_field::size, cob_inp_struct::this_x, cob_inp_struct::this_y, totl_index, and cob_inp_struct::up_index.

Referenced by screen_accept().

 {
     size_t          curr_index = (size_t)initial_curs;
     struct cob_inp_struct   *sptr = cob_base_inp + curr_index;
     cob_screen      *s = sptr->scr;
     unsigned char       *p = s->field->data;
     int         keyp;
     int         sline = sptr->this_y;
     int         scolumn = sptr->this_x;
     int         cline;
     int         ccolumn;
     int         rightpos = scolumn + (int)s->field->size - 1;
     int         ateof = 0;
     int         gotbacksp = 0;
     int         ungetched = 0;
     chtype          promptchar;
 
     cob_move_cursor (sline, scolumn);
     cob_screen_attr (s->foreg, s->backg, s->attr, ACCEPT_STATEMENT);
 
     for (; ;) {
         if (s->prompt) {
             promptchar = s->prompt->data[0];
         } else {
             promptchar = COB_CH_UL;
         }
 
         refresh ();
         errno = 0;
         timeout (gettimeout);
         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 ();
             cob_beep ();
             continue;
         }
 
         getyx (stdscr, cline, ccolumn);
 
         switch (keyp) {
         case KEY_ENTER:
             if (finalize_all_fields (cob_base_inp, totl_index)) {
                 cob_beep ();
                 continue;
             }
             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:
             finalize_field_input (s);
 
             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 + (int)s->field->size - 1;
             p = s->field->data;
             cob_move_cursor (sline, scolumn);
             cob_screen_attr (s->foreg, s->backg, s->attr,
                      ACCEPT_STATEMENT);
             continue;
         case KEY_BTAB:
             finalize_field_input (s);
 
             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 + (int)s->field->size - 1;
             if (ungetched) {
                 ungetched = 0;
                 p = s->field->data + rightpos;
                 cob_move_cursor (sline, rightpos);
             } else {
                 p = s->field->data;
                 cob_move_cursor (sline, scolumn);
             }
             cob_screen_attr (s->foreg, s->backg, s->attr,
                      ACCEPT_STATEMENT);
             continue;
         case KEY_UP:
             finalize_field_input (s);
 
             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 + (int)s->field->size - 1;
             p = s->field->data;
             cob_move_cursor (sline, scolumn);
             cob_screen_attr (s->foreg, s->backg, s->attr,
                      ACCEPT_STATEMENT);
             continue;
         case KEY_DOWN:
             finalize_field_input (s);
 
             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 + (int)s->field->size - 1;
             p = s->field->data;
             cob_move_cursor (sline, scolumn);
             cob_screen_attr (s->foreg, s->backg, s->attr,
                      ACCEPT_STATEMENT);
             continue;
         case KEY_HOME:
             finalize_field_input (s);
 
             curr_index = 0;
             sptr = cob_base_inp;
             s = sptr->scr;
             sline = sptr->this_y;
             scolumn = sptr->this_x;
             ateof = 0;
             gotbacksp = 0;
             rightpos = scolumn + (int)s->field->size - 1;
             p = s->field->data;
             cob_move_cursor (sline, scolumn);
             cob_screen_attr (s->foreg, s->backg, s->attr,
                      ACCEPT_STATEMENT);
             continue;
         case KEY_END:
             finalize_field_input (s);
 
             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 + (int)s->field->size - 1;
             p = s->field->data;
             cob_move_cursor (sline, scolumn);
             cob_screen_attr (s->foreg, s->backg, s->attr,
                      ACCEPT_STATEMENT);
             continue;
         case KEY_BACKSPACE:
             if (ccolumn > scolumn) {
                 if (gotbacksp || ccolumn != rightpos) {
                     ccolumn--;
                 } else {
                     ateof = 0;
                 }
                 gotbacksp = 1;
                 cob_move_cursor (cline, ccolumn);
                 if (s->attr & COB_SCREEN_SECURE) {
                     cob_addch (COB_CH_AS);
                 } else {
                     cob_addch (promptchar);
                 }
                 cob_move_cursor (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--;
                 cob_move_cursor (cline, ccolumn);
                 p = s->field->data + ccolumn - scolumn;
             } else {
                 ungetched = 1;
                 ungetch (KEY_BTAB);
             }
             continue;
         case KEY_RIGHT:
             gotbacksp = 0;
             if (ccolumn < rightpos) {
                 ccolumn++;
                 cob_move_cursor (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_or_numeric_edited (s->field)) {
                 if (keyp < '0' || keyp > '9') {
                     cob_beep ();
                     continue;
                 }
             }
             gotbacksp = 0;
             if (s->attr & COB_SCREEN_UPPER) {
                 if (islower (keyp)) {
                     keyp = toupper (keyp);
                 }
             } else if (s->attr & COB_SCREEN_LOWER) {
                 if (isupper (keyp)) {
                     keyp = tolower (keyp);
                 }
             }
 
             *p = (unsigned char) keyp;
 
             if (s->attr & COB_SCREEN_SECURE) {
                 cob_addch (COB_CH_AS);
             } else if (s->attr & COB_SCREEN_NO_ECHO) {
                 cob_addch (COB_CH_SP);
             } else {
                 cob_addch ((const chtype)keyp);
             }
             if (ccolumn == rightpos) {
                 if (s->attr & COB_SCREEN_AUTO) {
                     if (curr_index == totl_index - 1) {
                         goto screen_return;
                     } else {
                         ungetch ('\t');
                     }
                 }
                 cob_move_cursor (cline, ccolumn);
                 if (ateof) {
                     cob_beep ();
                 } else {
                     ateof = 1;
                 }
             } else {
                 p++;
             }
             continue;
         }
         gotbacksp = 0;
         (void)flushinp ();
         cob_beep ();
     }
 screen_return:
     refresh ();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void cob_screen_init ( void )

static

Definition at line 490 of file screenio.c.

References _, back_color, cob_current_x, cob_current_y, cob_has_color, __cob_global::cob_locale, __cob_global::cob_locale_ctype, __cob_global::cob_locale_orig, COB_MAX_X_COORD, COB_MAX_Y_COORD, cob_runtime_error(), __cob_global::cob_screen_initialized, cob_stop_run(), fore_color, global_return, NULL, and totl_index.

Referenced by cob_sys_sound_bell(), and init_cob_screen_if_needed().

 {
 
 #ifdef  HAVE_LIBPDCURSES
     size_t  i;
 #endif
 
     if (cobglobptr->cob_screen_initialized) {
         return;
     }
 
     cob_base_inp = NULL;
     totl_index = 0;
     cob_has_color = 0;
     global_return = 0;
     cob_current_y = 0;
     cob_current_x = 0;
     fore_color = 0;
     back_color = 0;
 
     fflush (stdout);
     fflush (stderr);
 
 #if 0   /* RXWRXW sigtin */
 #ifndef _WIN32
     /* If the process is backgrounded (running non interactively), */
     /* SIGTTIN or SIGTOU is emitted. If not caught, turns into a SIGSTP */
 #ifdef  SIGTTIN
     signal(SIGTTIN, SIG_IGN);
 #endif
 #ifdef  SIGTTOU
     signal(SIGTTOU, SIG_IGN);
 #endif
 #endif
 #endif
 
 #if 0   /* RXWRXW - setlocale */
 #ifdef  HAVE_SETLOCALE
     if (cobglobptr->cob_locale_orig) {
         setlocale (LC_ALL, cobglobptr->cob_locale_orig);
     }
     if (cobglobptr->cob_locale_ctype) {
         setlocale (LC_CTYPE, cobglobptr->cob_locale_ctype);
     }
 #endif
 #endif
 
     if (!initscr ()) {
         cob_runtime_error (_("Failed to initialize curses"));
         cob_stop_run (1);
     }
     cobglobptr->cob_screen_initialized = 1;
 #ifdef  HAVE_USE_LEGACY_CODING
     use_legacy_coding (2);
 #endif
 
 #if 0   /* RXWRXW - setlocale */
 #ifdef  HAVE_SETLOCALE
     if (cobglobptr->cob_locale) {
         setlocale (LC_ALL, cobglobptr->cob_locale);
         setlocale (LC_CTYPE, "C");
     }
 #endif
 #endif
 
     cbreak ();
     keypad (stdscr, 1);
     nonl ();
     noecho ();
     if (has_colors ()) {
         start_color ();
         pair_content ((short)0, &fore_color, &back_color);
         if (COLOR_PAIRS) {
 #ifdef  HAVE_LIBPDCURSES
             /* pdcurses sets ALL pairs to default fg/bg */
             /* IMHO a bug. */
             for (i = 1; i < (size_t)COLOR_PAIRS; ++i) {
                 init_pair ((short)i, 0, 0);
             }
 #endif
             cob_has_color = 1;
         }
     }
     attrset (A_NORMAL);
     getmaxyx (stdscr, COB_MAX_Y_COORD, COB_MAX_X_COORD);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void cob_screen_iterate ( cob_screen * s )

static

Definition at line 1490 of file screenio.c.

References __cob_screen::attr, __cob_screen::backg, __cob_screen::child, cob_screen_attr(), cob_screen_moveyx(), cob_screen_puts(), COB_SCREEN_TYPE_ATTRIBUTE, COB_SCREEN_TYPE_FIELD, COB_SCREEN_TYPE_GROUP, COB_SCREEN_TYPE_VALUE, DISPLAY_STATEMENT, __cob_screen::field, __cob_screen::foreg, __cob_screen::next, __cob_screen::occurs, __cob_screen::type, and __cob_screen::value.

Referenced by screen_display().

 {
     int n;
 
     switch (s->type) {
     case COB_SCREEN_TYPE_GROUP:
         cob_screen_moveyx (s);
         for (s = s->child; s; s = s->next) {
             cob_screen_iterate (s);
         }
         break;
     case COB_SCREEN_TYPE_FIELD:
         cob_screen_puts (s, s->field, 0, DISPLAY_STATEMENT);
         break;
     case COB_SCREEN_TYPE_VALUE:
         cob_screen_puts (s, s->value, 0, DISPLAY_STATEMENT);
         if (s->occurs) {
             for (n = 1; n < s->occurs; ++n) {
                 cob_screen_puts (s, s->value, 0,
                          DISPLAY_STATEMENT);
             }
         }
         break;
     case COB_SCREEN_TYPE_ATTRIBUTE:
         cob_screen_attr (s->foreg, s->backg, s->attr,
                  DISPLAY_STATEMENT);
         break;
     default:
         break;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void cob_screen_line_col	(	cob_field *	f,
		const int	l_or_c
	)

Definition at line 2366 of file screenio.c.

References cob_set_int(), COLS, init_cob_screen_if_needed(), and LINES.

 {
     init_cob_screen_if_needed ();
     if (!l_or_c) {
         cob_set_int (f, (int)LINES);
     } else {
         cob_set_int (f, (int)COLS);
     }
 }

Here is the call graph for this function:

static void cob_screen_moveyx ( cob_screen * s )

static

Definition at line 1391 of file screenio.c.

References __cob_screen::attr, cob_current_x, cob_current_y, cob_get_int(), cob_move_cursor(), COB_SCREEN_COLUMN_MINUS, COB_SCREEN_COLUMN_PLUS, COB_SCREEN_LINE_MINUS, COB_SCREEN_LINE_PLUS, __cob_screen::column, line, __cob_screen::line, origin_x, and origin_y.

Referenced by cob_prep_input(), and cob_screen_iterate().

 {
     int y;
     int x;
     int line;
     int column;
 
     if (s->line || s->column ||
         s->attr & (COB_SCREEN_LINE_PLUS | COB_SCREEN_LINE_MINUS |
                COB_SCREEN_COLUMN_PLUS |COB_SCREEN_COLUMN_MINUS)) {
         getyx (stdscr, y, x);
 #if 1   /* RXWRXW - Column adjust */
         if (x > 0) {
             x--;
         }
 #endif
         if (!s->line) {
             line = y;
         } else {
             line = origin_y + cob_get_int (s->line);
             if (line < 0) {
                 line = y;
             }
         }
         if (!s->column) {
             column = x;
         } else {
             column = origin_x + cob_get_int (s->column);
             if (column < 0) {
                 column = x;
             }
         }
         if (s->attr & COB_SCREEN_LINE_PLUS) {
             line = y + line;
         } else if (s->attr & COB_SCREEN_LINE_MINUS) {
             line = y - line;
         }
         if (s->attr & COB_SCREEN_COLUMN_PLUS) {
             column = x + column;
         } else if (s->attr & COB_SCREEN_COLUMN_MINUS) {
             column = x - column;
         }
 
         cob_move_cursor (line, column);
         refresh ();
         cob_current_y = line;
         cob_current_x = column;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void cob_screen_puts	(	cob_screen *	s,
		cob_field *	f,
		const cob_u32_t	is_input,
		const enum screen_statement	stmt
	)

static

Definition at line 800 of file screenio.c.

References __cob_screen::attr, __cob_screen::backg, cob_addch_no_trunc_check(), cob_addnstr(), COB_CH_AS, COB_CH_UL, cob_current_x, cob_current_y, cob_move_cursor(), cob_screen_attr(), COB_SCREEN_INPUT, COB_SCREEN_SECURE, cob_field::data, __cob_screen::foreg, get_screen_item_line_and_col(), line, __cob_screen::prompt, raise_ec_on_truncation(), and cob_field::size.

Referenced by cob_prep_input(), cob_screen_iterate(), and refresh_field().

 {
     unsigned char   *p;
     size_t      size;
     int     line;
     int     column;
     chtype      promptchar;
 
     get_screen_item_line_and_col (s, &line, &column);
 
     /* Move to specified position */
     cob_move_cursor (line, column);
     cob_current_y = line;
     cob_current_x = column;
 #if 0   /* RXWRXW - Attr */
     cob_screen_attr (s->foreg, s->backg, s->attr);
 #endif
     if (s->attr & COB_SCREEN_INPUT) {
         cob_screen_attr (s->foreg, s->backg, s->attr, stmt);
         if (s->prompt) {
             promptchar = s->prompt->data[0];
         } else {
             promptchar = COB_CH_UL;
         }
         p = f->data;
         raise_ec_on_truncation (f->size);
         for (size = 0; size < f->size; size++, p++) {
             if (s->attr & COB_SCREEN_SECURE) {
                 cob_addch_no_trunc_check (COB_CH_AS);
             } else if (*p <= ' ') {
                 cob_addch_no_trunc_check (promptchar);
             } else {
                 cob_addch_no_trunc_check ((const chtype)*p);
             }
         }
     } else if (!is_input) {
         cob_screen_attr (s->foreg, s->backg, s->attr, stmt);
         cob_addnstr ((char *)f->data, (int)f->size);
     } else {
         column += (int)f->size;
         cob_move_cursor (line, column);
     }
     refresh ();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void cob_screen_set_mode ( const cob_u32_t smode )

Definition at line 2388 of file screenio.c.

Referenced by cob_sys_system().

 {
     if (!smode) {
         refresh ();
         def_prog_mode ();
         endwin ();
     } else {
         reset_prog_mode ();
         refresh ();
     }
 }

Here is the caller graph for this function:

static void cob_speaker_beep ( void )

static

Definition at line 115 of file screenio.c.

Referenced by cob_beep(), and cob_sys_sound_bell().

 {
     int fd;
 
     fd = fileno (stdout);
     if (fd >= 0) {
         (void)write (fd, "\a", (size_t)1);
     }
 }

Here is the caller graph for this function:

int cob_sys_clear_screen ( void )

Definition at line 2377 of file screenio.c.

References cob_current_x, cob_current_y, and init_cob_screen_if_needed().

Referenced by GCic_().

 {
     init_cob_screen_if_needed ();
     clear ();
     refresh ();
     cob_current_y = 0;
     cob_current_x = 0;
     return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int cob_sys_get_csr_pos ( unsigned char * fld )

Definition at line 2530 of file screenio.c.

References COB_CHK_PARMS.

 {
 #ifdef  COB_GEN_SCREENIO
     int cline;
     int ccol;
 #endif
 
     COB_CHK_PARMS (CBL_GET_CSR_POS, 1);
 
 #ifdef  COB_GEN_SCREENIO
     getyx (stdscr, cline, ccol);
     fld[0] = (unsigned char)cline;
     fld[1] = (unsigned char)ccol;
 
 #else
     fld[0] = 1U;
     fld[1] = 1U;
 #endif
     return 0;
 }

int cob_sys_get_scr_size	(	unsigned char *	line,
		unsigned char *	col
	)

Definition at line 2552 of file screenio.c.

References COB_CHK_PARMS, COLS, and LINES.

 {
     COB_CHK_PARMS (CBL_GET_SCR_SIZE, 2);
 
 #ifdef  COB_GEN_SCREENIO
     *line = (unsigned char)LINES;
     *col = (unsigned char)COLS;
 #else
     *line = 24U;
     *col = 80U;
 #endif
     return 0;
 }

int cob_sys_sound_bell ( void )

Definition at line 2506 of file screenio.c.

References cob_beep(), COB_BEEP_VALUE, cob_screen_init(), __cob_global::cob_screen_initialized, and cob_speaker_beep().

 {
     if (COB_BEEP_VALUE == 9) {
         return 0;
     }
 #ifdef  COB_GEN_SCREENIO
     if (!cobglobptr->cob_screen_initialized &&
         COB_BEEP_VALUE != 2) {
         cob_screen_init ();
     }
     cob_beep ();
 #else
     cob_speaker_beep ();
 #endif
     return 0;
 }

Here is the call graph for this function:

static int compare_yx	(	const void *	m1,
		const void *	m2
	)

static

Definition at line 1368 of file screenio.c.

References cob_inp_struct::this_x, and cob_inp_struct::this_y.

Referenced by screen_accept().

 {
     const struct cob_inp_struct *s1;
     const struct cob_inp_struct *s2;
 
     s1 = m1;
     s2 = m2;
     if (s1->this_y < s2->this_y) {
         return -1;
     }
     if (s1->this_y > s2->this_y) {
         return 1;
     }
     if (s1->this_x < s2->this_x) {
         return -1;
     }
     if (s1->this_x > s2->this_x) {
         return 1;
     }
     return 0;
 }

Here is the caller graph for this function:

static void extract_line_and_col_vals	(	const int	is_screen,
		cob_field *	line,
		cob_field *	column,
		int *	sline,
		int *	scolumn
	)

static

Definition at line 1564 of file screenio.c.

References get_line_column(), NULL, pos_to_line_column(), and set_default_line_column().

Referenced by cob_field_accept(), cob_field_display(), cob_screen_accept(), and cob_screen_display().

 {
     if (column == NULL) {
         if (line == NULL) {
             set_default_line_column (is_screen, sline, scolumn);
         } else {
             /*
               line actually contains both the line and field
               numbers.
             */
             pos_to_line_column (line, sline, scolumn);
         }
     } else {
         get_line_column (line, column, sline, scolumn);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void field_accept	(	cob_field *	f,
		const int	sline,
		const int	scolumn,
		cob_field *	fgc,
		cob_field *	bgc,
		cob_field *	fscroll,
		cob_field *	ftimeout,
		cob_field *	prompt,
		cob_field *	size_is,
		const int	fattr
	)

static

Definition at line 1769 of file screenio.c.

References ACCEPT_STATEMENT, cob_field::attr, cob_addch(), cob_addch_no_trunc_check(), cob_addnch(), cob_beep(), COB_CH_AS, COB_CH_SP, COB_CH_UL, cob_check_pos_status(), cob_convert_key(), __cob_global::cob_exception_code, COB_FIELD_IS_NUMERIC, cob_field_is_numeric_or_numeric_edited(), cob_get_int(), __cob_settings::cob_insert_mode, COB_MEDIUM_MAX, cob_move(), cob_move_cursor(), cob_screen_attr(), COB_SCREEN_AUTO, COB_SCREEN_LOWER, COB_SCREEN_NO_ECHO, COB_SCREEN_PROMPT, COB_SCREEN_SCROLL_DOWN, COB_SCREEN_SECURE, COB_SCREEN_UPDATE, COB_SCREEN_UPPER, cob_set_int(), COB_TERM_BUFF, COB_TIMEOUT_SCALE, const_alpha_attr, cob_field::data, init_cob_screen_if_needed(), NULL, origin_x, origin_y, raise_ec_on_truncation(), cob_field::size, and unlikely.

Referenced by cob_field_accept().

 {
     unsigned char   *p;
     unsigned char   *p2;
     size_t      count;
     int     keyp;
     int     fret;
     int     cline;
     int     ccolumn;
     int     rightpos;
     int     ateof;
     int     move_char;      /* data shift character */
     int     prompt_char;    /* prompt character */
     int     gettimeout;
     chtype      promptchar;
     int     ssize_is = 0;   /* WITH SIZE IS */
     int     size_accept = 0;    /* final size to accept */
     cob_field   temp;
 #if 0   /* RXWRXW - Screen update */
     cob_field   char_temp;
     unsigned char   space_buff[4];
 #endif
 
     memset (COB_TERM_BUFF, ' ', (size_t)COB_MEDIUM_MAX);
     temp.data = COB_TERM_BUFF;
     temp.attr = &const_alpha_attr;
 #if 0   /* RXWRXW - Screen update */
     char_temp.data = space_buff;
     char_temp.attr = &const_alpha_attr;
     char_temp.size = 1;
     space_buff[0] = ' ';
     space_buff[1] = 0;
 #endif
 
     origin_y = 0;
     origin_x = 0;
 
     /* Set the default prompt character */
     if (prompt) {
         promptchar = prompt->data[0];
     } else {
         promptchar = COB_CH_UL;
     }
     init_cob_screen_if_needed ();
 
     if (ftimeout) {
         gettimeout = cob_get_int (ftimeout) * COB_TIMEOUT_SCALE;
         if (gettimeout >= 0 && gettimeout < 500) {
             gettimeout = 500;
         }
     } else {
         gettimeout = -1;
     }
 
     if (fscroll) {
         keyp = cob_get_int (fscroll);
         if (fattr & COB_SCREEN_SCROLL_DOWN) {
             keyp = -keyp;
         }
         scrollok (stdscr, 1);
         scrl (keyp);
         scrollok (stdscr, 0);
         refresh ();
     }
     cobglobptr->cob_exception_code = 0;
 
     cob_move_cursor (sline, scolumn);
 
     cob_screen_attr (fgc, bgc, fattr, ACCEPT_STATEMENT);
 
     if (f) {
         /* Field size to accept */
         size_accept = (int)f->size;
         /* WITH SIZE IS */
         if (size_is) {
             ssize_is = cob_get_int (size_is);
             /* Use WITH SIZE IS when less than field size */
             if (ssize_is > 0 && ssize_is < (int)f->size) {
               size_accept = ssize_is;
             }
         }
 
         p = COB_TERM_BUFF;
         temp.size = size_accept;
         if (fattr & COB_SCREEN_UPDATE) {
             cob_move (f, &temp);
         }
         /* SIZE IS greater than field, blank out trailing screen */
         if (ssize_is > (int)f->size) {
             cob_addnch (ssize_is, COB_CH_SP);
             cob_move_cursor (sline, scolumn);
         }
         raise_ec_on_truncation (size_accept);
         for (count = 0; count < size_accept; count++) {
             if (fattr & COB_SCREEN_SECURE) {
                 cob_addch_no_trunc_check (COB_CH_AS);
             } else if (fattr & COB_SCREEN_NO_ECHO) {
                 cob_addch_no_trunc_check (COB_CH_SP);
             } else if (fattr & COB_SCREEN_UPDATE) {
                 fret = *p++;
                 cob_addch_no_trunc_check ((const chtype)fret);
             } else if (COB_FIELD_IS_NUMERIC (f)) {
                 cob_addch_no_trunc_check ('0');
             } else if (fattr & COB_SCREEN_PROMPT) {
                 cob_addch_no_trunc_check (promptchar);
             } else {
                 cob_addch_no_trunc_check (COB_CH_SP);
             }
         }
         cob_move_cursor (sline, scolumn);
 #if 0   /* RXWRXW - Screen update */
         if (!(fattr & COB_SCREEN_UPDATE)) {
             if (cob_field_is_numeric_or_numeric_edited (f)) {
                 cob_set_int (f, 0);
             } else {
                 cob_move (&char_temp, f);
             }
         }
 #endif
         rightpos = scolumn + size_accept - 1;
         p = COB_TERM_BUFF;
     } else {
         rightpos = 0;
         p = NULL;
     }
     fret = 0;
     ateof = 0;
     count = 0;
 
     /* Get characters from keyboard, processing each one. */
     for (; ;) {
         /* Get current line, column. */
         getyx (stdscr, cline, ccolumn);
         /* Trailing prompts. */
         if (fattr & COB_SCREEN_NO_ECHO) {
             prompt_char = COB_CH_SP;
         } else if (f && COB_FIELD_IS_NUMERIC (f)) {
             prompt_char = '0';
         } else if (fattr & COB_SCREEN_PROMPT) {
             prompt_char = promptchar;
         } else {
             prompt_char = COB_CH_SP;
         }
         for (count = rightpos; count > scolumn - 1; count--) {
             /* Get character */
             p2 = COB_TERM_BUFF + count - scolumn;
             move_char = *p2;
             /* Field prompts. */
             if (COB_FIELD_IS_NUMERIC (f)) {
             /* Numeric prompt zeros. */
             if (move_char == '0') {
                 cob_move_cursor (cline, count);
                 cob_addch (prompt_char);
             } else {
                 /* Switch to remove prompts from within field. */
                 if (fattr & COB_SCREEN_NO_ECHO) {
                 prompt_char = COB_CH_SP;
                 } else if (fattr & COB_SCREEN_SECURE) {
                 prompt_char = COB_CH_AS;
                 } else {
                 prompt_char = '0';
                 }
             }
             } else {
             /* Alpha prompts. */
             if (move_char == ' ') {
                 cob_move_cursor (cline, count);
                 cob_addch (prompt_char);
             } else {
                 /* Switch to remove prompts from within field. */
                 if (fattr & COB_SCREEN_NO_ECHO) {
                 prompt_char = COB_CH_SP;
                 } else if (fattr & COB_SCREEN_SECURE) {
                 prompt_char = COB_CH_AS;
                 } else {
                 prompt_char = COB_CH_SP;
                 }
             }
             }
         }
         /* Cursor to current column. */
         cob_move_cursor (cline, ccolumn);
         /* Refresh screen. */
         refresh ();
         errno = 0;
         timeout (gettimeout);
 
         /* Get a character. */
         keyp = getch ();
 
         /* Key error. */
         if (keyp == ERR) {
             fret = 8001;
             goto field_return;
         }
         /* 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 ();
             cob_beep ();
             continue;
         }
 
         /* Return special keys */
         switch (keyp) {
         case KEY_ENTER:
             /* 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:
             /* Shift-Tab key, Back tab. */
             fret = 2008;
             goto field_return;
         default:
             break;
         }
 
         /* extension: ACCEPT OMITTED */
         if (unlikely(!f)) {
             (void)flushinp ();
             cob_beep ();
             continue;
         }
 
         /* Positioning keys */
         switch (keyp) {
         case KEY_BACKSPACE:
             /* Backspace key. */
             if (ccolumn > scolumn) {
                 /* Shift remainder left with cursor. */
                 for (count = ccolumn; count < rightpos + 1; count++) {
                 /* Get character. */
                 p2 = COB_TERM_BUFF + count - scolumn ;
                 move_char = *p2;
                 /* Move the character left. */
                 p2 = COB_TERM_BUFF + count - scolumn - 1;
                 *p2 = move_char;
                 /* Update screen with moved character. */
                 cob_move_cursor (cline, count - 1);
                 if (fattr & COB_SCREEN_NO_ECHO) {
                     cob_addch (COB_CH_SP);
                 } else if (fattr & COB_SCREEN_SECURE) {
                     cob_addch (COB_CH_AS);
                 } else {
                     cob_addch (move_char);
                 }
                 }
                 /* Put space as the right most character. */
                 p2 = COB_TERM_BUFF + size_accept - 1;
                 if (fattr & COB_SCREEN_NO_ECHO) {
                 *p2 = COB_CH_SP;
                 } else if (COB_FIELD_IS_NUMERIC (f)) {
                 *p2 = '0';
                 } else {
                 *p2 = COB_CH_SP;
             }
                 /* Move cursor left one from current. */
                 ccolumn--;
                 cob_move_cursor (cline, ccolumn);
                 p--;
             }
                 ateof = 0;
             continue;
         case KEY_HOME:
             /* Home key, cursor to start of characters. */
             /* Prepare for empty field. */
             ccolumn = rightpos;
             move_char = ' ';
             /* Find non-blank from left. */
             for (count = scolumn; count <= rightpos; count++) {
               /* Get character. */
               p2 = COB_TERM_BUFF + count - scolumn;
               move_char = *p2;
               /* Non blank stop. */
               if (move_char != ' ') {
                 ccolumn = count;
                 break;
               }
             }
             cob_move_cursor (cline, ccolumn);
             p = COB_TERM_BUFF + ccolumn - scolumn;
             ateof = 0;
             continue;
         case 01026:
             /* Alt-Home key, cursor to start of field. */
             cob_move_cursor (sline, scolumn);
             p = COB_TERM_BUFF;
             ateof = 0;
             continue;
         case KEY_END:
             /* End key, cursor to end of characters. */
             /* Prepare for empty field. */
             ccolumn = scolumn;
             move_char = ' ';
             /* Find non blank from right. */
             for (count = rightpos; count >= scolumn; count--) {
                 /* Get character. */
                 p2 = COB_TERM_BUFF + count - scolumn;
                 move_char = *p2;
                 /* Non blank stop. */
                 if (move_char != ' ') {
                 ccolumn = count;
                 break;
                 }
             }
             /* Cursor to first blank after. */
             if (move_char != ' ' && ccolumn != rightpos) {
                 ccolumn++;
             }
             cob_move_cursor (cline, ccolumn);
             p = COB_TERM_BUFF + ccolumn - scolumn;
             ateof = 0;
             continue;
         case 01021:
             /* Alt-End key, cursor to end of size of field */
             cob_move_cursor (sline, rightpos);
             p = COB_TERM_BUFF + size_accept - 1;
             ateof = 0;
             continue;
         case KEY_LEFT:
         case KEY_CLOSE:
             /* Left-arrow     KEY_LEFT  auto-skip. */
             /* Alt-left-arrow KEY_CLOSE no auto-skip. */
             if (ccolumn > scolumn) {
                 ccolumn--;
                 cob_move_cursor (cline, ccolumn);
                 p = COB_TERM_BUFF + ccolumn - scolumn;
                 continue;
             }
             /* End of field, auto-skip, return left-arrow. */
             if (fattr & COB_SCREEN_AUTO && keyp == KEY_LEFT) {
                 fret = 2009;
                 goto field_return;
             }
             cob_beep ();
             continue;
         case KEY_RIGHT:
         case KEY_PREVIOUS:
             /* Right-arrow     KEY_RIGHT    auto-skip. */
             /* Alt-right-arrow KEY_PREVIOUS no auto-skip. */
             if (ccolumn < rightpos) {
                 ccolumn++;
                 cob_move_cursor (cline, ccolumn);
                 p = COB_TERM_BUFF + ccolumn - scolumn;
                 continue;
             }
             /* End of field, auto-skip, return right-arrow. */
             if (fattr & COB_SCREEN_AUTO && keyp == KEY_RIGHT) {
                 fret = 2010;
                 goto field_return;
             }
             cob_beep ();
             continue;
         case KEY_IC:
             /* Insert key toggle. */
             /* If off turn on, if on turn off. */
             if (cobsetptr->cob_insert_mode == 0) {
                 cobsetptr->cob_insert_mode = 1;     /* on */
                 /* to do, needs vertical bar cursor */
                 /* this doesn't seem to work */
                 count = curs_set(1);
             } else {
                 cobsetptr->cob_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 = COB_TERM_BUFF + count - scolumn + 1;
                 move_char = *p2;
                 /* Move the character left. */
                 p2 = COB_TERM_BUFF + count - scolumn;
                 *p2 = move_char;
                 /* Update screen with moved character. */
                 cob_move_cursor (cline, count);
                 if (fattr & COB_SCREEN_NO_ECHO) {
                 cob_addch (COB_CH_SP);
                 } else if (fattr & COB_SCREEN_SECURE) {
                 cob_addch (COB_CH_AS);
                     } else {
                 cob_addch (move_char);
                     }
                 }
             /* Put space as the right most character. */
             p2 = COB_TERM_BUFF + size_accept - 1;
             if (fattr & COB_SCREEN_NO_ECHO) {
                 *p2 = COB_CH_SP;
             } else if (COB_FIELD_IS_NUMERIC (f)) {
                 *p2 = '0';
             } else {
                 *p2 = COB_CH_SP;
             }
             /* Put cursor back to original position. */
             cob_move_cursor (cline, ccolumn);
             continue;
         case KEY_EOL:
             /* Alt-Delete key, erase cursor to end of field. */
             for (count = ccolumn; count <= rightpos; count++) {
                 /* Character position. */
                 p2 = COB_TERM_BUFF + count - scolumn;
                 /* Blank character. */
                 if (fattr & COB_FIELD_IS_NUMERIC (f)) {
                 move_char = '0';
                 } else {
                 move_char = COB_CH_SP;
                 }
                 *p2 = move_char;
                 /* Update screen with blank character. */
                 cob_move_cursor (cline, count);
                 if (fattr & COB_SCREEN_NO_ECHO) {
                 cob_addch (COB_CH_SP);
                 } else if (fattr & COB_SCREEN_SECURE) {
                 cob_addch (COB_CH_AS);
             } else {
                 cob_addch (move_char);
                 }
             }
             /* Put cursor back to original position. */
             cob_move_cursor (cline, ccolumn);
             continue;
         default:
             break;
         }
 
         /* Printable character. */
         if (keyp > '\037' && keyp < (int)A_CHARTEXT) {
             /* Numeric field check. */
             if (cob_field_is_numeric_or_numeric_edited (f)) {
                 if (keyp < '0' || keyp > '9') {
                     cob_beep ();
                     continue;
                 }
             }
             if (fattr & COB_SCREEN_UPPER) {
                 if (islower (keyp)) {
                     keyp = toupper (keyp);
                 }
             } else if (fattr & COB_SCREEN_LOWER) {
                 if (isupper (keyp)) {
                     keyp = tolower (keyp);
                 }
             }
             /* Insert character. */
             if (cobsetptr->cob_insert_mode == 1) {
                 /* Move remainder to the right. */
                 for (count = rightpos; count > ccolumn - 1; count--) {
                 /* Get character */
                 p2 = COB_TERM_BUFF + count - scolumn - 1;
                 move_char = *p2;
                 /* Move character one right. */
                 p2 = COB_TERM_BUFF + count - scolumn;
                 *p2 = move_char;
                 /* Update screen with moved character. */
                 if (count > scolumn) {
                     cob_move_cursor (cline, count);
                     if (move_char != ' ') {
                     if (fattr & COB_SCREEN_NO_ECHO) {
                         cob_addch (COB_CH_SP);
                     } else if (fattr & COB_SCREEN_SECURE) {
                         cob_addch (COB_CH_AS);
                     } else {
                         cob_addch (move_char);
                     }
                     }
                 }
                 }
                 cob_move_cursor (cline, ccolumn);
             }
             *p = (unsigned char)keyp;
             count = 1;
             /* Display character or '*' if secure. */
             if (fattr & COB_SCREEN_SECURE) {
                 cob_addch (COB_CH_AS);
             } else if (fattr & COB_SCREEN_NO_ECHO) {
                 cob_addch (COB_CH_SP);
             } else {
                 cob_addch ((const chtype)keyp);
             }
             if (ccolumn == rightpos) {
                 /* Auto-skip at end of field. */
                 if (fattr & COB_SCREEN_AUTO) {
                     break;
                 }
                 cob_move_cursor (cline, ccolumn);
                 if (ateof) {
                     cob_beep ();
                 } else {
                     ateof = 1;
                 }
             } else {
                 p++;
             }
             continue;
         }
         (void)flushinp ();
         cob_beep ();
     }
 field_return:
     if (f) {
         cob_move_cursor (sline, rightpos + 1);
     }
     refresh ();
     cob_check_pos_status (fret);
     if (!f) {
         return;
     }
     cob_move (&temp, f);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void field_display	(	cob_field *	f,
		const int	line,
		const int	column,
		cob_field *	fgc,
		cob_field *	bgc,
		cob_field *	fscroll,
		cob_field *	size_is,
		const int	fattr
	)

static

Definition at line 1700 of file screenio.c.

References cob_field::attr, cob_addnch(), COB_CH_SP, cob_fatal_error(), COB_FERROR_CODEGEN, cob_get_int(), cob_move_cursor(), cob_screen_attr(), COB_SCREEN_EMULATE_NL, COB_SCREEN_NO_DISP, COB_SCREEN_SCROLL_DOWN, COB_TYPE_ALPHANUMERIC_ALL, cob_field::data, DISPLAY_STATEMENT, init_cob_screen_if_needed(), line, LINES, origin_x, origin_y, cob_field::size, cob_field_attr::type, and unlikely.

Referenced by cob_field_display().

 {
     int sline;
     int scolumn;
     int ssize_is = 0;   /* WITH SIZE IS */
     int size_display;   /* final size to display */
     char    fig_const;  /* figurative constant character */
 
     if (unlikely(!f)) {
         cob_fatal_error(COB_FERROR_CODEGEN);
     }
 
     init_cob_screen_if_needed ();
 
     origin_y = 0;
     origin_x = 0;
 
     /* Field size to display */
     size_display = (int)f->size;
     /* WITH SIZE IS */
     if (size_is) {
         ssize_is = cob_get_int (size_is);
         /* Use WITH SIZE IS when less than field size */
         if (ssize_is > 0 && ssize_is < (int)f->size) {
             size_display = ssize_is;
         }
     }
 
     if (fscroll) {
         sline = cob_get_int (fscroll);
         if (fattr & COB_SCREEN_SCROLL_DOWN) {
             sline = -sline;
         }
         scrollok (stdscr, 1);
         scrl (sline);
         scrollok (stdscr, 0);
         refresh ();
     }
 
     sline = line;
     scolumn = column;
     cob_move_cursor (sline, scolumn);
 
     cob_screen_attr (fgc, bgc, fattr, DISPLAY_STATEMENT);
     if (!(fattr & COB_SCREEN_NO_DISP)) {
         /* figurative constant and WITH SIZE repeats the character */
         if ((size_is)
            && f->attr->type == COB_TYPE_ALPHANUMERIC_ALL
            && (int)f->size == 1) {
             fig_const = f->data[0];
             cob_addnch (ssize_is, fig_const);
         } else {
             addnstr ((char *)f->data, size_display);
             /* WITH SIZE larger than field displays trailing spaces */
             cob_addnch (ssize_is - f->size, COB_CH_SP);
         }
     }
     if (fattr & COB_SCREEN_EMULATE_NL) {
         if (++sline >= LINES) {
             sline = 0;
         }
         cob_move_cursor (sline, 0);
     }
     refresh ();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int field_is_empty ( cob_screen * s )

static

Definition at line 854 of file screenio.c.

References cob_field::data, __cob_screen::field, and cob_field::size.

Referenced by satisfied_full_clause(), and satisfied_required_clause().

 {
     unsigned char   *data = s->field->data;
     size_t      size = s->field->size;
     size_t      i;
 
     for (i = 0; i < size; ++i) {
         if (!isspace (data[i])) {
             return 0;
         }
     }
 
     return 1;
 }

Here is the caller graph for this function:

static int field_is_full ( cob_screen * s )

static

Definition at line 962 of file screenio.c.

References cob_field::data, __cob_screen::field, and cob_field::size.

Referenced by satisfied_full_clause().

 {
     unsigned char   *data = s->field->data;
     size_t      size = s->field->size;
 
     /* Per the standard, only the first and last chars need be non-space. */
     return !isspace (*data) && !isspace (*(data + size - 1));
 }

Here is the caller graph for this function:

static int field_is_zero ( cob_screen * s )

static

Definition at line 870 of file screenio.c.

References COB_MODULE_PTR, cob_field::data, __cob_screen::field, and cob_field::size.

Referenced by field_is_zero_or_no_zero_suppression(), satisfied_full_clause(), and satisfied_required_clause().

 {
     unsigned char   *data = s->field->data;
     size_t      size = s->field->size;
     size_t      i;
     unsigned char   decimal_point = COB_MODULE_PTR->decimal_point;
 
     for (i = 0; i < size; ++i) {
         if (!(isspace (data[i]) || data[i] == '0'
               || data[i] == decimal_point)) {
             return 0;
         }
     }
 
     return 1;
 }

Here is the caller graph for this function:

static int field_is_zero_or_no_zero_suppression ( cob_screen * s )

static

Definition at line 928 of file screenio.c.

References COB_FIELD_DATA, COB_FIELD_PIC, COB_FIELD_SIZE, __cob_screen::field, field_is_zero(), get_num_int_digits_for_no_zero_sup(), and pic_has_zero_suppression().

Referenced by satisfied_full_clause().

 {
     const char  *pic = COB_FIELD_PIC (s->field);
     int     i;
     size_t      size = COB_FIELD_SIZE (s->field);
     unsigned char   *data = COB_FIELD_DATA (s->field);
     int     num_integer_digits;
     int     num_digits_seen = 0;
 
     if (field_is_zero (s) || !pic_has_zero_suppression (pic)) {
         return 1;
     }
 
     num_integer_digits = get_num_int_digits_for_no_zero_sup (pic);
 
     /*
       Verify there are sufficient non-zero digits before a decimal
       point/the end to fill the integer part of the field.
     */
     for (i = 0; i < size; ++i) {
         if (isdigit (data[i])) {
             if (data[i] != '0' || num_digits_seen != 0) {
                 ++num_digits_seen;
             }
         } else if (!isspace (data[i]) && num_digits_seen != 0) {
             break;
         }
     }
 
     return num_digits_seen >= num_integer_digits;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int finalize_all_fields	(	struct cob_inp_struct *	sptr,
		const size_t	total_idx
	)

static

Definition at line 1071 of file screenio.c.

References finalize_field_input(), and cob_inp_struct::scr.

Referenced by cob_screen_get_all().

 {
     const struct cob_inp_struct *end = sptr + total_idx;
 
     for (; sptr < end; ++sptr) {
         if (finalize_field_input (sptr->scr)) {
             return 1;
         }
     }
 
     return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int finalize_field_input ( cob_screen * s )

static

Definition at line 1053 of file screenio.c.

References cob_field_is_numeric_or_numeric_edited(), __cob_screen::field, format_field(), satisfied_full_clause(), satisfied_required_clause(), and valid_field_data().

Referenced by cob_screen_get_all(), and finalize_all_fields().

 {
     /* Only numeric types need to be validated and formatted. */
     if (cob_field_is_numeric_or_numeric_edited (s->field)) {
         if (!valid_field_data (s->field)) {
             return 1;
         }
         format_field (s);
     }
 
     if (!satisfied_full_clause (s) || !satisfied_required_clause (s)) {
         return 1;
     }
 
     return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void format_field ( cob_screen * s )

static

Definition at line 1025 of file screenio.c.

References cob_field::attr, COB_FIELD_INIT, COB_FIELD_IS_NUMERIC, cob_free(), cob_intr_numval(), cob_intr_numval_c(), cob_malloc(), cob_move(), COB_TYPE_NUMERIC_EDITED, cob_field::data, __cob_screen::field, NULL, refresh_field(), cob_field::size, and cob_field_attr::type.

Referenced by cob_intr_formatted_time(), and finalize_field_input().

 {
     cob_field   field;
     size_t      size = s->field->size;
     unsigned char   *data;
 
     /*
       We copy the data into another field and move it back to format the
       numeric data neatly, rather than re-implement that logic here. We
       assume the data is valid.
     */
     data = cob_malloc (size);
     memcpy (data, s->field->data, size);
     COB_FIELD_INIT (size, data, s->field->attr);
 
     if (COB_FIELD_IS_NUMERIC (s->field)) {
         cob_move (cob_intr_numval (&field), s->field);
     } else if (field.attr->type == COB_TYPE_NUMERIC_EDITED) {
         cob_move (cob_intr_numval_c (&field, NULL), s->field);
     }
 
     cob_free (data);
 
     refresh_field (s);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static cob_screen* get_last_child ( cob_screen *const s )

static

Definition at line 687 of file screenio.c.

References __cob_screen::child, and __cob_screen::next.

Referenced by get_prev_screen_item().

 {
     cob_screen  *child;
 
     for (child = s->child; child->next; child = child->next);
 
     if (child->child) {
         return get_last_child (child);
     } else {
         return child;
     }
 }

Here is the caller graph for this function:

static void get_line_column	(	cob_field *	fline,
		cob_field *	fcol,
		int *	line,
		int *	col
	)

static

Definition at line 273 of file screenio.c.

References cob_get_int(), and NULL.

Referenced by extract_line_and_col_vals().

 {
     int line_val;
     int col_val;
 
     if (fline == NULL) {
         *line = 0;
     } else {
         line_val = cob_get_int (fline) - 1;
         if (line_val < 0) {
             line_val = 0;
         }
 
         *line = line_val;
     }
 
     if (fcol == NULL) {
         *col = 0;
     } else {
         col_val = cob_get_int (fcol) - 1;
         if (col_val < 0) {
             col_val = 0;
         }
 
         *col = col_val;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int get_num_int_digits_for_no_zero_sup ( const char * pic )

static

Definition at line 906 of file screenio.c.

References COB_MODULE_PTR.

Referenced by field_is_zero_or_no_zero_suppression().

 {
     int i;
     int *times_repeated;
     int num_digits = 0;
     char    numeric_separator = COB_MODULE_PTR->numeric_separator;
 
     for (i = 0; pic[i] != '\0'; i += 5) {
         if (pic[i] == '9' || pic[i] == 'Z' || pic[i] == '*') {
             times_repeated = (int *) (pic + i + 1);
             num_digits += *times_repeated;
         } else if (!(pic[i] == numeric_separator
                  || pic[i] == 'B' || pic[i] == '0' || pic[i] == '/')
                && num_digits != 0) {
             break;
         }
     }
 
     return num_digits;
 }

Here is the caller graph for this function:

static cob_screen* get_prev_screen_item ( cob_screen *const s )

static

Definition at line 701 of file screenio.c.

References __cob_screen::child, get_last_child(), NULL, __cob_screen::parent, and __cob_screen::prev.

Referenced by get_screen_item_line_and_col().

 {
     if (s->prev) {
         if (s->prev->child) {
             return get_last_child (s->prev);
         } else {
             return s->prev;
         }
     } else if (s->parent) {
         return s->parent;
     } else {
         return NULL;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void get_screen_item_line_and_col	(	cob_screen *	s,
		int *const	line,
		int *const	col
	)

static

Definition at line 748 of file screenio.c.

References __cob_screen::child, __cob_screen::column, get_prev_screen_item(), get_size(), is_first_screen_item(), __cob_screen::line, origin_x, origin_y, update_column(), and update_line().

Referenced by cob_screen_puts().

 {
     int     found_line = 0;
     int     found_col = 0;
     int         is_screen_to_display = 1;
     int     is_parent;
 
     *line = 0;
     *col = 0;
 
     for (; s; s = get_prev_screen_item (s)) {
         if (s->line) {
             if (!found_line) {
                 update_line (s, line, &found_line);
             }
 
             if (!s->column) {
                 found_col = 1;
             }
         }
 
         if (!found_col) {
             is_parent = !!s->child;
 
             if (!is_screen_to_display && !is_parent) {
                 *col += get_size (s) - 1;
             }
 
             if (s->column) {
                 update_column (s, col, &found_col);
             }
 
             if (!s->column && !is_parent && !is_first_screen_item (s)) {
                 /*
                   Note that parents are excluded; the standard
                   assumes COL + 1, unless otherwise specified,
                   on all screen items. This seems silly on group
                   items, hence why this non-standard extension.
                 */
                 ++(*col);
             }
         }
 
             is_screen_to_display = 0;
     }
 
     *line += origin_y;
     *col += origin_x;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static size_t get_size ( cob_screen * s )

static

Definition at line 738 of file screenio.c.

References __cob_screen::field, cob_field::size, and __cob_screen::value.

Referenced by get_screen_item_line_and_col().

 {
     if (s->field) {
         return s->field->size;
     } else { /* s->value */
         return s->value->size;
     }
 
 }

Here is the caller graph for this function:

static COB_INLINE COB_A_INLINE void init_cob_screen_if_needed ( void )

static

Definition at line 1583 of file screenio.c.

References cob_screen_init(), and __cob_global::cob_screen_initialized.

Referenced by cob_screen_line_col(), cob_sys_clear_screen(), field_accept(), field_display(), screen_accept(), and screen_display().

 {
     if (!cobglobptr->cob_screen_initialized) {
         cob_screen_init ();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int is_first_screen_item ( cob_screen * s )

static

Definition at line 674 of file screenio.c.

References __cob_screen::parent, and __cob_screen::prev.

Referenced by get_screen_item_line_and_col().

 {
     do {
         if (s->prev) {
             return 0;
         }
         s = s->parent;
     } while (s);
 
     return 1;
 }

Here is the caller graph for this function:

static int pic_has_zero_suppression ( const char * pic )

static

Definition at line 888 of file screenio.c.

Referenced by field_is_zero_or_no_zero_suppression().

 {
     int i;
 
     for (i = 0; pic[i] != '\0'; i += 5) {
         /*
           NB: + and - are floating-insertion editing characters, not
           zero-suppression ones.
         */
         if (pic[i] == 'Z' || pic[i] == '*') {
             return 1;
         }
     }
 
     return 0;
 }

Here is the caller graph for this function:

static void pos_to_line_column	(	cob_field *	pos,
		int *	line,
		int *	column
	)

static

Definition at line 1540 of file screenio.c.

References cob_get_int(), and cob_field::size.

Referenced by extract_line_and_col_vals().

 {
     int pos_val = cob_get_int (pos);
     int max_line_column;
 
     if (pos->size < 4) {
         *line = pos_val - 1;
         *column = 0;
         return;
     }
 
     if (pos->size == 4) {
         max_line_column = 100;
     } else if (pos->size == 6) {
         max_line_column = 1000;
     } else {
         /* Throw an exception? EC-SCREEN-IMP-LINE-VAR-LENGTH? */
         max_line_column = 1; /* set to some value that don't chrash */
     }
     *line = (pos_val / max_line_column) - 1;
     *column = (pos_val % max_line_column) - 1;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void raise_ec_on_invalid_line_or_col	(	const int	line,
		const int	column
	)

static

Definition at line 302 of file screenio.c.

References COB_EC_SCREEN_LINE_NUMBER, COB_EC_SCREEN_STARTING_COLUMN, and cob_set_exception().

Referenced by cob_move_cursor().

 {
     int max_y;
     int max_x;
 
     getmaxyx (stdscr, max_y, max_x);
     if (line < 0 || line >= max_y) {
         cob_set_exception (COB_EC_SCREEN_LINE_NUMBER);
     }
     if (column < 0 || column >= max_x) {
         cob_set_exception (COB_EC_SCREEN_STARTING_COLUMN);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void raise_ec_on_truncation ( const int item_size )

static

Definition at line 623 of file screenio.c.

References COB_EC_SCREEN_ITEM_TRUNCATED, cob_set_exception(), and COB_UNUSED.

Referenced by cob_addch(), cob_addnch(), cob_addnstr(), cob_screen_puts(), and field_accept().

 {
     int y;
     int x;
     int max_y;
     int max_x;
 
     COB_UNUSED (y);
     COB_UNUSED (max_y);
 
     getyx (stdscr, y, x);
     getmaxyx (stdscr, max_y, max_x);
 
     if (x + item_size - 1 > max_x) {
         cob_set_exception (COB_EC_SCREEN_ITEM_TRUNCATED);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void refresh_field ( cob_screen * s )

static

Definition at line 1014 of file screenio.c.

References ACCEPT_STATEMENT, __cob_settings::cob_legacy, cob_move_cursor(), cob_screen_puts(), and __cob_screen::field.

Referenced by format_field().

 {
     int     y;
     int     x;
 
     getyx (stdscr, y, x);
     cob_screen_puts (s, s->field, cobsetptr->cob_legacy, ACCEPT_STATEMENT);
     cob_move_cursor (y, x);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int satisfied_full_clause ( cob_screen * s )

static

Definition at line 972 of file screenio.c.

References __cob_screen::attr, COB_FIELD_IS_NUMERIC, COB_FIELD_TYPE, COB_SCREEN_FULL, COB_TYPE_NUMERIC_EDITED, __cob_screen::field, field_is_empty(), field_is_full(), field_is_zero(), and field_is_zero_or_no_zero_suppression().

Referenced by finalize_field_input().

 {
     if (!(s->attr & COB_SCREEN_FULL)) {
         return 1;
     }
 
     if (COB_FIELD_IS_NUMERIC (s->field)) {
         return !field_is_zero (s);
     } else if (COB_FIELD_TYPE (s->field) == COB_TYPE_NUMERIC_EDITED) {
         return field_is_zero_or_no_zero_suppression (s);
     } else { /* field is alphanumeric */
         return field_is_full (s) || field_is_empty (s);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int satisfied_required_clause ( cob_screen * s )

static

Definition at line 988 of file screenio.c.

References __cob_screen::attr, cob_field_is_numeric_or_numeric_edited(), COB_SCREEN_REQUIRED, __cob_screen::field, field_is_empty(), and field_is_zero().

Referenced by finalize_field_input().

 {
     if (!(s->attr & COB_SCREEN_REQUIRED)) {
         return 1;
     }
 
     if (cob_field_is_numeric_or_numeric_edited (s->field)) {
         return !field_is_zero (s);
     } else { /* field is alphanumeric */
         return !field_is_empty (s);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void screen_accept	(	cob_screen *	s,
		const int	line,
		const int	column,
		cob_field *	ftimeout
	)

static

Definition at line 1604 of file screenio.c.

References __cob_screen::attr, cob_base_inp, cob_check_pos_status(), cob_current_x, cob_current_y, __cob_global::cob_exception_code, cob_get_int(), COB_INP_SIZE, cob_malloc(), cob_move_cursor(), cob_prep_input(), cob_screen_get_all(), COB_SCREEN_INITIAL, COB_TIMEOUT_SCALE, compare_yx(), cob_inp_struct::down_index, global_return, init_cob_screen_if_needed(), line, origin_x, origin_y, cob_inp_struct::scr, cob_inp_struct::this_y, totl_index, and cob_inp_struct::up_index.

Referenced by cob_screen_accept().

 {
     struct cob_inp_struct   *sptr;
     struct cob_inp_struct   *sptr2;
     size_t          idx;
     size_t          n;
     size_t          posu;
     size_t          posd;
     size_t          prevy;
     size_t          firsty;
     int         starty;
     int         initial_curs;
     int         gettimeout;
 
     init_cob_screen_if_needed ();
     if (!cob_base_inp) {
         cob_base_inp = cob_malloc (COB_INP_SIZE);
     } else {
         memset (cob_base_inp, 0, COB_INP_SIZE);
     }
     cobglobptr->cob_exception_code = 0;
     cob_current_y = 0;
     cob_current_x = 0;
     totl_index = 0;
     origin_y = line;
     origin_x = column;
 
     cob_move_cursor (line, column);
 
     /* Prepare input fields */
     if (cob_prep_input (s)) {
         cob_check_pos_status (9001);
         return;
     }
 
     /* No input field is an error */
     if (!totl_index) {
         cob_check_pos_status (8000);
         return;
     }
 
     if (ftimeout) {
         gettimeout = cob_get_int (ftimeout) * COB_TIMEOUT_SCALE;
         if (gettimeout >= 0 && gettimeout < 500) {
             gettimeout = 500;
         }
     } else {
         gettimeout = -1;
     }
 
     /* Sort input fields on line, column */
     qsort (cob_base_inp, totl_index,
            sizeof(struct cob_inp_struct), compare_yx);
 
     posu = 0;
     posd = 0;
     prevy = 0;
     firsty = 0;
     sptr = cob_base_inp;
     starty = sptr->this_y;
     initial_curs = -1;
     /* Set up array for Cursor UP/DOWN */
     for (n = 0; n < totl_index; n++) {
         sptr = cob_base_inp + n;
         if ((sptr->scr->attr & COB_SCREEN_INITIAL) && initial_curs < 0) {
             initial_curs = (int)n;
         }
         if (sptr->this_y > starty) {
             if (!firsty) {
                 firsty = n;
             }
             starty = sptr->this_y;
             sptr2 = cob_base_inp + posd;
             for (idx = posd; idx < n; idx++, sptr2++) {
                 sptr2->down_index = n;
             }
             posu = prevy;
             prevy = n;
             posd = n;
         }
         sptr->up_index = posu;
     }
     sptr = cob_base_inp;
     for (n = 0; n < firsty; n++, sptr++) {
         sptr->up_index = posd;
     }
     global_return = 0;
     if (initial_curs < 0) {
         initial_curs = 0;
     }
     cob_screen_get_all (initial_curs, gettimeout);
     cob_check_pos_status (global_return);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void screen_display	(	cob_screen *	s,
		const int	line,
		const int	column
	)

static

Definition at line 1591 of file screenio.c.

References cob_move_cursor(), cob_screen_iterate(), init_cob_screen_if_needed(), line, origin_x, and origin_y.

Referenced by cob_screen_display(), and yyparse().

 {
     init_cob_screen_if_needed ();
 
     origin_y = line;
     origin_x = column;
 
     cob_move_cursor (line, column);
     cob_screen_iterate (s);
     refresh ();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static COB_INLINE COB_A_INLINE void set_default_line_column	(	const int	is_screen,
		int *	sline,
		int *	scolumn
	)

static

Definition at line 1523 of file screenio.c.

Referenced by extract_line_and_col_vals().

 {
     if (is_screen) {
         *sline = 0;
         *scolumn = 0;
     } else {
         getyx (stdscr, *sline, *scolumn);
         if (*sline < 0) {
             *sline = 0;
         }
         if (*scolumn < 0) {
             *scolumn = 0;
         }
     }
 }

Here is the caller graph for this function:

static void update_column	(	cob_screen *	s,
		int *const	count,
		int *const	found_clause
	)

static

Definition at line 733 of file screenio.c.

Referenced by get_screen_item_line_and_col().

739 {

Here is the caller graph for this function:

static void update_line	(	cob_screen *	s,
		int *const	count,
		int *const	found_clause
	)

static

Definition at line 732 of file screenio.c.

Referenced by get_screen_item_line_and_col().

739 {

Here is the caller graph for this function:

static int valid_field_data ( cob_field * field )

static

Definition at line 1002 of file screenio.c.

References cob_field::attr, cob_check_numval(), COB_FIELD_IS_NUMERIC, COB_TYPE_NUMERIC_EDITED, NULL, and cob_field_attr::type.

Referenced by finalize_field_input().

 {
     if (COB_FIELD_IS_NUMERIC (field)) {
         return cob_check_numval (field, NULL, 0, 0) == 0;
     } else if (field->attr->type == COB_TYPE_NUMERIC_EDITED) {
         return cob_check_numval (field, NULL, 1, 0) == 0;
     } else {
         return 1;
     }
 }