termio.c File Reference

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

Include dependency graph for termio.c:

Macros
#define	COB_LIB_EXPIMP

Functions
static void	display_numeric (cob_field *f, FILE *fp)
static void	pretty_display_numeric (cob_field *f, FILE *fp)
static void	display_alnum (cob_field *f, FILE *fp)
static void	display_common (cob_field *f, FILE *fp)
void	cob_display (const int to_stderr, const int newline, const int varcnt,...)
void	cob_accept (cob_field *f)
void	cob_init_termio (cob_global *lptr)

Variables
static cob_global *	cobglobptr
static const unsigned short	bin_digits []
static const cob_field_attr	const_alpha_attr

Macro Definition Documentation

#define COB_LIB_EXPIMP

Function Documentation

void cob_accept

(

cob_field *

f

)

References cob_field::attr, COB_EC_IMP_ACCEPT, cob_field_accept(), COB_FIELD_IS_NUMERIC, COB_FIELD_TYPE, COB_MEDIUM_MAX, COB_MODULE_PTR, cob_move(), __cob_global::cob_screen_initialized, COB_SCREEN_PROMPT, cob_set_exception(), cob_set_int(), COB_TERM_BUFF, COB_TYPE_NUMERIC_DISPLAY, const_alpha_attr, cob_field::data, NULL, p, cob_field::size, and unlikely.

{
    unsigned char   *p;
    size_t      size;
    int     ipchr;
    cob_field   temp;

    if (cobglobptr->cob_screen_initialized) {
        cob_field_accept (f, NULL, NULL, NULL, NULL,
                  NULL, NULL, NULL, COB_SCREEN_PROMPT);
        return;
    }
    if (COB_MODULE_PTR->crt_status) {
        if (COB_FIELD_IS_NUMERIC (COB_MODULE_PTR->crt_status)) {
            cob_set_int (COB_MODULE_PTR->crt_status, 0);
        } else {
            memset (COB_MODULE_PTR->crt_status->data, '0', (size_t)4);
        }
    }
    /* extension: ACCEPT OMITTED */
    if (unlikely(!f)) {
        for (; ; ) {
            ipchr = getchar ();
            if (ipchr == '\n' || ipchr == EOF) {
                break;
            }
        }
        return;
    }
    p = COB_TERM_BUFF;
    temp.data = p;
    temp.attr = &const_alpha_attr;
    size = 0;
    /* Read a line */
    for (; size < COB_MEDIUM_MAX; ) {
        ipchr = getchar ();
        if (unlikely(ipchr == EOF)) {
            cob_set_exception (COB_EC_IMP_ACCEPT);
            if (!size) {
                size = 1;
                p[0] = ' ';
                p[1] = 0;
            }
            break;
        } else if (ipchr == '\n') {
            break;
        }
        p[size++] = (char) ipchr;
    }
    temp.size = size;
    if (COB_FIELD_TYPE(f) == COB_TYPE_NUMERIC_DISPLAY) {
        if (temp.size > f->size) {
            temp.size = f->size;
        }
    }
    cob_move (&temp, f);
}

void cob_display	(	const int	to_stderr,
		const int	newline,
		const int	varcnt,
			...
	)

References COB_DISP_TO_STDERR, cob_field_display(), COB_SCREEN_EMULATE_NL, __cob_global::cob_screen_initialized, cob_u32_t, display_common(), NULL, and unlikely.

{
    FILE        *fp;
    cob_field   *f;
    int     i;
    int     nlattr;
    cob_u32_t   disp_redirect;
    va_list     args;

    disp_redirect = 0;
    if (to_stderr) {
        fp = stderr;
    } else {
        fp = stdout;
        if (cobglobptr->cob_screen_initialized) {
            if (!COB_DISP_TO_STDERR) {
                disp_redirect = 1;
            } else {
                fp = stderr;
            }
        }
    }

    nlattr = newline ? COB_SCREEN_EMULATE_NL : 0;
    va_start (args, varcnt);
    for (i = 0; i < varcnt; ++i) {
        f = va_arg (args, cob_field *);
        if (unlikely(disp_redirect)) {
            cob_field_display (f, NULL, NULL, NULL, NULL,
                       NULL, nlattr);
        } else {
            display_common (f, fp);
        }
    }
    va_end (args);

    if (newline && !disp_redirect) {
        putc ('\n', fp);
        fflush (fp);
    }
}

