Difference between revisions of "Library dblsamp"

Revision as of 13:48, 6 May 2009 (view source) Yvonnemilne (Talk | contribs) ← Older edit		Revision as of 13:49, 6 May 2009 (view source) Yvonnemilne (Talk | contribs) Newer edit →
Line 1:		Line 1:
−	The following program is written in 'C' as an example program using the RECITAL/Library functions. This file is stored in the SDK dbl sub-directory and is called "dblsamp.c".	+	/*#============================================================================
−		+	*# Copyright (C) 1988-1991 Recital Corporation Inc.
−	<code lang="c">	+	*# As an unpublished licenced proprietary work.
−	/*#==================================================	+
−	*# Copyright (C) 1988-2009 Recital Corporation Inc.	+
−	*# As an unpublished licensed proprietary work.	+
	*# All rights reserved worldwide.		*# All rights reserved worldwide.
	*#		*#
Line 11:		Line 8:
	*# copyright notice is included.		*# copyright notice is included.
	*#		*#
−	#===================================================	+	*#============================================================================
	*		*
−	*MODULE : dblsamp.c	+	*     MODULE         : dblsamp.c
	*		*
−	*PURPOSE : Recital Database Library sample program.	+	*     PURPOSE         : Recital DataBase Library sample program.
	*		*
−	*AUTHOR : RECITAL CORPORATION	+	*     AUTHOR         : RECITAL CORPORATION
−	*	+	*
−	*==================================================*/	+	*     DATE            : 26 Jan 91
		+	*      REVISION        : 29 Oct 91
		+	*      REVISION        : 09 May 95
		+	*
		+	*==========================================================================*/
	#include <stdio.h>		#include <stdio.h>
Line 26:		Line 27:
	#include <sys/types.h>		#include <sys/types.h>
	#include <unistd.h>		#include <unistd.h>
−	#include "dbl.h" /* Recital Library include file */	+	#include "dbl.h"                       /* Recital/Library include file */
−	#include "dblproto.h" /* Recital Library prototype file */	+	#include "dblproto.h"                   /* Recital/Library prototype file */
		+
−	extern int g_disable_txcount;	+	extern int g_disable_iostats;
−	/*-----------------------------------------------------------------------------------------*/	+	/*----------------------------------------------*/
	/* Table structure for db to be constructed. */		/* Table structure for db to be constructed. */
−	/* Structure dBFIELD defined in dbl.h */	+	/* Structure dBFIELD defined in dbl.h.          */
−	/*-----------------------------------------------------------------------------------------*/	+	/*----------------------------------------------*/
−	static dBFIELD fields[7] = {	+	static dBFIELD fields[7] = {
−	"VESSEL", 'C', 18, 0, 0,	+	"VESSEL",       'C',   18,     0, 0,
−	"LAT", 'N', 4, 1, 0,	+	"LAT",         'N',   4,     1, 0,
−	"LONG", 'N', 4, 1, 0,	+	"LONG",         'N',   4,     1, 0,
−	"AMOUNT", 'N', 10, 0, 0,	+	"AMOUNT",       'N',   10,     0, 0,
−	"DATE", 'D', 8, 0, 0,	+	"DATE",         'D',   8,     0, 0,
−	"FLAG", 'C', 9, 0, 0,	+	"FLAG",         'C',   9,     0, 0,
−	"MEMO", 'M', sizeof(MEMO), 0, 0	+	"MEMO",         'M',   sizeof(MEMO),     0, 0
	};		};
	#define DB_RECORD_SIZE  100		#define DB_RECORD_SIZE  100
−	/*-----------------------------------------------------------------------------------------*/	+	/*----------------------------------------------*/
−	/* Static Error Handling procedure. */	+	/* Static Error Handling procedure.            */
−	/*-----------------------------------------------------------------------------------------*/	+	/*----------------------------------------------*/
−	static int errorproc();	+	static void errorproc(
		+	char    *func,
		+	char    *str,
		+	int    rc);
		+
		+	/*----------------------------------------------*/
		+	/* Table records to add.                    */
		+	/*----------------------------------------------*/
		+	static char *text_table[] =  {
		+	"Santa Margarita  80.027.5  700000095/01/01Spanish  ",
		+	"Santa Rosa        81.824.8  3000000032/01/01Spanish  ",
		+	"Unknown galleon  83.123.0        015/01/01Spanish  ",
		+	"Jessie            97.127.4    10000075/01/01U.S.    ",
		+	"Lea              96.227.8  100000080/01/01U.S.    ",
		+	"S.J. Lee          96.926.9    20000075/01/01U.S.    ",
		+	"Genovase          78.418.4  185000030/01/01Spanish  ",
		+	"Unknown Vessel    77.517.9        075/01/01U.S.    "
		+	};
−	/*-----------------------------------------------------------------------------------------*/
−	/* Table records to add. */
−	/*-----------------------------------------------------------------------------------------*/
−	static char
−	*text_table[] = {
−	"Santa Margarita  80.027.5  700000095/01/01Spanish  ",
−	"Santa Rosa        81.824.8  3000000032/01/01Spanish  ",
−	"Unknown galleon  83.123.0        015/01/01Spanish  ",
−	"Jessie            97.127.4    10000075/01/01U.S.    ",
−	"Lea              96.227.8  100000080/01/01U.S.    ",
−	"S.J. Lee          96.926.9    20000075/01/01U.S.    ",
−	"Genovase          78.418.4  185000030/01/01Spanish  ",
−	"Unknown Vessel    77.517.9        075/01/01U.S.    "
−	};
−	/*-----------------------------------------------------------------------------------------*/	+	/*---------------------------*/
	/* Main program entry point. */		/* Main program entry point. */
