external/cde
1
0
Fork 0
mirror of git://git.code.sf.net/p/cdesktopenv/code synced 2025-02-15 04:32:24 +00:00
Code Issues Releases Wiki Activity

libDtSearch: NO_TIMESTAMP is always on for CDE

Browse source
This commit is contained in:
Peter Howkins 2018-06-29 00:47:03 +01:00
parent a1ad4ae25b
commit 9d921ba219
55 changed files with 0 additions and 1230 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

29
cde/lib/DtSearch/raima/cmstat.c
View file

@ -48,33 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Test timestamp status of current member
*/
d_cmstat(set TASK_PARM DBN_PARM)
int set;
TASK_DECL
DBN_DECL
{
ULONG cts, uts;
ULONG cmts;
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_IO));
if ( d_ctscm(set, &cts TASK_PARM DBN_PARM) == S_OKAY ) {
if ( cts ) {
cmts = cm_time[NUM2INT(set - SETMARK, st_offset)];
if ( cts > cmts )
db_status = S_DELETED;
else {
d_utscm(set, &uts TASK_PARM DBN_PARM);
if ( uts > cmts )
db_status = S_UPDATED;
}
}
else
dberr(S_TIMESTAMP);
}
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin cmstat.c */

20
cde/lib/DtSearch/raima/connect.c
View file

@ -58,9 +58,6 @@ typedef struct {
LONG total; /* total number of members in set */
DB_ADDR first; /* database address of first member in set */
DB_ADDR last; /* database address of last member in set */
#ifndef NO_TIMESTAMP
ULONG timestamp; /* set update timestamp - if used */
#endif
} SET_PTR;
/* member pointer structure definition */
@ -91,9 +88,6 @@ DBN_DECL /* Database number */
DB_ADDR ndba; /* db address of next member record */
INT ordering; /* set order control variable */
int stat, compare; /* status code & sort comparison result */
#ifndef NO_TIMESTAMP
FILE_NO file;
#endif
SET_ENTRY *set_ptr;
DB_ADDR *co_ptr;
DB_ADDR *cm_ptr;
@ -251,13 +245,6 @@ DBN_DECL /* Database number */
inserted:
/* increment total members in set */
++cosp.total;
#ifndef NO_TIMESTAMP
/* check for timestamp */
if ( set_ptr->st_flags & TIMESTAMPED ) {
file = NUM2INT((FILE_NO)((*co_ptr >> FILESHIFT) & FILEMASK), ft_offset);
cosp.timestamp = dio_pzgetts(file);
}
#endif
if ( mrec ) {
/* put member pointer back into member record and mark member
record as modified
@ -285,13 +272,6 @@ inserted:
/* set current member to current record */
*cm_ptr = curr_rec;
#ifndef NO_TIMESTAMP
/* check and fetch timestamps */
if ( db_tsrecs )
d_utscr(&cm_time[set] TASK_PARM);
if ( db_tssets )
cs_time[set] = cosp.timestamp;
#endif
RETURN( db_status );
/* error return */

30
cde/lib/DtSearch/raima/costat.c
View file

@ -48,34 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Test timestamp status of current owner
*/
d_costat(set TASK_PARM DBN_PARM)
int set;
TASK_DECL
DBN_DECL
{
ULONG cts, uts;
ULONG cots;
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_IO));
if ( d_ctsco(set, &cts TASK_PARM DBN_PARM) == S_OKAY ) {
if ( cts ) {
cots = co_time[NUM2INT(set - SETMARK, st_offset)];
if ( cts > cots )
db_status = S_DELETED;
else {
d_utsco(set, &uts TASK_PARM DBN_PARM);
if ( uts > cots )
db_status = S_UPDATED;
}
}
else
dberr(S_TIMESTAMP);
}
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin costat.c */

24
cde/lib/DtSearch/raima/crstat.c
View file

@ -48,28 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Test timestamp status of current record
*/
d_crstat(TASK_ONLY)
TASK_DECL
{
ULONG cts, uts;
DB_ENTER(NO_DB_ID TASK_ID LOCK_SET(RECORD_IO));
if ( d_ctscr(&cts TASK_PARM) == S_OKAY ) {
if ( cts ) {
d_utscr(&uts TASK_PARM);
if ( cts > cr_time )
db_status = S_DELETED;
else if ( uts > cr_time )
db_status = S_UPDATED;
}
else
dberr(S_TIMESTAMP);
}
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin crstat.c */

14
cde/lib/DtSearch/raima/crwrite.c
View file

@ -57,9 +57,6 @@ char *data; /* data area to contain field contents */
TASK_DECL
DBN_DECL /* database number */
{
#ifndef NO_TIMESTAMP
ULONG timestamp;
#endif
int stat, fld, rec;
RECORD_ENTRY *rec_ptr;
FIELD_ENTRY *fld_ptr;
@ -93,18 +90,7 @@ DBN_DECL /* database number */
/* put data into record and return */
if ( r_pfld(fld, fld_ptr, crloc, data, &curr_rec) != S_OKAY )
RETURN( db_status );
#ifndef NO_TIMESTAMP
/* check for timestamp */
if ( rec_ptr->rt_flags & TIMESTAMPED ) {
timestamp = dio_pzgetts(rec_ptr->rt_file);
bytecpy( crloc + RECUPTIME, &timestamp, sizeof(LONG));
}
#endif
dio_write(curr_rec, NULL, PGFREE);
#ifndef NO_TIMESTAMP
if (( db_status == S_OKAY ) && ( rec_ptr->rt_flags & TIMESTAMPED ))
cr_time = timestamp;
#endif
RETURN( db_status );
}
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin crwrite.c */

14
cde/lib/DtSearch/raima/csmwrite.c
View file

@ -58,9 +58,6 @@ const char *data; /* Data area to contain field contents */
TASK_DECL
DBN_DECL /* database number */
{
#ifndef NO_TIMESTAMP
ULONG timestamp;
#endif
int stat, fld, rec;
char *recp;
SET_ENTRY *set_ptr;
@ -98,18 +95,7 @@ DBN_DECL /* database number */
/* Put data into record */
if ( r_pfld(fld, fld_ptr, recp, data, cm_ptr) != S_OKAY )
RETURN( db_status );
#ifndef NO_TIMESTAMP
/* check for timestamp */
if ( rec_ptr->rt_flags & TIMESTAMPED ) {
timestamp = dio_pzgetts(rec_ptr->rt_file);
bytecpy( recp + RECUPTIME, &timestamp, sizeof(LONG));
}
#endif
dio_write(*cm_ptr, NULL, PGFREE);
#ifndef NO_TIMESTAMP
if (( db_status == S_OKAY ) && ( rec_ptr->rt_flags & TIMESTAMPED ))
cm_time[set] = timestamp;
#endif
RETURN( db_status );
}
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin csmwrite.c */

14
cde/lib/DtSearch/raima/csowrite.c
View file

@ -58,9 +58,6 @@ const char *data; /* Data area to contain field contents */
TASK_DECL
DBN_DECL /* database number */
{
#ifndef NO_TIMESTAMP
ULONG timestamp;
#endif
int stat, fld, rec;
char *recp;
SET_ENTRY *set_ptr;
@ -98,18 +95,7 @@ DBN_DECL /* database number */
/* Put data into record */
if ( r_pfld(fld, fld_ptr, recp, data, co_ptr) != S_OKAY )
RETURN( db_status );
#ifndef NO_TIMESTAMP
/* check for timestamp */
if ( rec_ptr->rt_flags & TIMESTAMPED ) {
timestamp = dio_pzgetts(rec_ptr->rt_file);
bytecpy( recp + RECUPTIME, &timestamp, sizeof(LONG));
}
#endif
dio_write(*co_ptr, (char *)NULL, PGFREE);
#ifndef NO_TIMESTAMP
if (( db_status == S_OKAY ) && ( rec_ptr->rt_flags & TIMESTAMPED ))
co_time[set] = timestamp;
#endif
RETURN( db_status );
}
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin csowrite.c */

23
cde/lib/DtSearch/raima/csstat.c
View file

@ -48,27 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Test timestamp status of current set
*/
d_csstat(set TASK_PARM DBN_PARM)
int set;
TASK_DECL
DBN_DECL
{
ULONG uts;
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_IO));
if ( d_utscs(set, &uts TASK_PARM DBN_PARM) == S_OKAY ) {
if ( uts ) {
if ( uts > cs_time[NUM2INT(set - SETMARK, st_offset)] )
db_status = S_UPDATED;
}
else
dberr(S_TIMESTAMP);
}
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin csstat.c */

41
cde/lib/DtSearch/raima/ctscm.c
View file

@ -48,45 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Get creation timestamp of current member
*/
d_ctscm(set, timestamp TASK_PARM DBN_PARM)
int set;
ULONG *timestamp;
TASK_DECL
DBN_DECL
{
INT rec;
char *rptr;
SET_ENTRY *set_ptr;
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_IO));
if (nset_check(set, &set, (SET_ENTRY * *)&set_ptr) != S_OKAY)
RETURN( db_status );
/* make sure we have a current member */
if ( ! curr_mem[set] )
RETURN( dberr(S_NOCM) );
/* read current member */
if ( dio_read( curr_mem[set], (char * *)&rptr , NOPGHOLD) != S_OKAY )
RETURN( db_status );
/* get record id */
bytecpy(&rec, rptr, sizeof(INT));
if ( rec >= 0 ) {
rec &= ~RLBMASK; /* mask off rlb */
if (record_table[NUM2INT(rec, rt_offset)].rt_flags & TIMESTAMPED)
bytecpy(timestamp, rptr + RECCRTIME, sizeof(ULONG));
else
*timestamp = 0L;
}
else
db_status = S_DELETED;
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin ctscm.c */

