dbe_edit.c

来自「db.* (pronounced dee-be star) is an adva」· C语言 代码 · 共 531 行 · 第 1/2 页

/***************************************************************************
 *                                                                         *
 * db.*                                                                    *
 * open source database, dbedit 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.                                      * 
 *                                                                         *
 **************************************************************************/

/*-----------------------------------------------------------------------

    dbe_edit.c - DBEDIT, edit command

    This file contains functions to edit the current record (for editing
    of the current file - edit hex command - see DBE_EDX.C)

-----------------------------------------------------------------------*/

#include "db.star.h"
#include "dbe_type.h"
#include "dbe_str.h"
#include "dbe_io.h"
#include "dbe_err.h"
#include "dbe_ext.h"


int edit(DBE_TOK *tokens, int *tokenptr, DB_TCHAR *errstr, DB_TASK *task)
{
    int         token, error, opt, set, mem, first, last, offset;
    short       fno;
    short       rec;
    DB_ULONG    recNum;

    error = 0;
    token = *tokenptr + 1;

    if (tokens[token].type == TYPE_KWD)
        switch (opt = tokens[token++].ival)
        {
            case K_TYPE:                  /* Edit record type */
                if ((error = dbe_chkdba(task->curr_rec, task)) >= 0)
                {
                    if ((error = edit_type(slot.buffer, task)) >= 0)
                        changed = 1;
                }
                break;

            case K_DBA:       /* Edit database Address stored in record */
                if ((error = dbe_chkdba(task->curr_rec, task)) >= 0)
                {
                    if ((error = edit_dba(slot.buffer + sizeof(short),
                            1, task)) >= 0)
                    {
                        changed = 1;
                    }
                }
                break;

            case K_OPT:                   /* Edit stored optional keys */
                if ((error = dbe_chkdba(task->curr_rec, task)) >= 0)
                {
                    if ((error = edit_opt(slot.buffer, task)) >= 0)
                        changed = 1;
                }
                break;

            case K_COUNT:                 /* Edit owner pointer */
            case K_FIRST:
            case K_LAST:
                set = tokens[token++].ival;
                if ((error = dbe_chkdba(task->curr_rec, task)) < 0)
                    break;
                if ((rec = getrtype(slot.buffer, task)) == -1)
                {
                    error = BAD_TYPE;
                    break;
                }

                /* Check current record is an owner of specified set */
                if (task->set_table[set].st_own_rt != rec)
                {
                    error = ERR_OSET;
                    break;
                }
                offset = task->set_table[set].st_own_ptr;
                if (opt == K_FIRST || opt == K_LAST)
                    offset += sizeof(long);
                if (opt == K_LAST)
                    offset += sizeof(DB_ADDR);
                error = (opt == K_COUNT) ?
                    edit_num(slot.buffer + offset) :
                    edit_dba(slot.buffer + offset, 0, task);
                if (error >= 0)
                    changed = 1;
                break;

            case K_OWN:                   /* Edit member pointer */
            case K_PREV:
            case K_NEXT:
                set = tokens[token++].ival;
                if ((error = dbe_chkdba(task->curr_rec, task)) < 0)
                    break;

                /* Check current record is an member of specified set */
                if ((rec = getrtype(slot.buffer, task)) == -1)
                {
                    error = BAD_TYPE;
                    break;
                }
                first = task->set_table[set].st_members;
                last = first + task->set_table[set].st_memtot;
                for (mem = first; mem < last; mem++)
                {
                    if (task->member_table[mem].mt_record == rec)
                        break;
                }
                if (mem == last)
                {
                    error = ERR_MSET;
                    break;
                }
                offset = task->member_table[mem].mt_mem_ptr;
                if (opt == K_PREV || opt == K_NEXT)
                    offset += sizeof(DB_ADDR);
                if (opt == K_NEXT)
                    offset += sizeof(DB_ADDR);
                if ((error = edit_dba(slot.buffer + offset, 0, task)) >= 0)
                    changed = 1;
                break;

            case K_DCHAIN:        /* Edit delete chain pointer, current file */
                error = edit_dchain(task);
                break;

            case K_NEXTS:              /* Edit next slot number, current file */
                error = edit_nextslot(task);
                break;

            case K_HEX:          /* Edit hex - bytewise edit of current file */
                if ((error = dbe_chkdba(task->curr_rec, task)) != ERR_CFIL)
                {
                    error = 0;

                    /* Changes to current record must appear in edit hex */
                    if (changed)
                    {
                        if ((error = dbe_write(task)) < 0)
                            break;
                        changed = 0;
                    }
                    edit_hex(task);

                    /* Contents of current record may have changed */
                    dbe_read(task->curr_rec, task);
                }
                break;

            default:
                break;
        }

    if (error == ERR_WRIT)
    {
        d_decode_dba(task->curr_rec, &fno, &recNum);
        vtstrcpy(errstr, task->file_table[fno].ft_name);
    }

    *tokenptr = token;
    return (error);
}