void cob_init_termio

(

cob_global *

lptr

)

Referenced by cob_init().

{
    cobglobptr = lptr;
}

static void display_alnum ( cob_field *  f, FILE *  fp  )

static

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

Referenced by display_common().

{
    size_t  i;

    for (i = 0; i < f->size; ++i) {
        putc (f->data[i], fp);
    }
}

static void display_common ( cob_field *  f, FILE *  fp  )

static

References cob_field::attr, bin_digits, COB_FIELD_IS_NUMERIC, COB_FIELD_IS_POINTER, COB_FIELD_REAL_BINARY, COB_FIELD_TYPE, COB_MODULE_PTR, cob_print_ieeedec(), cob_print_realbin(), COB_TYPE_NUMERIC_BINARY, COB_TYPE_NUMERIC_DOUBLE, COB_TYPE_NUMERIC_FLOAT, COB_TYPE_NUMERIC_FP_DEC128, COB_TYPE_NUMERIC_FP_DEC64, cob_field::data, cob_field_attr::digits, display_alnum(), display_numeric(), p, pretty_display_numeric(), and cob_field::size.

Referenced by cob_display().

{
    unsigned char   *p;
    union {
        double      f1doub;
        float       f1float;
    } un;
    int     n;
#if 0   /* RXWRXW - Print bin */
    cob_field   temp;
    cob_field_attr  attr;
#endif

    if (f->size == 0) {
        return;
    }
    switch (COB_FIELD_TYPE (f)) {
    case COB_TYPE_NUMERIC_DOUBLE:
        memcpy (&un.f1doub, f->data, sizeof (double));
        fprintf (fp, "%-.16G", un.f1doub);
        return;
    case COB_TYPE_NUMERIC_FLOAT:
        memcpy (&un.f1float, f->data, sizeof (float));
        fprintf (fp, "%-.8G", (double)un.f1float);
        return;
    case COB_TYPE_NUMERIC_FP_DEC64:
    case COB_TYPE_NUMERIC_FP_DEC128:
        cob_print_ieeedec (f, fp);
        return;
    default:
        break;
    }
    if (COB_FIELD_IS_POINTER (f)) {
        fprintf (fp, "0x");
#ifdef  WORDS_BIGENDIAN
        p = f->data;
        for (n = 0; n < sizeof(void *); ++n, ++p) {
#else
        p = f->data + sizeof(void *) - 1;
        for (n = sizeof(void *) - 1; n >= 0; --n, --p) {
#endif
            fprintf (fp, "%x%x", *p >> 4, *p & 0xF);
        }
        return;
    } else if (COB_FIELD_REAL_BINARY(f) ||
           (COB_FIELD_TYPE(f) == COB_TYPE_NUMERIC_BINARY &&
            !COB_MODULE_PTR->flag_pretty_display)) {
        cob_print_realbin (f, fp, bin_digits[f->size]);
        return;
#if 0   /* RXWRXW - print bin */
    } else if (COB_FIELD_TYPE(f) == COB_TYPE_NUMERIC_BINARY &&
            !COB_MODULE_PTR->flag_pretty_display) {
        attr = *f->attr;
        temp = *f;
        attr.digits = bin_digits[f->size];
        temp.attr = &attr;
        display_numeric (&temp, fp);
        return;
#endif
    } else if (COB_FIELD_IS_NUMERIC (f)) {
        if (COB_MODULE_PTR->flag_pretty_display) {
            pretty_display_numeric (f, fp);
        } else {
            display_numeric (f, fp);
        }
        return;
    }
    display_alnum (f, fp);
}

static void display_numeric ( cob_field *  f, FILE *  fp  )

static

References _, cob_field::attr, COB_ATTR_INIT, COB_FIELD_DIGITS, COB_FIELD_HAVE_SIGN, COB_FIELD_SCALE, COB_FIELD_SIGN_LEADING, COB_FIELD_TYPE, COB_FLAG_HAVE_SIGN, COB_FLAG_SIGN_LEADING, COB_FLAG_SIGN_SEPARATE, COB_MEDIUM_MAX, cob_move(), COB_TERM_BUFF, COB_TYPE_NUMERIC_DISPLAY, cob_field::data, cob_field_attr::flags, NULL, and cob_field::size.

Referenced by display_common().

{
    int     i;
    int     digits;
    int     scale;
    int     size;
    cob_field_attr  attr;
    cob_field   temp;

    digits = COB_FIELD_DIGITS (f);
    scale = COB_FIELD_SCALE (f);
    size = digits + (COB_FIELD_HAVE_SIGN (f) ? 1 : 0);
    if (size >= COB_MEDIUM_MAX) {
        fputs (_("(Not representable)"), fp);
        return;
    }
    COB_ATTR_INIT (COB_TYPE_NUMERIC_DISPLAY, digits, scale, 0, NULL);
    temp.size = size;
    temp.data = COB_TERM_BUFF;
    temp.attr = &attr;
    if (COB_FIELD_HAVE_SIGN (f)) {
        attr.flags = COB_FLAG_HAVE_SIGN | COB_FLAG_SIGN_SEPARATE;
        if (COB_FIELD_SIGN_LEADING (f) ||
            COB_FIELD_TYPE (f) != COB_TYPE_NUMERIC_DISPLAY) {
            attr.flags |= COB_FLAG_SIGN_LEADING;
        }
    }

    cob_move (f, &temp);
    for (i = 0; i < size; ++i) {
        putc (temp.data[i], fp);
    }
}

static void pretty_display_numeric ( cob_field *  f, FILE *  fp  )

static

References _, cob_field::attr, COB_ATTR_INIT, COB_FIELD_DIGITS, COB_FIELD_HAVE_SIGN, COB_FIELD_SCALE, COB_MEDIUM_MAX, COB_MODULE_PTR, cob_move(), COB_TERM_BUFF, COB_TYPE_NUMERIC_EDITED, cob_field::data, p, and cob_field::size.

Referenced by display_common().

{
    unsigned char   *p;
    unsigned char   *q;
    int     i;
    int     digits;
    int     scale;
    int     size;
    cob_field_attr  attr;
    cob_field   temp;
    unsigned char   pic[32];

    digits = COB_FIELD_DIGITS (f);
    scale = COB_FIELD_SCALE (f);
    size = (digits + (COB_FIELD_HAVE_SIGN (f) ? 1 : 0)
        + (scale > 0 ? 1 : 0));
    if (size > COB_MEDIUM_MAX) {
        fputs (_("(Not representable)"), fp);
        return;
    }
    q = COB_TERM_BUFF;
    temp.size = size;
    temp.data = q;
    temp.attr = &attr;
    COB_ATTR_INIT (COB_TYPE_NUMERIC_EDITED, digits, scale, 0,
               (const char *)pic);
    p = pic;
#if 0   /* RXWRXW - memset */
    memset (pic, 0, sizeof (pic));
    memset (q, 0, 256);
#endif
    if (COB_FIELD_HAVE_SIGN (f)) {
        *p++ = '+';
        i = 1;
        memcpy (p, (unsigned char *)&i, sizeof(int));
        p += sizeof(int);
    }
    if (scale > 0) {
        i = digits - scale;
        if (i > 0 ) {
            *p++ = '9';
            memcpy (p, (unsigned char *)&i, sizeof(int));
            p += sizeof(int);
        }
        *p++ = COB_MODULE_PTR->decimal_point;
        i = 1;
        memcpy (p, (unsigned char *)&i, sizeof(int));
        p += sizeof(int);
        *p++ = '9';
        i = scale;
        memcpy (p, (unsigned char *)&i, sizeof(int));
        p += sizeof(int);
    } else {
        *p++ = '9';
        i = digits;
        memcpy (p, (unsigned char *)&i, sizeof(int));
        p += sizeof(int);
    }
    *p = 0;

    cob_move (f, &temp);
    for (i = 0; i < size; ++i) {
        putc (q[i], fp);
    }
}

Variable Documentation

const unsigned short bin_digits[]

static

Initial value:

=
    { 1, 3, 5, 8, 10, 13, 15, 17, 20 }

Referenced by display_common().

cob_global* cobglobptr

static

const cob_field_attr const_alpha_attr

static

Initial value:

=
                {COB_TYPE_ALPHANUMERIC, 0, 0, 0, NULL}

Referenced by cob_accept().