−	/*-----------------------------------------------------------------------------------------*/	+	/*---------------------------*/
−	main()	+	main()
	{		{
−	int rc; /* Return Code for error handling */	+	int     rc;                     /* Return Code for error handling */
−	char *dbf; /* File descriptor for table */	+	char   *dbf;                   /* File descriptor for table   */
−	char *dbx; /* File descriptor for tagged index */	+	char   *dbx;                   /* File descriptor for tagged index   */
−	char *ndx; /* File descriptor for index */	+	char   *ndx;                   /* File descriptor for index       */
−	char *dbt; /* File descriptor for memo file */	+	char   *dbt;                   /* File descriptor for memo file   */
−	char record[58]; /* Array of char for records */	+	char   record[DB_RECORD_SIZE]; /* Array of char for records       */
−	char keytype; /* Variable for varying keytype */	+	char   keytype;               /* Variable for varying keytype   */
−	char key[21]; /* Storage location for keys */	+	char   key[21];               /* Storage location for keys       */
−	char tagname[21]; /* Storage location for tag name */	+	char   tagname[21];           /* Storage location for tag name */
−	char keyexpr[512]; /* Storage location for key expr */	+	char   keyexpr[512];           /* Storage location for key expr   */
−	char forexpr[512]; /* Storage location for for expr */	+	char   forexpr[512];           /* Storage location for for expr   */
−	int kexprlen; /* The key expression length */	+	int     kexprlen;               /* The key expression length       */
−	int keylen; /* The key length */	+	int     keylen;                 /* The key length                 */
−	dBFIELD dbfields[128]; /* Storage location for field names */	+	dBFIELD dbfields[MAX_RECORD_FIELDS];         /* Storage location for fld names */
−	FLDNUM fieldcount; /* Number of fields to create */	+	FLDNUM fieldcount;             /* Number of fields to create     */
−	int fldpos[128]; /* Fields position buffer */	+	int     fldpos[MAX_RECORD_FIELDS];           /* Fields position buffer         */
−	char flddes[128][26]; /* Fields description buffer */	+	char   flddes[MAX_RECORD_FIELDS][26];       /* Fields description buffer       */
−	char tmpbuf[81]; /* Temporary storage buffer */	+	char   tmpbuf[81];             /* Temporary storage buffer       */
−	char fldbuf[128][256]; /* Field buffer (recin()/out()) */	+	char   fldbuf[MAX_RECORD_FIELDS][256];       /* Field buffer (recin()/out())   */
−	char nextkey[10][20]; /* Key buffers (dbnkey()) */	+	char   nextkey[10][20];       /* Key buffers (dbnkey())         */
−	char status; /* Deleted record flag */	+	char   status;                 /* Deleted record flag             */
−	long recno; /* Table record variable */	+	long   recno;                 /* Table record variable       */
−	long rec_no[10]; /* Record number array (dbnkey()) */	+	long   rec_no[10];             /* Record number array (dbnkey()) */
−	long db_size; /* Size of table variable */	+	long   db_size;               /* Size of table variable       */
−	int reclen; /* Table record length variable */	+	int     reclen;                 /* Table record length variable */
−	char month; /* Month variable */	+	char   month;                 /* Month variable                 */
−	char day; /* Day variable */	+	char   day;                   /* Day variable                   */
−	char year; /* Year variable */	+	char   year;                   /* Year variable                   */
−	FLDNUM nofields; /* Number of table fields variable */	+	FLDNUM nofields;               /* Number of table fields var  */
−	int i; /* Loop control variable */	+	int     i;             /* Loop control variable           */
−	double n; /* Double numeric variable */	+	double n;                     /* Double numeric variable         */
−	int keyunique; /* Boolean for unique tag key */	+	int keyunique; /* Boolean for unqiue tag key */
−	int keydescend; /* Boolean for descending tag key */	+	int keydescend; /* Boolean for descending tag key */
−	int notags; /* number of tags in a dbx file */	+	int notags; /* number of tags in a dbx file */
−	/*---------------------------------------------------------------------------------------*/
−	/* Perform operational Library environment functions. */
−	/*---------------------------------------------------------------------------------------*/
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------*/
−	/* DBDCACHE() - this example allocates a 100 record caching area */	+	/* Perform operational Library environment functions. */
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------*/
−	rc = dbdcache(100);	+
−	errorproc("dbdcache()", "table cache specified.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------------*/
−	/* DBICACHE() - this example allocates 51200 bytes for index caching */	+	/* DBDCACHE() - this example allocates a 100 record caching area */
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------------*/
−	rc = dbicache(100);	+	rc = dbdcache(100);
−	errorproc("dbicache()", "index cache specified.", rc);	+	errorproc("dbdcache()","table cache specified.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------------------------*/
−	/* DBFILEMODE() - shared, read write access */	+	/* DBICACHE() - this example allocates 51200 bytes for index caching */
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------------------------*/
−	rc = dbfilemode(1, 0);	+	rc = dbicache(100);
−	errorproc("dbfilemode()", "file mode specified.", rc);	+	errorproc("dbicache()", "index cache specified.",rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------*/
−	/* DBSET() - Set exact index match to true */	+	/* DBFILEMODE() - shared, read write access */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------*/
−	rc = dbset("EXACT", 1);	+	rc = dbfilemode(1,0);
−	errorproc("dbset()", "filemode specified.", rc);	+	errorproc("dbfilemode()", "filemode specified.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------*/
−	/* Perform basic table functions. */	+	/* DBSET() - Set exact index match to true  */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------*/
−	fieldcount = 7; /* Number of Fields */	+	rc = dbset("EXACT", 1);
		+	errorproc("dbset()", "filemode specified.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------*/
−	/* DBCREAT() - this example creates a table according to the 'dBFIELD' */	+	/* Perform basic table functions. */
−	/* array fields. */	+	/*--------------------------------*/
−	/*---------------------------------------------------------------------------------------*/	+	fieldcount = 7;                         /* Number of Fields          */
−	rc = dbcreat("shipwreck.dbf", fieldcount, fields);	+
−	errorproc("dbcreat()", "database created.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*-----------------------------------------------------------*/
−	/* DBCREATX() - Enables the addition of table field descriptions. */	+	/* DBCREAT() - this example creates a table according to the */
−	/*---------------------------------------------------------------------------------------*/	+	/*            'dBFIELD' array fields.                       */
−	strcpy(flddes[0], "The vessel's name.");	+	/*-----------------------------------------------------------*/
−	strcpy(flddes[1], "The latitude.");	+	rc = dbcreat("shipwreck.dbf",fieldcount, fields);
−	strcpy(flddes[2], "The longitude.");	+	errorproc("dbcreat()","datebase created.", rc);
−	strcpy(flddes[3], "The value.");	+
−	strcpy(flddes[4], "The date.");	+
−	strcpy(flddes[5], "The vessel's flag.");	+
−	strcpy(flddes[6], "Notes.");	+
−	rc = dbcreatx("shipwreck.dbf", fieldcount, fields, flddes);	+	/*----------------------------------------------------------------*/
		+	/* DBCREATX() - Enables the addition of table field descriptions. */
		+	/*----------------------------------------------------------------*/
		+	strcpy(flddes[0], "The vessel's name.");
		+	strcpy(flddes[1], "The latitude.");
		+	strcpy(flddes[2], "The longitude.");
		+	strcpy(flddes[3], "The value.");
		+	strcpy(flddes[4], "The date.");
		+	strcpy(flddes[5], "The vessel's flag.");
		+	strcpy(flddes[6], "Notes.");
−	/*---------------------------------------------------------------------------------------*/	+	rc = dbcreatx("shipwreck.dbf", fieldcount, fields, flddes);
−	/* DBOPEN() - example opens table 'shipwreck.dbf' returning the table */	+
−	/* file descriptor (dbf) used in upcoming functions */	+
−	/*---------------------------------------------------------------------------------------*/	+
−	rc = dbopen("shipwreck.dbf", &dbf);	+
−	errorproc("dbopen()", "table opened.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------------------*/
−	/* DBGETF() - obtain table information on the table referenced by the */	+	/* DBOPEN() - example opens table 'shipwreck.dbf' returning the     */
−	/* 'dbf' file descriptor. */	+	/*           table file descriptor (dbf) used in upcoming funcs  */
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------------------*/
−	rc = dbgetf(dbf, &reclen, &month, &day, &year, &nofields, dbfields);	+	rc = dbopen("shipwreck.dbf", &dbf);
−	errorproc("dbgetf()", "information retrieved.", rc);	+	errorproc("dbopen()","table opened.", rc);
−	printf("\t\tRecord length in bytes: %d\n", reclen);	+
−	printf("\t\tCreation date: \t\t%d/%d/%d\n", month, day, year);	+
−	printf("\t\tNumber of fields: \t%d\n", nofields);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------------------*/
−	/* DBGETFX() - obtain extended table information including the numeric */	+	/* DBGETF() - obtain table information on the table referenced */
−	/* field location array (fldpos) and the field descriptions (flddes). */	+	/*           by the 'dbf' file descriptor.                   */
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------------------*/
−	rc = dbgetfx(dbf, &reclen, &month, &day, &year, &nofields, dbfields,	+	rc = dbgetf(dbf, &reclen, &month, &day,
−	fldpos, flddes);	+	&year, &nofields, dbfields);
−	errorproc("dbgetfx()", "extra information retrieved.", rc);	+	errorproc("dbgetf()","information retrieved.", rc);
−	printf("\t\tLocation of fields in buffer: \t%d,%d,%d,%d,%d,%d\n",	+	printf("\t\tRecord length in bytes: %d\n", reclen);
−	fldpos[1], fldpos[2], fldpos[3], fldpos[4], fldpos[5], fldpos[6]);	+	printf("\t\tCreation date: \t\t%d/%d/%d\n",month,day,year);
		+	printf("\t\tNumber of fields: \t%d\n", nofields);
−	/*---------------------------------------------------------------------------------------*/	+
−	/* DBLOCKF() - locks the table for the additions that follow. */	+	/*-----------------------------------------------------------------*/
−	/* Synonymous with DBTLOCKF(), which tests the lock */	+	/* DBGETFX() - obtain extended table information including the    */
−	/*---------------------------------------------------------------------------------------*/	+	/*            numeric field location array (fldpos) and the field */
−	rc = dblockf(dbf);	+	/*            descriptions (flddes).                              */
−	if (rc == SUCCESS) {	+	/*-----------------------------------------------------------------*/
−	printf("Function: \tdblockf() \tfile locked successfully.\n");	+	rc = dbgetfx(dbf, &reclen, &month, &day, &year,
−	} else {	+	&nofields, dbfields, fldpos, flddes);
−	printf("Lock Failed. tError: %d\n", rc);	+	errorproc("dbgetfx()", "extra information retrieved.", rc);
		+	printf("\t\tLocation of fields in buffer: \t%d,%d,%d,%d,%d,%d\n",
		+	fldpos[1],fldpos[2],fldpos[3],fldpos[4],fldpos[5],fldpos[6]);
		+
		+	/*-------------------------------------------------------------*/
		+	/* DBLOCKF() - locks the table for following additions.        */
		+	/*            Synonomous with DBTLOCKF() which tests the lock */
		+	/*-------------------------------------------------------------*/
		+	rc = dblockf(dbf);
		+	if ( rc == SUCCESS ) {
		+	printf("Function: \tdblockf() \tfile locked successfully.\n");
		+	} else {
		+	printf("Lock Failed. \tError: %d\n",rc);
	}		}
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------*/
−	/* DBCLOSE() - close the active table */	+	/* DBCLOSE() - close the active table */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------*/
	rc = dbclose(dbf);		rc = dbclose(dbf);
−	errorproc("dbclose()", "table closed.", rc);	+	errorproc("dbclose()", "table closed.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------*/
−	/* Exclusive read write access of the table is required to create or delete */	+	/* Exclusive, read write access of the table is */
−	/* tags. */	+	/* required to create or delete tags.         */
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------*/
−	rc = dbfilemode(0, 0);	+	rc = dbfilemode(0,0);
−	rc = dbopen("shipwreck.dbf", &dbf);	+	rc = dbopen("shipwreck.dbf", &dbf);
−	errorproc("dbopen()", "table opened in exclusive mode.", rc);	+	errorproc("dbopen()","table opened in exclusive mode.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------*/
−	/* Perform basic tagged index functions. */	+	/* Perform basic tagged index functions. */
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------*/
−	/*---------------------------------------------------------------------------------------*/
−	/* DBXCREATE() - in this example creates a tag on field VESSEL */
−	/*---------------------------------------------------------------------------------------*/
−	rc = dbxcreate(dbf,
−	fields[0].fieldnm, /* "VESSEL", */
−	&dbx,
−	fields[0].fieldnm, /* "VESSEL", */
−	NULL,
−	0,
−	0);
−	errorproc("dbxcreate()", "tag created", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------------------------*/
−	/* DBXCREATE() - in this example creates a tag on field FLAG */	+	/* DBXCREATE() - in this example creates an tag on field VESSEL */
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------------------------*/
−	rc = dbxcreate(dbf,	+	rc = dbxcreate( dbf,
−	fields[5].fieldnm, /* "FLAG",   */	+	fields[0].fieldnm, /* "VESSEL", */
−	&dbx,	+	&dbx,
−	fields[5].fieldnm, /* "FLAG",   */	+	fields[0].fieldnm, /* "VESSEL", */
−	NULL,	+	NULL,
−	0,	+	0,
−	0);	+	0);
−	errorproc("dbxcreate()", "tag created", rc);	+	errorproc("dbxcreate()","tag created", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------------------------*/
−	/* DBXNOTAGS() - obtains the number of tagged indexes */	+	/* DBXCREATE() - in this example creates an tag on field FLAG */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------------------------*/
−	rc = dbxnotags(dbx, &notags);	+	rc = dbxcreate( dbf,
−	errorproc("dbxnotags()", "tagged index count obtained.", rc);	+	fields[5].fieldnm, /* "FLAG",  */
−	printf("\t Key count: \t%d\n", notags);	+	&dbx,
		+	fields[5].fieldnm, /* "FLAG",  */
		+	NULL,
		+	0,
		+	0);
		+	errorproc("dbxcreate()","tag created", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------*/
−	/* DBXKEXPR() - obtains tagged index information */	+	/* DBXNOTAGS() - obtains the number of tagged indexes */
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------*/
		+	rc = dbxnotags(dbx, &notags);
		+	errorproc("dbxnotags()","tagged index count obtained.", rc);
		+	printf("\t        Key count: \t%d\n", notags );
		+
		+	/*-----------------------------------------------*/
		+	/* DBXKEXPR() - obtains tagged index information */
		+	/*-----------------------------------------------*/
	for (i = 1; i <= notags; i++) {		for (i = 1; i <= notags; i++) {
−	rc = dbxkexpr(dbx,	+	rc = dbxkexpr(dbx,
−	&i,	+	&i,
−	tagname,	+	tagname,
−	&keytype,	+	&keytype,
−	keyexpr,	+	keyexpr,
−	forexpr,	+	forexpr,
−	&kexprlen,	+	&kexprlen,
−	&keylen,	+	&keylen,
−	&keyunique,	+	&keyunique,
−	&keydescend);	+	&keydescend);
−	errorproc("dbxkexpr()", "key information retrieved.", rc);	+	errorproc("dbxkexpr()", "key information retrieved.", rc);
−	printf("\t Key number: \t%d\n", i);	+	printf("\t       Key number: \t%d\n", i );
−	printf("\t Key name: \t%s\n", tagname);	+	printf("\t       Key name: \t%s\n", tagname );
−	printf("\t Key type: \t%c\n", keytype);	+	printf("\t       Key type: \t%c\n", keytype );
−	printf("\t Key expression: %s\n", keyexpr);	+	printf("\t       Key expression: %s\n", keyexpr);
−	printf("\t Key length: %d  Expression length: %d\n", kexprlen, keylen);	+	printf("\t       Key length: %d  Expression length: %d\n",
−	printf("\t For expression: %s\n", forexpr);	+	kexprlen, keylen);
−	printf("\t Key unique: \t%s\n", keyunique ? "Yes" : "No");	+	printf("\t       For expression: %s\n", forexpr);
−	printf("\t Key descending: \t%s\n", keydescend ? "Yes" : "No");	+	printf("\t       Key unique: \t%s\n", keyunique ? "Yes" : "No" );
		+	printf("\t       Key descending: \t%s\n", keydescend?"Yes":"No" );
	}		}
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------*/
−	/* DBXDROPTAGS() - Drop the specified tag */	+	/* DBXDROPTAGS() - Drop the specified tag */
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------*/
−	rc = dbxdroptag(dbx, fields[5].fieldnm);	+	rc = dbxdroptag(dbx, fields[5].fieldnm);
−	errorproc("dbxdroptag()", "tagged index 'FLAG' dropped.", rc);	+	errorproc("dbxdroptag()","tagged index 'FLAG' dropped.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------*/
−	/* DBXCLOSE() - close the active tagged index */	+	/* DBXCLOSE() - close the active tagged index */
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------*/
−	rc = dbxclose(dbx);	+	rc = dbxclose(dbx);
−	errorproc("dbxclose()", "tagged index closed.", rc);	+	errorproc("dbxclose()", "tagged index closed.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------*/
−	/* DBCLOSE() - close the active table */	+	/* DBCLOSE() - close the active table */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------*/
−	rc = dbclose(dbf);	+	rc = dbclose(dbf);
−	errorproc("dbclose()", "table closed.", rc);	+	errorproc("dbclose()", "table closed.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------*/
−	/* Reopen the table in shared, read-write access mode */	+	/* Reopen the table in shared, read-write access mode */
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------*/
−	rc = dbfilemode(1, 0);	+	rc = dbfilemode(1,0);
−	rc = dbopen("shipwreck.dbf", &dbf);	+	rc = dbopen("shipwreck.dbf", &dbf);
−	errorproc("dbopen()", "table opened in shared mode.", rc);	+	errorproc("dbopen()","table opened in shared mode.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------------------------------*/
−	/* DBXOPEN() - example opens index file 'shipwreck.dbx' returning the */	+	/* DBXOPEN() - example opens tag index 'shipwreck.dbx' returning the */
−	/* tagged index file descriptor (dbx) used in upcoming functions */	+	/*           taged index file descriptor (dbx) used in upcoming funcs */
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------------------------------*/
−	rc = dbxopen(dbf, "shipwreck.dbx", &dbx);	+	rc = dbxopen(dbf, "shipwreck.dbx", &dbx);
−	errorproc("dbxopen()", "tagged index opened.", rc);	+	errorproc("dbxopen()","tagged index opened.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------*/
−	/* Perform basic index functions. */	+	/* Perform basic index functions. */
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------*/
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------------*/
−	/* DBICREAT() - in this example creates an index on field VESSEL */	+	/* DBICREAT() - in this example creates an index on field VESSEL */
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------------*/
−	rc = dbicreat("shipwreck.ndx", fields[0].fieldnm, 18, 'C');	+	rc = dbicreat( "shipwreck.ndx", fields[0].fieldnm, 18, 'C');
−	errorproc("dbicreat()", "index created", rc);	+	errorproc("dbicreat()","index created", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------*/
−	/* DBIOPEN() - opens index to active status */	+	/* DBIOPEN() - opens index to active status */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------*/
−	rc = dbiopen("shipwreck.ndx", &ndx);	+	rc = dbiopen( "shipwreck.ndx", &ndx);
−	errorproc("dbiopen()", "index opened.", rc);	+	errorproc("dbiopen()", "index opened.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------*/
−	/* DBKEXPR() - obtains index information */	+	/* DBKEXPR() - obtains index information */
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------*/
−	rc = dbkexpr(ndx, &keytype, keyexpr, &kexprlen, &keylen);	+	rc = dbkexpr(ndx, &keytype, keyexpr, &kexprlen, &keylen);
−	errorproc("dbkexpr()", "key information retrieved.", rc);	+	errorproc("dbkexpr()", "key information retrieved.", rc);
−	printf("\t Key type: \t%c\n", keytype);	+	printf("\t       Key type: \t%c\n", keytype );
−	printf("\t Key expression: %s\n", keyexpr);	+	printf("\t       Key expression: %s\n", keyexpr);
−	printf("\t Key length: %d  Expression length: %d\n", kexprlen, keylen);	+	printf("\t       Key length: %d  Expression length: %d\n",
		+	kexprlen, keylen);
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------*/
	/* Lock data file */		/* Lock data file */
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------*/
	rc = dblockf(dbf);		rc = dblockf(dbf);
−	if (rc == SUCCESS) {	+	if ( rc == SUCCESS ) {
−	printf("Function: \tdblockf() \tfile locked successfully.\n");	+	printf("Function: \tdblockf() \tfile locked successfully.\n");
−	} else {	+	} else {
−	printf("Lock Failed. \tError: %d\n", rc);	+	printf("Lock Failed. \tError: %d\n",rc);
	}		}
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------------------*/
−	/* DBLOCKI() - locks the index for following additions */	+	/* DBLOCKI() - locks the index for following additions         */
−	/* Synonymous with DBTLOCKI() which tests the lock */	+	/*             Synonomous with DBTLOCKI() which tests the lock */
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------------------*/
−	rc = dblocki(ndx);	+	rc = dblocki(ndx);
−	if (rc == SUCCESS) {	+	if ( rc == SUCCESS ) {
−	printf("Function: \tdblocki() \tindex locked successfully.\n");	+	printf("Function: \tdblocki() \tindex locked successfully.\n");
−	} else {	+	} else {
−	printf("Lock Failed. tError: %d\n", rc);	+	printf("Lock Failed. \tError: %d\n",rc);
	}		}
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------*/
−	/* Perform basic memo file functions. */	+	/* Perform basic memo file functions. */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------*/
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------------------*/
−	/* DBMCREAT() - creates a table memo file (if one needs creating) */	+	/* DBMCREAT() - creates a table memo file (if one needs creating) */
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------------------*/
−	rc = dbmcreat("shipwreck.dbt");	+	rc = dbmcreat("shipwreck.dbt");
−	errorproc("dbmcreat()", "memo file create", rc);	+	errorproc("dbmcreat()", "memo file create", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------*/
−	/* DBMOPEN() - opens an associated memo file */	+	/* DBMOPEN() - opens an associated memo file */
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------*/
−	rc = dbmopen("shipwreck.dbt", &dbt);	+	rc = dbmopen("shipwreck.dbt", &dbt);
−	errorproc("dbmopen()", "memo file open.", rc);	+	errorproc("dbmopen()", "memo file open.", rc);
−	/*---------------------------------------------------------------------------------------*/
−	/* Perform table input functions. */
−	/*---------------------------------------------------------------------------------------*/
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------*/
−	/* DBAPPEND() - appends a record to the end of the active table */	+	/* Perform table input functions. */
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------*/
−	rc = dbappend(dbf, text_table[0], &recno);	+
−	errorproc("dbappend()", "record appended.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------------------------*/
−	/* DBAKEY() - adds a key to the active index after dbappend() */	+	/* DBAPPEND() - appends a record to the end of the active table */
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------------------------*/
−	rc = dbakey(ndx, "Santa Margarita  ", recno);	+	rc = dbappend(dbf, text_table[0], &recno);
−	errorproc("dbakey()", "key added.", rc);	+	errorproc("dbappend()", "record appended.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------------------------*/
−	/* DBXAKEY() - adds a key to the tagged index after dbappend() */	+	/* DBAKEY() - adds a key to the active index after dbappend() */
−	/* The tagged index file must be lock first */	+	/*------------------------------------------------------------*/
−	/*---------------------------------------------------------------------------------------*/	+	rc = dbakey(ndx,"Santa Margarita  " , recno);
−	rc = dbxlocki(dbx);	+	errorproc("dbakey()", "key added.", rc);
−	errorproc("dbxlocki()", "tagged index file locked.", rc);	+
−	rc = dbxakey(dbx, recno);	+
−	errorproc("dbxakey()", "key added.", rc);	+
−	rc = dbxunlocki(dbx);	+
−	errorproc("dbxunlocki()", "tagged index file unlocked.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------------------*/
−	/* DBFLUSH() - flushes the record cache to disk */	+	/* DBXAKEY() - adds a key to the tagged index after dbappend() */
−	/*---------------------------------------------------------------------------------------*/	+	/*       The tagged index file must be lock first       */
−	rc = dbflush(dbf);	+	/*-------------------------------------------------------------*/
−	errorproc("dbflush()", "table cache flushed.", rc);	+	rc = dbxlocki(dbx);
		+	errorproc("dbxlocki()",  "tagged index file locked.", rc);
		+	rc = dbxakey(dbx,recno);
		+	errorproc("dbxakey()",  "key added.", rc);
		+	rc = dbxunlocki(dbx);
		+	errorproc("dbxunlocki()", "tagged index file unlocked.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------*/
−	/* DBIFLSH() - flushes the index cache to disk */	+	/* DBFLUSH() - flushes the record cache to disk */
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------*/
−	rc = dbiflsh(ndx);	+	rc = dbflush(dbf);
−	errorproc("dbiflsh()", "index cache flushed.", rc);	+	errorproc("dbflush()", "table cache flushed.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------*/
−	/* DBXFLSH() - flushes the tagged index cache to disk */	+	/* DBIFLSH() - flushes the index cache to disk */
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------*/
−	rc = dbxflsh(dbx);	+	rc = dbiflsh(ndx);
−	errorproc("dbxflsh()", "Tagged index cache flushed.", rc);	+	errorproc("dbiflsh()", "index cache flushed.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------*/
−	/* DBGETR() - retrieves a record */	+	/* DBXFLSH() - flushes the tagged index cache to disk */
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------*/
−	rc = dbgetr(dbf, (long) 1, record, &status);	+	rc = dbxflsh(dbx);
−	errorproc("dbgetr()", "record retrieved.", rc);	+	errorproc("dbxflsh()", "Tagged index cache flushed.", rc);
−	printf("\t\t%s\n", record);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------*/
−	/* DBPUTM() - put the memo information */	+	/* DBGETR() - retrieves a record */
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------*/
−	rc = dbputm(dbt, "128' 30% coral cover.", &record[53]);	+	rc = dbgetr(dbf, (long)1, record, &status);
−	errorproc("dbputm", "memo placed in buffer", rc);	+	errorproc("dbgetr()", "record retreived.", rc);
		+	printf("\t\t%s\n", record);
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------*/
−	/* DBUPDR() - updates the record in buffer 'record' */	+	/* DBPUTM() - put the memo information */
−	/* As of v8.0 this function automatically updates any attached indexes. */	+	/*-------------------------------------*/
−	/*---------------------------------------------------------------------------------------*/	+	rc = dbputm(dbt, "128' 30% coral cover.", &record[53]);
−	rc = dbupdr(dbf, (long) 1, record);	+	errorproc("dbputm", "memo placed in buffer",rc);
−	errorproc("dbupdr()", "record updated.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*-----------------------------------------------------------*/
−	/* DBGETM() - this example extracts the memo from the record buffer */	+	/* DBUPDR() - updates the record in buffer 'record'          */
−	/*---------------------------------------------------------------------------------------*/	+	/*            As of v8.0 this function automatically updates */
−	rc = dbgetm(dbt, &record[53], tmpbuf, 0);	+	/*            any attached indexes.                          */
−	errorproc("dbgetm()", "retrieved memo.", rc);	+	/*-----------------------------------------------------------*/
		+	rc = dbupdr(dbf, (long)1, record);
		+	errorproc("dbupdr()", "record updated.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------------------------------*/
−	/* DBUPDM() - Updates the memo field for this record */	+	/* DBGETM() - this example extracts the memo from the record buffer */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------------------------------*/
−	strcat(tmpbuf, " Appending this string to the end of memo...");	+	rc = dbgetm(dbt, &record[53], tmpbuf, 0);
−	rc = dbupdm(dbt, tmpbuf, &record[53], &record[53]);	+	errorproc("dbgetm()", "retreived memo.", rc);
−	errorproc("dbupdm()", "updated memo.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------------*/
−	/* DBPUTRK() - the following example adds a record and index */	+	/* DBUPDM() - Updates the memofield for this record */
−	/* to the respective files. */	+	/*--------------------------------------------------*/
−	/* DBRECOUT() - scatter the record stored in buffer 'record' to a two */	+	strcat(tmpbuf, " Appending this string to the end of memo...");
−	/* dimensional character array 'fldbuf' */	+	rc = dbupdm(dbt, tmpbuf, &record[53], &record[53]);
−	/*---------------------------------------------------------------------------------------*/	+	errorproc("dbupdm()", "updated memo.", rc);
−	/*---------------------------------------------------------------------------------------*/
−	/* Read in 6 more records */
−	/*---------------------------------------------------------------------------------------*/
−	for (i = 1; i <= 6; i++) {	+	/*--------------------------------------------------------------*/
−	dbrecout(dbf, dbfields, fldpos, text_table[i], fldbuf);	+	/* DBPUTRK() - the following example adds a record and index    */
−	rc = dbputrk(dbf, ndx, fldbuf[0], text_table[i]);	+	/*            to the respective files.                        */
−	errorproc("dbputrk()", "record placed by key.", rc);	+	/* DBRECOUT() - scatter the record stored in buffer 'record' to */
−	}	+	/*              two dimensional character array 'fldbuf'        */
−	errorproc("dbputrk()", "6 records placed by key.", rc);	+	/*--------------------------------------------------------------*/
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------*/
−	/* DBFLUSH() - flushes the record cache to disk */	+	/* Read in 6 more records */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------*/
−	rc = dbflush(dbf);	+
−	errorproc("dbflush()", "table cache flushed.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+	for( i = 1; i <= 6; i++)  {
−	/* DBIFLSH() - flushes the index cache to disk */	+	dbrecout( dbf, dbfields, fldpos, text_table[i], fldbuf);
−	/*---------------------------------------------------------------------------------------*/	+	rc = dbputrk(dbf, ndx, fldbuf[0], text_table[i]);
−	rc = dbiflsh(ndx);	+	errorproc("dbputrk()", "record placed by key.", rc);
−	errorproc("dbiflsh()", "index cache flushed.", rc);	+	}
		+	errorproc("dbputrk()", "6 records placed by key.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------*/
−	/* DBXFLSH() - flushes the tagged index cache to disk */	+	/* DBFLUSH() - flushes the record cache to disk */
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------*/
−	rc = dbxflsh(dbx);	+	rc = dbflush(dbf);
−	errorproc("dbxflsh()", "Tagged index cache flushed.", rc);	+	errorproc("dbflush()", "table cache flushed.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------*/
−	/* DBFIELD() - this example extracts the field 'VESSEL' from the */	+	/* DBIFLSH() - flushes the index cache to disk */
−	/* record (#5) stored in buffer 'record' */	+	/*---------------------------------------------*/
−	/*---------------------------------------------------------------------------------------*/	+	rc = dbiflsh(ndx);
−	rc = dbgetr(dbf, (long) 5, record, &status);	+	errorproc("dbiflsh()", "index cache flushed.", rc);
−	/* rc = dbfield( dbf, record, "FLAG", tmpbuf); */	+
−	rc = dbfield(dbf, record, fields[5].fieldnm, tmpbuf);	+
−	errorproc("dbfield()", "field extracted.", rc);	+
−	printf("\t\tFlag: \t%s\n", tmpbuf);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------*/
−	/* Modify a single field in record number 5 */	+	/* DBXFLSH() - flushes the tagged index cache to disk */
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------*/
		+	rc = dbxflsh(dbx);
		+	errorproc("dbxflsh()", "Tagged index cache flushed.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------------*/
−	/* DBSCATTER() - scatter the record into specified field buffers */	+	/* DBFIELD() - this example extracts the field 'VESSEL' from the */
−	/*---------------------------------------------------------------------------------------*/	+	/*            record (#5) stored in buffer 'record'            */
−	rc = dbscatter(dbf, record, fldbuf);	+	/*---------------------------------------------------------------*/
−	errorproc("dbscatter()", "record scattered.", rc);	+	rc = dbgetr(dbf, (long)5, record, &status);
		+	/* rc = dbfield( dbf, record, "FLAG", tmpbuf); */
		+	rc = dbfield( dbf, record, fields[5].fieldnm, tmpbuf);
		+	errorproc("dbfield()", "field extracted.", rc);
		+	printf("\t\tFlag: \t%s\n", tmpbuf);
−	for (i = 0; i < nofields; i++) {	+	/*------------------------------------------*/
−	fprintf(stdout, "\t\tfldbuf[%d]='%s'\n", i, fldbuf[i]);	+	/* Modify a single field in record number 5 */
−	}	+	/*------------------------------------------*/
−	strcpy(fldbuf[5], "Spanish"); /* Modify Field */	+
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------------------*/
−	/* DBGATHER() - gather the field buffers and place the contents */	+	/* DBSCATTER() - scatters the record into specified field buffers.*/
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------------------*/
−	rc = dbgather(dbf, record, fldbuf);	+	rc = dbscatter(dbf, record, fldbuf);
−	errorproc("dbgather()", "record gathered.", rc);	+	errorproc("dbscatter()", "record scattered.", rc);
−	printf("\t\t%s\n", record);	+
−	rc = dbupdr(dbf, (long) 5, record); /* Finish Example */	+	strcpy(fldbuf[6], "Spanish");               /* Modify Field */
−	errorproc("dbupdr()", "record updated.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------------------*/
−	/* Perform index / index conversion functions. */	+	/* DBGATHER() - Gathers the field buffers and places the contents */
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------------------*/
		+	rc = dbgather(dbf, record, fldbuf);
		+	errorproc("dbgather()", "record gathered.", rc);
		+	printf("\t\t%s\n", record);
−	/*---------------------------------------------------------------------------------------*/	+	rc = dbupdr(dbf, (long)5, record);              /* Finish Example    */
−	/* DBREWIND() - position the record pointer to the top of the index file */	+	errorproc("dbupdr()", "record updated.", rc);
−	/*---------------------------------------------------------------------------------------*/	+
−	rc = dbrewind(ndx);	+
−	errorproc("dbrewind()", "index rewound.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------*/
−	/* DBGETNR() - after 'rewinding' to the top of the table, the first record */	+	/* Perform index / index conversion functions. */
−	/* can be retrieved with dbgetnr() using the active key */	+	/*---------------------------------------------*/
−	/*---------------------------------------------------------------------------------------*/	+
−	for (i = 1; i <= 6; i++) {	+
−	rc = dbgetnr(dbf, ndx, record, &status);	+
−	printf("\t\t%d: %s\n", i, record);	+
−	}	+
−	errorproc("dbgetnr()", "6 records retrieved by key.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------------------*/
−	/* DBNKEY() - get next key */	+	/* DBREWIND() - positions the record pointer to the top of the */
−	/*---------------------------------------------------------------------------------------*/	+	/*              index file                                    */
−	rc = dbnkey(ndx, nextkey[0], rec_no);	+	/*-------------------------------------------------------------*/
−	errorproc("dbnkey()", "next key retrieved.", rc);	+	rc = dbrewind(ndx);
−	printf("\t\tnext key: \t%s\n", nextkey[0]);	+	errorproc("dbrewind()", "index rewound.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------------*/
−	/* DBFWD() - position the pointer to the end of the table */	+	/* DBGETNR() - after 'rewind()ing' to the top of the table */
−	/*---------------------------------------------------------------------------------------*/	+	/*            the first record using the active key can be */
−	rc = dbfwd(ndx);	+	/*            retrieved with dbgetnr()                    */
−	errorproc("dbfwd()", "index pointer placed at bottom.", rc);	+	/*----------------------------------------------------------*/
		+	for( i = 1; i <= 6; i++)  {
		+	rc = dbgetnr(dbf, ndx, record, &status);
		+	printf("\t\t%d: %s\n", i,record);
		+	}
		+	errorproc("dbgetnr()", "6 records retrieved by key.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------*/
−	/* DBPKEY() - get previous key */	+	/* DBNKEY() - get next key */
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------*/
−	rc = dbpkey(ndx, nextkey[0], rec_no);	+	rc = dbnkey(ndx, nextkey[0], rec_no);
−	errorproc("dbpkey()", "previous key found.", rc);	+	errorproc("dbnkey()", "next key retrieved.", rc);
−	printf("\t\tprev key: \t%s\n", nextkey[0]);	+	printf("\t\tnext key: \t%s\n", nextkey[0]);
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------------------*/
−	/* DBGETPR() - obtain the previous record by key */	+	/* DBFWD() - position the pointer to the end of the table */
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------------------*/
−	rc = dbgetpr(dbf, ndx, record, &status);	+	rc = dbfwd(ndx);
−	errorproc("dbgetpr()", "previous record (by key) retrieved.", rc);	+	errorproc("dbfwd()", "index pointer placed at bottom.", rc);
−	printf("Previous: \t%s\n", record);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*-----------------------------*/
−	/* Rewind the index */	+	/* DBPKEY() - get previous key */
−	/*---------------------------------------------------------------------------------------*/	+	/*-----------------------------*/
−	dbrewind(ndx);	+	rc = dbpkey(ndx, nextkey[0], rec_no);
		+	errorproc("dbpkey()", "previous key found.", rc);
		+	printf("\t\tprev key: \t%s\n", nextkey[0]);
−	/*---------------------------------------------------------------------------------------*/	+	/*-----------------------------------------------*/
−	/* Perform table retrieval functions using indexes. */	+	/* DBGETPR() - obtain the previous record by key */
−	/*---------------------------------------------------------------------------------------*/	+	/*-----------------------------------------------*/
		+	rc = dbgetpr(dbf, ndx, record, &status);
		+	errorproc("dbgetpr()", "previous record (by key) retrieved.", rc);
		+	printf("Previous: \t%s\n", record);
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------*/
−	/* DBTKEY() - translates supplied key to record number */	+	/* Rewind the index */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------*/
−	rc = dbtkey(ndx, "Santa Rosa   ", &recno);	+	dbrewind(ndx);
−	errorproc("dbtkey()", "record number found by key.", rc);	+
−	printf("\t\trecord number: \t%d\n", recno);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------------*/
−	/* DBGETRK() - obtains the record from the specified key */	+	/* Perform table retrieval functions using indexes. */
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------------*/
−	rc = dbgetrk(dbf, ndx, "Santa Rosa ", record, &status);	+
−	errorproc("dbgetrk()", "record retrieved by key.", rc);	+
−	printf("\t\t%s\n", record);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*-----------------------------------------------------*/
−	/* DBCKEY() - read the current key */	+	/* DBTKEY() - translates supplied key to record number */
−	/*---------------------------------------------------------------------------------------*/	+	/*-----------------------------------------------------*/
−	rc = dbckey(ndx, key, &recno);	+	rc = dbtkey(ndx, "Santa Rosa        ", &recno);
−	errorproc("dbckey()", "current key read.", rc);	+	errorproc("dbtkey()", "record number found by key.", rc);
−	printf("\t\tcurrent key: \t%s\n", key);	+	printf("\t\trecord number: \t%d\n", recno);
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------------*/
−	/* Perform tagged index functions. */	+	/* DBGETRK() - obtains the record from the specified key */
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------------*/
		+	rc = dbgetrk(dbf, ndx, "Santa Rosa        ", record, &status);
		+	errorproc("dbgetrk()", "record retrieved by key.", rc);
		+	printf("\t\t%s\n", record);
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------*/
−	/* DBXREWIND() - position the pointer to the top of the index file */	+	/* DBCKEY() - read the current key */
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------*/
−	rc = dbxrewind(dbx);	+	rc = dbckey(ndx, key, &recno);
−	errorproc("dbxrewind()", "Tagged index rewound.", rc);	+	errorproc("dbckey()", "current key read.", rc);
		+	printf("\t\tcurrent key: \t%s\n", key);
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------*/
−	/* DBXGETNR() - after 'rewinding' to the top of the table, the first record */	+	/* Perform tagged index functions. */
−	/* can be retrieved with dbgetnr() using the active key */	+	/*---------------------------------*/
−	/*---------------------------------------------------------------------------------------*/	+
−	for (i = 1; i <= 6; i++) {	+
−	rc = dbxgetnr(dbf, dbx, record, &status);	+
−	printf("\t\t%d: %s\n", i, record);	+
−	}	+
−	errorproc("dbxgetnr()", "6 records retrieved by tag key.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------------------------*/
−	/* DBXNKEY() - get next key */	+	/* DBXREWIND() - positions the record pointer to the top of the */
−	/*---------------------------------------------------------------------------------------*/	+	/*              index file                                      */
−	rc = dbxnkey(dbx, nextkey[0], rec_no);	+	/*--------------------------------------------------------------*/
−	errorproc("dbxnkey()", "next key retrieved in tagged index.", rc);	+	rc = dbxrewind(dbx);
−	printf("\t\tnext key: \t%s\n", nextkey[0]);	+	errorproc("dbxrewind()", "Tagged index rewound.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*-----------------------------------------------------------*/
−	/* DBXFWD() - position the pointer to the end of the table */	+	/* DBXGETNR() - after 'rewind()ing' to the top of the table */
−	/*---------------------------------------------------------------------------------------*/	+	/*            the first record using the active key can be  */
−	rc = dbxfwd(dbx);	+	/*            retrieved with dbgetnr()                      */
−	errorproc("dbxfwd()", "index pointer placed at bottom.", rc);	+	/*-----------------------------------------------------------*/
		+	for( i = 1; i <= 6; i++)  {
		+	rc = dbxgetnr(dbf, dbx, record, &status);
		+	printf("\t\t%d: %s\n", i,record);
		+	}
		+	errorproc("dbxgetnr()", "6 records retrieved by tag key.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------*/
−	/* DBXPKEY() - get previous key */	+	/* DBXNKEY() - get next key */
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------*/
−	rc = dbxpkey(dbx, nextkey[0], rec_no);	+	rc = dbxnkey(dbx, nextkey[0], rec_no);
−	errorproc("dbxpkey()", "previous key found in tagged index.", rc);	+	errorproc("dbxnkey()", "next key retrieved in tagged index.", rc);
−	printf("\t\tprev key: \t%s\n", nextkey[0]);	+	printf("\t\tnext key: \t%s\n", nextkey[0]);
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------*/
−	/* DBXGETPR() - obtain the previous record by key */	+	/* DBXFWD() - position the pointer to the end of the table */
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------*/
−	rc = dbxgetpr(dbf, dbx, record, &status);	+	rc = dbxfwd(dbx);
−	errorproc("dbxgetpr()", "previous record (by key) retrieved.", rc);	+	errorproc("dbxfwd()", "index pointer placed at bottom.", rc);
−	printf("Previous: \t%s\n", record);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*-----------------------------*/
−	/* Rewind the index */	+	/* DBXPKEY() - get previous key */
−	/*---------------------------------------------------------------------------------------*/	+	/*-----------------------------*/
−	dbxrewind(dbx);	+	rc = dbxpkey(dbx, nextkey[0], rec_no);
		+	errorproc("dbxpkey()", "previous key found in tagged index.", rc);
		+	printf("\t\tprev key: \t%s\n", nextkey[0]);
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------------*/
−	/* Perform table retrieval functions using tagged indexes.*/	+	/* DBXGETPR() - obtain the previous record by key */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------------*/
		+	rc = dbxgetpr(dbf, dbx, record, &status);
		+	errorproc("dbxgetpr()", "previous record (by key) retrieved.", rc);
		+	printf("Previous: \t%s\n", record);
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------*/
−	/* DBTKEY() - translates supplied key to record number */	+	/* Rewind the index */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------*/
−	rc = dbtkey(ndx, "Santa Rosa   ", &recno);	+	dbxrewind(dbx);
−	errorproc("dbtkey()", "record number found by key.", rc);	+
−	printf("\t\trecord number: \t%d\n", recno);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------*/
−	/* DBXGETRK() - obtains the record from the specified key */	+	/* Perform table retrieval functions using tagged indexes. */
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------*/
−	rc = dbxgetrk(dbf, dbx, "Santa Rosa   ", record, &status);	+
−	errorproc("dbxgetrk()", "record retrieved by key.", rc);	+
−	printf("\t\t%s\n", record);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*-----------------------------------------------------*/
−	/* DBXCKEY() - read the current key */	+	/* DBTKEY() - translates supplied key to record number */
−	/*---------------------------------------------------------------------------------------*/	+	/*-----------------------------------------------------*/
−	rc = dbxckey(dbx, key, &recno);	+	rc = dbtkey(ndx, "Santa Rosa        ", &recno);
−	errorproc("dbxckey()", "current key read.", rc);	+	errorproc("dbtkey()", "record number found by key.", rc);
−	printf("\t\tcurrent key: \t%s\n", key);	+	printf("\t\trecord number: \t%d\n", recno);
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------------------*/
−	/* Perform field level functions including index/ASCII functions. */	+	/* DBXGETRK() - obtains the record from the specified key */
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------------------*/
		+	rc = dbxgetrk(dbf, dbx, "Santa Rosa        ", record, &status);
		+	errorproc("dbxgetrk()", "record retrieved by key.", rc);
		+	printf("\t\t%s\n", record);
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------*/
−	/* DBATOFLD() - converts ASCII string to Recital field */	+	/* DBXCKEY() - read the current key */
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------*/
−	rc = dbatofld("23.3", 4, 1, tmpbuf);	+	rc = dbxckey(dbx, key, &recno);
−	errorproc("dbatofld()", "string converted.", rc);	+	errorproc("dbxckey()", "current key read.", rc);
		+	printf("\t\tcurrent key: \t%s\n", key);
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------------*/
−	/* DBATOKEY() - converts a ASCII string to Recital date key */	+	/* Perform field level functions including index/ASCII functions.*/
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------------*/
−	key[0] = 'D';	+
−	rc = dbatokey("16430411", key);	+
−	errorproc("dbatokey()", "string converted to key.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------------------*/
−	/* DBFLDTOA() - converts extracted field to ASCII */	+	/* DBATOFLD() - converts ASCII string to Recital compat. field */
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------------------*/
−	rc = dbfldtoa(record + 18, 4, tmpbuf);	+	rc = dbatofld("23.3", 4, 1, tmpbuf);
−	errorproc("dbfldtoa()", "field converted.", rc);	+	errorproc("dbatofld()", "string converted.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------------*/
−	/* DBSTRCPY() - formats character strings to Recital types */	+	/* DBATOKEY() - converts a ASCII string to Recital date key */
−	/*---------------------------------------------------------------------------------------*/	+	/*-----------------------------------------------------------*/
−	dbstrcpy(key, 'L', 10, " 320000");	+	key[0] = 'D';
−	printf("Function: \tdbstrcpy() \toutput: %s\n", key);	+	rc = dbatokey("16430411", key);
		+	errorproc("dbatokey()", "string converted to key.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------------*/
−	/* DBSTRING() - formats non-'C' strings to C strings (null term) */	+	/* DBFLDTOA() - converts extracted field to ASCII */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------------*/
−	dbstring("Santa Pedro", 13, tmpbuf);	+	rc = dbfldtoa(record + 18, 4, tmpbuf);
−	printf("Function: \tdbstring() \toutput: %s\n", tmpbuf);	+	errorproc("dbfldtoa()", "field converted.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------*/
−	/* DBKEYTOA() - converts an extracted key to ASCII */	+	/* DBSTRCPY() - formats character strings to Rectial types */
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------*/
−	tmpbuf[0] = 0; /* Number of decimal places */	+	dbstrcpy(key, 'L', 10, "  320000");
−	tmpbuf[1] = 'N'; /* Key Type */	+	printf("Function: \tdbstrcpy() \toutput: %s\n", key);
−	rc = dbkeytoa(key, tmpbuf);	+
−	errorproc("dbkeytoa()", "key converted.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------------*/
−	/* Perform record/index deletion and file access */	+	/* DBSTRING() - formats non-'C' strings to C strings (null term) */
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------------*/
		+	dbstring("Santa Pedro", 13, tmpbuf);
		+	printf("Function: \tdbstring() \toutput: %s\n", tmpbuf);
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------*/
−	/* DBSIZE() - retrieve the size of the table */	+	/* DBKEYTOA() - converts an extracted key to ASCII */
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------*/
−	rc = dbsize(dbf, &db_size);	+	tmpbuf[0] = 0; /* Number of dec. places */
−	errorproc("dbsize()", "size retrieved.", rc);	+	tmpbuf[1] = 'N'; /* Key Type              */
−	printf("\t No. of Records: \t%d\n", db_size);	+	rc = dbkeytoa(key, tmpbuf);
		+	errorproc("dbkeytoa()", "key converted.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*-----------------------------------------------*/
−	/* DBPUTR() - adds a record to the end of the table */	+	/* Perform record/index deletion and file access */
−	/* You can also 'insert' a record using this function */	+	/*-----------------------------------------------*/
−	/*---------------------------------------------------------------------------------------*/	+
−	rc = dbputr(dbf, db_size + 1L, text_table[7]);	+
−	errorproc("dbputr()", "record placed.", rc);	+
−	rc = dbakey(ndx, "Unknown Vessel ", db_size + 1L);	+
−	errorproc("dbakey()", "key added.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+
−	/* Add record to the Production Index as well */	+
−	/*---------------------------------------------------------------------------------------*/	+
−	rc = dbxakey(dbx, db_size + 1L);	+
−	errorproc("dbxakey()", "key added.", rc);	+
−	dbflush(dbf);	+	/*-------------------------------------------*/
−	dbiflsh(ndx);	+	/* DBSIZE() - retrieve the size of the table */
		+	/*-------------------------------------------*/
		+	rc = dbsize(dbf, &db_size);
		+	errorproc("dbsize()", "size retrieved.", rc);
		+	printf("\t        No. of Records: \t%d\n", db_size);
		+
		+	/*---------------------------------------------------------------*/
		+	/* DBPUTR() - adds a record to the end of the table              */
		+	/*            You can also 'insert' a record using this function */
		+	/*---------------------------------------------------------------*/
		+	rc = dbputr(dbf, db_size + 1L, text_table[7]);
		+	errorproc("dbputr()", "record placed.", rc);
		+	rc = dbakey(ndx,"Unknown Vessel    " , db_size + 1L);
		+	errorproc("dbakey()",  "key added.", rc);
		+	rc = dbxakey(dbx, db_size + 1L);
		+	errorproc("dbxakey()",  "key added.", rc);
		+
		+	dbflush(dbf);                  /* Good Habit on shared files */
		+	dbiflsh(ndx);
	dbxflsh(dbx);		dbxflsh(dbx);
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------*/
−	/* DBDELETE() - mark a record (number 8) for deletion */	+	/* DBDELETE() - mark a record (number 8) for deletion */
−	/*---------------------------------------------------------------------------------------*/	+	/*----------------------------------------------------*/
−	rc = dbdelete(dbf, 8L);	+	rc = dbdelete(dbf, 8L);
−	errorproc("dbdelete()", "record 8 marked for deletion.", rc);	+	errorproc("dbdelete()", "record 8 marked for deletion.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------------------*/
−	/* DBRECALL() - recall a record marked for deletion (number 8) */	+	/* DBRECALL() - recall a record marked for deletion (number 8) */
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------------------------------*/
−	rc = dbrecall(dbf, 8L);	+	rc = dbrecall(dbf, 8L);
−	errorproc("dbrecall()", "record 8 recalled.", rc);	+	errorproc("dbrecall()", "record 8 recalled.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------------------------------*/
−	/* DBRMVKEY() - physically remove a key.  As of v8.0, this function */	+	/* DBRMVKEY() - physically remove a key.  As of v8.0, this function */
−	/* is not permitted on tables opened shareable. */	+	/*             is not permitted on tables opened shareable.       */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------------------------------*/
−	/* rc = dbrmvkey(ndx, "Unknown Vessel ", db_size+1L); */	+	/* rc = dbrmvkey(ndx, "Unknown Vessel   ", db_size+1L);           */
−	/* errorproc("dbrmvkey()", "key physically removed.", rc); */	+	/* errorproc("dbrmvkey()", "key physically removed.", rc);         */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------------------------------*/
−	/* DBRMVR() - physically remove a data record. As of v8.0 this */	+	/* DBRMVR() - physically remove a data record. As of v8.0 this     */
−	/* function is not permitted on tables opened shareable. */	+	/*           function is not permitted on tables opened shareable. */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------------------------------*/
−	/* rc = dbrmvr(dbf, db_size+1L); */	+	/* rc = dbrmvr(dbf, db_size+1L);                                   */
−	/* errorproc("dbrmvr()", "record 7 physically removed.", rc); */	+	/* errorproc("dbrmvr()", "record 7 physically removed.", rc);       */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------*/
−	/* DBUNLOCKF() - unlocks a table file */	+	/* DBUNLOCKF() - unlocks a table file */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------*/
−	rc = dbunlockf(dbf);	+	rc = dbunlockf(dbf);
−	if (rc == SUCCESS) {	+	if ( rc == SUCCESS ) {
−	printf("Function: \tdbunlockf() \tFile unlocked successfully\n");	+	printf("Function: \tdbunlockf() \tFile unlocked successfully\n");
−	} else {	+	} else {
−	printf("Unlock Failed. \tError: %d\n", rc);	+	printf("Unlock Failed. \tError: %d\n", rc);
	}		}
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------*/
−	/* DBUNLOCKI() - unlocks an index file */	+	/* DBUNLOCKI() - unlocks an index file */
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------*/
−	rc = dbunlocki(ndx);	+	rc = dbunlocki(ndx);
−	if (rc == SUCCESS) {	+	if ( rc == SUCCESS ) {
−	printf("Function: \tdbunlocki() \tFile unlocked successfully\n");	+	printf("Function: \tdbunlocki() \tFile unlocked successfully\n");
−	} else {	+	} else {
−	printf("Unlock Failed. \tError: %d\n", rc);	+	printf("Unlock Failed. \tError: %d\n", rc);
	}		}
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------------*/
−	/* DBLOCKR() - tests available record locking in a multi user */	+	/* DBLOCKR() - tests available record locking in a multiuser    */
−	/* environment.  Same as DBTLOCKR() in multi access */	+	/*             environment.  Same as DBTLOCKR() in multi access */
−	/*---------------------------------------------------------------------------------------*/	+	/*---------------------------------------------------------------*/
−	rc = dblockr(dbf, (long) 7);	+	rc = dblockr(dbf, (long)7);
−	if (rc == SUCCESS) {	+	if ( rc == SUCCESS ) {
−	printf("Function: \tdblockr() \trecord locked successfully.\n");	+	printf("Function: \tdblockr() \trecord locked successfully.\n");
−	} else {	+	} else {
−	printf("Lock Failed. tError: %d\n", rc);	+	printf("Lock Failed. \tError: %d\n", rc);
	}		}
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------*/
−	/* DBUNLOCKR() - unlocks a table Record */	+	/* DBUNLOCKR() - unlocks a table Record */
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------*/
−	rc = dbunlockr(dbf, (long) 7);	+	rc = dbunlockr(dbf, (long)7);
−	if (rc == SUCCESS) {	+	if ( rc == SUCCESS ) {
−	printf("Function \tdbunlockr(): \trecord unlocked successfully\n");	+	printf("Function \tdbunlockr(): \trecord unlocked successfully\n");
−	} else {	+	} else {
−	printf("Unlock Failed. \tError: %d\n", rc);	+	printf("Unlock Failed. \tError: %d\n", rc);
	}		}
−	/*---------------------------------------------------------------------------------------*/
−	/* Perform record/index close functions */
−	/*---------------------------------------------------------------------------------------*/
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------*/
−	/* DBICLOSE() - close the active index */	+	/* Perform record/index close functions */
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------*/
−	rc = dbiclose(ndx);	+
−	errorproc("dbiclose()", "index closed.", rc);	+
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------*/
−	/* DBXCLOSE() - close the active tagged index */	+	/* DBICLOSE() - close the active index */
−	/*---------------------------------------------------------------------------------------*/	+	/*-------------------------------------*/
−	rc = dbxclose(dbx);	+	rc = dbiclose(ndx);
−	errorproc("dbxclose()", "tagged index closed.", rc);	+	errorproc("dbiclose()", "index closed.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------*/
−	/* DBCLOSE() - close the active table */	+	/* DBXCLOSE() - close the active tagged index */
−	/*---------------------------------------------------------------------------------------*/	+	/*--------------------------------------------*/
−	rc = dbclose(dbf);	+	rc = dbxclose(dbx);
−	errorproc("dbclose()", "table closed.", rc);	+	errorproc("dbxclose()", "tagged index closed.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------*/
−	/* DBMCLOSE() - close the active memo table */	+	/* DBCLOSE() - close the active table */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------*/
−	rc = dbmclose(dbt);	+	rc = dbclose(dbf);
−	errorproc("dbmclose()", "memo table closed.", rc);	+	errorproc("dbclose()", "table closed.", rc);
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------*/
−	/* Perform miscellaneous Recital/Library functions */	+	/* DBMCLOSE() - close the active memo table */
−	/*---------------------------------------------------------------------------------------*/	+	/*------------------------------------------*/
		+	rc = dbmclose(dbt);
		+	errorproc("dbmclose()", "memo table closed.", rc);
−	/*---------------------------------------------------------------------------------------*/
−	/* DBONERROR() - enables/disables (1/0) recovery from errors */
−	/*---------------------------------------------------------------------------------------*/
−	dbonerror(0); /* Recovery disabled */
−	printf("Function: \tdbonerror()  \terror checking disabled\n");
−	printf("\nEnd of Recital C Library test program....\n");	+	/*-------------------------------------------------*/
		+	/* Perform miscellaneous Recital/Library functions */
		+	/*-------------------------------------------------*/
−	exit(0);	+	/*-----------------------------------------------------------*/
		+	/* DBONERROR() - enables/disables (1/0) recovery from errors */
		+	/*-----------------------------------------------------------*/
		+	dbonerror(0);                          /* Recovery disabled */
		+	printf("Function: \tdbonerror()  \terror checking disabled\n");
−	}	+	printf("\nEnd of Recital C Library test program....\n");
−	/*-----------------------------------------------------------------------------------------*/	+	exit(0);
−	/* This procedure handles the return codes from called RECITAL/library */	+
−	/* functions.  Intended to eliminate cryptic  'if...else...' statements */	+
−	/* following library calls. */	+
−	/*-----------------------------------------------------------------------------------------*/	+
−	static int errorproc(func, str, rc)
−	char *func;char *str;int rc; {
−	if (rc != SUCCESS) {
−	printf("\n  Error performing function %s -> %d\n", func, rc);
−	exit(1);
−	}
−	printf("Function: \t%s, \t%s - Ok\n", func, str);
−	return;
	}		}
−	</code>
−	[[Category:Documentation]]	+	/*----------------------------------------------------------------------*/
−	[[Category:Library]]	+	/* This procedure handles the return codes from called RECITAL/library  */
−	[[Category:Reference]]	+	/* functions.  Intended to eliminate cryptic  'if...else...' statements */
		+	/* following library calls.                                            */
		+	/*----------------------------------------------------------------------*/
		+
		+	static void errorproc(func, str, rc)
		+	char    *func;
		+	char    *str;
		+	int    rc;
		+	{
		+	if ( rc != SUCCESS )  {
		+	printf("\n  Error performing function %s -> %d\n", func, rc);
		+	exit(1);
		+	}
		+	printf("Function: \t%s, \t%s - Ok\n", func,str);
		+	return;
		+	}

---

Revision as of 13:49, 6 May 2009

/*#============================================================================

*# Copyright (C) 1988-1991 Recital Corporation Inc.
*# As an unpublished licenced proprietary work.
*# All rights reserved worldwide.
*#
*# This program may be freely copied and used as a template for user
*# programs which make use of the Recital/Library in so long as the above
*# copyright notice is included.
*#
*#============================================================================
*
*      MODULE          : dblsamp.c
*
*      PURPOSE         : Recital DataBase Library sample program.
*
*      AUTHOR          : RECITAL CORPORATION
*
*      DATE            : 26 Jan 91
*      REVISION        : 29 Oct 91
*      REVISION        : 09 May 95
*
*==========================================================================*/

1. include <stdio.h>
2. include <stdlib.h>
3. include <string.h>
4. include <sys/types.h>
5. include <unistd.h>
6. include "dbl.h" /* Recital/Library include file */
7. include "dblproto.h" /* Recital/Library prototype file */

extern int g_disable_iostats;

/*----------------------------------------------*/ /* Table structure for db to be constructed. */ /* Structure dBFIELD defined in dbl.h. */ /*----------------------------------------------*/ static dBFIELD fields[7] = {

       "VESSEL",       'C',    18,     0,	0,
       "LAT",          'N',    4,      1,	0,
       "LONG",         'N',    4,      1,	0,
       "AMOUNT",       'N',    10,     0,	0,
       "DATE",         'D',    8,      0,	0,
       "FLAG",         'C',    9,      0,	0,
       "MEMO",         'M',    sizeof(MEMO),      0,	0 

};

1. define DB_RECORD_SIZE 100

/*----------------------------------------------*/ /* Static Error Handling procedure. */ /*----------------------------------------------*/ static void errorproc( char *func, char *str, int rc);

/*----------------------------------------------*/ /* Table records to add. */ /*----------------------------------------------*/ static char *text_table[] = {

   "Santa Margarita   80.027.5   700000095/01/01Spanish  ",
   "Santa Rosa        81.824.8  3000000032/01/01Spanish  ",
   "Unknown galleon   83.123.0         015/01/01Spanish  ",
   "Jessie            97.127.4    10000075/01/01U.S.     ",
   "Lea               96.227.8   100000080/01/01U.S.     ",
   "S.J. Lee          96.926.9    20000075/01/01U.S.     ",
   "Genovase          78.418.4   185000030/01/01Spanish  ",
   "Unknown Vessel    77.517.9         075/01/01U.S.     "

};

/*---------------------------*/ /* Main program entry point. */ /*---------------------------*/ main() {

       int     rc;                     /* Return Code for error handling  */
       char    *dbf;                   /* File descriptor for table    */
       char    *dbx;                   /* File descriptor for tagged index   */
       char    *ndx;                   /* File descriptor for index       */
       char    *dbt;                   /* File descriptor for memo file   */
       char    record[DB_RECORD_SIZE]; /* Array of char for records       */
       char    keytype;                /* Variable for varying keytype    */
       char    key[21];                /* Storage location for keys       */
       char    tagname[21];            /* Storage location for tag name */
       char    keyexpr[512];           /* Storage location for key expr   */
       char    forexpr[512];           /* Storage location for for expr   */
       int     kexprlen;               /* The key expression length       */
       int     keylen;                 /* The key length                  */
       dBFIELD dbfields[MAX_RECORD_FIELDS];          /* Storage location for fld names  */
       FLDNUM  fieldcount;             /* Number of fields to create      */
       int     fldpos[MAX_RECORD_FIELDS];            /* Fields position buffer          */
       char    flddes[MAX_RECORD_FIELDS][26];        /* Fields description buffer       */
       char    tmpbuf[81];             /* Temporary storage buffer        */
       char    fldbuf[MAX_RECORD_FIELDS][256];       /* Field buffer (recin()/out())    */
       char    nextkey[10][20];        /* Key buffers (dbnkey())          */
       char    status;                 /* Deleted record flag             */
       long    recno;                  /* Table record variable        */
       long    rec_no[10];             /* Record number array (dbnkey())  */
       long    db_size;                /* Size of table variable       */
       int     reclen;                 /* Table record length variable */
       char    month;                  /* Month variable                  */
       char    day;                    /* Day variable                    */
       char    year;                   /* Year variable                   */
       FLDNUM  nofields;               /* Number of table fields var   */
       int     i;             	 	/* Loop control variable           */
       double  n;                      /* Double numeric variable         */

int keyunique; /* Boolean for unqiue tag key */ int keydescend; /* Boolean for descending tag key */ int notags; /* number of tags in a dbx file */

       /*----------------------------------------------------*/
       /* Perform operational Library environment functions. */
       /*----------------------------------------------------*/

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

       /* DBDCACHE() - this example allocates a 100 record caching area */

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

       rc = dbdcache(100);
       errorproc("dbdcache()","table cache specified.", rc);

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

       /* DBICACHE() - this example allocates 51200 bytes for index caching */

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

       rc = dbicache(100);
       errorproc("dbicache()", "index cache specified.",rc);

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

       /* DBFILEMODE() - shared, read write access */

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

       rc = dbfilemode(1,0);
       errorproc("dbfilemode()", "filemode specified.", rc);

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

       /* DBSET() - Set exact index match to true  */

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

       rc = dbset("EXACT", 1);
       errorproc("dbset()", "filemode specified.", rc);

       /*--------------------------------*/
       /* Perform basic table functions. */
       /*--------------------------------*/
       fieldcount = 7;                         /* Number of Fields          */

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

       /* DBCREAT() - this example creates a table according to the */
       /*             'dBFIELD' array fields.                       */

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

       rc = dbcreat("shipwreck.dbf",fieldcount, fields);
       errorproc("dbcreat()","datebase created.", rc);

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

       /* DBCREATX() - Enables the addition of table field descriptions. */

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

       strcpy(flddes[0], "The vessel's name.");
       strcpy(flddes[1], "The latitude.");
       strcpy(flddes[2], "The longitude.");
       strcpy(flddes[3], "The value.");
       strcpy(flddes[4], "The date.");
       strcpy(flddes[5], "The vessel's flag.");
       strcpy(flddes[6], "Notes.");

       rc = dbcreatx("shipwreck.dbf", fieldcount, fields, flddes);

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

       /* DBOPEN() - example opens table 'shipwreck.dbf' returning the     */
       /*            table file descriptor (dbf) used in upcoming funcs  */

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

       rc = dbopen("shipwreck.dbf", &dbf);
       errorproc("dbopen()","table opened.", rc);

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

       /* DBGETF() - obtain table information on the table referenced */
       /*            by the 'dbf' file descriptor.                    */

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

       rc = dbgetf(dbf, &reclen, &month, &day,
                       &year, &nofields, dbfields);
       errorproc("dbgetf()","information retrieved.", rc);
       printf("\t\tRecord length in bytes: %d\n", reclen);
       printf("\t\tCreation date: \t\t%d/%d/%d\n",month,day,year);
       printf("\t\tNumber of fields: \t%d\n", nofields);

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

       /* DBGETFX() - obtain extended table information including the     */
       /*             numeric field location array (fldpos) and the field */
       /*             descriptions (flddes).                              */

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

       rc = dbgetfx(dbf, &reclen, &month, &day, &year,
                    &nofields, dbfields, fldpos, flddes);
       errorproc("dbgetfx()", "extra information retrieved.", rc);
       printf("\t\tLocation of fields in buffer: \t%d,%d,%d,%d,%d,%d\n",
           fldpos[1],fldpos[2],fldpos[3],fldpos[4],fldpos[5],fldpos[6]);

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

       /* DBLOCKF() - locks the table for following additions.        */
       /*             Synonomous with DBTLOCKF() which tests the lock */

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

       rc = dblockf(dbf);
       if ( rc == SUCCESS ) {
           printf("Function: \tdblockf() \tfile locked successfully.\n");
       } else {
           printf("Lock Failed. \tError: %d\n",rc);

}

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

       /* DBCLOSE() - close the active table */

/*------------------------------------*/ rc = dbclose(dbf);

       errorproc("dbclose()", "table closed.", rc);

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

       /* Exclusive, read write access of the table is */

/* required to create or delete tags. */ /*----------------------------------------------*/

       rc = dbfilemode(0,0);
       rc = dbopen("shipwreck.dbf", &dbf);
       errorproc("dbopen()","table opened in exclusive mode.", rc);

       /*---------------------------------------*/
       /* Perform basic tagged index functions. */
       /*---------------------------------------*/

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

       /* DBXCREATE() - in this example creates an tag on field VESSEL */

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

       rc = dbxcreate( dbf,

fields[0].fieldnm, /* "VESSEL", */ &dbx, fields[0].fieldnm, /* "VESSEL", */ NULL, 0, 0);

       errorproc("dbxcreate()","tag created", rc);

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

       /* DBXCREATE() - in this example creates an tag on field FLAG */

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

       rc = dbxcreate( dbf,

fields[5].fieldnm, /* "FLAG", */ &dbx, fields[5].fieldnm, /* "FLAG", */ NULL, 0, 0);

       errorproc("dbxcreate()","tag created", rc);

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

       /* DBXNOTAGS() - obtains the number of tagged indexes */

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

       rc = dbxnotags(dbx, &notags);
       errorproc("dbxnotags()","tagged index count obtained.", rc);
       printf("\t        Key count: \t%d\n", notags );

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

       /* DBXKEXPR() - obtains tagged index information */

/*-----------------------------------------------*/ for (i = 1; i <= notags; i++) {

           rc = dbxkexpr(dbx, 

&i, tagname, &keytype, keyexpr, forexpr, &kexprlen, &keylen, &keyunique, &keydescend);

           errorproc("dbxkexpr()", "key information retrieved.", rc);
           printf("\t        Key number: \t%d\n", i );
           printf("\t        Key name: \t%s\n", tagname );
           printf("\t        Key type: \t%c\n", keytype );
           printf("\t        Key expression: %s\n", keyexpr);
           printf("\t        Key length: %d   Expression length: %d\n",
                             kexprlen, keylen);
           printf("\t        For expression: %s\n", forexpr);
           printf("\t        Key unique: \t%s\n", keyunique ? "Yes" : "No" );
           printf("\t        Key descending: \t%s\n", keydescend?"Yes":"No" );

}

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

       /* DBXDROPTAGS() - Drop the specified tag */

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

       rc = dbxdroptag(dbx, fields[5].fieldnm);
       errorproc("dbxdroptag()","tagged index 'FLAG' dropped.", rc);

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

       /* DBXCLOSE() - close the active tagged index */

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

       rc = dbxclose(dbx);
       errorproc("dbxclose()", "tagged index closed.", rc);

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

       /* DBCLOSE() - close the active table */

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

       rc = dbclose(dbf);
       errorproc("dbclose()", "table closed.", rc);

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

       /* Reopen the table in shared, read-write access mode */

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

       rc = dbfilemode(1,0);
       rc = dbopen("shipwreck.dbf", &dbf);
       errorproc("dbopen()","table opened in shared mode.", rc);

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

       /* DBXOPEN() - example opens tag index 'shipwreck.dbx' returning the  */
       /*           taged index file descriptor (dbx) used in upcoming funcs */

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

       rc = dbxopen(dbf, "shipwreck.dbx", &dbx);
       errorproc("dbxopen()","tagged index opened.", rc);

       /*--------------------------------*/
       /* Perform basic index functions. */
       /*--------------------------------*/

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

       /* DBICREAT() - in this example creates an index on field VESSEL */

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

       rc = dbicreat( "shipwreck.ndx", fields[0].fieldnm, 18, 'C');
       errorproc("dbicreat()","index created", rc);

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

       /* DBIOPEN() - opens index to active status */

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

       rc = dbiopen( "shipwreck.ndx", &ndx);
       errorproc("dbiopen()", "index opened.", rc);

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

       /* DBKEXPR() - obtains index information */

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

       rc = dbkexpr(ndx, &keytype, keyexpr, &kexprlen, &keylen);
       errorproc("dbkexpr()", "key information retrieved.", rc);
       printf("\t        Key type: \t%c\n", keytype );
       printf("\t        Key expression: %s\n", keyexpr);
       printf("\t        Key length: %d   Expression length: %d\n",
                         kexprlen, keylen);

/*----------------*/ /* Lock data file */ /*----------------*/ rc = dblockf(dbf);

       if ( rc == SUCCESS ) {
           printf("Function: \tdblockf() \tfile locked successfully.\n");
       } else {
           printf("Lock Failed. \tError: %d\n",rc);

}

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

       /* DBLOCKI() - locks the index for following additions         */
       /*             Synonomous with DBTLOCKI() which tests the lock */

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

       rc = dblocki(ndx);
       if ( rc == SUCCESS ) {
           printf("Function: \tdblocki() \tindex locked successfully.\n");
       } else {
           printf("Lock Failed. \tError: %d\n",rc);

}

       /*------------------------------------*/
       /* Perform basic memo file functions. */
       /*------------------------------------*/

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

       /* DBMCREAT() - creates a table memo file (if one needs creating) */

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

       rc = dbmcreat("shipwreck.dbt");
       errorproc("dbmcreat()", "memo file create", rc);

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

       /* DBMOPEN() - opens an associated memo file */

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

       rc = dbmopen("shipwreck.dbt", &dbt);
       errorproc("dbmopen()", "memo file open.", rc);

       /*--------------------------------*/
       /* Perform table input functions. */
       /*--------------------------------*/

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

       /* DBAPPEND() - appends a record to the end of the active table */

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

       rc = dbappend(dbf, text_table[0], &recno);
       errorproc("dbappend()", "record appended.", rc);

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

       /* DBAKEY() - adds a key to the active index after dbappend() */

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

       rc = dbakey(ndx,"Santa Margarita   " , recno);
       errorproc("dbakey()",  "key added.", rc);

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

       /* DBXAKEY() - adds a key to the tagged index after dbappend() */

/* The tagged index file must be lock first */ /*-------------------------------------------------------------*/

       rc = dbxlocki(dbx);
       errorproc("dbxlocki()",  "tagged index file locked.", rc);
       rc = dbxakey(dbx,recno);
       errorproc("dbxakey()",  "key added.", rc);
       rc = dbxunlocki(dbx);
       errorproc("dbxunlocki()",  "tagged index file unlocked.", rc);

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

       /* DBFLUSH() - flushes the record cache to disk */

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

       rc = dbflush(dbf);
       errorproc("dbflush()", "table cache flushed.", rc);

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

       /* DBIFLSH() - flushes the index cache to disk */

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

       rc = dbiflsh(ndx);
       errorproc("dbiflsh()", "index cache flushed.", rc);

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

       /* DBXFLSH() - flushes the tagged index cache to disk */

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

       rc = dbxflsh(dbx);
       errorproc("dbxflsh()", "Tagged index cache flushed.", rc);

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

       /* DBGETR() - retrieves a record */

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

       rc = dbgetr(dbf, (long)1, record, &status);
       errorproc("dbgetr()", "record retreived.", rc);
       printf("\t\t%s\n", record);

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

       /* DBPUTM() - put the memo information */

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

       rc = dbputm(dbt, "128' 30% coral cover.", &record[53]);
       errorproc("dbputm", "memo placed in buffer",rc);

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

       /* DBUPDR() - updates the record in buffer 'record'          */

/* As of v8.0 this function automatically updates */ /* any attached indexes. */ /*-----------------------------------------------------------*/

       rc = dbupdr(dbf, (long)1, record);
       errorproc("dbupdr()", "record updated.", rc);

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

       /* DBGETM() - this example extracts the memo from the record buffer */

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

       rc = dbgetm(dbt, &record[53], tmpbuf, 0);
       errorproc("dbgetm()", "retreived memo.", rc);

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

       /* DBUPDM() - Updates the memofield for this record */

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

       strcat(tmpbuf, " Appending this string to the end of memo...");
       rc = dbupdm(dbt, tmpbuf, &record[53], &record[53]);
       errorproc("dbupdm()", "updated memo.", rc);

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

       /* DBPUTRK() - the following example adds a record and index    */
       /*             to the respective files.                         */
       /* DBRECOUT() - scatter the record stored in buffer 'record' to */
       /*              two dimensional character array 'fldbuf'        */

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

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

       /* Read in 6 more records */

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

       for( i = 1; i <= 6; i++)  {
           dbrecout( dbf, dbfields, fldpos, text_table[i], fldbuf);
           rc = dbputrk(dbf, ndx, fldbuf[0], text_table[i]);
           errorproc("dbputrk()", "record placed by key.", rc);
       }
       errorproc("dbputrk()", "6 records placed by key.", rc);

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

       /* DBFLUSH() - flushes the record cache to disk */

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

       rc = dbflush(dbf);
       errorproc("dbflush()", "table cache flushed.", rc);

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

       /* DBIFLSH() - flushes the index cache to disk */

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

       rc = dbiflsh(ndx);
       errorproc("dbiflsh()", "index cache flushed.", rc);

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

       /* DBXFLSH() - flushes the tagged index cache to disk */

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

       rc = dbxflsh(dbx);
       errorproc("dbxflsh()", "Tagged index cache flushed.", rc);

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

       /* DBFIELD() - this example extracts the field 'VESSEL' from the */
       /*             record (#5) stored in buffer 'record'             */

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

       rc = dbgetr(dbf, (long)5, record, &status);
       /* rc = dbfield( dbf, record, "FLAG", tmpbuf); */
       rc = dbfield( dbf, record, fields[5].fieldnm, tmpbuf);
       errorproc("dbfield()", "field extracted.", rc);
       printf("\t\tFlag: \t%s\n", tmpbuf);

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

       /* Modify a single field in record number 5 */

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

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

       /* DBSCATTER() - scatters the record into specified field buffers.*/

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

       rc = dbscatter(dbf, record, fldbuf);
       errorproc("dbscatter()", "record scattered.", rc);

       strcpy(fldbuf[6], "Spanish");                /* Modify Field */

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

       /* DBGATHER() - Gathers the field buffers and places the contents */

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

       rc = dbgather(dbf, record, fldbuf);
       errorproc("dbgather()", "record gathered.", rc);
       printf("\t\t%s\n", record);

       rc = dbupdr(dbf, (long)5, record);              /* Finish Example    */
       errorproc("dbupdr()", "record updated.", rc);

       /*---------------------------------------------*/
       /* Perform index / index conversion functions. */
       /*---------------------------------------------*/

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

       /* DBREWIND() - positions the record pointer to the top of the */
       /*              index file                                     */

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

       rc = dbrewind(ndx);
       errorproc("dbrewind()", "index rewound.", rc);

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

       /* DBGETNR() - after 'rewind()ing' to the top of the table  */
       /*             the first record using the active key can be */
       /*             retrieved with dbgetnr()                     */

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

       for( i = 1; i <= 6; i++)  {
           rc = dbgetnr(dbf, ndx, record, &status);
           printf("\t\t%d: %s\n", i,record);
       }
       errorproc("dbgetnr()", "6 records retrieved by key.", rc);

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

       /* DBNKEY() - get next key */

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

       rc = dbnkey(ndx, nextkey[0], rec_no);
       errorproc("dbnkey()", "next key retrieved.", rc);
       printf("\t\tnext key: \t%s\n", nextkey[0]);

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

       /* DBFWD() - position the pointer to the end of the table */

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

       rc = dbfwd(ndx);
       errorproc("dbfwd()", "index pointer placed at bottom.", rc);

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

       /* DBPKEY() - get previous key */

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

       rc = dbpkey(ndx, nextkey[0], rec_no);
       errorproc("dbpkey()", "previous key found.", rc);
       printf("\t\tprev key: \t%s\n", nextkey[0]);

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

       /* DBGETPR() - obtain the previous record by key */

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

       rc = dbgetpr(dbf, ndx, record, &status);
       errorproc("dbgetpr()", "previous record (by key) retrieved.", rc);
       printf("Previous: \t%s\n", record);

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

       /* Rewind the index */

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

       dbrewind(ndx);

       /*--------------------------------------------------*/
       /* Perform table retrieval functions using indexes. */
       /*--------------------------------------------------*/

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

       /* DBTKEY() - translates supplied key to record number */

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

       rc = dbtkey(ndx, "Santa Rosa        ", &recno);
       errorproc("dbtkey()", "record number found by key.", rc);
       printf("\t\trecord number: \t%d\n", recno);

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

       /* DBGETRK() - obtains the record from the specified key */

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

       rc = dbgetrk(dbf, ndx, "Santa Rosa        ", record, &status);
       errorproc("dbgetrk()", "record retrieved by key.", rc);
       printf("\t\t%s\n", record);

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

       /* DBCKEY() - read the current key */

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

       rc = dbckey(ndx, key, &recno);
       errorproc("dbckey()", "current key read.", rc);
       printf("\t\tcurrent key: \t%s\n", key);

       /*---------------------------------*/
       /* Perform tagged index functions. */
       /*---------------------------------*/

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

       /* DBXREWIND() - positions the record pointer to the top of the */
       /*              index file                                      */

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

       rc = dbxrewind(dbx);
       errorproc("dbxrewind()", "Tagged index rewound.", rc);

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

       /* DBXGETNR() - after 'rewind()ing' to the top of the table  */
       /*             the first record using the active key can be  */
       /*             retrieved with dbgetnr()                      */

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

       for( i = 1; i <= 6; i++)  {
           rc = dbxgetnr(dbf, dbx, record, &status);
           printf("\t\t%d: %s\n", i,record);
       }
       errorproc("dbxgetnr()", "6 records retrieved by tag key.", rc);

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

       /* DBXNKEY() - get next key */

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

       rc = dbxnkey(dbx, nextkey[0], rec_no);
       errorproc("dbxnkey()", "next key retrieved in tagged index.", rc);
       printf("\t\tnext key: \t%s\n", nextkey[0]);

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

       /* DBXFWD() - position the pointer to the end of the table */

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

       rc = dbxfwd(dbx);
       errorproc("dbxfwd()", "index pointer placed at bottom.", rc);

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

       /* DBXPKEY() - get previous key */

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

       rc = dbxpkey(dbx, nextkey[0], rec_no);
       errorproc("dbxpkey()", "previous key found in tagged index.", rc);
       printf("\t\tprev key: \t%s\n", nextkey[0]);

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

       /* DBXGETPR() - obtain the previous record by key */

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

       rc = dbxgetpr(dbf, dbx, record, &status);
       errorproc("dbxgetpr()", "previous record (by key) retrieved.", rc);
       printf("Previous: \t%s\n", record);

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

       /* Rewind the index */

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

       dbxrewind(dbx);

       /*---------------------------------------------------------*/
       /* Perform table retrieval functions using tagged indexes. */
       /*---------------------------------------------------------*/

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

       /* DBTKEY() - translates supplied key to record number */

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

       rc = dbtkey(ndx, "Santa Rosa        ", &recno);
       errorproc("dbtkey()", "record number found by key.", rc);
       printf("\t\trecord number: \t%d\n", recno);

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

       /* DBXGETRK() - obtains the record from the specified key */

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

       rc = dbxgetrk(dbf, dbx, "Santa Rosa        ", record, &status);
       errorproc("dbxgetrk()", "record retrieved by key.", rc);
       printf("\t\t%s\n", record);

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

       /* DBXCKEY() - read the current key */

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

       rc = dbxckey(dbx, key, &recno);
       errorproc("dbxckey()", "current key read.", rc);
       printf("\t\tcurrent key: \t%s\n", key);

       /*---------------------------------------------------------------*/
       /* Perform field level functions including index/ASCII functions.*/
       /*---------------------------------------------------------------*/

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

       /* DBATOFLD() - converts ASCII string to Recital compat. field */

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

       rc = dbatofld("23.3", 4, 1, tmpbuf);
       errorproc("dbatofld()", "string converted.", rc);

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

       /* DBATOKEY() - converts a ASCII string to Recital date key */

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

       key[0] = 'D';
       rc = dbatokey("16430411", key);
       errorproc("dbatokey()", "string converted to key.", rc);

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

       /* DBFLDTOA() - converts extracted field to ASCII */

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

       rc = dbfldtoa(record + 18, 4, tmpbuf);
       errorproc("dbfldtoa()", "field converted.", rc);

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

       /* DBSTRCPY() - formats character strings to Rectial types */

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

       dbstrcpy(key, 'L', 10, "  320000");
       printf("Function: \tdbstrcpy() \toutput: %s\n", key);

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

       /* DBSTRING() - formats non-'C' strings to C strings (null term) */

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

       dbstring("Santa Pedro", 13, tmpbuf);
       printf("Function: \tdbstring() \toutput: %s\n", tmpbuf);

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

       /* DBKEYTOA() - converts an extracted key to ASCII */

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

       tmpbuf[0] = 0;		/* Number of dec. places */
       tmpbuf[1] = 'N';	/* Key Type              */
       rc = dbkeytoa(key, tmpbuf);
       errorproc("dbkeytoa()", "key converted.", rc);

       /*-----------------------------------------------*/
       /* Perform record/index deletion and file access */
       /*-----------------------------------------------*/

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

       /* DBSIZE() - retrieve the size of the table */

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

       rc = dbsize(dbf, &db_size);
       errorproc("dbsize()", "size retrieved.", rc);
       printf("\t        No. of Records: \t%d\n", db_size);

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

       /* DBPUTR() - adds a record to the end of the table              */
       /*            You can also 'insert' a record using this function */

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

       rc = dbputr(dbf, db_size + 1L, text_table[7]);
       errorproc("dbputr()", "record placed.", rc);
       rc = dbakey(ndx,"Unknown Vessel    " , db_size + 1L);
       errorproc("dbakey()",  "key added.", rc);
       rc = dbxakey(dbx, db_size + 1L);
       errorproc("dbxakey()",  "key added.", rc);

       dbflush(dbf);                   /* Good Habit on shared files */
       dbiflsh(ndx);

dbxflsh(dbx);

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

       /* DBDELETE() - mark a record (number 8) for deletion */

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

       rc = dbdelete(dbf, 8L);
       errorproc("dbdelete()", "record 8 marked for deletion.", rc);

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

       /* DBRECALL() - recall a record marked for deletion (number 8) */

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

       rc = dbrecall(dbf, 8L);
       errorproc("dbrecall()", "record 8 recalled.", rc);

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

       /* DBRMVKEY() - physically remove a key.  As of v8.0, this function */

/* is not permitted on tables opened shareable. */ /*------------------------------------------------------------------*/

       /* rc = dbrmvkey(ndx, "Unknown Vessel    ", db_size+1L);            */
       /* errorproc("dbrmvkey()", "key physically removed.", rc);          */

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

       /* DBRMVR() - physically remove a data record. As of v8.0 this      */

/* function is not permitted on tables opened shareable. */ /*------------------------------------------------------------------*/

       /* rc = dbrmvr(dbf, db_size+1L);                                    */
       /* errorproc("dbrmvr()", "record 7 physically removed.", rc);       */

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

       /* DBUNLOCKF() - unlocks a table file */

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

       rc = dbunlockf(dbf);
       if ( rc == SUCCESS ) {
           printf("Function: \tdbunlockf() \tFile unlocked successfully\n");
       } else {
           printf("Unlock Failed. \tError: %d\n", rc);

}

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

       /* DBUNLOCKI() - unlocks an index file */

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

       rc = dbunlocki(ndx);
       if ( rc == SUCCESS ) {
           printf("Function: \tdbunlocki() \tFile unlocked successfully\n");
       } else {
           printf("Unlock Failed. \tError: %d\n", rc);

}

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

       /* DBLOCKR() - tests available record locking in a multiuser     */
       /*              environment.  Same as DBTLOCKR() in multi access */

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

       rc = dblockr(dbf, (long)7);
       if ( rc == SUCCESS ) {
           printf("Function: \tdblockr() \trecord locked successfully.\n");
       } else {
           printf("Lock Failed. \tError: %d\n", rc);

}

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

       /* DBUNLOCKR() - unlocks a table Record */

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

       rc = dbunlockr(dbf, (long)7);
       if ( rc == SUCCESS ) {
           printf("Function \tdbunlockr(): \trecord unlocked successfully\n");
       } else {
           printf("Unlock Failed. \tError: %d\n", rc);

}

       /*--------------------------------------*/
       /* Perform record/index close functions */
       /*--------------------------------------*/

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

       /* DBICLOSE() - close the active index */

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

       rc = dbiclose(ndx);
       errorproc("dbiclose()", "index closed.", rc);

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

       /* DBXCLOSE() - close the active tagged index */

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

       rc = dbxclose(dbx);
       errorproc("dbxclose()", "tagged index closed.", rc);

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

       /* DBCLOSE() - close the active table */

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

       rc = dbclose(dbf);
       errorproc("dbclose()", "table closed.", rc);

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

       /* DBMCLOSE() - close the active memo table */

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

       rc = dbmclose(dbt);
       errorproc("dbmclose()", "memo table closed.", rc);

       /*-------------------------------------------------*/
       /* Perform miscellaneous Recital/Library functions */
       /*-------------------------------------------------*/

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

       /* DBONERROR() - enables/disables (1/0) recovery from errors */

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

       dbonerror(0);                           /* Recovery disabled */
       printf("Function: \tdbonerror()  \terror checking disabled\n");

       printf("\nEnd of Recital C Library test program....\n");

       exit(0);

}

/*----------------------------------------------------------------------*/ /* This procedure handles the return codes from called RECITAL/library */ /* functions. Intended to eliminate cryptic 'if...else...' statements */ /* following library calls. */ /*----------------------------------------------------------------------*/

static void errorproc(func, str, rc) char *func; char *str; int rc; {

       if ( rc != SUCCESS )  {
           printf("\n  Error performing function %s -> %d\n", func, rc);
           exit(1);
       }
       printf("Function: \t%s, \t%s - Ok\n", func,str);
       return;

}