recfcns.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 - Record Manipulation Functions
--------------------------------------------------------------------------*/
#include "db.star.h"
#include "ddlnms.h"
#include "ida_d.h"
#include "ida.h"

/************************** EXTERNAL FUNCTIONS ****************************/
extern char *fldtotxt();
extern char *txttofld();
extern char *txttokey();

/*************************** GLOBAL VARIABLES *****************************/
int entry_flag = 0;                    /* record entry flag */

/*************************** LOCAL  VARIABLES *****************************/
#define FIRST_FIND      0
#define LAST_FIND       1
#define RPP 16                         /* records per page */
static int key = -1;                   /* key field number */
static long keyc;                      /* key field constant */
static int pgtot;                      /* total keys on current page */
static int cur_page;                   /* current page number */
static int top_key;                    /* entry number of top key */
static char rectxt[255];               /* display value of record */
static char frstkey[255];              /* value of first search key */
static int frstrec;                    /* value of first record */
static DB_ADDR seldba[RPP];            /* selection page dba's */
static char *keytbl[RPP] = {NULL};     /* key page display table */
static char keynm[32];                 /* key field name */
static int rtype;                      /* record type */
static char *edrec = NULL;             /* ptr to record editing area */

/************************** FORWARD REFERENCES ****************************/
void rrsnfcn(void);
void rsnfcn(void);
void rectotxt(char *, char *);
static int txtcpy(int *, char *, char *);
void rkffcn(void);
void rklfcn(void);
static void rrflfcn(int);

/* ========================================================================
    Scan and view keys
*/
void rsfcn()
{
    char ckey[80];
    char *tp;
    register int i, kno;

    if (tot_keys == 0)
    {
        usererr("no key fields defined");
        return;
    }
    if (keytbl[0] == NULL)
    {                                   /* allocate table memory */
        for (i = 0; i < RPP; ++i)
        {
            if ((keytbl[i] = malloc(80)) == NULL)
            {
                usererr("cannot allocate display memory");
                keytbl[0] = NULL;
                return;
            }
        }
    }
    tprintf("@m0300@E\nSELECT KEY FIELD TO BE SCANNED:\n");
    key = list_selection(6, tot_keys, keynames, 1, key, 1);
    tprintf("@m0300@E");
    if (key == -1)
        return;
    strcpy(keynm, keynames[key]);
    kno = keyfields[key];
    rtype = task->field_table[kno].fd_rec;
    keyc = rtype * FLDMARK + kno - task->record_table[rtype].rt_fields;
    cur_page = 0;
    tprintf("@m0200enter key value: @e");
    switch (rdtext(ckey))
    {
        case -1:
            return;
        case 0:
            if (d_keyfrst(keyc, task, CURR_DB) == S_NOTFOUND)
                d_keynext(keyc, task, CURR_DB);
            frstkey[0] = '\0';
            break;
        default:
            if (task->field_table[kno].fd_type == 'k')
                tp = txttokey(kno, ckey, frstkey);
            else
                tp = txttofld(kno, ckey, frstkey);
            if (tp)
            {
                usererr("input error");
                return;
            }
            else
            {
                d_keyfind(keyc, frstkey, task, CURR_DB);
                if (task->db_status == S_NOTFOUND)
                {
                    d_keynext(keyc, task, CURR_DB);
                    usererr("record not found");
                }
            }
    }
    if (task->db_status != S_OKAY)
        return;
    rsnfcn();
    menu(RS_MENU);
}

/* ========================================================================
    Display next page of keys
*/
void rsnfcn()
{
    int dbopen_sv;
    DB_ADDR dba;
    char *rec;
    register int i;

    if (task->db_status == S_NOTFOUND)
    {
        usererr("no more keys");
        return;
    }
    ++cur_page;
    top_key = (cur_page - 1) * RPP + 1;
    for (pgtot = 0; pgtot < RPP && task->db_status == S_OKAY;
          d_keynext(keyc, task, CURR_DB), ++pgtot)
    {
        d_crget(&dba, task, CURR_DB);
        dbopen_sv = task->dbopen;
        task->dbopen = 2;
        dio_read(dba, &rec, NOPGHOLD , task);
        task->dbopen = dbopen_sv;
        if (task->db_status != S_OKAY)
            return;
        memcpy(&(seldba[pgtot]), &dba, DB_ADDR_SIZE);
        rectotxt(rec, rectxt);
        if (dio_release(dba, NOPGFREE , task) != S_OKAY)
            return;
        rectxt[70] = '\0';               /* truncate for display */
        strcpy(keytbl[pgtot], rectxt);
    }
    tprintf("@m0300@E\n@SRecord:@s %-16s  ", task->record_names[rtype]);
    tprintf("@SKey:@s %-16s                      ", keynm);
    tprintf("@SPage:@s %d\n\n", cur_page);
    tprintf("@SENTRY RECORD CONTENTS@s\n");
    for (i = 0; i < pgtot; ++i)
    {
        tprintf("%4d.", top_key + i);
        tprintf(" %s\n", keytbl[i]);
    }
}

