home *** CD-ROM | disk | FTP | other *** search
/ Frostbyte's 1980s DOS Shareware Collection / floppyshareware.zip / floppyshareware / BOUT / SNIP9-91.ZIP / STRUCFIL.C < prev    next >
C/C++ Source or Header  |  1991-09-05  |  5KB  |  184 lines
  1. /*******************************************************************
  2.  * Generic structure <> disk file manipulations. These functions
  3.  * form a basic template for reading and writing structures to a 
  4.  * sequential file. This template is probably most useful for files
  5.  * with 500 or less records and eliminates the need for a more 
  6.  * elaborate file handler such as C-Tree, DB-Vista, Mix etc.
  7.  * Routines to put data in the struct is out of scope here.
  8.  * Written by Lynn Nash 8/28/91 and donated to the public domain.
  9.  */
  10. #include <io.h>
  11. #include <string.h>
  12. #include <stdlib.h>
  13. #include <stdio.h>
  14.  
  15. #ifndef ERROR
  16. #define ERROR -1
  17. #define OK     0
  18. #endif
  19.  
  20. #ifndef TRUE
  21. #define TRUE 1
  22. #define FALSE !TRUE
  23. #endif
  24.  
  25. /* make sure the record structure is byte aligned */
  26. #pragma pack(1) 
  27.  
  28. static struct blackbook {
  29.     int delete_flag;        /* 0 = active  -1 = deleted */
  30.     int recordnum;          /* a sequential number in the file */
  31.    /* The data fields in asciiz.  */
  32.     char firstname[11];         
  33.     char lastname[16];         
  34.     char addr[26];          
  35.     char city[16];
  36.     char state[3];
  37.     char zip[10];
  38.     char phone[11];
  39. } rec, oldrec;             /* 97 byte record  * 2 */
  40.  
  41. #pragma pack()
  42.  
  43. /*-------------------- general globals ---------------------*/
  44.  
  45. static long cur_rec = 0;      /* the current record number */
  46. static FILE *fsptr = NULL;    /* fixed record data file pointer */
  47.  
  48. /* if file exists open in read/write mode else create file */
  49.  
  50. FILE * open_file(char *filename)
  51. {
  52.       if (access(filename, 0) == 0)
  53.             fsptr = fopen(filename, "rb+"); 
  54.       else  fsptr = fopen(filename, "wb+"); 
  55.       return fsptr;                       /* return the file pointer */
  56. } 
  57.  
  58. /* add new records to the data file */
  59.  
  60. int datadd(void)
  61. {
  62.       if (fsptr)
  63.       {
  64.             if (fseek(fsptr, 0L, SEEK_END) != 0)
  65.                   return ERROR;  /* seek failure */
  66.             rec.delete_flag = 0; /* active record tag */
  67.             rec.recordnum = (int) (ftell(fsptr) / 
  68.                   (long) sizeof(struct blackbook));
  69.             if (fwrite(&rec, sizeof(struct blackbook), 1, fsptr) != 1)
  70.             {
  71.                   return ERROR; /* write error */
  72.             }
  73.             else
  74.             {
  75.                   /* put your clean up code here */ 
  76.                   return OK;
  77.             }
  78.       }
  79.       return ERROR;
  80. }
  81.  
  82. /* tag the last record read in the file as deleted */
  83.  
  84. int data_delete(void)
  85. {
  86.       if (fsptr)
  87.       {
  88.             if (fseek(fsptr, (long) sizeof(struct blackbook) * -1L,
  89.                   SEEK_CUR) != 0)
  90.             {
  91.                   return ERROR;
  92.             }
  93.             rec.delete_flag = -1;   /* tag the record as deleted */
  94.             if (fwrite(&rec, sizeof(struct blackbook), 1, fsptr) != 1)
  95.                   return ERROR;
  96.             else  return OK;
  97.       }
  98.       return ERROR;
  99. }
  100.  
  101. /* read a random structure. If successful the global cur_rec will 
  102.  * contain the number of the last record read & it can be compared
  103.  * to the number in the struct as a double check (belt & suspenders)
  104.  */
  105.  
  106. int data_read(long recnum)
  107. {
  108.       if (fseek(fsptr, (long) sizeof(struct blackbook) * recnum,
  109.             SEEK_SET) != 0)
  110.       {
  111.             return ERROR;
  112.       }
  113.       cur_rec = recnum; /* keep tabs on record pointer in global */  
  114.  
  115.       /* now read the record into save struct*/
  116.  
  117.       if (fread(&oldrec, sizeof(struct blackbook), 1, fsptr) != 1)
  118.       {
  119.             return ERROR;
  120.       }
  121.       else                          /* copy save struct to edit struct */
  122.       {
  123.             memcpy(&rec, &oldrec, sizeof(struct blackbook));
  124.             return OK;
  125.       }
  126. }
  127.  
  128. /* rewrite the last read record back to disk */
  129.  
  130. int data_update(void)
  131. {
  132.       if (memcmp(&rec, &oldrec, sizeof(struct blackbook)) == 0)
  133.             return TRUE;  /* no update needed */
  134.  
  135.       /* back up one record before writing */
  136.  
  137.       if (fseek(fsptr, (long) sizeof(struct blackbook) * -1L, 
  138.             SEEK_CUR) != 0)
  139.       {
  140.             return ERROR; /* seek error */ 
  141.       }
  142.  
  143.       /* now write the record */
  144.  
  145.       if (fwrite(&rec, sizeof(struct blackbook), 1, fsptr) != 1)
  146.             return ERROR; /* write error */
  147.       return OK;
  148. }
  149.  
  150. /* get the next valid record in the file */
  151.  
  152. int read_forward(void)
  153. {
  154.       do
  155.       {
  156.             cur_rec++; /* upcount the record number */
  157.             if (data_read(cur_rec) != 0)
  158.             {
  159.                   cur_rec--; /* decrement the record number */
  160.                   return ERROR;
  161.             }
  162.       } while (oldrec.delete_flag != 0); /* record read was deleted */
  163.       return OK;
  164. }
  165.  
  166. /* get the previous valid record in the file */
  167.  
  168. int read_backward(void)
  169. {
  170.       do
  171.       {
  172.             cur_rec--;  /* decrement the record number */
  173.             if (cur_rec >= 0)
  174.             {
  175.                   if ( data_read(cur_rec) != 0 )
  176.                   {
  177.                         cur_rec++; /* increment the record number */
  178.                         return ERROR;
  179.                   }
  180.             }  
  181.       } while (oldrec.delete_flag != 0); /* record read was deleted */
  182.       return OK;
  183. }
  184.