cnvfld.c

db.* (pronounced dee-be star) is an advanced, high performance, small footprint embedded database fo

/***************************************************************************
 *                                                                         *
 * db.*                                                                    *
 * open source database, ida utility                                       *
 *                                                                         *
 * Copyright (c) 2000 Centura Software Corporation. All rights reserved.   *
 *                                                                         *
 * Use of this software, whether in source code format, or in executable,  *
 * binary object code form, is governed by the CENTURA OPEN SOURCE LICENSE *
 * which is fully described in the LICENSE.TXT file, included within this  *
 * distribution of source code files.                                      * 
 *                                                                         *
 **************************************************************************/

/* -------------------------------------------------------------------------
    IDA - Data Field Conversion Functions
--------------------------------------------------------------------------*/
#include "db.star.h"
#include "ida.h"

/* temporary struct text buffer */
#define MAXTEXT 1600
static char sbuf[MAXTEXT];

static void txtcpy(int *, char *, char *, int);

/* =============================================================
    Convert data field to text
*/
char *fldtotxt(
    int fld,                            /* task->field_table index */
    char *data,                         /* pointer to contents of field */
    char *txt)                          /* pointer to text buffer */
{
    /* field value variables */
    DB_ADDR           f_db_addr;
    unsigned int      f_uint;
    unsigned short    f_ushort;
    unsigned long     f_ulong;
    int               f_int;
    short             f_short;
    long              f_long;

    float             f_float;
    double            f_double;
    int               txtp;
    short             fno;
    DB_ULONG          rno;
    char              buf[40];       /* temporary formatted spec. buffer */

    int               fd_type;       /* field type */
    int               fd_len;        /* total length of field */
    int               fd_size;       /* size of each entry in field */
    int               fd_elts;       /* number of array elements in field */
    int               fd_dims;       /* number of array dimensions in field */
    char             *fd_pos;        /* points to start of next data element */
    char             *sm_pos;        /* points to struct member data element */
    char             *r_base;        /* base address of record */

    int               cnt;
    register int      elt,
                      i;

    /* get pertinent info from task->field_table */
    fd_type = task->field_table[fld].fd_type;
    fd_len = task->field_table[fld].fd_len;

    /* compute number of array elements */
    for ( fd_elts = 1, fd_dims = 0;
          fd_dims <= MAXDIMS && task->field_table[fld].fd_dim[fd_dims];
          ++fd_dims)
    {
        fd_elts = fd_elts * task->field_table[fld].fd_dim[fd_dims];
    }
    if (fd_type == CHARACTER)
        fd_elts = 1;

    fd_size = fd_len / fd_elts;

    txtp = 0;
    *txt = '\0';                        /* initialize display text buffer */
    for (elt = 0; elt < fd_elts; ++elt)
    {
        fd_pos = data + (elt * fd_size);
        if (fd_type != CHARACTER)
        {
            for (cnt = 1, i = elt + 1; i < fd_elts; ++i, ++cnt)
            {
                /* compute repitition factor */
                if (memcmp(fd_pos, data + (i * fd_size), fd_size))
                    break;
            }
            if (elt)
                txtcpy(&txtp, txt, ",", 0);
            if (cnt > 2)
            {
                sprintf(buf, "%d*", cnt);
                txtcpy(&txtp, txt, buf, 0);
                elt = i - 1;
                fd_pos = data + (elt * fd_size);
            }
        }
        switch (fd_type)
        {
            case GROUPED:
                r_base = fd_pos - task->field_table[fld].fd_ptr;
                txtcpy(&txtp, txt, "{", 0);
                for (i = fld + 1;
                     i < task->size_fd && (STRUCTFLD & task->field_table[i].fd_flags); ++i)
                {
                    if (i - (fld + 1))
                        txtcpy(&txtp, txt, ",", 0);
                    sm_pos = r_base + task->field_table[i].fd_ptr;
                    if (task->field_table[i].fd_type == CHARACTER)
                    {
                        txtcpy(&txtp, txt, "\"", 0);
                        txtcpy(&txtp, txt, fldtotxt(i, sm_pos, sbuf), 0);
                        txtcpy(&txtp, txt, "\"", 0);
                    }
                    else
                    {
                        txtcpy(&txtp, txt, fldtotxt(i, sm_pos, sbuf), 0);
                    }
                }
                txtcpy(&txtp, txt, "}", 0);
                break;

            case CHARACTER:
                if (fd_len == 1 || fd_dims > 1)
                    txtcpy(&txtp, txt, fd_pos, fd_len);
                else
                    txtcpy(&txtp, txt, fd_pos, 0);
                break;

            case DBADDR:
                memcpy(&f_db_addr, fd_pos, DB_ADDR_SIZE);
                d_decode_dba(f_db_addr, &fno, &rno);
                sprintf(buf, "[%d:%ld]", fno, rno);
                txtcpy(&txtp, txt, buf, 0);
                break;

            case REGINT:
                if (task->field_table[fld].fd_flags & UNSIGNEDFLD)
                {
                    memcpy(&f_uint, fd_pos, INT_SIZE);
                    sprintf(buf, "%u", f_uint);
                }
                else
                {
                    memcpy(&f_int, fd_pos, INT_SIZE);
                    sprintf(buf, "%d", f_int);
                }
                txtcpy(&txtp, txt, buf, 0);
                break;

            case SHORTINT:
                if (task->field_table[fld].fd_flags & UNSIGNEDFLD)
                {
                    memcpy(&f_ushort, fd_pos, SHORT_SIZE);
                    sprintf(buf, "%u", f_ushort);
                }
                else
                {
                    memcpy(&f_short, fd_pos, SHORT_SIZE);
                    sprintf(buf, "%d", f_short);
                }
                txtcpy(&txtp, txt, buf, 0);
                break;

            case LONGINT:
                if (task->field_table[fld].fd_flags & UNSIGNEDFLD)
                {
                    memcpy(&f_ulong, fd_pos, LONG_SIZE);
                    sprintf(buf, "%lu", f_ulong);
                }
                else
                {
                    memcpy(&f_long, fd_pos, LONG_SIZE);
                    sprintf(buf, "%ld", f_long);
                }
                txtcpy(&txtp, txt, buf, 0);
                break;

            case FLOAT:
                memcpy(&f_float, fd_pos, FLOAT_SIZE);
                sprintf(buf, "%.20g", f_float);
                txtcpy(&txtp, txt, buf, 0);
                break;

            case DOUBLE:
                memcpy(&f_double, fd_pos, DOUBLE_SIZE);
                sprintf(buf, "%.20g", f_double);
                txtcpy(&txtp, txt, buf, 0);
                break;
                
            default:
                break;
        }
    }
    return (txt);
}

