falso
/
cdesktopenv
mirror of https://git.code.sf.net/p/cdesktopenv/code
1
0
Fork 0
Code Issues Releases Wiki Activity
cdesktopenv/cde/lib/DtSearch/raima/recfcns.c

584 lines
16 KiB
C
Raw Blame History

/*
* CDE - Common Desktop Environment
*
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
*
* These libraries and programs are free software; you can
* redistribute them and/or modify them under the terms of the GNU
* Lesser General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* These libraries and programs are distributed in the hope that
* they will be useful, but WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with these libraries and programs; if not, write
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301 USA
*/
/* $XConsortium: recfcns.c /main/2 1996/05/09 04:13:59 drk $ */
/*
* COMPONENT_NAME: austext
*
* FUNCTIONS: r_chkfld
* r_clropt
* r_delrec
* r_gfld
* r_gmem
* r_gset
* r_pfld
* r_pmem
* r_pset
* r_setopt
* r_smem
* r_tstopt
*
* ORIGINS: 157
*
* OBJECT CODE ONLY SOURCE MATERIALS
*/
/*---------------------------------------------------------------------------
recfcns.c - db_VISTA Record Access/Manipulation Functions
Copyright (C) 1984, 1985, 1986 by Raima Corporation.
---------------------------------------------------------------------------*/
/* ********************** EDIT HISTORY *******************************
SCR DATE INI DESCRIPTION
----- --------- --- -----------------------------------------------------
158 15-JUN-88 RSC passed new flag to key_bldcom.
103 27-Jun-88 RSC Improve generation of single user version
04-Aug-88 RTK MULTI_TASK changes
310 10-Aug-88 RSC Cleanup function prototype.
420 16-Aug-88 RTK Missing FAR pointer
*/
#include <stdio.h>
#include "vista.h"
#include "dbtype.h"
#define FALSE 0
#define TRUE 1
/* toggle for checking struct key modifications */
static int struct_key_chk = 1;
/* Check a field for permission to change it
*/
int
r_chkfld(
INT field, /* field_table entry number */
FIELD_ENTRY *fld_ptr, /* corresponds to field */
char *rec, /* pointer to record slot */
const char *data /* pointer to data area containing field contents */
)
{
DB_ADDR dba;
long fld;
INT rn;
char *fptr, ckey[256];
int i;
FIELD_ENTRY *sfld_ptr;
RECORD_ENTRY *rec_ptr;
bytecpy(&rn, rec, sizeof(INT));
rn &= ~RLBMASK; /* mask off rlb */
if ( rn != NUM2EXT(fld_ptr->fd_rec, rt_offset) )
return( dberr(S_INVFLD) );
rec_ptr = &record_table[fld_ptr->fd_rec];
fld = FLDMARK*rn + field - rec_ptr->rt_fields;
if ( fld_ptr->fd_type == COMKEY ) {
/* build compound key value. NOTE: cflag MUST be the same here as for
the call to key_bldcom in recwrite, which calls this function. */
fptr = rec + rec_ptr->rt_data;
key_bldcom(field, fptr, ckey, FALSE);
fptr = ckey;
}
else
fptr = rec + fld_ptr->fd_ptr;
/* do nothing unless the new value is different */
if (fldcmp(fld_ptr, data, fptr) == 0)
return( db_status = S_OKAY );
/* if this is a unique key field, make sure the key does not already
exist
*/
if ( fld_ptr->fd_key == UNIQUE ) {
dba = curr_rec;
/* If the key field is not optional, or optional and stored */
if ((!(fld_ptr->fd_flags & OPTKEYMASK) || r_tstopt(fld_ptr, rec)) &&
(d_keyfind(fld, data CURRTASK_PARM , curr_db) == S_OKAY)) {
/* another record is already using this key value */
db_status = S_DUPLICATE;
}
curr_rec = dba;
if ( db_status == S_DUPLICATE ) return( db_status );
}
/* if field is grouped, call r_chkfld for 1st entry of each sub-field */
if ( fld_ptr->fd_type == GROUPED ) {
for (i = field + 1, sfld_ptr = fld_ptr + 1;
(i < size_fd) && (sfld_ptr->fd_flags & STRUCTFLD);
++i, ++sfld_ptr) {
fptr = (char *)data - (sfld_ptr->fd_ptr -
record_table[sfld_ptr->fd_rec].rt_data);
if (r_chkfld(i, sfld_ptr, rec, fptr) != S_OKAY)
return( db_status );
}
}
return( db_status = S_OKAY );
}
/* Delete the current record
*/
int
r_delrec(INT rt, DB_ADDR db_addr)
{
char *rec; /* ptr to record slot */
char *fptr; /* field data ptr */
char ckey[256]; /* compound key data */
FILE_NO fno;
F_ADDR rno;
int fld;
RECORD_ENTRY *rec_ptr;
FIELD_ENTRY *fld_ptr;
if ( dio_read( db_addr, (char * *)&rec, PGHOLD) != S_OKAY )
return( db_status );
rec_ptr = &record_table[rt];
/* remove any key fields from the key files */
for (fld = rec_ptr->rt_fields, fld_ptr = &field_table[fld];
(fld < size_fd) && (fld_ptr->fd_rec == rt);
++fld, ++fld_ptr) {
if ( fld_ptr->fd_key != NOKEY ) {
if ( fld_ptr->fd_type == COMKEY ) {
key_bldcom(fld, rec + rec_ptr->rt_data, ckey, TRUE);
fptr = ckey;
}
else {
fptr = rec + fld_ptr->fd_ptr;
}
/* delete the key if it exists */
if ((!(fld_ptr->fd_flags & OPTKEYMASK) || r_tstopt(fld_ptr, rec)) &&
(key_delete(fld, fptr, db_addr) != S_OKAY))
return( db_status );
}
}
fno = NUM2INT((FILE_NO)((db_addr >> FILESHIFT) & FILEMASK), ft_offset);
rno = ADDRMASK & db_addr;
dio_write(db_addr, NULL, PGFREE);
/* place this record onto the delete chain */
dio_pzdel(fno, rno);
return( db_status );
}
/* Get data field from record
*/
int
r_gfld(
FIELD_ENTRY *fld_ptr,
char *rec, /* pointer to record */
char *data /* pointer to data area to contain field contents */
)
{
int kt_lc; /* loop control */
INT rn;
FIELD_ENTRY *kfld_ptr;
KEY_ENTRY *key_ptr;
bytecpy(&rn, rec, sizeof(INT));
if ( rn < 0 )
return( db_status = S_DELETED );
rn += curr_db_table->rt_offset;
if ( fld_ptr->fd_rec != rn )
return( dberr(S_INVFLD) );
if ( fld_ptr->fd_type == KEY ) {
/* clear compound key data area */
byteset(data, '\0', fld_ptr->fd_len);
/* copy each field of compound key to data area */
for (kt_lc = size_kt - fld_ptr->fd_ptr,
key_ptr = &key_table[fld_ptr->fd_ptr];
(--kt_lc >= 0) && (&field_table[key_ptr->kt_key] == fld_ptr);
++key_ptr) {
kfld_ptr = &field_table[key_ptr->kt_field];
bytecpy(data + key_ptr->kt_ptr, rec + kfld_ptr->fd_ptr,
kfld_ptr->fd_len);
}
}
else {
bytecpy(data, rec + fld_ptr->fd_ptr, fld_ptr->fd_len);
}
return( db_status = S_OKAY );
}
/* Get member pointer from record
*/
int
r_gmem(
int set, /* set table entry number */
char *rec, /* pointer to record */
char *mem_addr /* pointer to member pointer */
)
{
INT rt;
int mem, memtot;
SET_ENTRY *set_ptr;
MEMBER_ENTRY *mem_ptr;
/* search member list of set for record */
set_ptr = &set_table[set];
bytecpy(&rt, rec, sizeof(INT));
rt &= ~RLBMASK;
for (mem = set_ptr->st_members, memtot = mem + set_ptr->st_memtot,
mem_ptr = &member_table[mem];
mem < memtot;
++mem, ++mem_ptr) {
if (NUM2EXT(mem_ptr->mt_record, rt_offset) == rt) {
/* have found correct member record */
bytecpy(mem_addr, rec + mem_ptr->mt_mem_ptr, MEMPSIZE);
return( db_status = S_OKAY );
}
}
/* this record is not member of set */
return( dberr(S_INVMEM) );
}
/* Get set pointer from record
*/
int
r_gset(
int set, /* set table entry number */
char *rec, /* pointer to record */
char *setptr /* pointer to set pointer */
)
{
INT rt;
int len;
SET_ENTRY *set_ptr;
set_ptr = &set_table[set];
bytecpy(&rt, rec, sizeof(INT));
if (NUM2EXT(set_ptr->st_own_rt, rt_offset) == (rt & ~RLBMASK)) {
len = SETPSIZE - sizeof(ULONG);
bytecpy(setptr, rec + set_ptr->st_own_ptr, len);
return( db_status = S_OKAY );
}
return( dberr(S_INVOWN) );
}
/* Put data field into record
*/
int
r_pfld(
INT field, /* field_table entry number */
FIELD_ENTRY *fld_ptr, /* corresponds to field */
char *rec, /* pointer to existing record */
const char *data, /* pointer to data area containing new field contents */
DB_ADDR *db_addr
)
{
DB_ADDR mdba, odba, dba;
int set, sn;
char memp[MEMPSIZE];
char *fptr;
const char *tfptr;
int s, i, strfld;
FIELD_ENTRY *sfld_ptr;
SORT_ENTRY *srt_ptr;
DB_ADDR *co_ptr, *cm_ptr;
db_status = S_OKAY;
fptr = rec + fld_ptr->fd_ptr;
/* do nothing unless the new value is different */
if (fldcmp(fld_ptr, fptr, data) == 0)
return( db_status );
bytecpy(&dba, db_addr, DB_ADDR_SIZE);
/* if this is a key field, change the key file also */
if ((fld_ptr->fd_key != NOKEY) &&
(!(fld_ptr->fd_flags & OPTKEYMASK) || r_tstopt(fld_ptr, rec))) {
/* delete the old key and insert the new one */
if ( key_delete(field, fptr, dba) == S_OKAY ) {
if ( key_insert( field, data, dba ) != S_OKAY )
return( db_status );
}
else
return( db_status == S_NOTFOUND? dberr(S_KEYERR): db_status );
}
/* if subfield of struct field, check to see if struct is a key */
if ( struct_key_chk && fld_ptr->fd_flags & STRUCTFLD ) {
for (strfld = field - 1, sfld_ptr = &field_table[strfld];
sfld_ptr->fd_type != GROUPED;
--strfld, --sfld_ptr)
; /* find struct field */
if ((sfld_ptr->fd_key != NOKEY) &&
/* make sure it is stored */
(!(sfld_ptr->fd_flags & OPTKEYMASK) || r_tstopt(sfld_ptr, rec))) {
/* delete the old struct key */
if (key_delete(strfld, rec + sfld_ptr->fd_ptr, dba) != S_OKAY)
return( db_status );
}
else strfld = -1;
}
else strfld = -1;
/* copy data into record area */
switch ( fld_ptr->fd_type ) {
case CHARACTER:
if ( fld_ptr->fd_dim[1] )
bytecpy(fptr, data, fld_ptr->fd_len);
else if ( fld_ptr->fd_dim[0] )
strncpy(fptr, data, fld_ptr->fd_len);
else
*fptr = *data;
break;
case GROUPED:
if ( ! fld_ptr->fd_dim[0] ) {
/* non-arrayed structure */
struct_key_chk = 0;
for (i = field + 1, sfld_ptr = fld_ptr + 1;
(i < size_fd) && (sfld_ptr->fd_flags & STRUCTFLD);
++i, ++sfld_ptr) {
tfptr = data + sfld_ptr->fd_ptr - fld_ptr->fd_ptr;
if ( r_pfld(i, sfld_ptr, rec, tfptr, &dba) != S_OKAY )
break;
}
struct_key_chk = 1;
if ( db_status != S_OKAY ) return( db_status );
break;
}
/* arrayed struct fall-thru to a full field copy */
default:
bytecpy(fptr, data, fld_ptr->fd_len);
}
/* if this field is part of an ordered set, reconnect */
if (fld_ptr->fd_flags & SORTFLD) {
for (s = 0, srt_ptr = sort_table; s < size_srt; ++s, ++srt_ptr) {
if ( srt_ptr->se_fld == field ) {
sn = srt_ptr->se_set;
if ( r_gmem( sn, rec, memp ) != S_OKAY ) return( db_status );
if ( ! null_dba(memp+MP_OWNER) ) {
/* save currency */
odba = *(co_ptr = &curr_own[sn]);
mdba = *(cm_ptr = &curr_mem[sn]);
/* set current owner and member to sorted set */
bytecpy(co_ptr, memp+MP_OWNER, DB_ADDR_SIZE);
*cm_ptr = dba;
/* calculate set constant */
set = NUM2EXT(sn + SETMARK, st_offset);
/* disconnect from prior order set and reconnect in new order */
d_discon(set CURRTASK_PARM , curr_db);
d_connect(set CURRTASK_PARM , curr_db);
/* reset currency */
*co_ptr = odba;
*cm_ptr = mdba;
}
}
}
}
if ( strfld >= 0 ) {
/* insert the new struct key */
if ( key_insert( strfld, rec + sfld_ptr->fd_ptr, dba ) != S_OKAY )
return( db_status );
}
return( db_status );
}
/* Put member pointer into record
*/
int
r_pmem(
int set, /* set table entry number */
char *rec, /* pointer to record */
char *mem_addr /* pointer to member pointer */
)
{
INT rt;
int mem, memtot;
SET_ENTRY *set_ptr;
MEMBER_ENTRY *mem_ptr;
/* search member list of set for record */
set_ptr = &set_table[set];
bytecpy(&rt, rec, sizeof(INT));
rt &= ~RLBMASK;
for (mem = set_ptr->st_members, memtot = mem + set_ptr->st_memtot,
mem_ptr = &member_table[mem];
mem < memtot;
++mem, ++mem_ptr) {
if (NUM2EXT(mem_ptr->mt_record, rt_offset) == rt) {
/* have found correct member record */
bytecpy(rec + mem_ptr->mt_mem_ptr, mem_addr, MEMPSIZE);
return( db_status = S_OKAY );
}
}
/* this record is not member of set */
return( dberr(S_INVMEM) );
}
/* Put set pointer into record
*/
int
r_pset(
int set, /* set table entry number */
char *rec, /* pointer to record */
char *setptr /* pointer to set pointer */
)
{
INT rt;
int len;
SET_ENTRY *set_ptr;
set_ptr = &set_table[set];
bytecpy(&rt, rec, sizeof(INT));
if (NUM2EXT(set_ptr->st_own_rt, rt_offset) == (rt & ~RLBMASK)) {
len = SETPSIZE - sizeof(ULONG);
bytecpy(rec + set_ptr->st_own_ptr, setptr, len);
return( db_status = S_OKAY );
}
else {
return( dberr(S_INVOWN) );
}
}
/* Set the current set member from record
*/
int
r_smem(DB_ADDR *db_addr, INT set)
{
char mem[MEMPSIZE], *ptr;
DB_ADDR dba;
bytecpy(&dba, db_addr, DB_ADDR_SIZE);
/* make sure record is owned */
if ((dio_read(dba, (char * *)&ptr, NOPGHOLD) != S_OKAY) ||
(r_gmem(set, ptr, mem) != S_OKAY))
return( db_status );
if ( null_dba( mem+MP_OWNER ) ) return( dberr( S_NOTCON ) );
bytecpy( &curr_own[set], mem+MP_OWNER, DB_ADDR_SIZE );
/* ownership okay, set the member */
curr_mem[set] = dba;
return( db_status = S_OKAY );
}
/* Set the optional key field "stored" bit */
int
r_setopt(
FIELD_ENTRY *fld_ptr, /* field table entry of optional key */
char *rec /* Pointer to record */
)
{
int offset; /* offset to the bit map */
int keyndx; /* index into bit map of this key */
int byteno, bitno; /* position within bit map of this key */
/* calculate the position to the bit map */
offset = (record_table[fld_ptr->fd_rec].rt_flags & TIMESTAMPED) ?
(RECHDRSIZE + 2*sizeof(LONG)) : RECHDRSIZE;
/* extract the index into the bit map of this key */
keyndx = (((fld_ptr->fd_flags & OPTKEYMASK) >> OPTKEYSHIFT) & OPTKEYNDX) - 1;
if ( keyndx < 0 ) return( dberr(S_SYSERR) );
/* determine which byte, and which bit within the byte */
byteno = keyndx/BITS_PER_BYTE;
bitno = keyndx - byteno*BITS_PER_BYTE;
/* set the bit */
rec[byteno + offset] |= 1 << (BITS_PER_BYTE - bitno - 1);
return( db_status = S_OKAY );
}
/* Clear the optional key field "stored" bit */
int
r_clropt(
FIELD_ENTRY *fld_ptr, /* Field table entry of optional key */
char *rec /* Pointer to record */
)
{
int offset; /* offset to the bit map */
int keyndx; /* index into bit map of this key */
int byteno, bitno; /* position within bit map of this key */
/* calculate the position to the bit map */
offset = (record_table[fld_ptr->fd_rec].rt_flags & TIMESTAMPED) ?
(RECHDRSIZE + 2*sizeof(LONG)) : RECHDRSIZE;
/* extract the index into the bit map of this key */
keyndx = (((fld_ptr->fd_flags & OPTKEYMASK) >> OPTKEYSHIFT) & OPTKEYNDX) - 1;
if ( keyndx < 0 ) return( dberr(S_SYSERR) );
/* determine which byte, and which bit within the byte */
byteno = keyndx / BITS_PER_BYTE;
bitno = keyndx - byteno*BITS_PER_BYTE;
/* clear the bit */
rec[byteno + offset] &= ~(1 << (BITS_PER_BYTE - bitno - 1));
return( S_OKAY );
}
/* Test the optional key field "stored" bit */
int
r_tstopt(
FIELD_ENTRY *fld_ptr, /* Field table entry of optional key */
char *rec /* Pointer to record */
)
{
int offset; /* offset to the bit map */
int keyndx; /* index into bit map of this key */
int byteno, bitno; /* position within bit map of this key */
/* calculate the position to the bit map */
offset = (record_table[fld_ptr->fd_rec].rt_flags & TIMESTAMPED) ?
(RECHDRSIZE + 2*sizeof(LONG)) : RECHDRSIZE;
/* extract the index into the bit map of this key */
keyndx = (((fld_ptr->fd_flags & OPTKEYMASK) >> OPTKEYSHIFT) & OPTKEYNDX) - 1;
if ( keyndx < 0 ) return( dberr(S_SYSERR) );
/* determine which byte, and which bit within the byte */
byteno = keyndx / BITS_PER_BYTE;
bitno = keyndx - byteno*BITS_PER_BYTE;
/* extract the bit */
if (rec[byteno + offset] & (1 << (BITS_PER_BYTE - bitno - 1)))
return( db_status = S_DUPLICATE );
return( db_status = S_OKAY );
}
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin recfcns.c */
Reference in New Issue View Git Blame Copy Permalink