home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / database / db12 / db_seq.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-11-15  |  8.3 KB  |  292 lines
  1. /****************************************************************************/
  2. /*                                                                          */
  3. /*                                                                          */
  4. /*      db_seq.c      (c) 1987  Ken Harris                                  */
  5. /*                                                                          */
  6. /*                                                                          */
  7. /****************************************************************************/
  8. /*                                                                          */
  9. /*      This software is made available on an AS-IS basis. Unrestricted     */
  10. /*      use is granted provided that the copywrite notice remains intack.   */
  11. /*      The author makes no warranties expressed or implied.                */
  12. /*                                                                          */
  13. /****************************************************************************/
  14.  
  15. #include <stdio.h>
  16. #ifdef MSC
  17. #include <fcntl.h>
  18. #include <sys\types.h>
  19. #include <sys\stat.h>
  20. #endif
  21. #include "db.h"
  22.  
  23. /*
  24.  *      db_add_seq  -  Add a record to a sequential file
  25.  */
  26.  
  27. void db_add_seq(ds, user_data)
  28.  DATA_SET ds;
  29.  char *user_data;
  30. {
  31.         FILE_HDR  fh;
  32.         BUFFER   buf;
  33.         char   *rbuf;
  34.  
  35.         db_error = 0;
  36.  
  37.         fh  = (FILE_HDR) ds->ds_fhdr->buf_data;
  38.         buf = ds->ds_buf;
  39.  
  40.         db_get_next_avail(ds, buf);
  41.         if (db_error) return;
  42.  
  43.         db_add_blk = buf->buf_cur_blk;
  44.         db_add_rec = buf->buf_rec_inx;
  45.  
  46.         rbuf = buf->buf_data + (buf->buf_rec_inx - 1) * fh->fh_rec_size;
  47.  
  48.         memcpy(rbuf+fh->fh_ctl_size, user_data, fh->fh_data_size);
  49.  
  50.         fh->fh_rec_cnt++;
  51.  
  52.         db_put_blk(ds,ds->ds_fhdr);
  53.         db_put_blk(ds,buf);
  54. }
  55.  
  56. /*
  57.  *      db_read_first_seq  -  Read First Record in a Sequential File
  58.  */
  59.  
  60. void db_read_first_seq(ds, user_data)
  61.  DATA_SET ds;
  62.  char *user_data;
  63. {
  64.         FILE_HDR fh;
  65.         BUFFER  buf;
  66.         SEQ_REC seq;
  67.         ulong   blk;
  68.         ushort  rec;
  69.         char  *rbuf;
  70.  
  71.         db_error = 0;
  72.  
  73.         fh  = (FILE_HDR) ds->ds_fhdr->buf_data;
  74.         buf = ds->ds_buf;
  75.  
  76.         for (blk=1; blk <= fh->fh_last_block; blk++)
  77.         {       db_get_blk(ds, blk, buf);
  78.                 if (db_error) return;
  79.  
  80.                 rbuf = buf->buf_data;
  81.  
  82.                 for (rec=1; rec <= fh->fh_recs_per_blk; rec++)
  83.                 {       seq = (SEQ_REC) rbuf;
  84.  
  85.                         if (seq->seq_stat == DB_INUSE)
  86.                         {       buf->buf_rec_inx = rec;
  87.                                 memcpy(user_data, rbuf+fh->fh_ctl_size,
  88.                                                               fh->fh_data_size);
  89.                                 return;
  90.                         }
  91.                         rbuf += fh->fh_rec_size;
  92.                 }
  93.         }
  94.         db_error= DB_END_OF_FILE;
  95. }
  96.  
  97. /*
  98.  *      db_read_next_seq  -  Read Next Record in a Sequential File
  99.  */
  100.  
  101. void db_read_next_seq(ds, user_data)
  102.  DATA_SET ds;
  103.  char *user_data;
  104. {
  105.         FILE_HDR fh;
  106.         BUFFER  buf;
  107.         SEQ_REC seq;
  108.         ulong   blk;
  109.         ushort  rec;
  110.         char  *rbuf;
  111.  
  112.         db_error = 0;
  113.  
  114.         fh  = (FILE_HDR) ds->ds_fhdr->buf_data;
  115.         buf = ds->ds_buf;
  116.  
  117.         db_get_blk(ds, ds->ds_prev_blk, buf);
  118.         if (db_error) return;
  119.  
  120.         buf->buf_rec_inx = ds->ds_prev_rec + 1;
  121.  
  122.         rbuf = buf->buf_data + (buf->buf_rec_inx - 1) * fh->fh_rec_size;
  123.  
  124.         for (rec=buf->buf_rec_inx; rec <= fh->fh_recs_per_blk; rec++)
  125.         {       seq = (SEQ_REC) rbuf;
  126.  
  127.                 if (seq->seq_stat == DB_INUSE)
  128.                 {       buf->buf_rec_inx = rec;
  129.                         memcpy(user_data, rbuf+fh->fh_ctl_size, fh->fh_data_size);
  130.                         return;
  131.                 }
  132.                 rbuf += fh->fh_rec_size;
  133.         }
  134.  
  135.         for (blk=buf->buf_cur_blk+1; blk <= fh->fh_last_block; blk++)
  136.         {       db_get_blk(ds, blk, buf);
  137.                 if (db_error) return;
  138.  
  139.                 rbuf = buf->buf_data;
  140.  
  141.                 for (rec=1; rec <= fh->fh_recs_per_blk; rec++)
  142.                 {       seq = (SEQ_REC) rbuf;
  143.  
  144.                         if (seq->seq_stat == DB_INUSE)
  145.                         {       buf->buf_rec_inx = rec;
  146.                                 memcpy(user_data, rbuf+fh->fh_ctl_size,
  147.                                                               fh->fh_data_size);
  148.                                 return;
  149.                         }
  150.                         rbuf += fh->fh_rec_size;
  151.                 }
  152.         }
  153.         db_error= DB_END_OF_FILE;
  154. }
  155.  
  156. /*
  157.  *    db_read_last_seq  -  Read Last Record in a Sequential File
  158.  */
  159.  
  160. void db_read_last_seq(ds, user_data)
  161.  DATA_SET ds;
  162.  char *user_data;
  163. {
  164.         FILE_HDR fh;
  165.         BUFFER  buf;
  166.         SEQ_REC seq;
  167.         ulong   blk;
  168.         ushort  rec;
  169.         char  *rbuf;
  170.  
  171.         db_error = 0;
  172.  
  173.         fh  = (FILE_HDR) ds->ds_fhdr->buf_data;
  174.         buf = ds->ds_buf;
  175.  
  176.     for (blk=fh->fh_last_block; blk >= 1; blk--)
  177.         {       db_get_blk(ds, blk, buf);
  178.                 if (db_error) return;
  179.  
  180.         rbuf = buf->buf_data + (fh->fh_recs_per_blk - 1) * fh->fh_rec_size;
  181.  
  182.         for (rec=fh->fh_recs_per_blk; rec >= 1; rec--)
  183.                 {       seq = (SEQ_REC) rbuf;
  184.  
  185.                         if (seq->seq_stat == DB_INUSE)
  186.                         {       buf->buf_rec_inx = rec;
  187.                                 memcpy(user_data, rbuf+fh->fh_ctl_size,
  188.                                                               fh->fh_data_size);
  189.                                 return;
  190.                         }
  191.             rbuf -= fh->fh_rec_size;
  192.                 }
  193.         }
  194.         db_error= DB_END_OF_FILE;
  195. }
  196.  
  197. /*
  198.  *    db_read_prev_seq  -  Read Prev Record in a Sequential File
  199.  */
  200.  
  201. void db_read_prev_seq(ds, user_data)
  202.  DATA_SET ds;
  203.  char *user_data;
  204. {
  205.         FILE_HDR fh;
  206.         BUFFER  buf;
  207.         SEQ_REC seq;
  208.         ulong   blk;
  209.         ushort  rec;
  210.         char  *rbuf;
  211.  
  212.         db_error = 0;
  213.  
  214.         fh  = (FILE_HDR) ds->ds_fhdr->buf_data;
  215.         buf = ds->ds_buf;
  216.  
  217.         db_get_blk(ds, ds->ds_prev_blk, buf);
  218.         if (db_error) return;
  219.  
  220.     buf->buf_rec_inx = ds->ds_prev_rec - 1;
  221.  
  222.         rbuf = buf->buf_data + (buf->buf_rec_inx - 1) * fh->fh_rec_size;
  223.  
  224.     for (rec=buf->buf_rec_inx; rec >= 1; rec--)
  225.         {       seq = (SEQ_REC) rbuf;
  226.  
  227.                 if (seq->seq_stat == DB_INUSE)
  228.                 {       buf->buf_rec_inx = rec;
  229.                         memcpy(user_data, rbuf+fh->fh_ctl_size, fh->fh_data_size);
  230.                         return;
  231.                 }
  232.         rbuf -= fh->fh_rec_size;
  233.         }
  234.  
  235.     for (blk=buf->buf_cur_blk-1; blk >= 1; blk--)
  236.         {       db_get_blk(ds, blk, buf);
  237.                 if (db_error) return;
  238.  
  239.         rbuf = buf->buf_data + (fh->fh_recs_per_blk - 1) * fh->fh_rec_size;
  240.  
  241.         for (rec=fh->fh_recs_per_blk; rec >= 1; rec--)
  242.                 {       seq = (SEQ_REC) rbuf;
  243.  
  244.                         if (seq->seq_stat == DB_INUSE)
  245.                         {       buf->buf_rec_inx = rec;
  246.                                 memcpy(user_data, rbuf+fh->fh_ctl_size,
  247.                                                               fh->fh_data_size);
  248.                                 return;
  249.                         }
  250.             rbuf -= fh->fh_rec_size;
  251.                 }
  252.         }
  253.         db_error= DB_END_OF_FILE;
  254. }
  255.  
  256. /*
  257.  *      db_update_seq  -  Update Record in a Sequential File
  258.  */
  259.  
  260. void db_update_seq(ds, user_data)
  261.  DATA_SET ds;
  262.  char *user_data;
  263. {
  264.         FILE_HDR  fh;
  265.         BUFFER   buf;
  266.         SEQ_REC  seq;
  267.         char   *rbuf;
  268.  
  269.         db_error = 0;
  270.  
  271.         fh  = (FILE_HDR) ds->ds_fhdr->buf_data;
  272.         buf = ds->ds_buf;
  273.  
  274.         if (buf->buf_cur_blk == 0 || buf->buf_rec_inx == 0)
  275.         {       db_error = DB_NO_CURRENT_REC;
  276.                 return;
  277.         }
  278.  
  279.         rbuf = buf->buf_data + (buf->buf_rec_inx - 1) * fh->fh_rec_size;
  280.  
  281.         seq = (SEQ_REC) rbuf;
  282.  
  283.         if (seq->seq_stat != DB_INUSE)
  284.         {       db_error = DB_DELETED_REC;
  285.                 return;
  286.         }
  287.  
  288.         memcpy(rbuf+fh->fh_ctl_size, user_data, fh->fh_data_size);
  289.  
  290.         db_put_blk(ds, buf);
  291. }                           
  292.