41
cde/lib/DtSearch/raima/ctsco.c
View file

@ -48,45 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Get creation timestamp of current owner
*/
d_ctsco(set, timestamp TASK_PARM DBN_PARM)
int set;
ULONG *timestamp;
TASK_DECL
DBN_DECL
{
INT rec;
char *rptr;
SET_ENTRY *set_ptr;
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_IO));
if (nset_check(set, &set, (SET_ENTRY * *)&set_ptr) != S_OKAY)
RETURN( db_status );
/* make sure we have a current owner */
if ( ! curr_own[set] )
RETURN( dberr(S_NOCO) );
/* read current owner */
if ( dio_read( curr_own[set], (char * *)&rptr , NOPGHOLD) != S_OKAY )
RETURN( db_status );
/* get record id */
bytecpy(&rec, rptr, sizeof(INT));
if ( rec >= 0 ) {
rec &= ~RLBMASK; /* mask off rlb */
if (record_table[NUM2INT(rec, rt_offset)].rt_flags & TIMESTAMPED)
bytecpy(timestamp, rptr + RECCRTIME, sizeof(ULONG));
else
*timestamp = 0L;
}
else
db_status = S_DELETED;
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin ctsco.c */

34
cde/lib/DtSearch/raima/ctscr.c
View file

@ -48,38 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Get creation timestamp of current record
*/
d_ctscr(timestamp TASK_PARM)
ULONG *timestamp;
TASK_DECL
{
INT rec;
DB_ENTER(NO_DB_ID TASK_ID LOCK_SET(RECORD_IO));
/* make sure we have a current record */
if ( ! curr_rec )
RETURN( dberr(S_NOCR) );
/* read current record */
if ( dio_read( curr_rec, (char * *)&crloc , NOPGHOLD) != S_OKAY )
RETURN( db_status );
/* get record id */
bytecpy(&rec, crloc, sizeof(INT));
if ( rec >= 0 ) {
rec &= ~RLBMASK; /* mask off rlb */
if (record_table[NUM2INT(rec, rt_offset)].rt_flags & TIMESTAMPED)
bytecpy(timestamp, crloc + RECCRTIME, sizeof(ULONG));
else
*timestamp = 0L;
}
else
db_status = S_DELETED;
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin ctscr.c */

17
cde/lib/DtSearch/raima/dblfcns.c
View file

@ -408,9 +408,6 @@ TASK_DECL
dio_free(); */
}
if ( dbopen ) {
#ifndef NO_TIMESTAMP
cr_time = 0;
#endif
setdb_on = FALSE;
curr_db = 0;
no_of_dbs = 1;
@ -448,20 +445,6 @@ void termfree()
MEM_UNLOCK(&db_global.Curr_own);
FREE(&db_global.Curr_own);
}
#ifndef NO_TIMESTAMP
if ( co_time ) {
MEM_UNLOCK(&db_global.Co_time);
FREE(&db_global.Co_time);
}
if ( cm_time ) {
MEM_UNLOCK(&db_global.Cm_time);
FREE(&db_global.Cm_time);
}
if ( cs_time ) {
MEM_UNLOCK(&db_global.Cs_time);
FREE(&db_global.Cs_time);
}
#endif
if ( sort_table ) {
MEM_UNLOCK(&db_global.Sort_table);
FREE(&db_global.Sort_table);

5
cde/lib/DtSearch/raima/dbtype.h
View file

@ -107,7 +107,6 @@ Failure to do so will produce compilation errors.
HHS = Harris H-series
*/
#define NO_TIMESTAMP
#define PGHOLD 1
#define NOPGHOLD 0
@ -188,10 +187,6 @@ Failure to do so will produce compilation errors.
#define SP_FIRST 4
/* Offset to last member ptr in set ptr = 2+DB_ADDR_SIZE */
#define SP_LAST 8
#ifndef NO_TIMESTAMP
/* Offset to timestamp in set ptr */
#define SP_UTIME 12
#endif
/* Size of member pointer = 3*DB_ADDR_SIZE */
#define MEMPSIZE 12
/* Offset to owner ptr in member ptr */

18
cde/lib/DtSearch/raima/dbxtrn.h
View file

@ -100,14 +100,6 @@ typedef struct TASK_S {
DB_ADDR Curr_rec; /* current record address */
DB_ADDR_P Curr_own; /* current set owners array */
DB_ADDR_P Curr_mem; /* current set members array */
#ifndef NO_TIMESTAMP
ULONG Cr_time;
ULONG_P Co_time; /* co_time = NULL */
ULONG_P Cm_time; /* cm_time = NULL */
ULONG_P Cs_time; /* cs_time = NULL */
BOOLEAN Db_tsrecs;
BOOLEAN Db_tssets;
#endif
FILE_NO Ov_file;
BOOLEAN Setdb_on;
INT No_of_dbs;
@ -163,11 +155,6 @@ typedef struct TASK_S {
#define key_table db_global.Key_table.ptr
#define pgzero db_global.Pgzero.ptr
#define root_ix db_global.Root_ix.ptr
#ifndef NO_TIMESTAMP
#define co_time db_global.Co_time.ptr
#define cm_time db_global.Cm_time.ptr
#define cs_time db_global.Cs_time.ptr
#endif
/* Used in DIO.C and OVFCNS.C */
#define ixpg_table Ixpg_table.ptr
#define dbpgbuff Dbpgbuff.ptr
@ -201,11 +188,6 @@ typedef struct TASK_S {
#define curr_db db_global.Curr_db
#define curr_db_table db_global.Curr_db_table
#define curr_rec db_global.Curr_rec
#ifndef NO_TIMESTAMP
#define cr_time db_global.Cr_time
#define db_tsrecs db_global.Db_tsrecs
#define db_tssets db_global.Db_tssets
#endif
#define ov_file db_global.Ov_file
#define setdb_on db_global.Setdb_on
#define no_of_dbs db_global.No_of_dbs

20
cde/lib/DtSearch/raima/delete.c
View file

@ -63,9 +63,6 @@ DBN_DECL
SET_ENTRY *set_ptr;
MEMBER_ENTRY *mem_ptr;
DB_ADDR *co_ptr, *cm_ptr;
#ifndef NO_TIMESTAMP
ULONG *cots_ptr, *cmts_ptr, *sts_ptr;
#endif
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_IO));
@ -103,34 +100,17 @@ DBN_DECL
/* delete record */
if ( r_delrec( rt, curr_rec ) == S_OKAY ) {
/* nullify any currency containing deleted record */
#ifndef NO_TIMESTAMP
for (i = 0, co_ptr = curr_own, cm_ptr = curr_mem, cots_ptr = co_time,
cmts_ptr = cm_time, sts_ptr = cs_time;
i < size_st;
++i, ++co_ptr, ++cm_ptr, ++cots_ptr, ++cmts_ptr, ++sts_ptr) {
#else
for (i = 0, co_ptr = curr_own, cm_ptr = curr_mem;
i < size_st;
++i, ++co_ptr, ++cm_ptr) {
#endif
if ( ADDRcmp(&curr_rec, co_ptr) == 0 ) {
*co_ptr = NULL_DBA;
#ifndef NO_TIMESTAMP
if ( db_tsrecs ) *cots_ptr = 0L;
if ( db_tssets ) *sts_ptr = 0L;
#endif
}
if ( ADDRcmp(&curr_rec, cm_ptr) == 0 ) {
*cm_ptr = NULL_DBA;
#ifndef NO_TIMESTAMP
if ( db_tsrecs ) *cmts_ptr = 0L;
#endif
}
}
curr_rec = NULL_DBA;
#ifndef NO_TIMESTAMP
cr_time = 0L;
#endif
}
RETURN( db_status );
}

33
cde/lib/DtSearch/raima/dio.c
View file

@ -1055,39 +1055,6 @@ LOOKUP_ENTRY *lu_ptr; /* corresponding to pg_ptr */
Page zero handling functions for data and key files
***********************************************************************/
#ifndef NO_TIMESTAMP
/* Increment and return file timestamp
*/
ULONG dio_pzsetts(fno )
FILE_NO fno;
{
ULONG ts;
PGZERO *pgzero_ptr;
if ( db_tsrecs || db_tssets ) {
pgzero_ptr = &pgzero[fno];
pgzero_ptr->pz_modified = TRUE;
ts = ++pgzero_ptr->pz_timestamp;
}
else
ts = 0;
return( ts );
}
/* Return file timestamp
*/
ULONG dio_pzgetts(fno)
FILE_NO fno;
{
if ( pgzero[fno].pz_next == 0L )
dio_pzread(fno);
o_fileinit(fno);
return ( pgzero[fno].pz_timestamp );
}
#endif
/* Initialize page zero table
*/

24
cde/lib/DtSearch/raima/discon.c
View file

@ -52,9 +52,6 @@ typedef struct {
LONG total; /* total number of members in set */
DB_ADDR first; /* database address of first member in set */
DB_ADDR last; /* database address of last member in set */
#ifndef NO_TIMESTAMP
ULONG timestamp; /* set update timestamp - if used */
#endif
} SET_PTR;
/* member pointer structure definition */
@ -83,9 +80,6 @@ DBN_DECL /* database number */
DB_ADDR npdba; /* db address of next or previous member */
int set; /* set_table entry */
int stat; /* status code variable */
#ifndef NO_TIMESTAMP
FILE_NO file; /* file containing owner record */
#endif
SET_ENTRY *set_ptr;
DB_ADDR *co_ptr, *cm_ptr;
@ -150,13 +144,6 @@ DBN_DECL /* database number */
(dio_write(npdba, NULL, NOPGFREE) != S_OKAY))
goto quit_a;
}
#ifndef NO_TIMESTAMP
/* check for timestamp */
if ( set_ptr->st_flags & TIMESTAMPED ) {
file = NUM2INT((FILE_NO)((*co_ptr >> FILESHIFT) & FILEMASK), ft_offset);
cosp.timestamp = dio_pzgetts(file);
}
#endif
/* update membership count */
--cosp.total;
@ -176,17 +163,6 @@ DBN_DECL /* database number */
if ((r_pmem(set, mrec, (char *)&cmmp) != S_OKAY) ||
(dio_write(mdba, NULL, PGFREE) != S_OKAY))
RETURN( db_status );
#ifndef NO_TIMESTAMP
/* note timestamps */
if ( db_tsrecs )
d_utscr( &cr_time TASK_PARM );
if ( db_tsrecs && *cm_ptr )
d_utscm(nset, &cm_time[set] TASK_PARM DBN_PARM);
/* check for timestamp */
if ( set_ptr->st_flags & TIMESTAMPED )
cs_time[set] = cosp.timestamp;
#endif
RETURN( db_status = *cm_ptr ? S_OKAY : S_EOS );
quit_a:

33
cde/lib/DtSearch/raima/dproto.h
View file

@ -187,16 +187,10 @@ int d_close(P0); /* dblfcns.c */
int d_cmstat(P1(int) DBN_Dn); /* cmstat.c */
int d_cmtype(P1(int) Pi(int *) DBN_Dn); /* cmtype.c */
int d_connect(P1(int) DBN_Dn); /* connect.c */
#ifndef NO_TIMESTAMP /* NO_TIMESTAMP */
int d_costat(P1(int) DBN_Dn); /* costat.c */
#endif /* NO_TIMESTAMP */
int d_cotype(P1(int) Pi(int *) DBN_Dn); /* cotype.c */
int d_crget(P1(DB_ADDR *) DBN_Dn); /* crget.c */
int d_crread(P1(long) Pi(char *) DBN_Dn); /* crread.c */
int d_crset(P1(DB_ADDR *) DBN_Dn); /* crset.c */
#ifndef NO_TIMESTAMP /* NO_TIMESTAMP */
int d_crstat(P0); /* crstat.c */
#endif /* NO_TIMESTAMP */
int d_crtype(P1(int *) DBN_Dn); /* crtype.c */
int d_crwrite(P1(long) Pi(char *) DBN_Dn); /* crwrite.c */
int d_csmget(P1(int) Pi(DB_ADDR *) DBN_Dn); /* csmget.c */
@ -211,12 +205,6 @@ int d_csoread(P1(int) Pi(long) Pi(char *) DBN_Dn);
int d_csoset(P1(int) Pi(DB_ADDR *) DBN_Dn); /* csoset.c */
int d_csowrite(P1(int) Pi(long) Pi(const char *) DBN_Dn);
/* csowrite.c */
#ifndef NO_TIMESTAMP /* NO_TIMESTAMP */
int d_csstat(P1(int) DBN_Dn); /* csstat.c */
int d_ctscm(P1(int) Pi(ULONG *) DBN_Dn); /* ctscm.c */
int d_ctsco(P1(int) Pi(ULONG *) DBN_Dn); /* ctsco.c */
int d_ctscr(P1(ULONG *)); /* ctscr.c */
#endif /* NO_TIMESTAMP */
#ifndef NO_COUNTRY
int d_ctbpath(P1(const char *)); /* pathfcns.c */
#endif /* NO_COUNTRY */
@ -238,12 +226,6 @@ int d_findlm(P1(int) DBN_Dn); /* findlm.c */
int d_findnm(P1(int) DBN_Dn); /* findnm.c */
int d_findpm(P1(int) DBN_Dn); /* findpm.c */
int d_freeall(P0); /* dblfcns.c */
#ifndef NO_TIMESTAMP /* NO_TIMESTAMP */
int d_gtscm(P1(int) Pi(ULONG *) DBN_Dn); /* gtscm.c */
int d_gtsco(P1(int) Pi(ULONG *) DBN_Dn); /* gtsco.c */
int d_gtscr(P1(ULONG *)); /* gtscr.c */
int d_gtscs(P1(int) Pi(ULONG *) DBN_Dn); /* gtscs.c */
#endif /* NO_TIMESTAMP */
int d_initialize(DBN_D1); /* initial.c */
int d_initfile(P1(FILE_NO) DBN_Dn); /* initial.c */
int d_ismember(P1(int) DBN_Dn); /* ismember.c */
@ -281,9 +263,6 @@ int d_reclstat(P1(int) Pi(char *) DBN_Dn); /* dblfcns.c */
int d_recover(P1(const char *)); /* recover.c */
int d_recread(P1(char *) DBN_Dn); /* recread.c */
int d_recset(P1(int) DBN_Dn); /* recset.c */
#ifndef NO_TIMESTAMP /* NO_TIMESTAMP */
int d_recstat(P1(DB_ADDR) Pi(ULONG)); /* recstat.c */
#endif /* NO_TIMESTAMP */
int d_recwrite(P1(const char *) DBN_Dn); /* recwrite.c */
int d_renfile(P1(const char *) Pi(FILE_NO)
Pi(const char *)); /* renfile.c */
@ -305,22 +284,10 @@ int d_setoo(P1(int) Pi(int) DBN_Dn); /* setoo.c */
int d_setor(P1(int) DBN_Dn); /* setor.c */
int d_setrm(P1(int) DBN_Dn); /* setrm.c */
int d_setro(P1(int) DBN_Dn); /* setro.c */
#ifndef NO_TIMESTAMP /* NO_TIMESTAMP */
int d_stscm(P1(int) Pi(ULONG) DBN_Dn); /* stscm.c */
int d_stsco(P1(int) Pi(ULONG) DBN_Dn); /* stsco.c */
int d_stscr(P1(ULONG)); /* stscr.c */
int d_stscs(P1(int) Pi(ULONG) DBN_Dn); /* stscs.c */
#endif /* NO_TIMESTAMP */
int d_timeout(P1(int)); /* dblfcns.c */
int d_trabort(P0); /* dblfcns.c */
int d_trbegin(P1(const char *)); /* dblfcns.c */
int d_trend(P0); /* dblfcns.c */
#ifndef NO_TIMESTAMP /* NO_TIMESTAMP */
int d_utscm(P1(int) Pi(ULONG *) DBN_Dn); /* utscm.c */
int d_utsco(P1(int) Pi(ULONG *) DBN_Dn); /* utsco.c */
int d_utscr(P1(ULONG *)); /* utscr.c */
int d_utscs(P1(int) Pi(ULONG *) DBN_Dn); /* utscs.c */
#endif /* NO_TIMESTAMP */
int dberr(P1(int)); /* dberr.c */

33
cde/lib/DtSearch/raima/dtcover.h
View file

@ -46,16 +46,10 @@
#define d_cmstat dt_cmstat
#define d_cmtype dt_cmtype
#define d_connect dt_connect
#ifndef NO_TIMESTAMP
#define d_costat dt_costat
#endif
#define d_cotype dt_cotype
#define d_crget dt_crget
#define d_crread dt_crread
#define d_crset dt_crset
#ifndef NO_TIMESTAMP
#define d_crstat dt_crstat
#endif
#define d_crtype dt_crtype
#define d_crwrite dt_crwrite
#define d_csmget dt_csmget
@ -66,12 +60,6 @@
#define d_csoread dt_csoread
#define d_csoset dt_csoset
#define d_csowrite dt_csowrite
#ifndef NO_TIMESTAMP
#define d_csstat dt_csstat
#define d_ctscm dt_ctscm
#define d_ctsco dt_ctsco
#define d_ctscr dt_ctscr
#endif
#ifndef NO_COUNTRY
#define d_ctbpath dt_ctbpath
#endif
@ -93,12 +81,6 @@
#define d_findnm dt_findnm
#define d_findpm dt_findpm
#define d_freeall dt_freeall
#ifndef NO_TIMESTAMP
#define d_gtscm dt_gtscm
#define d_gtsco dt_gtsco
#define d_gtscr dt_gtscr
#define d_gtscs dt_gtscs
#endif
#define d_initialize dt_initialize
#define d_initfile dt_initfile
#define d_ismember dt_ismember
@ -132,9 +114,6 @@
#define d_recover dt_recover
#define d_recread dt_recread
#define d_recset dt_recset
#ifndef NO_TIMESTAMP
#define d_recstat dt_recstat
#endif
#define d_recwrite dt_recwrite
#define d_renfile dt_renfile
#define d_retries dt_retries
@ -155,21 +134,9 @@
#define d_setor dt_setor
#define d_setrm dt_setrm
#define d_setro dt_setro
#ifndef NO_TIMESTAMP
#define d_stscm dt_stscm
#define d_stsco dt_stsco
#define d_stscr dt_stscr
#define d_stscs dt_stscs
#endif
#define d_timeout dt_timeout
#define d_trabort dt_trabort
#define d_trbegin dt_trbegin
#define d_trend dt_trend
#ifndef NO_TIMESTAMP
#define d_utscm dt_utscm
#define d_utsco dt_utsco
#define d_utscr dt_utscr
#define d_utscs dt_utscs
#endif
#define d_wrcurr dt_wrcurr
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC dtcover.h */