/* Edit record type *********************************************************
*/
int edit_type(char *ptr, DB_TASK *task)
{
    DB_TCHAR    line[80], type_str[40], *p;
    short       rec_type, new_type;
    int         del_flag, rlb_flag;
    long        lowbyte, highbyte;
    short       fno;
    DB_ULONG    slot;

    del_flag = rlb_flag = 0;

    /* Display old record type */
    vtstrcpy(line, dbe_getstr(M_EDITCV));
    p = do_hexstr(ptr, line, sizeof(short));

    /* Append record name */
    memcpy(&rec_type, ptr, sizeof(short));
    if (rec_type < 0)
    {
        rec_type = (short) (~rec_type);
        del_flag = 1;
    }
    if (rec_type & RLBMASK)
    {
        rec_type &= ~RLBMASK;
        rlb_flag = 1;
    }
    if (rec_type >= 0 && rec_type < task->size_rt)
    {
        vtstrcat(p, DB_TEXT(" "));
        vtstrcat(p, task->record_names[rec_type]);

        /* Record lock bit set ? */
        if (rlb_flag)
        vtstrcat(line, dbe_getstr(M_FLAGLB));

        /* Record deleted ? */
        if (del_flag)
            vtstrcat(line, dbe_getstr(M_FLAGDE));
    }
    vtstrcat(p, DB_TEXT("\n"));
    dbe_out(line, STDOUT);

    /* Get new record type */
    dbe_getline(dbe_getstr(M_EDITNV), line, sizeof(line) / sizeof(DB_TCHAR));
    p = gettoken(line, type_str, sizeof(type_str) / sizeof(DB_TCHAR));

    /* Nothing entered - don't change current value */
    if (!(type_str[0]))
        return (0);

    /* User may enter record name or number */
    if ((rec_type = (short) getrec(type_str, task)) < 0)
    {                                   /* If not record name */
        if ((lowbyte = gethex(type_str)) < 0)
            return (BAD_TYPE);
        highbyte = 0;
        p = gettoken(p, type_str, sizeof(type_str) / sizeof(DB_TCHAR));
        if (type_str[0])
        {
            if ((highbyte = gethex(type_str)) < 0)
                return (BAD_TYPE);
            highbyte <<= BITS_PER_BYTE;
            p = gettoken(p, type_str, sizeof(type_str) / sizeof(DB_TCHAR));
            if (type_str[0])
                return (BAD_TYPE);
        }
        rec_type = (short) (highbyte | lowbyte);
    }

    /* Check that new record type is in current file */
    d_decode_dba(task->curr_rec, &fno, &slot);
    new_type = rec_type;
    if (new_type < 0)
        new_type = (short) ~new_type;
    if (new_type & RLBMASK)
        new_type &= ~RLBMASK;
    if (new_type < 0 || new_type >= task->size_rt)
        return (BAD_TYPE);
    if (task->record_table[new_type].rt_file != (short) fno)
        return (ERR_RFIL);

    memcpy(ptr, &rec_type, sizeof(short));
    return (0);
}