/* =============================================================
    Convert text to data field
*/
char *txttofld(int fld, char *txt, char *data)
{
    /* field value variables */
    DB_ADDR           f_db_addr;
    unsigned int      f_uint;
    unsigned short    f_ushort;
    unsigned long     f_ulong;
    int               f_int;
    short             f_short;
    long              f_long;

    float             f_float;
    double            f_double;

    short             sno;
    DB_ULONG          rno;

    int               fd_type;          /* field type */
    int               fd_len;           /* field length */
    int               fd_size;          /* size of each entry in field */
    int               fd_elts;          /* number of array elements in
                                         * field */
    int               fd_dims;          /* number of array dimensions in
                                         * field */
    char             *fd_pos;           /* points to start of next data
                                         * element */
    register char    *tp;               /* text pointer position */
    register int      i,
                      j,
                      cnt;
    char              del,
                     *tq;
    char             *sm_pos;           /* points to struct member data
                                         * element */
    char             *r_base;           /* base address of record */

    fd_len = task->field_table[fld].fd_len;
    fd_type = task->field_table[fld].fd_type;

    /* compute number of array elements */
    for ( fd_elts = 1, fd_dims = 0;
          fd_dims <= MAXDIMS && task->field_table[fld].fd_dim[fd_dims];
          ++fd_dims)
    {
        fd_elts = fd_elts * task->field_table[fld].fd_dim[fd_dims];
    }

    if (fd_type == CHARACTER && fd_dims < 2)
        fd_elts = 1;

    fd_size = fd_len / fd_elts;
    fd_pos = data;
    tp = txt;

    if (fd_type == CHARACTER)
    {
        *fd_pos = '\0';
        if (*tp == '"' || *tp == '\'')       /* delimited string */
            del = *tp++;