15
cde/lib/DtSearch/raima/fillnew.c
View file

@ -61,9 +61,6 @@ const char *recval; /* record value */
TASK_DECL
DBN_DECL /* database number */
{
#ifndef NO_TIMESTAMP
ULONG timestamp;
#endif
DB_ADDR db_addr;
INT recnum, stat;
FILE_NO file;
@ -118,15 +115,6 @@ DBN_DECL /* database number */
/* place the record number and db_addr at the start of the record */
bytecpy( ptr, &recnum, sizeof(INT) );
bytecpy( ptr+sizeof(INT), &db_addr, DB_ADDR_SIZE );
#ifndef NO_TIMESTAMP
/* check for timestamp */
if ( rec_ptr->rt_flags & TIMESTAMPED ) {
timestamp = dio_pzgetts(file);
bytecpy( ptr + RECCRTIME, &timestamp, sizeof(LONG));
bytecpy( ptr + RECUPTIME, &timestamp, sizeof(LONG));
}
else timestamp = 0;
#endif
/* copy the record value into place */
bytecpy( ptr+rec_ptr->rt_data, recval, rec_ptr->rt_len-rec_ptr->rt_data );
@ -151,9 +139,6 @@ DBN_DECL /* database number */
if ( dio_write(db_addr, NULL, PGFREE) == S_OKAY ) {
curr_rec = db_addr;
#ifndef NO_TIMESTAMP
if ( db_tsrecs ) cr_time = timestamp;
#endif
}
RETURN( db_status );
}

10
cde/lib/DtSearch/raima/findco.c
View file

@ -86,16 +86,6 @@ DBN_DECL
curr_own[set] = own;
curr_mem[set] = curr_rec;
curr_rec = own;
#ifndef NO_TIMESTAMP
/* set any timestamps */
if ( db_tsrecs ) {
d_utscr( &cr_time TASK_PARM );
d_utscm(nset, &cm_time[set] TASK_PARM DBN_PARM);
co_time[set] = cr_time;
}
if ( db_tssets )
d_utscs(nset, &cs_time[set] TASK_PARM DBN_PARM);
#endif
RETURN( db_status = S_OKAY );
}
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin findco.c */

10
cde/lib/DtSearch/raima/findfm.c
View file

@ -88,16 +88,6 @@ DBN_DECL
RETURN( db_status = S_EOS );
curr_rec = mem;
#ifndef NO_TIMESTAMP
/* set timestamps */
if ( db_tsrecs ) {
d_utscr( &cr_time TASK_PARM );
cm_time[set] = cr_time;
}
if ( db_tssets )
/* only needed for system record support */
d_utscs(nset, &cs_time[set] TASK_PARM DBN_PARM);
#endif
RETURN( db_status = S_OKAY );
}
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin findfm.c */

10
cde/lib/DtSearch/raima/findlm.c
View file

@ -88,16 +88,6 @@ DBN_DECL
RETURN( db_status = S_EOS );
curr_rec = mem;
#ifndef NO_TIMESTAMP
/* set timestamps */
if ( db_tsrecs ) {
d_utscr( &cr_time TASK_PARM );
cm_time[set] = cr_time;
}
if ( db_tssets )
/* only needed for system record support */
d_utscs(nset, &cs_time[set] TASK_PARM DBN_PARM);
#endif
RETURN( db_status = S_OKAY );
}
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin findlm.c */

7
cde/lib/DtSearch/raima/findnm.c
View file

@ -90,13 +90,6 @@ DBN_DECL
RETURN( db_status = S_EOS );
curr_rec = mem;
#ifndef NO_TIMESTAMP
/* set timestamps */
if ( db_tsrecs ) {
d_utscr( &cr_time TASK_PARM );
cm_time[set] = cr_time;
}
#endif
RETURN( db_status = S_OKAY );
}
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin findnm.c */

7
cde/lib/DtSearch/raima/findpm.c
View file

@ -90,13 +90,6 @@ DBN_DECL
RETURN( db_status = S_EOS );
curr_rec = mem;
#ifndef NO_TIMESTAMP
/* set timestamps */
if ( db_tsrecs ) {
d_utscr( &cr_time TASK_PARM );
cm_time[set] = cr_time;
}
#endif
RETURN( db_status = S_OKAY );
}
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin findpm.c */

29
cde/lib/DtSearch/raima/gtscm.c
View file

@ -48,33 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Get timestamp of current member
*/
d_gtscm(set, timestamp TASK_PARM DBN_PARM)
int set;
ULONG *timestamp;
TASK_DECL
DBN_DECL
{
SET_ENTRY *set_ptr;
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_NOIO));
if (nset_check(set, &set, (SET_ENTRY * *)&set_ptr) != S_OKAY)
RETURN( db_status );
/* make sure we have a current member */
if ( curr_mem[set] ) {
if ( db_tsrecs )
*timestamp = cm_time[set];
else
dberr(S_TIMESTAMP);
}
else
dberr(S_NOCM);
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin gtscm.c */

29
cde/lib/DtSearch/raima/gtsco.c
View file

@ -48,33 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Get timestamp of current owner
*/
d_gtsco(set, timestamp TASK_PARM DBN_PARM)
int set;
ULONG *timestamp;
TASK_DECL
DBN_DECL
{
SET_ENTRY *set_ptr;
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_NOIO));
if (nset_check(set, &set, (SET_ENTRY * *)&set_ptr) != S_OKAY)
RETURN( db_status );
/* make sure we have a current owner */
if ( curr_own[set] ) {
if ( db_tsrecs )
*timestamp = co_time[set];
else
dberr(S_TIMESTAMP);
}
else
dberr(S_NOCO);
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin gtsco.c */

24
cde/lib/DtSearch/raima/gtscr.c
View file

@ -48,28 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Get timestamp of current record
*/
d_gtscr(timestamp TASK_PARM)
ULONG *timestamp;
TASK_DECL
{
DB_ENTER(NO_DB_ID TASK_ID LOCK_SET(RECORD_NOIO));
db_status = S_OKAY;
/* make sure we have a current record */
if ( curr_rec ) {
if ( db_tsrecs )
*timestamp = cr_time;
else
dberr(S_TIMESTAMP);
}
else
dberr(S_NOCR);
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin gtscr.c */

29
cde/lib/DtSearch/raima/gtscs.c
View file

@ -48,33 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Get timestamp of set
*/
d_gtscs(set, timestamp TASK_PARM DBN_PARM)
int set;
ULONG *timestamp;
TASK_DECL
DBN_DECL
{
SET_ENTRY *set_ptr;
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_NOIO));
if (nset_check(set, &set, (SET_ENTRY * *)&set_ptr) != S_OKAY)
RETURN( db_status );
/* make sure we have a current owner */
if ( curr_own[set] ) {
if ( db_tssets )
*timestamp = cs_time[set];
else
dberr(S_TIMESTAMP);
}
else
dberr(S_NOCO);
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin gtscs.c */

37
cde/lib/DtSearch/raima/inittab.c
View file

