libDtSearch: Tidy up the LOCK and DBN macro madness

cde/lib/DtSearch/raima/cmtype.c

@@ -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;

cde/lib/DtSearch/raima/connect.c

@@ -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 */

cde/lib/DtSearch/raima/cotype.c

@@ -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;

cde/lib/DtSearch/raima/crget.c

@@ -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));
 

cde/lib/DtSearch/raima/crread.c

@@ -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;

cde/lib/DtSearch/raima/crset.c

@@ -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));
 

cde/lib/DtSearch/raima/crtype.c

@@ -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;
 

cde/lib/DtSearch/raima/crwrite.c

@@ -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;

cde/lib/DtSearch/raima/csmget.c

@@ -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;
 

cde/lib/DtSearch/raima/csmread.c

@@ -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;

cde/lib/DtSearch/raima/csmset.c

@@ -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;

cde/lib/DtSearch/raima/csmwrite.c

@@ -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;

cde/lib/DtSearch/raima/csoget.c

@@ -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;
 

cde/lib/DtSearch/raima/csoread.c

@@ -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;

cde/lib/DtSearch/raima/csoset.c

@@ -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;

cde/lib/DtSearch/raima/csowrite.c

@@ -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;

cde/lib/DtSearch/raima/dbtype.h

@@ -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
 

cde/lib/DtSearch/raima/delete.c

@@ -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;

cde/lib/DtSearch/raima/discon.c

@@ -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 */

cde/lib/DtSearch/raima/disdel.c

@@ -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);
+	 d_setor(nset , dbn);
-	 while (d_findfm(nset DBN_PARM) == S_OKAY)
+	 while (d_findfm(nset , dbn) == S_OKAY)
-	    if (d_discon(nset DBN_PARM) < 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) {
+	    if (d_ismember(nset , dbn) == S_OKAY) {
-	       d_csmset(nset, &dba DBN_PARM);
+	       d_csmset(nset, &dba , dbn);
-	       if (d_discon(nset DBN_PARM) < S_OKAY)
+	       if (d_discon(nset , dbn) < S_OKAY)
 		  RETURN (db_status);
 	    }
 	 }

cde/lib/DtSearch/raima/fillnew.c

@@ -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 );

cde/lib/DtSearch/raima/findco.c

@@ -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];

cde/lib/DtSearch/raima/findfm.c

@@ -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;

cde/lib/DtSearch/raima/findlm.c

@@ -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;

cde/lib/DtSearch/raima/findnm.c

@@ -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) ||

cde/lib/DtSearch/raima/findpm.c

@@ -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) ||

cde/lib/DtSearch/raima/initial.c

@@ -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)

cde/lib/DtSearch/raima/ismember.c

@@ -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;

cde/lib/DtSearch/raima/isowner.c

@@ -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;

cde/lib/DtSearch/raima/keydel.c

@@ -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) );

cde/lib/DtSearch/raima/keyexist.c

@@ -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) );

cde/lib/DtSearch/raima/keyfind.c

@@ -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;

cde/lib/DtSearch/raima/keyfrst.c

@@ -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;

cde/lib/DtSearch/raima/keylast.c

@@ -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;

cde/lib/DtSearch/raima/keynext.c

@@ -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;

cde/lib/DtSearch/raima/keyprev.c

@@ -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;

cde/lib/DtSearch/raima/keystore.c

@@ -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) );

cde/lib/DtSearch/raima/makenew.c

@@ -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);

cde/lib/DtSearch/raima/members.c

@@ -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;

cde/lib/DtSearch/raima/recfcns.c

@@ -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_discon(set CURRTASK_PARM , curr_db);
-	       d_connect(set CURRTASK_PARM CURR_DB_PARM);
+	       d_connect(set CURRTASK_PARM , curr_db);
 
 	       /* reset currency */
 	       *co_ptr = odba;

cde/lib/DtSearch/raima/recfrst.c

@@ -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;

cde/lib/DtSearch/raima/reclast.c

@@ -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.

cde/lib/DtSearch/raima/recnext.c

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

cde/lib/DtSearch/raima/recprev.c

@@ -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.

cde/lib/DtSearch/raima/recread.c

@@ -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;

cde/lib/DtSearch/raima/recset.c

@@ -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.

cde/lib/DtSearch/raima/recwrite.c

@@ -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 */

cde/lib/DtSearch/raima/setmm.c

@@ -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 );
 

cde/lib/DtSearch/raima/setmo.c

@@ -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;

cde/lib/DtSearch/raima/setmr.c

@@ -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);
 

cde/lib/DtSearch/raima/setom.c

@@ -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);

cde/lib/DtSearch/raima/setoo.c

@@ -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;

cde/lib/DtSearch/raima/setor.c

@@ -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);

cde/lib/DtSearch/raima/setrm.c

@@ -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;
 

cde/lib/DtSearch/raima/setro.c

@@ -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;
 

cde/lib/DtSearch/raima/startup.c

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

cde/lib/DtSearch/raima/task.h

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