/* ========================================================================
    Display first page of keys
*/
void rsffcn()
{
    cur_page = 0;
    d_keyfind(keyc, frstkey, task, CURR_DB);
    if (task->db_status == S_NOTFOUND)
        d_keynext(keyc, task, CURR_DB);
    rsnfcn();
}

/* ========================================================================
    Select record from key on current page
*/
void rssfcn()
{
    register int i;

    if ((i = list_selection(7, pgtot, keytbl, top_key, 0, 0)) != -1)
    {
        tprintf("@c");
        disp_rec(&(seldba[i]));
    }
}

/* ========================================================================
    Find record by key
*/
void rffcn()
{
    char ckey[80];
    char skey[255];
    char *tp;
    register int kno;

    if (tot_keys == 0)
    {
        usererr("no key fields defined");
        return;
    }
    tprintf("@m0300@E\nSELECT KEY FIELD:\n");
    key = list_selection(6, tot_keys, keynames, 1, key, 1);
    tprintf("@m0300@E");
    if (key == -1)
        return;
    kno = keyfields[key];
    rtype = task->field_table[kno].fd_rec;
    keyc = rtype * FLDMARK + kno - task->record_table[rtype].rt_fields;
    tprintf("@m0200enter key value: @e");
    switch (rdtext(ckey))
    {
        case -1:
            return;
        case 0:
            d_keyfrst(keyc, task, CURR_DB);
            break;
        default:
            if (task->field_table[kno].fd_type == 'k')
                tp = txttokey(kno, ckey, skey);
            else
                tp = txttofld(kno, ckey, skey);
            if (tp)
            {
                usererr("input error");
                return;
            }
            else
            {
                d_keyfind(keyc, skey, task, CURR_DB);
            }
    }
    if (task->db_status == S_NOTFOUND)
    {
        if (d_keynext(keyc, task, CURR_DB) == S_NOTFOUND)
        {
            usererr("no records found");
            return;
        }
        else
            usererr("record not found");
    }
    disp_rec(NULL);
}

/* ========================================================================
    Find next record by key
*/
void rnfcn()
{
    if (key >= 0 && d_keynext(keyc, task, CURR_DB) == S_OKAY)
        disp_rec(NULL);
    else
    {
        usererr("no more keys");
    }
}

/* ========================================================================
    Find previous record by key
*/
void rpfcn()
{
    if (key >= 0 && d_keyprev(keyc, task, CURR_DB) == S_OKAY)
        disp_rec(NULL);
    else
    {
        usererr("no more keys");
    }
}

/* ========================================================================
    Read record by database address
*/
void rgfcn()
{
    DB_ADDR dba;

    switch (rd_dba(&dba))
    {
        case -1:
            break;
        case 0:
            usererr("invalid database address");
            break;
        default:
            if (d_crset(&dba, task, CURR_DB) == S_OKAY)
                disp_rec(NULL);
    }
}

/* ========================================================================
    Enter records
*/
void refcn()
{
    int i, size;

    tprintf("@m0400@ESELECT RECORD TYPE TO BE ENTERED:");
    rtype = list_selection(6, task->size_rt, task->record_names, 0, rtype, 1);
    tprintf("@m0400@E");
    if (rtype == -1)
        return;

    size = task->record_table[rtype].rt_len - task->record_table[rtype].rt_data;
    /* allocate memory for record */
    if ((edrec = malloc(size)) == NULL)
    {
        usererr("insufficient memory");
        return;
    }
    /* clear record area */
    for (i = 0; i < size; ++i)
        edrec[i] = '\0';

    entry_flag = 1;

    show_rec(rtype, edrec);
    menu(REC_MENU);
    free(edrec);
}

/* ========================================================================
    Modify current record
*/
void rmfcn()
{