@ -106,11 +106,7 @@ inittab()
FILE_ENTRY *file_ptr;
FIELD_ENTRY *fld_ptr;
#define DB_ENABLE 1
#ifndef NO_TIMESTAMP
#define TS_ENABLE 1
#else
#define TS_ENABLE 0
#endif
#if DB_ENABLE | TS_ENABLE
RECORD_ENTRY *rec_ptr;
SET_ENTRY *set_ptr;
@ -119,9 +115,6 @@ inittab()
SORT_ENTRY *srt_ptr;
KEY_ENTRY *key_ptr;
#ifndef NO_TIMESTAMP
db_tsrecs = db_tssets = FALSE;
#endif
size_ft = size_rt = size_st = size_mt = size_srt = size_fd = size_kt = 0;
/* compute individual dictionary sizes and offsets */
@ -469,11 +462,6 @@ goodver:
++i, ++rec_ptr) {
rec_ptr->rt_file += curr_db_table->ft_offset;
rec_ptr->rt_fields += curr_db_table->fd_offset;
#ifndef NO_TIMESTAMP
if ( rec_ptr->rt_flags & TIMESTAMPED ) {
db_tsrecs = TRUE;
}
#endif
}
#endif
/* adjust field table entries */
@ -499,11 +487,6 @@ goodver:
++i, ++set_ptr) {
set_ptr->st_own_rt += curr_db_table->rt_offset;
set_ptr->st_members += curr_db_table->mt_offset;
#ifndef NO_TIMESTAMP
if ( set_ptr->st_flags & TIMESTAMPED ) {
db_tssets = TRUE;
}
#endif
}
#endif
@ -669,26 +652,6 @@ static int initcurr()
!= S_OKAY ) {
return( db_status );
}
#ifndef NO_TIMESTAMP
new_size = size_st * sizeof(ULONG);
old_size = old_size_st * sizeof(ULONG);
if ( db_tsrecs ) {
if ( ALLOC_TABLE(&db_global.Co_time, new_size, old_size, "co_time")
!= S_OKAY ) {
return( db_status );
}
if ( ALLOC_TABLE(&db_global.Cm_time, new_size, old_size, "cm_time")
!= S_OKAY ) {
return( db_status );
}
}
if ( db_tssets ) {
if ( ALLOC_TABLE(&db_global.Cs_time, new_size, old_size, "cs_time")
!= S_OKAY ) {
return( db_status );
}
}
#endif
/* for each db make system record as curr_own of its sets */
for (dbt_lc = no_of_dbs, curr_db_table = &db_table[old_no_of_dbs];
--dbt_lc >= 0; ++curr_db_table) {

5
cde/lib/DtSearch/raima/keyfind.c
View file

@ -91,11 +91,6 @@ DBN_DECL /* database number */
/* set current record to found db addr */
curr_rec = dba;
}
#ifndef NO_TIMESTAMP
/* set timestamp */
if ( curr_rec && db_tsrecs )
d_utscr( &cr_time TASK_PARM );
#endif
RETURN( db_status = S_OKAY );
}

5
cde/lib/DtSearch/raima/keyfrst.c
View file

@ -70,11 +70,6 @@ DBN_DECL /* database number */
if ( key_boundary(KEYFRST, &dba) == S_OKAY ) {
curr_rec = dba;
#ifndef NO_TIMESTAMP
/* set timestamp */
if ( db_tsrecs )
d_utscr( &cr_time TASK_PARM );
#endif
}
RETURN( db_status );
}

5
cde/lib/DtSearch/raima/keylast.c
View file

@ -70,11 +70,6 @@ DBN_DECL /* database number */
if ( key_boundary(KEYLAST, &dba) == S_OKAY ) {
curr_rec = dba;
#ifndef NO_TIMESTAMP
/* set timestamp */
if ( db_tsrecs )
d_utscr( &cr_time TASK_PARM );
#endif
}
RETURN( db_status );
}

5
cde/lib/DtSearch/raima/keynext.c
View file

@ -71,11 +71,6 @@ DBN_DECL /* database number */
if ( key_scan(KEYNEXT, &dba) == S_OKAY ) {
curr_rec = dba;
#ifndef NO_TIMESTAMP
/* set timestamp */
if ( db_tsrecs )
d_utscr( &cr_time TASK_PARM );
#endif
}
RETURN( db_status );
}

5
cde/lib/DtSearch/raima/keyprev.c
View file

@ -71,11 +71,6 @@ DBN_DECL /* database number */
if ( key_scan(KEYPREV, &dba) == S_OKAY ) {
curr_rec = dba;
#ifndef NO_TIMESTAMP
/* set timestamp */
if ( db_tsrecs )
d_utscr( &cr_time TASK_PARM );
#endif
}
RETURN( db_status );
}

16
cde/lib/DtSearch/raima/makenew.c
View file

@ -141,9 +141,6 @@ int nrec;
TASK_DECL
DBN_DECL
{
#ifndef NO_TIMESTAMP
ULONG timestamp;
#endif
DB_ADDR db_addr;
INT recnum, fld, stat;
FILE_NO file;
@ -207,15 +204,6 @@ DBN_DECL
/* place the record number and db_addr at the start of the record */
bytecpy( ptr, &recnum, sizeof(INT) );
bytecpy( ptr+sizeof(INT), &db_addr, DB_ADDR_SIZE);
#ifndef NO_TIMESTAMP
/* check for timestamp */
if ( rec_ptr->rt_flags & TIMESTAMPED ) {
timestamp = dio_pzgetts(file);
bytecpy( ptr + RECCRTIME, &timestamp, sizeof(LONG));
bytecpy( ptr + RECUPTIME, &timestamp, sizeof(LONG));
}
else timestamp = 0L;
#endif
/* for each keyed field, enter the key value into the key file */
for (fld = rec_ptr->rt_fields, fldtot = fld + rec_ptr->rt_fdtot,
fld_ptr = &field_table[fld];
@ -253,10 +241,6 @@ DBN_DECL
}
if ( dio_write(db_addr, NULL, PGFREE) == S_OKAY ) {
curr_rec = db_addr;
#ifndef NO_TIMESTAMP
if ( db_tsrecs )
cr_time = timestamp;
#endif
}
RETURN( db_status );
}

4
cde/lib/DtSearch/raima/proto.h
View file

@ -171,10 +171,6 @@ int dio_findpg(P1(FILE_NO) Pi(F_ADDR) Pi(PAGE_ENTRY *)
Pi(PAGE_ENTRY * *)
Pi(LOOKUP_ENTRY * *));
int dio_out(P1(PAGE_ENTRY *) Pi(LOOKUP_ENTRY *));
#ifndef NO_TIMESTAMP
ULONG dio_pzsetts(P1(FILE_NO));
ULONG dio_pzgetts(P1(FILE_NO));
#endif
int dio_pzread(P1(FILE_NO));
int dio_pzalloc(P1(FILE_NO) Pi(F_ADDR *));
int dio_pzdel(P1(FILE_NO) Pi(F_ADDR));

34
cde/lib/DtSearch/raima/recfcns.c
View file

@ -147,9 +147,6 @@ DB_ADDR db_addr;
char *rec; /* ptr to record slot */
char *fptr; /* field data ptr */
char ckey[256]; /* compound key data */
#ifndef NO_TIMESTAMP
ULONG timestamp;
#endif
FILE_NO fno;
F_ADDR rno;
int fld;
@ -180,14 +177,6 @@ DB_ADDR db_addr;
}
fno = NUM2INT((FILE_NO)((db_addr >> FILESHIFT) & FILEMASK), ft_offset);
rno = ADDRMASK & db_addr;
#ifndef NO_TIMESTAMP
/* update timestamp, if necessary */
if ( rec_ptr->rt_flags & TIMESTAMPED ) {
timestamp = dio_pzgetts(fno);
bytecpy( rec + RECCRTIME, &timestamp, sizeof(ULONG));
bytecpy( rec + RECUPTIME, &timestamp, sizeof(ULONG));
}
#endif
dio_write(db_addr, NULL, PGFREE);
/* place this record onto the delete chain */
@ -287,11 +276,6 @@ char *setptr; /* pointer to set pointer */
set_ptr = &set_table[set];
bytecpy(&rt, rec, sizeof(INT));
if (NUM2EXT(set_ptr->st_own_rt, rt_offset) == (rt & ~RLBMASK)) {
#ifndef NO_TIMESTAMP
if ( set_ptr->st_flags & TIMESTAMPED )
len = SETPSIZE;
else
#endif
len = SETPSIZE - sizeof(ULONG);
bytecpy(setptr, rec + set_ptr->st_own_ptr, len);
return( db_status = S_OKAY );
@ -471,11 +455,6 @@ char *setptr; /* pointer to set pointer */
set_ptr = &set_table[set];
bytecpy(&rt, rec, sizeof(INT));
if (NUM2EXT(set_ptr->st_own_rt, rt_offset) == (rt & ~RLBMASK)) {
#ifndef NO_TIMESTAMP
if ( set_ptr->st_flags & TIMESTAMPED )
len = SETPSIZE;
else
#endif
len = SETPSIZE - sizeof(ULONG);
bytecpy(rec + set_ptr->st_own_ptr, setptr, len);
return( db_status = S_OKAY );
@ -493,9 +472,6 @@ r_smem( db_addr, set )
DB_ADDR *db_addr;
INT set;
{
#ifndef NO_TIMESTAMP
int nset;
#endif
char mem[MEMPSIZE], *ptr;
DB_ADDR dba;
@ -512,16 +488,6 @@ INT set;
/* ownership okay, set the member */
curr_mem[set] = dba;
#ifndef NO_TIMESTAMP
nset = NUM2EXT(set + SETMARK, st_offset);
/* set timestamps */
if ( db_tsrecs ) {
d_utsco( nset, &co_time[set] CURRTASK_PARM CURR_DB_PARM );
d_utscm( nset, &cm_time[set] CURRTASK_PARM CURR_DB_PARM );
}
if ( db_tssets )
d_utscs( nset, &cs_time[set] CURRTASK_PARM CURR_DB_PARM );
#endif
return( db_status = S_OKAY );
}

41
cde/lib/DtSearch/raima/recstat.c
View file

@ -48,45 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Test timestamp status of record
*/
d_recstat(dba, rts TASK_PARM)
DB_ADDR dba;
ULONG rts;
TASK_DECL
{
INT rec;
char *ptr;
ULONG cts, uts;
DB_ENTER(NO_DB_ID TASK_ID LOCK_SET(RECORD_IO));
if ((check_dba(dba) != S_OKAY) || (dio_read(dba, (char * *)&ptr, NOPGHOLD) != S_OKAY))
RETURN( db_status );
/* get record id */
bytecpy(&rec, ptr, sizeof(INT));
if ( rec >= 0 ) {
rec &= ~RLBMASK; /* mask off rlb */
rec += curr_db_table->rt_offset;
if ( record_table[rec].rt_flags & TIMESTAMPED ) {
bytecpy(&cts, ptr + RECCRTIME, sizeof(ULONG));
if ( cts > rts )
db_status = S_DELETED;
else {
bytecpy(&uts, ptr + RECUPTIME, sizeof(ULONG));
if ( uts > rts )
db_status = S_UPDATED;
}
}
else
dberr(S_TIMESTAMP);
}
else
db_status = S_DELETED;
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin recstat.c */

16
cde/lib/DtSearch/raima/recwrite.c
View file

@ -57,9 +57,6 @@ const char *rec; /* ptr to record area */
TASK_DECL
DBN_DECL
{
#ifndef NO_TIMESTAMP
ULONG timestamp;
#endif
INT rt; /* record type */
char *fptr; /* field data pointer */
char ckey[256]; /* current compound key data */
@ -145,21 +142,8 @@ DBN_DECL
}
}
}
#ifndef NO_TIMESTAMP
/* check for timestamp */
if ( rec_ptr->rt_flags & TIMESTAMPED ) {
timestamp = dio_pzgetts(rec_ptr->rt_file);
bytecpy( crloc + RECUPTIME, &timestamp, sizeof(LONG));
}
else
timestamp = 0L;
#endif
/* write current record to page */
dio_write(curr_rec, NULL, PGFREE);
#ifndef NO_TIMESTAMP
if (( db_status == S_OKAY ) && db_tsrecs )
cr_time = timestamp;
#endif
RETURN( db_status );
}
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin recwrite.c */

