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: Tidy up the LOCK and DBN macro madness

Browse source
This commit is contained in:
Peter Howkins 2018-06-29 16:16:21 +01:00
parent 60edbd3491
commit bcdb2dd909
57 changed files with 199 additions and 209 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
cde/lib/DtSearch/raima/cmtype.c
View file

@ -52,10 +52,10 @@
/* Get current member type
*/
int
d_cmtype(set, cmtype DBN_PARM)
d_cmtype(set, cmtype , dbn)
int set;
int *cmtype;
DBN_DECL
int dbn;
{
char *mrec;
INT crt;

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

@ -71,9 +71,9 @@ typedef struct {
/* Connect the current record as member of set
*/
int
d_connect(set DBN_PARM)
d_connect(set , dbn)
int set; /* Set constant */
DBN_DECL /* Database number */
int dbn; /* Database number */
{
MEM_PTR crmp; /* current record's member pointer */
SET_PTR cosp; /* current owner's set pointer */

4
cde/lib/DtSearch/raima/cotype.c
View file

@ -51,10 +51,10 @@
/* Get current owner type
*/
int
d_cotype(set, cotype DBN_PARM)
d_cotype(set, cotype , dbn)
int set;
int *cotype;
DBN_DECL
int dbn;
{
char *orec;
INT crt;

4
cde/lib/DtSearch/raima/crget.c
View file

@ -50,9 +50,9 @@
/* Get current record
*/
int
d_crget(dba DBN_PARM)
d_crget(dba , dbn)
DB_ADDR *dba; /* db address of record to become current */
DBN_DECL
int dbn;
{
DB_ENTER(DB_ID TASK_ID LOCK_SET(RECORD_NOIO));

4
cde/lib/DtSearch/raima/crread.c
View file

@ -51,10 +51,10 @@
/* Read data from field of current record
*/
int
d_crread(field, data DBN_PARM)
d_crread(field, data , dbn)
long field; /* Field constant */
char *data; /* Data area to contain field contents */
DBN_DECL /* database number */
int dbn; /* database number */
{
int fld, rec;
RECORD_ENTRY *rec_ptr;

4
cde/lib/DtSearch/raima/crset.c
View file

@ -50,9 +50,9 @@
/* Set current record
*/
int
d_crset(dba DBN_PARM)
d_crset(dba , dbn)
DB_ADDR *dba; /* db address of record to become current */
DBN_DECL
int dbn;
{
DB_ENTER(DB_ID TASK_ID LOCK_SET(RECORD_IO));

4
cde/lib/DtSearch/raima/crtype.c
View file

@ -50,9 +50,9 @@
/* Get current record type
*/
int
d_crtype(crtype DBN_PARM)
d_crtype(crtype , dbn)
int *crtype;
DBN_DECL
int dbn;
{
INT crt;

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

@ -51,10 +51,10 @@
/* Write data to a field in the current record
*/
int
d_crwrite(field, data DBN_PARM)
d_crwrite(field, data , dbn)
long field; /* field constant */
char *data; /* data area to contain field contents */
DBN_DECL /* database number */
int dbn; /* database number */
{
int stat, fld, rec;
RECORD_ENTRY *rec_ptr;

4
cde/lib/DtSearch/raima/csmget.c
View file

@ -50,10 +50,10 @@
/* Get current set member
*/
int
d_csmget(set, dba DBN_PARM)
d_csmget(set, dba , dbn)
int set; /* Set table entry */
DB_ADDR *dba; /* db address of record to become current */
DBN_DECL /* database number */
int dbn; /* database number */
{
SET_ENTRY *set_ptr;

4
cde/lib/DtSearch/raima/csmread.c
View file

@ -51,11 +51,11 @@
/* Read data from field of current set member
*/
int
d_csmread(set, field, data DBN_PARM)
d_csmread(set, field, data , dbn)
int set; /* Set constant */
long field; /* Field constant */
char *data; /* Data area to contain field contents */
DBN_DECL /* database number */
int dbn; /* database number */
{
int fld, rec;
char *recp;

4
cde/lib/DtSearch/raima/csmset.c
View file

@ -50,10 +50,10 @@
/* Set current set member
*/
int
d_csmset(set, dba DBN_PARM)
d_csmset(set, dba , dbn)
int set; /* Set table entry */
DB_ADDR *dba; /* db address of record to become current */
DBN_DECL /* database number */
int dbn; /* database number */
{
INT type;
char *ptr;

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

@ -51,11 +51,11 @@
/* Write data to a field in the current set member
*/
int
d_csmwrite(set, field, data DBN_PARM)
d_csmwrite(set, field, data , dbn)
int set; /* Set constant */
long field; /* Field constant */
const char *data; /* Data area to contain field contents */
DBN_DECL /* database number */
int dbn; /* database number */
{
int stat, fld, rec;
char *recp;

4
cde/lib/DtSearch/raima/csoget.c
View file

@ -51,10 +51,10 @@
/* Get current set owner
*/
int
d_csoget(set, dba DBN_PARM)
d_csoget(set, dba , dbn)
int set; /* Set table entry */
DB_ADDR *dba; /* db address of record to become current */
DBN_DECL /* database number */
int dbn; /* database number */
{
SET_ENTRY *set_ptr;

4
cde/lib/DtSearch/raima/csoread.c
View file

@ -51,11 +51,11 @@
/* Read data from field of current set owner
*/
int
d_csoread(set, field, data DBN_PARM)
d_csoread(set, field, data , dbn)
int set; /* Set constant */
long field; /* Field constant */
char *data; /* Data area to contain field contents */
DBN_DECL /* database number */
int dbn; /* database number */
{
int fld, rec;
char *recp;

4
cde/lib/DtSearch/raima/csoset.c
View file

@ -51,10 +51,10 @@
/* Set current set owner
*/
int
d_csoset(set, dba DBN_PARM)
d_csoset(set, dba , dbn)
int set; /* Set table entry */
DB_ADDR *dba; /* db address of record to become current */
DBN_DECL /* database number */
int dbn; /* database number */
{
INT type;
char *ptr;

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

@ -51,11 +51,11 @@
/* Write data to a field in the current set owner
*/
int
d_csowrite(set, field, data DBN_PARM)
d_csowrite(set, field, data , dbn)
int set; /* Set constant */
long field; /* Field constant */
const char *data; /* Data area to contain field contents */
DBN_DECL /* database number */
int dbn; /* database number */
{
int stat, fld, rec;
char *recp;

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

@ -344,10 +344,6 @@ typedef struct RN_ENTRY_S {
#define NUM2INT(num, offset) ((num) + db_global.Curr_db_table->offset)
#define NUM2EXT(num, offset) ((num) - db_global.Curr_db_table->offset)
#define ORIGIN(offset) (curr_db_table->offset)
#define CURR_DB_PARM , curr_db
#define DBN_PARM , dbn
#define DBN_ONLY dbn
#define DBN_DECL int dbn;
#define TABLE_SIZE(size) DB_REF(size)
/* Country code table definition */
@ -469,22 +465,17 @@ typedef struct MESSAGE_S {
#ifdef COMMA /* COMMA */
#define DB_ID , dbn
#define NO_DB_ID , -1
#define DBN_PARAM , b
#else /* COMMA */
#define DB_ID dbn
#define NO_DB_ID -1
#define DBN_PARAM b
#define COMMA
#endif /* COMMA */
#define TASK_ID /**/
#define LOCK_PARAM /**/
#define LOCK_PARM /**/
#define LOCK_DECL /**/
#define LOCK_SET(a) /**/
#define TDTL_PARAM DBN_PARAM LOCK_PARAM
#define TDTL_PARAM
#define DB_ENTER(TDTL_PARAM) if ( startup(TDTL_PARAM) != S_OKAY ) { return( db_status ); } else

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

@ -54,7 +54,7 @@ static DB_ADDR zap_dba = NULL_DBA;
*/
int
d_delete(dbn)
DBN_DECL
int dbn;
{
int st_lc, mt_lc; /* loop control */
INT i, rt;

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

@ -65,9 +65,9 @@ typedef struct {
/* Disconnect the current member of set
*/
int
d_discon(nset DBN_PARM)
d_discon(nset , dbn)
int nset; /* set number */
DBN_DECL /* database number */
int dbn; /* database number */
{
SET_PTR cosp; /* current owner's set pointer */
MEM_PTR cmmp; /* member's member pointer */

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

@ -52,7 +52,7 @@
*/
int
d_disdel(dbn)
DBN_DECL
int dbn;
{
int rectype, nset, cset;
int set, mem;
@ -64,11 +64,11 @@ DBN_DECL
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_IO));
if ( d_crtype(&rectype DBN_PARM) != S_OKAY )
if ( d_crtype(&rectype , dbn) != S_OKAY )
RETURN( db_status );
rectype += NUM2INT(-RECMARK, rt_offset);
d_crget(&dba DBN_PARM);
d_crget(&dba , dbn);
for (set = 0, set_ptr = &set_table[ORIGIN(st_offset)];
set < TABLE_SIZE(Size_st);
++set, ++set_ptr) {
@ -80,11 +80,11 @@ DBN_DECL
mdba = *cm_ptr;
if (set_ptr->st_own_rt == rectype) {
/* disconnect all member records from set s */
d_setor(nset DBN_PARM);
while (d_findfm(nset DBN_PARM) == S_OKAY)
if (d_discon(nset DBN_PARM) < S_OKAY)
d_setor(nset , dbn);
while (d_findfm(nset , dbn) == S_OKAY)
if (d_discon(nset , dbn) < S_OKAY)
RETURN (db_status);
d_setro(nset DBN_PARM);
d_setro(nset , dbn);
}
for (mem = set_ptr->st_members, memtot = mem + set_ptr->st_memtot,
mem_ptr = &member_table[mem];
@ -92,9 +92,9 @@ DBN_DECL
++mem, ++mem_ptr) {
if (mem_ptr->mt_record == rectype) {
/* disconnect current record from set */
if (d_ismember(nset DBN_PARM) == S_OKAY) {
d_csmset(nset, &dba DBN_PARM);
if (d_discon(nset DBN_PARM) < S_OKAY)
if (d_ismember(nset , dbn) == S_OKAY) {
d_csmset(nset, &dba , dbn);
if (d_discon(nset , dbn) < S_OKAY)
RETURN (db_status);
}
}

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

@ -55,10 +55,10 @@
/* Create and fill a new record
*/
int
d_fillnew( nrec, recval DBN_PARM )
d_fillnew( nrec, recval , dbn )
int nrec; /* record number */
const char *recval; /* record value */
DBN_DECL /* database number */
int dbn; /* database number */
{
DB_ADDR db_addr;
INT recnum, stat;
@ -88,7 +88,7 @@ DBN_DECL /* database number */
else
key_bldcom(fld, (char *)recval, ptr = key, FALSE); /* Don't complement */
d_keyfind(FLDMARK*(long)recnum + (fld - rec_ptr->rt_fields), ptr
DBN_PARM);
, dbn);
curr_rec = db_addr;
if ( db_status == S_OKAY )
RETURN( db_status = S_DUPLICATE );

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

@ -50,9 +50,9 @@
/* Find owner of current record
*/
int
d_findco(nset DBN_PARM)
d_findco(nset , dbn)
int nset;
DBN_DECL
int dbn;
{
int set;
char mem[MEMPSIZE];

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

@ -50,9 +50,9 @@
/* Find first member of set
*/
int
d_findfm(nset DBN_PARM)
d_findfm(nset , dbn)
int nset;
DBN_DECL
int dbn;
{
char setp[SETPSIZE];
DB_ADDR mem;

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

@ -50,9 +50,9 @@
/* Find last member of set
*/
int
d_findlm(nset DBN_PARM)
d_findlm(nset , dbn)
int nset;
DBN_DECL
int dbn;
{
char setp[SETPSIZE];
DB_ADDR mem;

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

@ -50,9 +50,9 @@
/* Find next member of set
*/
int
d_findnm(nset DBN_PARM)
d_findnm(nset , dbn)
int nset;
DBN_DECL
int dbn;
{
int set;
char memp[MEMPSIZE];
@ -72,7 +72,7 @@ DBN_DECL
/* find first member if no current member */
if ( !*(cm_ptr = &curr_mem[set]) )
RETURN( d_findfm(nset DBN_PARM) );
RETURN( d_findfm(nset , dbn) );
/* read current member of set and get member pointer from record */
if ((dio_read(*cm_ptr, (char * *)&recp, NOPGHOLD) != S_OKAY) ||

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

@ -50,9 +50,9 @@
/* Find previous member of set
*/
int
d_findpm(nset DBN_PARM)
d_findpm(nset , dbn)
int nset;
DBN_DECL
int dbn;
{
int set;
char memp[MEMPSIZE];
@ -72,7 +72,7 @@ DBN_DECL
/* find last member if no current member */
if ( !*(cm_ptr = &curr_mem[set]) )
RETURN( d_findlm(nset DBN_PARM) );
RETURN( d_findlm(nset , dbn) );
/* read current member of set and get member pointer from record */
if ((dio_read(*cm_ptr, (char * *)&recp, NOPGHOLD) != S_OKAY) ||

8
cde/lib/DtSearch/raima/initial.c
View file

@ -90,7 +90,7 @@ extern int max_open_files; /* see dio.c */
*/
int
d_initialize(dbn)
DBN_DECL
int dbn;
{
FILE_NO fno;
@ -101,7 +101,7 @@ DBN_DECL
else {
/* initialize db files in file_table */
for (fno = 0; fno < DB_REF(Size_ft); ++fno) {
if ( d_initfile(fno DBN_PARM) != S_OKAY )
if ( d_initfile(fno , dbn) != S_OKAY )
break;
}
}
@ -113,9 +113,9 @@ DBN_DECL
/* Initialize database file
*/
int
d_initfile(fno DBN_PARM)
d_initfile(fno , dbn)
FILE_NO fno; /* file table entry of file to be initialized */
DBN_DECL
int dbn;
{
INIT_PAGE_P Page;
#define page (Page.ptr)

4
cde/lib/DtSearch/raima/ismember.c
View file

@ -51,9 +51,9 @@
/* Check to see if current record is a connected member of SET
*/
int
d_ismember(set DBN_PARM)
d_ismember(set , dbn)
int set; /* set table entry */
DBN_DECL /* database number */
int dbn; /* database number */
{
char crmp[MEMPSIZE]; /* current record's member pointer */
SET_ENTRY *set_ptr;

4
cde/lib/DtSearch/raima/isowner.c
View file

@ -51,9 +51,9 @@
/* Check to see if current record is a owner of non-empty SET
*/
int
d_isowner(set DBN_PARM)
d_isowner(set , dbn)
int set; /* set table entry */
DBN_DECL /* database number */
int dbn; /* database number */
{
char crsp[SETPSIZE]; /* current record's set pointer */
SET_ENTRY *set_ptr;

6
cde/lib/DtSearch/raima/keydel.c
View file

@ -54,9 +54,9 @@
/* Delete optional key value
*/
int
d_keydel(field DBN_PARM)
d_keydel(field , dbn)
long field; /* key field constant */
DBN_DECL /* database number */
int dbn; /* database number */
{
int fld; /* field number */
int rec, rn; /* record type of current record */
@ -73,7 +73,7 @@ DBN_DECL /* database number */
RETURN( db_status );
/* ensure current record is valid for this field */
d_crtype(&rn DBN_PARM);
d_crtype(&rn , dbn);
if (rec != NUM2INT(rn - RECMARK, rt_offset))
RETURN( dberr(S_BADFIELD) );

6
cde/lib/DtSearch/raima/keyexist.c
View file

@ -46,9 +46,9 @@
/* Check for optional key existence
*/
int
d_keyexist(field DBN_PARM)
d_keyexist(field , dbn)
long field; /* key field constant */
DBN_DECL /* database number */
int dbn; /* database number */
{
int fld; /* field number */
int rec, rn; /* record type of current record */
@ -63,7 +63,7 @@ DBN_DECL /* database number */
RETURN( db_status );
/* ensure current record is valid for this field */
d_crtype(&rn DBN_PARM);
d_crtype(&rn , dbn);
if (rec != NUM2INT(rn - RECMARK, rt_offset))
RETURN( dberr(S_BADFIELD) );

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

@ -57,10 +57,10 @@ static void chk_desc_key(P1(int) Pi(FIELD_ENTRY *)
/* Find record thru key field
*/
int
d_keyfind(field, fldval DBN_PARM)
d_keyfind(field, fldval , dbn)
long field; /* field constant */
const char *fldval; /* value of the data field */
DBN_DECL /* database number */
int dbn; /* database number */
{
int fld, rec;
DB_ADDR dba;

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

@ -51,9 +51,9 @@
/* Find first key
*/
int
d_keyfrst(field DBN_PARM)
d_keyfrst(field , dbn)
long field; /* field constant */
DBN_DECL /* database number */
int dbn; /* database number */
{
int fld, rec;
DB_ADDR dba;

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

@ -51,9 +51,9 @@
/* Find last key
*/
int
d_keylast(field DBN_PARM)
d_keylast(field , dbn)
long field; /* field constant */
DBN_DECL /* database number */
int dbn; /* database number */
{
int fld, rec;
DB_ADDR dba;

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

@ -52,9 +52,9 @@
/* Find next record thru key field
*/
int
d_keynext(field DBN_PARM)
d_keynext(field , dbn)
long field; /* field constant */
DBN_DECL /* database number */
int dbn; /* database number */
{
int fld, rec;
DB_ADDR dba;

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

@ -52,9 +52,9 @@
/* Find previous record thru key field
*/
int
d_keyprev(field DBN_PARM)
d_keyprev(field , dbn)
long field; /* field constant */
DBN_DECL /* database number */
int dbn; /* database number */
{
int fld, rec;
DB_ADDR dba;

6
cde/lib/DtSearch/raima/keystore.c
View file

@ -53,9 +53,9 @@
/* Store optional key value
*/
int
d_keystore(field DBN_PARM)
d_keystore(field , dbn)
long field; /* key field constant */
DBN_DECL /* database number */
int dbn; /* database number */
{
int fld; /* field number */
int rec, rn; /* record type of current record */
@ -76,7 +76,7 @@ DBN_DECL /* database number */
RETURN( dberr(S_NOCR) );
/* ensure current record is valid for this field */
d_crtype(&rn DBN_PARM);
d_crtype(&rn , dbn);
if (rec != NUM2INT(rn - RECMARK, rt_offset))
RETURN( dberr(S_BADFIELD) );

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

@ -54,10 +54,10 @@
/* Set the value of a key field
*/
int
d_setkey( field, fldvalue DBN_PARM )
d_setkey( field, fldvalue , dbn )
long field;
const char *fldvalue;
DBN_DECL
int dbn;
{
SK_P *sk_ptr;
SK_P sk_p;
@ -135,9 +135,9 @@ int sk_free()
/* Create a new empty record
*/
int
d_makenew( nrec DBN_PARM )
d_makenew( nrec , dbn )
int nrec;
DBN_DECL
int dbn;
{
DB_ADDR db_addr;
INT recnum, fld, stat;
@ -176,7 +176,7 @@ DBN_DECL
}
MEM_LOCK(&sk_ptr->ptr->sk_val);
d_keyfind(FLDMARK*(long)recnum + (long)(fld - rec_ptr->rt_fields),
sk_ptr->ptr->sk_val.ptr DBN_PARM);
sk_ptr->ptr->sk_val.ptr , dbn);
MEM_UNLOCK(&sk_ptr->ptr->sk_val);
curr_rec = db_addr;
ll_deaccess(&sk_list);

4
cde/lib/DtSearch/raima/members.c
View file

@ -51,10 +51,10 @@
/* Get number of members of the current set owner
*/
int
d_members(set, tot DBN_PARM)
d_members(set, tot , dbn)
int set; /* Set table entry */
LONG *tot; /* total members of set */
DBN_DECL /* database number */
int dbn; /* database number */
{
char setp[SETPSIZE];
char *recp;

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

@ -115,7 +115,7 @@ const char *data; /* pointer to data area containing field contents */
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_PARM) == S_OKAY)) {
(d_keyfind(fld, data CURRTASK_PARM , curr_db) == S_OKAY)) {
/* another record is already using this key value */
db_status = S_DUPLICATE;
}
@ -389,8 +389,8 @@ DB_ADDR *db_addr;
set = NUM2EXT(sn + SETMARK, st_offset);
/* disconnect from prior order set and reconnect in new order */
d_discon(set CURRTASK_PARM CURR_DB_PARM);
d_connect(set CURRTASK_PARM CURR_DB_PARM);
d_discon(set CURRTASK_PARM , curr_db);
d_connect(set CURRTASK_PARM , curr_db);
/* reset currency */
*co_ptr = odba;

4
cde/lib/DtSearch/raima/recfrst.c
View file

@ -49,9 +49,9 @@
/* Find first record of type
*/
int
d_recfrst( rec DBN_PARM )
d_recfrst( rec , dbn )
int rec; /* record type/table entry */
DBN_DECL
int dbn;
{
INT rectype;
FILE_NO ftype;

4
cde/lib/DtSearch/raima/reclast.c
View file

@ -73,9 +73,9 @@
/* ======================================================================
d_reclast - find last record occurrence in database
*/
int d_reclast( rec DBN_PARM )
int d_reclast( rec , dbn )
int rec; /* record # to find last occurrence of */
DBN_DECL /* optional database number */
int dbn; /* optional database number */
{
/*
RETURNS: db_status. Sets current record to last record, if found.

2
cde/lib/DtSearch/raima/recnext.c
View file

@ -51,7 +51,7 @@
*/
int
d_recnext(dbn)
DBN_DECL
int dbn;
{
INT rectype;
FILE_NO fno;

2
cde/lib/DtSearch/raima/recprev.c
View file

@ -74,7 +74,7 @@
d_recprev - find previous record via database address
*/
int d_recprev( dbn )
DBN_DECL
int dbn;
{
/*
RETURNS: db_status. Also sets current record to previous matched record.

4
cde/lib/DtSearch/raima/recread.c
View file

@ -52,9 +52,9 @@
/* Read contents of current record
*/
int
d_recread(rec DBN_PARM)
d_recread(rec , dbn)
char *rec; /* ptr to record area */
DBN_DECL
int dbn;
{
INT rt; /* record type */
DB_ADDR dba;

4
cde/lib/DtSearch/raima/recset.c
View file

@ -71,9 +71,9 @@
/* ======================================================================
set record type and database address to current
*/
int d_recset( rec DBN_PARM )
int d_recset( rec , dbn )
int rec; /* record type */
DBN_DECL
int dbn;
{
/*
RETURNS: db_status return code.

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

@ -52,9 +52,9 @@
/* Write contents to current record
*/
int
d_recwrite(rec DBN_PARM)
d_recwrite(rec , dbn)
const char *rec; /* ptr to record area */
DBN_DECL
int dbn;
{
INT rt; /* record type */
char *fptr; /* field data pointer */

6
cde/lib/DtSearch/raima/setmm.c
View file

@ -50,10 +50,10 @@
/* Set current member to current member
*/
int
d_setmm(sett, sets DBN_PARM)
d_setmm(sett, sets , dbn)
int sett; /* set table entry number of target member */
int sets; /* set table entry number of source member */
DBN_DECL /* database number */
int dbn; /* database number */
{
int cmtype; /* current member type */
int mem;
@ -63,7 +63,7 @@ DBN_DECL /* database number */
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_IO));
if ((d_cmtype(sets, &cmtype DBN_PARM) != S_OKAY) ||
if ((d_cmtype(sets, &cmtype , dbn) != S_OKAY) ||
(nset_check(sett, &sett, (SET_ENTRY * *)&set_ptr) != S_OKAY))
RETURN( db_status );

4
cde/lib/DtSearch/raima/setmo.c
View file

@ -50,10 +50,10 @@
/* Set current member to current owner
*/
int
d_setmo(setm, seto DBN_PARM)
d_setmo(setm, seto , dbn)
int setm; /* set table entry number of member */
int seto; /* set table entry number of owner */
DBN_DECL /* database number */
int dbn; /* database number */
{
int mem;
SET_ENTRY *setm_ptr, *seto_ptr;

6
cde/lib/DtSearch/raima/setmr.c
View file

@ -50,9 +50,9 @@
/* Set current member to current record
*/
int
d_setmr(set DBN_PARM)
d_setmr(set , dbn)
int set; /* set table entry number */
DBN_DECL /* database number */
int dbn; /* database number */
{
int crtype; /* current record type */
int mem;
@ -68,7 +68,7 @@ DBN_DECL /* database number */
if ( ! curr_rec )
RETURN( dberr( S_NOCR ) );
if ( d_crtype(&crtype DBN_PARM) != S_OKAY )
if ( d_crtype(&crtype , dbn) != S_OKAY )
RETURN( db_status );
crtype += NUM2INT(-RECMARK, rt_offset);

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

@ -51,10 +51,10 @@
/* Set current owner to current member
*/
int
d_setom(nseto, nsetm DBN_PARM)
d_setom(nseto, nsetm , dbn)
int nseto; /* set table entry number of owner */
int nsetm; /* set table entry number of member */
DBN_DECL /* database number */
int dbn; /* database number */
{
int seto, setm;
int cmtype; /* current record type */
@ -62,7 +62,7 @@ DBN_DECL /* database number */
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_IO));
if ((d_cmtype(nsetm, &cmtype DBN_PARM) != S_OKAY) ||
if ((d_cmtype(nsetm, &cmtype , dbn) != S_OKAY) ||
(nset_check(nseto, &seto, (SET_ENTRY * *)&set_ptr) != S_OKAY))
RETURN( db_status );
cmtype += NUM2INT(-RECMARK, rt_offset);

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

@ -51,10 +51,10 @@
/* Set current owner to current owner
*/
int
d_setoo(nsett, nsets DBN_PARM)
d_setoo(nsett, nsets , dbn)
int nsett; /* set table entry number of target owner */
int nsets; /* set table entry number of source owner */
DBN_DECL /* database number */
int dbn; /* database number */
{
int sett, sets;
SET_ENTRY *sett_ptr, *sets_ptr;

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

@ -50,9 +50,9 @@
/* Set current owner to current record
*/
int
d_setor(nset DBN_PARM)
d_setor(nset , dbn)
int nset; /* set number */
DBN_DECL /* database number */
int dbn; /* database number */
{
int set;
int crtype; /* current record type */
@ -61,7 +61,7 @@ DBN_DECL /* database number */
DB_ENTER(DB_ID TASK_ID LOCK_SET(SET_IO));
if ((nset_check(nset, &set, (SET_ENTRY * *)&set_ptr) != S_OKAY) ||
(d_crtype(&crtype DBN_PARM) != S_OKAY))
(d_crtype(&crtype , dbn) != S_OKAY))
RETURN( db_status );
crtype += NUM2INT(-RECMARK, rt_offset);

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

@ -50,9 +50,9 @@
/* Set current record to current member
*/
int
d_setrm(set DBN_PARM)
d_setrm(set , dbn)
int set; /* set table entry number */
DBN_DECL /* database number */
int dbn; /* database number */
{
SET_ENTRY *set_ptr;

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

@ -50,9 +50,9 @@
/* Set current record to current owner
*/
int
d_setro(set DBN_PARM)
d_setro(set , dbn)
int set; /* set table entry number */
DBN_DECL /* database number */
int dbn; /* database number */
{
SET_ENTRY *set_ptr;

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

@ -46,9 +46,8 @@
/* Called once at the beginning of each external function
*/
int startup(DB_ID LOCK_PARM)
DBN_DECL
LOCK_DECL
int startup(DB_ID)
int dbn;
{
db_status = S_OKAY;
if ( ! db_glob_init ) {

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

@ -407,73 +407,73 @@ int EXTERNAL_FIXED dt_trend(TASK_D1); /* dblfcns.c */
#define d_trend() dt_trend(CURRTASK_ONLY)
#define d_wrcurr(a) dt_wrcurr(a CURRTASK_PARM)
#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)
#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)
#define d_crset(a DBN_PARM) dt_crset(a CURRTASK_PARM DBN_PARM)
#define d_crtype(a DBN_PARM) dt_crtype(a CURRTASK_PARM DBN_PARM)
#define d_crwrite(a, b DBN_PARM) dt_crwrite(a, b CURRTASK_PARM DBN_PARM)
#define d_csmget(a, b DBN_PARM) dt_csmget(a, b CURRTASK_PARM DBN_PARM)
#define d_csmread(a, b, c DBN_PARM) dt_csmread(a, b, c CURRTASK_PARM DBN_PARM)
#define d_csmset(a, b DBN_PARM) dt_csmset(a, b CURRTASK_PARM DBN_PARM)
#define d_csmwrite(a, b, c DBN_PARM) dt_csmwrite(a, b, c CURRTASK_PARM DBN_PARM)
#define d_csoget(a, b DBN_PARM) dt_csoget(a, b CURRTASK_PARM DBN_PARM)
#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)
#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)
#define d_recprev(DBN_PARM) dt_recprev(CURRTASK_ONLY DBN_PARM)
#define d_discon(a DBN_PARM) dt_discon(a CURRTASK_PARM DBN_PARM)
#define d_fillnew(a, b DBN_PARM) dt_fillnew(a, b CURRTASK_PARM DBN_PARM)
#define d_findco(a DBN_PARM) dt_findco(a CURRTASK_PARM DBN_PARM)
#define d_findfm(a DBN_PARM) dt_findfm(a CURRTASK_PARM DBN_PARM)
#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)
#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)
#define d_isowner(a DBN_PARM) dt_isowner(a CURRTASK_PARM DBN_PARM)
#define d_keydel(a DBN_PARM) dt_keydel(a CURRTASK_PARM DBN_PARM)
#define d_keyexist(a DBN_PARM) dt_keyexist(a CURRTASK_PARM DBN_PARM)
#define d_keyfind(a, b DBN_PARM) dt_keyfind(a, b CURRTASK_PARM DBN_PARM)
#define d_keyfree(a DBN_PARM) dt_keyfree(a CURRTASK_PARM DBN_PARM)
#define d_keyfrst(a DBN_PARM) dt_keyfrst(a CURRTASK_PARM DBN_PARM)
#define d_keylast(a DBN_PARM) dt_keylast(a CURRTASK_PARM DBN_PARM)
#define d_keylock(a, b DBN_PARM) dt_keylock(a, b CURRTASK_PARM DBN_PARM)
#define d_keylstat(a, b DBN_PARM) dt_keylstat(a, b CURRTASK_PARM DBN_PARM)
#define d_keynext(a DBN_PARM) dt_keynext(a CURRTASK_PARM DBN_PARM)
#define d_keyprev(a DBN_PARM) dt_keyprev(a CURRTASK_PARM DBN_PARM)
#define d_keyread(a DBN_PARM) dt_keyread(a CURRTASK_PARM)
#define d_keystore(a DBN_PARM) dt_keystore(a CURRTASK_PARM DBN_PARM)
#define d_lock(a, b DBN_PARM) dt_lock(a, b CURRTASK_PARM DBN_PARM)
#define d_makenew(a DBN_PARM) dt_makenew(a CURRTASK_PARM DBN_PARM)
#define d_members(a, b DBN_PARM) dt_members(a, b CURRTASK_PARM DBN_PARM)
#define d_recfree(a DBN_PARM) dt_recfree(a CURRTASK_PARM DBN_PARM)
#define d_recfrst(a DBN_PARM) dt_recfrst(a CURRTASK_PARM DBN_PARM)
#define d_reclast(a DBN_PARM) dt_reclast(a CURRTASK_PARM DBN_PARM)
#define d_reclock(a, b DBN_PARM) dt_reclock(a, b CURRTASK_PARM DBN_PARM)
#define d_reclstat(a, b DBN_PARM) dt_reclstat(a, b CURRTASK_PARM DBN_PARM)
#define d_recread(a DBN_PARM) dt_recread(a CURRTASK_PARM DBN_PARM)
#define d_recset(a DBN_PARM) dt_recset(a CURRTASK_PARM DBN_PARM)
#define d_recwrite(a DBN_PARM) dt_recwrite(a CURRTASK_PARM DBN_PARM)
#define d_setfree(a DBN_PARM) dt_setfree(a CURRTASK_PARM DBN_PARM)
#define d_setkey(a, b DBN_PARM) dt_setkey(a, b CURRTASK_PARM DBN_PARM)
#define d_setlock(a, b DBN_PARM) dt_setlock(a, b CURRTASK_PARM DBN_PARM)
#define d_setlstat(a, b DBN_PARM) dt_setlstat(a, b CURRTASK_PARM DBN_PARM)
#define d_setmm(a, b DBN_PARM) dt_setmm(a, b CURRTASK_PARM DBN_PARM)
#define d_setmo(a, b DBN_PARM) dt_setmo(a, b CURRTASK_PARM DBN_PARM)
#define d_setmr(a DBN_PARM) dt_setmr(a CURRTASK_PARM DBN_PARM)
#define d_setom(a, b DBN_PARM) dt_setom(a, b CURRTASK_PARM DBN_PARM)
#define d_setoo(a, b DBN_PARM) dt_setoo(a, b CURRTASK_PARM DBN_PARM)
#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)
#define d_cmstat(a , dbn) dt_cmstat(a CURRTASK_PARM , dbn)
#define d_cmtype(a, b , dbn) dt_cmtype(a, b CURRTASK_PARM , dbn)
#define d_connect(a , dbn) dt_connect(a CURRTASK_PARM , dbn)
#define d_cotype(a, b , dbn) dt_cotype(a, b CURRTASK_PARM , dbn)
#define d_crget(a , dbn) dt_crget(a CURRTASK_PARM , dbn)
#define d_crread(a, b , dbn) dt_crread(a, b CURRTASK_PARM , dbn)
#define d_crset(a , dbn) dt_crset(a CURRTASK_PARM , dbn)
#define d_crtype(a , dbn) dt_crtype(a CURRTASK_PARM , dbn)
#define d_crwrite(a, b , dbn) dt_crwrite(a, b CURRTASK_PARM , dbn)
#define d_csmget(a, b , dbn) dt_csmget(a, b CURRTASK_PARM , dbn)
#define d_csmread(a, b, c , dbn) dt_csmread(a, b, c CURRTASK_PARM , dbn)
#define d_csmset(a, b , dbn) dt_csmset(a, b CURRTASK_PARM , dbn)
#define d_csmwrite(a, b, c , dbn) dt_csmwrite(a, b, c CURRTASK_PARM , dbn)
#define d_csoget(a, b , dbn) dt_csoget(a, b CURRTASK_PARM , dbn)
#define d_csoread(a, b, c , dbn) dt_csoread(a, b, c CURRTASK_PARM , dbn)
#define d_csoset(a, b , dbn) dt_csoset(a, b CURRTASK_PARM , dbn)
#define d_csowrite(a, b, c , dbn) dt_csowrite(a, b, c CURRTASK_PARM , dbn)
#define d_delete(, dbn) dt_delete(CURRTASK_ONLY , dbn)
#define d_disdel(, dbn) dt_disdel(CURRTASK_ONLY , dbn)
#define d_recnext(, dbn) dt_recnext(CURRTASK_ONLY , dbn)
#define d_recprev(, dbn) dt_recprev(CURRTASK_ONLY , dbn)
#define d_discon(a , dbn) dt_discon(a CURRTASK_PARM , dbn)
#define d_fillnew(a, b , dbn) dt_fillnew(a, b CURRTASK_PARM , dbn)
#define d_findco(a , dbn) dt_findco(a CURRTASK_PARM , dbn)
#define d_findfm(a , dbn) dt_findfm(a CURRTASK_PARM , dbn)
#define d_findlm(a , dbn) dt_findlm(a CURRTASK_PARM , dbn)
#define d_findnm(a , dbn) dt_findnm(a CURRTASK_PARM , dbn)
#define d_findpm(a , dbn) dt_findpm(a CURRTASK_PARM , dbn)
#define d_initialize(, dbn) dt_initialize(CURRTASK_ONLY , dbn)
#define d_initfile(a , dbn) dt_initfile(a CURRTASK_PARM , dbn)
#define d_ismember(a , dbn) dt_ismember(a CURRTASK_PARM , dbn)
#define d_isowner(a , dbn) dt_isowner(a CURRTASK_PARM , dbn)
#define d_keydel(a , dbn) dt_keydel(a CURRTASK_PARM , dbn)
#define d_keyexist(a , dbn) dt_keyexist(a CURRTASK_PARM , dbn)
#define d_keyfind(a, b , dbn) dt_keyfind(a, b CURRTASK_PARM , dbn)
#define d_keyfree(a , dbn) dt_keyfree(a CURRTASK_PARM , dbn)
#define d_keyfrst(a , dbn) dt_keyfrst(a CURRTASK_PARM , dbn)
#define d_keylast(a , dbn) dt_keylast(a CURRTASK_PARM , dbn)
#define d_keylock(a, b , dbn) dt_keylock(a, b CURRTASK_PARM , dbn)
#define d_keylstat(a, b , dbn) dt_keylstat(a, b CURRTASK_PARM , dbn)
#define d_keynext(a , dbn) dt_keynext(a CURRTASK_PARM , dbn)
#define d_keyprev(a , dbn) dt_keyprev(a CURRTASK_PARM , dbn)
#define d_keyread(a , dbn) dt_keyread(a CURRTASK_PARM)
#define d_keystore(a , dbn) dt_keystore(a CURRTASK_PARM , dbn)
#define d_lock(a, b , dbn) dt_lock(a, b CURRTASK_PARM , dbn)
#define d_makenew(a , dbn) dt_makenew(a CURRTASK_PARM , dbn)
#define d_members(a, b , dbn) dt_members(a, b CURRTASK_PARM , dbn)
#define d_recfree(a , dbn) dt_recfree(a CURRTASK_PARM , dbn)
#define d_recfrst(a , dbn) dt_recfrst(a CURRTASK_PARM , dbn)
#define d_reclast(a , dbn) dt_reclast(a CURRTASK_PARM , dbn)
#define d_reclock(a, b , dbn) dt_reclock(a, b CURRTASK_PARM , dbn)
#define d_reclstat(a, b , dbn) dt_reclstat(a, b CURRTASK_PARM , dbn)
#define d_recread(a , dbn) dt_recread(a CURRTASK_PARM , dbn)
#define d_recset(a , dbn) dt_recset(a CURRTASK_PARM , dbn)
#define d_recwrite(a , dbn) dt_recwrite(a CURRTASK_PARM , dbn)
#define d_setfree(a , dbn) dt_setfree(a CURRTASK_PARM , dbn)
#define d_setkey(a, b , dbn) dt_setkey(a, b CURRTASK_PARM , dbn)
#define d_setlock(a, b , dbn) dt_setlock(a, b CURRTASK_PARM , dbn)
#define d_setlstat(a, b , dbn) dt_setlstat(a, b CURRTASK_PARM , dbn)
#define d_setmm(a, b , dbn) dt_setmm(a, b CURRTASK_PARM , dbn)
#define d_setmo(a, b , dbn) dt_setmo(a, b CURRTASK_PARM , dbn)
#define d_setmr(a , dbn) dt_setmr(a CURRTASK_PARM , dbn)
#define d_setom(a, b , dbn) dt_setom(a, b CURRTASK_PARM , dbn)
#define d_setoo(a, b , dbn) dt_setoo(a, b CURRTASK_PARM , dbn)
#define d_setor(a , dbn) dt_setor(a CURRTASK_PARM , dbn)
#define d_setrm(a , dbn) dt_setrm(a CURRTASK_PARM , dbn)
#define d_setro(a , dbn) dt_setro(a CURRTASK_PARM , dbn)
#endif /* NO_DT_COVER */
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC task.h */