24
cde/lib/DtSearch/raima/rwcurr.c
View file

@ -65,10 +65,6 @@ TASK_DECL
DB_ENTER(NO_DB_ID TASK_ID LOCK_SET(SET_NOIO));
cs = 2*size_st + 1;
#ifndef NO_TIMESTAMP
if ( db_tsrecs ) cs *= 2;
if ( db_tssets ) cs += size_st;
#endif
*currbuff = (DB_ADDR *)ALLOC(NULL, cs*sizeof(DB_ADDR), "currbuff");
if ( *currbuff == NULL ) RETURN( dberr(S_NOMEMORY) );
*currsize = cs * sizeof(DB_ADDR);
@ -86,16 +82,6 @@ TASK_DECL
*(cb_ptr = *currbuff) = curr_rec;
bytecpy(++cb_ptr, curr_own, size_st*sizeof(*cb_ptr));
bytecpy(cb_ptr += size_st, curr_mem, size_st*sizeof(*cb_ptr));
#ifndef NO_TIMESTAMP
if ( db_tsrecs ) {
*(cb_ptr += size_st) = cr_time;
bytecpy(++cb_ptr, co_time, size_st*sizeof(*cb_ptr));
bytecpy(cb_ptr += size_st, cm_time, size_st*sizeof(*cb_ptr));
}
if ( db_tssets ) {
bytecpy(cb_ptr + size_st, cs_time, size_st*sizeof(*cb_ptr));
}
#endif
MEM_UNLOCK(currbuff);
RETURN( db_status = S_OKAY );
}
@ -117,16 +103,6 @@ TASK_DECL
curr_rec = *cb_ptr;
bytecpy(curr_own, ++cb_ptr, size_st*sizeof(*cb_ptr));
bytecpy(curr_mem, cb_ptr += size_st, size_st*sizeof(*cb_ptr));
#ifndef NO_TIMESTAMP
if ( db_tsrecs ) {
cr_time = *(cb_ptr += size_st);
bytecpy(co_time, ++cb_ptr, size_st*sizeof(*cb_ptr));
bytecpy(cm_time, cb_ptr += size_st, size_st*sizeof(*cb_ptr));
}
if ( db_tssets ) {
bytecpy(cs_time, cb_ptr + size_st, size_st*sizeof(*cb_ptr));
}
#endif
}
free(currbuff);
RETURN( db_status = S_OKAY );

10
cde/lib/DtSearch/raima/setom.c
View file

@ -74,16 +74,6 @@ DBN_DECL /* database number */
curr_own[seto] = curr_mem[setm];
curr_mem[seto] = NULL_DBA;
#ifndef NO_TIMESTAMP
/* set timestamps */
if ( db_tsrecs ) {
co_time[seto] = cm_time[setm];
cm_time[seto] = 0L;
}
if ( db_tssets ) {
d_utscs( nseto, &cs_time[seto] TASK_PARM DBN_PARM );
}
#endif
RETURN( db_status );
}
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin setom.c */

10
cde/lib/DtSearch/raima/setoo.c
View file

@ -74,16 +74,6 @@ DBN_DECL /* database number */
curr_own[sett] = curr_own[sets];
curr_mem[sett] = NULL_DBA;
#ifndef NO_TIMESTAMP
/* set timestamps */
if ( db_tsrecs ) {
co_time[sett] = co_time[sets];
cm_time[sett] = 0L;
}
if ( db_tssets ) {
d_utscs( nsett, &cs_time[sett] TASK_PARM DBN_PARM );
}
#endif
RETURN( db_status = S_OKAY );
}
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin setoo.c */

10
cde/lib/DtSearch/raima/setor.c
View file

@ -72,16 +72,6 @@ DBN_DECL /* database number */
curr_own[set] = curr_rec;
curr_mem[set] = NULL_DBA;
#ifndef NO_TIMESTAMP
/* set timestamps */
if ( db_tsrecs ) {
co_time[set] = cr_time;
cm_time[set] = 0L;
}
if ( db_tssets ) {
d_utscs( nset, &cs_time[set] TASK_PARM DBN_PARM );
}
#endif
RETURN( db_status );
}
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin setor.c */

5
cde/lib/DtSearch/raima/setrm.c
View file

@ -66,11 +66,6 @@ DBN_DECL /* database number */
RETURN( dberr( S_NOCM ) );
curr_rec = curr_mem[set];
#ifndef NO_TIMESTAMP
/* set timestamp */
if ( db_tsrecs )
cr_time = cm_time[set];
#endif
RETURN( db_status = S_OKAY );
}
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin setrm.c */

5
cde/lib/DtSearch/raima/setro.c
View file

@ -66,11 +66,6 @@ DBN_DECL /* database number */
RETURN( dberr( S_NOCO ) );
curr_rec = curr_own[set];
#ifndef NO_TIMESTAMP
/* set timestamp */
if ( db_tsrecs )
cr_time = co_time[set];
#endif
RETURN( db_status = S_OKAY );
}
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin setro.c */

29
cde/lib/DtSearch/raima/stscm.c
View file

@ -48,33 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Set timestamp of current member
*/
d_stscm(set, timestamp TASK_PARM DBN_PARM)
int set;
ULONG timestamp;
TASK_DECL
DBN_DECL
{
SET_ENTRY *set_ptr;
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_NOIO));
if (nset_check(set, &set, (SET_ENTRY * *)&set_ptr) != S_OKAY)
RETURN( db_status );
/* make sure we have a current member */
if ( curr_mem[set] ) {
if ( db_tsrecs )
cm_time[set] = timestamp;
else
dberr(S_TIMESTAMP);
}
else
dberr(S_NOCM);
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin stscm.c */

29
cde/lib/DtSearch/raima/stsco.c
View file

@ -48,33 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Set timestamp of current owner
*/
d_stsco(set, timestamp TASK_PARM DBN_PARM)
int set;
ULONG timestamp;
TASK_DECL
DBN_DECL
{
SET_ENTRY *set_ptr;
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_NOIO));
if (nset_check(set, &set, (SET_ENTRY * *)&set_ptr) != S_OKAY)
RETURN( db_status );
/* make sure we have a current owner */
if ( curr_own[set] ) {
if ( db_tsrecs )
co_time[set] = timestamp;
else
dberr(S_TIMESTAMP);
}
else
dberr(S_NOCO);
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin stsco.c */

24
cde/lib/DtSearch/raima/stscr.c
View file

@ -48,28 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Set timestamp of current record
*/
d_stscr(timestamp TASK_PARM)
ULONG timestamp;
TASK_DECL
{
DB_ENTER(NO_DB_ID TASK_ID LOCK_SET(RECORD_NOIO));
db_status = S_OKAY;
/* make sure we have a current record */
if ( curr_rec ) {
if ( db_tsrecs )
cr_time = timestamp;
else
dberr(S_TIMESTAMP);
}
else
dberr(S_NOCR);
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin stscr.c */

29
cde/lib/DtSearch/raima/stscs.c
View file

@ -48,33 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Set timestamp of set
*/
d_stscs(set, timestamp TASK_PARM DBN_PARM)
int set;
ULONG timestamp;
TASK_DECL
DBN_DECL
{
SET_ENTRY *set_ptr;
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_NOIO));
if (nset_check(set, &set, (SET_ENTRY * *)&set_ptr) != S_OKAY)
RETURN( db_status );
/* make sure we have a current owner */
if ( curr_own[set] ) {
if ( db_tssets )
cs_time[set] = timestamp;
else
dberr(S_TIMESTAMP);
}
else
dberr(S_NOCO);
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin stscs.c */

75
cde/lib/DtSearch/raima/task.h
View file

@ -263,18 +263,12 @@ int EXTERNAL_DBN dt_cmstat(P1(int) TASK_Di DBN_Dn); /* cmstat.c */
int EXTERNAL_DBN dt_cmtype(P1(int) Pi(int *) TASK_Di DBN_Dn);
/* cmtype.c */
int EXTERNAL_DBN dt_connect(P1(int) TASK_Di DBN_Dn); /* connect.c */
#ifndef NO_TIMESTAMP
int EXTERNAL_DBN dt_costat(P1(int) TASK_Di DBN_Dn); /* costat.c */
#endif
int EXTERNAL_DBN dt_cotype(P1(int) Pi(int *) TASK_Di DBN_Dn);
/* cotype.c */
int EXTERNAL_DBN dt_crget(P1(DB_ADDR *) TASK_Di DBN_Dn); /* crget.c */
int EXTERNAL_DBN dt_crread(P1(long) Pi(char *) TASK_Di DBN_Dn);
/* crread.c */
int EXTERNAL_DBN dt_crset(P1(DB_ADDR *) TASK_Di DBN_Dn); /* crset.c */
#ifndef NO_TIMESTAMP
int EXTERNAL_FIXED dt_crstat(TASK_D1); /* crstat.c */
#endif
int EXTERNAL_DBN dt_crtype(P1(int *) TASK_Di DBN_Dn); /* crtype.c */
int EXTERNAL_DBN dt_crwrite(P1(long) Pi(char *) TASK_Di DBN_Dn);
/* crwrite.c */
@ -294,14 +288,6 @@ int EXTERNAL_DBN dt_csoset(P1(int) Pi(DB_ADDR *) TASK_Di DBN_Dn);
/* csoset.c */
int EXTERNAL_DBN dt_csowrite(P1(int) Pi(long) Pi(const char *) TASK_Di
DBN_Dn); /* csowrite.c */
#ifndef NO_TIMESTAMP
int EXTERNAL_DBN dt_csstat(P1(int) TASK_Di DBN_Dn); /* csstat.c */
int EXTERNAL_DBN dt_ctscm(P1(int) Pi(ULONG *) TASK_Di DBN_Dn);
/* ctscm.c */
int EXTERNAL_DBN dt_ctsco(P1(int) Pi(ULONG *) TASK_Di DBN_Dn);
/* ctsco.c */
int EXTERNAL_FIXED dt_ctscr(P1(ULONG *) TASK_Di ); /* ctscr.c */
#endif
#ifndef NO_COUNTRY
int EXTERNAL_FIXED dt_ctbpath(P1(const char *) TASK_Di); /* pathfcns.c */
#endif
@ -323,15 +309,6 @@ int EXTERNAL_DBN dt_findlm(P1(int) TASK_Di DBN_Dn); /* findlm.c */
int EXTERNAL_DBN dt_findnm(P1(int) TASK_Di DBN_Dn); /* findnm.c */
int EXTERNAL_DBN dt_findpm(P1(int) TASK_Di DBN_Dn); /* findpm.c */
int EXTERNAL_FIXED dt_freeall(TASK_D1); /* dblfcns.c */
#ifndef NO_TIMESTAMP
int EXTERNAL_DBN dt_gtscm(P1(int) Pi(ULONG *) TASK_Di DBN_Dn);
/* gtscm.c */
int EXTERNAL_DBN dt_gtsco(P1(int) Pi(ULONG *) TASK_Di DBN_Dn);
/* gtsco.c */
int EXTERNAL_FIXED dt_gtscr(P1(ULONG *) TASK_Di ); /* gtscr.c */
int EXTERNAL_DBN dt_gtscs(P1(int) Pi(ULONG *) TASK_Di DBN_Dn);
/* gtscs.c */
#endif
int EXTERNAL_DBN dt_initialize(TASK_D1 DBN_Dn); /* initial.c */
int EXTERNAL_DBN dt_initfile(P1(FILE_NO) TASK_Di DBN_Dn); /* initial.c */
int EXTERNAL_DBN dt_ismember(P1(int) TASK_Di DBN_Dn); /* ismember.c */
@ -377,9 +354,6 @@ int EXTERNAL_DBN dt_reclstat(P1(int) Pi(char *) TASK_Di DBN_Dn);
int EXTERNAL_FIXED dt_recover(P1(const char *) TASK_Di ); /* recover.c */
int EXTERNAL_DBN dt_recread(P1(char *) TASK_Di DBN_Dn); /* recread.c */
int EXTERNAL_DBN dt_recset(P1(int) TASK_Di DBN_Dn); /* recset.c */
#ifndef NO_TIMESTAMP
int EXTERNAL_FIXED dt_recstat(P1(DB_ADDR) Pi(ULONG) TASK_Di ); /* recstat.c */
#endif
int EXTERNAL_DBN dt_recwrite(P1(const char *) TASK_Di DBN_Dn);
/* recwrite.c */
int EXTERNAL_FIXED dt_renfile(P1(const char *) Pi(FILE_NO)
@ -405,25 +379,10 @@ int EXTERNAL_DBN dt_setoo(P1(int) Pi(int) TASK_Di DBN_Dn); /* setoo.c */
int EXTERNAL_DBN dt_setor(P1(int) TASK_Di DBN_Dn); /* setor.c */
int EXTERNAL_DBN dt_setrm(P1(int) TASK_Di DBN_Dn); /* setrm.c */
int EXTERNAL_DBN dt_setro(P1(int) TASK_Di DBN_Dn); /* setro.c */
#ifndef NO_TIMESTAMP
int EXTERNAL_DBN dt_stscm(P1(int) Pi(ULONG) TASK_Di DBN_Dn); /* stscm.c */
int EXTERNAL_DBN dt_stsco(P1(int) Pi(ULONG) TASK_Di DBN_Dn); /* stsco.c */
int EXTERNAL_FIXED dt_stscr(P1(ULONG) TASK_Di ); /* stscr.c */
int EXTERNAL_DBN dt_stscs(P1(int) Pi(ULONG) TASK_Di DBN_Dn); /* stscs.c */
#endif
int EXTERNAL_FIXED dt_timeout(P1(int) TASK_Di ); /* dblfcns.c */
int EXTERNAL_FIXED dt_trabort(TASK_D1); /* dblfcns.c */
int EXTERNAL_FIXED dt_trbegin(P1(const char *) TASK_Di); /* dblfcns.c */
int EXTERNAL_FIXED dt_trend(TASK_D1); /* dblfcns.c */
#ifndef NO_TIMESTAMP
int EXTERNAL_DBN dt_utscm(P1(int) Pi(ULONG *) TASK_Di DBN_Dn);
/* utscm.c */
int EXTERNAL_DBN dt_utsco(P1(int) Pi(ULONG *) TASK_Di DBN_Dn);
/* utsco.c */
int EXTERNAL_FIXED dt_utscr(P1(ULONG *) TASK_Di ); /* utscr.c */
int EXTERNAL_DBN dt_utscs(P1(int) Pi(ULONG *) TASK_Di DBN_Dn);
/* utscs.c */
#endif
#ifndef NO_DT_COVER
@ -449,22 +408,10 @@ int EXTERNAL_DBN dt_utscs(P1(int) Pi(ULONG *) TASK_Di DBN_Dn);
#define d_trbegin(a) dt_trbegin(a CURRTASK_PARM)
#define d_trend() dt_trend(CURRTASK_ONLY)
#define d_wrcurr(a) dt_wrcurr(a CURRTASK_PARM)
#ifndef NO_TIMESTAMP
#define d_crstat() dt_crstat(CURRTASK_ONLY)
#define d_gtscr(a) dt_gtscr(a CURRTASK_PARM)
#define d_recstat(a, b) dt_recstat(a, b CURRTASK_PARM)
#define d_rlbclr() dt_rlbclr(CURRTASK_ONLY)
#define d_rlbset() dt_rlbset(CURRTASK_ONLY)
#define d_rlbtst() dt_rlbtst(CURRTASK_ONLY)
#define d_utscr(a) dt_utscr(a CURRTASK_PARM)
#endif
#define d_cmstat(a DBN_PARM) dt_cmstat(a CURRTASK_PARM DBN_PARM)
#define d_cmtype(a, b DBN_PARM) dt_cmtype(a, b CURRTASK_PARM DBN_PARM)
#define d_connect(a DBN_PARM) dt_connect(a CURRTASK_PARM DBN_PARM)
#ifndef NO_TIMESTAMP
#define d_costat(a DBN_PARM) dt_costat(a CURRTASK_PARM DBN_PARM)
#endif
#define d_cotype(a, b DBN_PARM) dt_cotype(a, b CURRTASK_PARM DBN_PARM)
#define d_crget(a DBN_PARM) dt_crget(a CURRTASK_PARM DBN_PARM)
#define d_crread(a, b DBN_PARM) dt_crread(a, b CURRTASK_PARM DBN_PARM)
@ -479,12 +426,6 @@ int EXTERNAL_DBN dt_utscs(P1(int) Pi(ULONG *) TASK_Di DBN_Dn);
#define d_csoread(a, b, c DBN_PARM) dt_csoread(a, b, c CURRTASK_PARM DBN_PARM)
#define d_csoset(a, b DBN_PARM) dt_csoset(a, b CURRTASK_PARM DBN_PARM)
#define d_csowrite(a, b, c DBN_PARM) dt_csowrite(a, b, c CURRTASK_PARM DBN_PARM)
#ifndef NO_TIMESTAMP
#define d_csstat(a DBN_PARM) dt_csstat(a CURRTASK_PARM DBN_PARM)
#define d_ctscm(a, b DBN_PARM) dt_ctscm(a, b CURRTASK_PARM DBN_PARM)
#define d_ctsco(a, b DBN_PARM) dt_ctsco(a, b CURRTASK_PARM DBN_PARM)
#define d_ctscr(a DBN_PARM) dt_ctscr(a CURRTASK_PARM)
#endif
#define d_delete(DBN_PARM) dt_delete(CURRTASK_ONLY DBN_PARM)
#define d_disdel(DBN_PARM) dt_disdel(CURRTASK_ONLY DBN_PARM)
#define d_recnext(DBN_PARM) dt_recnext(CURRTASK_ONLY DBN_PARM)
@ -496,11 +437,6 @@ int EXTERNAL_DBN dt_utscs(P1(int) Pi(ULONG *) TASK_Di DBN_Dn);
#define d_findlm(a DBN_PARM) dt_findlm(a CURRTASK_PARM DBN_PARM)
#define d_findnm(a DBN_PARM) dt_findnm(a CURRTASK_PARM DBN_PARM)
#define d_findpm(a DBN_PARM) dt_findpm(a CURRTASK_PARM DBN_PARM)
#ifndef NO_TIMESTAMP
#define d_gtscm(a, b DBN_PARM) dt_gtscm(a, b CURRTASK_PARM DBN_PARM)
#define d_gtsco(a, b DBN_PARM) dt_gtsco(a, b CURRTASK_PARM DBN_PARM)
#define d_gtscs(a, b DBN_PARM) dt_gtscs(a, b CURRTASK_PARM DBN_PARM)
#endif
#define d_initialize(DBN_PARM) dt_initialize(CURRTASK_ONLY DBN_PARM)
#define d_initfile(a DBN_PARM) dt_initfile(a CURRTASK_PARM DBN_PARM)
#define d_ismember(a DBN_PARM) dt_ismember(a CURRTASK_PARM DBN_PARM)
@ -540,17 +476,6 @@ int EXTERNAL_DBN dt_utscs(P1(int) Pi(ULONG *) TASK_Di DBN_Dn);
#define d_setor(a DBN_PARM) dt_setor(a CURRTASK_PARM DBN_PARM)
#define d_setrm(a DBN_PARM) dt_setrm(a CURRTASK_PARM DBN_PARM)
#define d_setro(a DBN_PARM) dt_setro(a CURRTASK_PARM DBN_PARM)
#ifndef NO_TIMESTAMP
#define d_stscm(a, b DBN_PARM) dt_stscm(a, b CURRTASK_PARM DBN_PARM)
#define d_stsco(a, b DBN_PARM) dt_stsco(a, b CURRTASK_PARM DBN_PARM)
#define d_stscr(a DBN_PARM) dt_stscr(a CURRTASK_PARM DBN_PARM)
#define d_stscs(a, b DBN_PARM) dt_stscs(a, b CURRTASK_PARM DBN_PARM)
#endif
#ifndef NO_TIMESTAMP
#define d_utscm(a, b DBN_PARM) dt_utscm(a, b CURRTASK_PARM DBN_PARM)
#define d_utsco(a, b DBN_PARM) dt_utsco(a, b CURRTASK_PARM DBN_PARM)
#define d_utscs(a, b DBN_PARM) dt_utscs(a, b CURRTASK_PARM DBN_PARM)
#endif
#endif /* NO_DT_COVER */
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC task.h */

43
cde/lib/DtSearch/raima/utscm.c
View file

@ -48,47 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Get update timestamp of current member
*/
d_utscm(set, timestamp TASK_PARM DBN_PARM)
int set;
ULONG *timestamp;
TASK_DECL
DBN_DECL
{
INT rec;
char *rptr;
SET_ENTRY *set_ptr;
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_IO));
if (nset_check(set, &set, (SET_ENTRY * *)&set_ptr) != S_OKAY)
RETURN( db_status );
/* make sure we have a current member */
if ( ! curr_mem[set] )
RETURN( dberr(S_NOCM) );
/* read current member */
if ( dio_read( curr_mem[set], (char * *)&rptr , NOPGHOLD) != S_OKAY )
RETURN( db_status );
/* get record id */
bytecpy(&rec, rptr, sizeof(INT));
if ( rec >= 0 ) {
rec &= ~RLBMASK; /* mask off rlb */
rec += curr_db_table->rt_offset;
if ( record_table[rec].rt_flags & TIMESTAMPED )
bytecpy(timestamp, rptr + RECUPTIME, sizeof(ULONG));
else
*timestamp = 0L;
db_status = S_OKAY;
}
else
db_status = S_DELETED;
RETURN( db_status = S_OKAY );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin utscm.c */

43
cde/lib/DtSearch/raima/utsco.c
View file

@ -48,47 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Get update timestamp of current owner
*/
d_utsco(set, timestamp TASK_PARM DBN_PARM)
int set;
ULONG *timestamp;
TASK_DECL
DBN_DECL
{
INT rec;
char *rptr;
SET_ENTRY *set_ptr;
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_IO));
if (nset_check(set, &set, (SET_ENTRY * *)&set_ptr) != S_OKAY)
RETURN( db_status );
/* make sure we have a current owner */
if ( ! curr_own[set] )
RETURN( dberr(S_NOCO) );
/* read current owner */
if ( dio_read( curr_own[set], (char * *)&rptr , NOPGHOLD) != S_OKAY )
RETURN( db_status );
/* get record id */
bytecpy(&rec, rptr, sizeof(INT));
if ( rec >= 0 ) {
rec &= ~RLBMASK; /* mask off rlb */
rec += curr_db_table->rt_offset;
if ( record_table[rec].rt_flags & TIMESTAMPED )
bytecpy(timestamp, rptr + RECUPTIME, sizeof(ULONG));
else
*timestamp = 0L;
db_status = S_OKAY;
}
else
db_status = S_DELETED;
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin utsco.c */

41
cde/lib/DtSearch/raima/utscr.c
View file

@ -48,45 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Get update timestamp of current record
*/
d_utscr(timestamp TASK_PARM)
ULONG *timestamp;
TASK_DECL
{
INT rec;
int dbopen_sv;
DB_ENTER(NO_DB_ID TASK_ID LOCK_SET(RECORD_IO));
/* make sure we have a current record */
if ( ! curr_rec )
RETURN( dberr(S_NOCR) );
/* set up to allow unlocked read access */
dbopen_sv = dbopen;
dbopen = 2;
/* read current record */
if ( dio_read( curr_rec, (char * *)&crloc , NOPGHOLD) != S_OKAY )
RETURN( db_status );
dbopen = dbopen_sv;
/* get record id */
bytecpy(&rec, crloc, sizeof(INT));
if ( rec >= 0 ) {
rec &= ~RLBMASK; /* mask off rlb */
rec += curr_db_table->rt_offset;
if ( record_table[rec].rt_flags & TIMESTAMPED )
bytecpy(timestamp, crloc + RECUPTIME, sizeof(ULONG));
else
*timestamp = 0L;
db_status = S_OKAY;
}
else
db_status = S_DELETED;
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin utscr.c */

43
cde/lib/DtSearch/raima/utscs.c
View file

@ -48,47 +48,4 @@
#include "dbtype.h"
#ifndef NO_TIMESTAMP
/* Get update timestamp of set
*/
d_utscs(set, timestamp TASK_PARM DBN_PARM)
int set;
ULONG *timestamp;
TASK_DECL
DBN_DECL
{
INT rec;
char *rptr;
SET_ENTRY *set_ptr;
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_IO));
if (nset_check(set, &set, (SET_ENTRY * *)&set_ptr) != S_OKAY)
RETURN( db_status );
/* make sure we have a current owner */
if ( ! curr_own[set] )
RETURN( dberr(S_NOCO) );
/* read current owner */
if ( dio_read( curr_own[set], (char * *)&rptr , NOPGHOLD) != S_OKAY )
RETURN( db_status );
/* get record id to ensure record not deleted */
bytecpy(&rec, rptr, sizeof(INT));
if ( rec >= 0 ) {
if (set_ptr->st_flags & TIMESTAMPED) {
bytecpy(timestamp, rptr + set_ptr->st_own_ptr + SP_UTIME, sizeof(ULONG));
}
else
*timestamp = 0L;
db_status = S_OKAY;
}
else
db_status = S_DELETED;
RETURN( db_status );
}
#endif
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC -f/usr/users/master/config/nonwin utscs.c */