home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c160 / 1.ddi / SOURCE / D4WRITE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-19  |  3.9 KB  |  146 lines
  1.  
  2. /*  (c)Copyright Sequiter Software Inc., 1987-1990.  All rights reserved.
  3.  
  4.     d4write.c
  5. */
  6.  
  7. #include "p4misc.h"
  8. #include "d4all.h"
  9. #include "u4error.h"
  10.  
  11. #include <string.h>
  12. #ifndef UNIX
  13. #include <io.h>
  14. #endif
  15.  
  16. extern BASE  *v4base ;
  17. extern INDEX *v4index ;
  18.  
  19. extern int    v4cur_base ;
  20. extern int    v4unique_error ;
  21. extern int    v4lock_wait ;
  22.  
  23. int d4write( long rec_num )
  24. {
  25.    int    index_on, rc ;
  26.    char  *key_ptr, conv_buffer[34], *buffer_ptr, key_data[MAX_KEY_SIZE+8] ;
  27.    BASE  *base_ptr  ;
  28.    INDEX *index_ptr ;
  29.    char H_PTR  h_ptr ;
  30.  
  31.    if ( rec_num <= 0L )  return ( d4append() ) ;
  32.  
  33.    if ( v4cur_base < 0 ) 
  34.    {
  35.       u4error( E_D_MISSING, (char *) 0 ) ; 
  36.       return( -1 ) ;
  37.    }
  38.  
  39.    base_ptr  =  v4base +  v4cur_base ;
  40.    base_ptr->buffer_changed =  0 ;
  41.  
  42.    /* Lock the record if necessary. */
  43.    if ( ! d4locked(rec_num) )
  44.    {
  45.       if ( i4unlock(-1) < 0)  return -1 ;
  46.       if ( (rc = d4lock( rec_num, v4lock_wait)) < 0 )  return rc ;
  47.    }
  48.  
  49.    #ifndef SMALL
  50.    if ( base_ptr->index_ref >= 0 )
  51.    {
  52.       buffer_ptr =  base_ptr->buffer ;
  53.       base_ptr->buffer =  base_ptr->old_buf ;
  54.       rc = d4read(rec_num) ;
  55.       base_ptr->buffer =  buffer_ptr ;
  56.       if ( rc < 0 )  return rc ;
  57.       if ( memcmp( base_ptr->buffer, base_ptr->old_buf, (size_t) base_ptr->buffer_len) == 0)
  58.          return 0 ;
  59.    }
  60.  
  61.    for ( index_on = base_ptr->index_ref; index_on >= 0; index_on = index_ptr->prev)
  62.    {
  63.       index_ptr =  v4index+ index_on ;
  64.  
  65.       key_ptr =  i4eval(index_on) ;
  66.       if ( key_ptr == (char *) 0)  return( -1 ) ;
  67.  
  68.       memcpy( key_data, key_ptr, (size_t) index_ptr->key_len ) ;
  69.  
  70.       base_ptr->buffer =  base_ptr->old_buf ;
  71.       key_ptr =  i4eval(index_on) ;
  72.       base_ptr->buffer =  buffer_ptr ;
  73.       if ( key_ptr == (char *) 0)  return( -1 ) ;
  74.  
  75.       if ( memcmp( key_data, key_ptr, (size_t) index_ptr->key_len ) != 0  ||
  76.            index_ptr->filter != (I4FILTER *) 0 )
  77.       {
  78.          /* Remove Old and Add New */
  79.          if ( (rc = i4remove( index_on, key_ptr, rec_num)) < 0)
  80.             return  rc ;
  81.          rc = i4add( index_on, key_data, rec_num ) ;
  82.      if ( rc != 0 )
  83.      {
  84.             if ( rc == 3 )  continue ;
  85.             if ( rc == 2 )
  86.             {
  87.            u4error( E_I_DATE, i4name(index_on), (char *) 0 ) ;
  88.                return -1 ;
  89.         }
  90.         if ( rc < 0 )  return -1 ;
  91.  
  92.         if ( v4unique_error == 0 )  continue ;
  93.  
  94.             u4error( E_UNIQUE, i4name(index_on), (char *) 0 ) ;
  95.  
  96.             /* Unique Key Error.  Undo the Write so far. */
  97.             for ( index_on = index_ptr->next; index_on >= 0; index_on = index_ptr->next)
  98.             {
  99.            index_ptr =  v4index + index_on ;
  100.  
  101.                key_ptr =  i4eval(index_on) ;
  102.                if ( key_ptr == (char *) 0)  return( -1 ) ;
  103.  
  104.            if ( i4remove( index_on, key_ptr, rec_num) < 0 )
  105.               return -1 ;
  106.  
  107.                base_ptr->buffer =  base_ptr->old_buf ;
  108.                key_ptr =  i4eval(index_on) ;
  109.                base_ptr->buffer =  buffer_ptr ;
  110.                if ( key_ptr == (char *) 0)  return( -1 ) ;
  111.  
  112.                if ( i4add( index_on, key_data, rec_num ) < 0 )  return -1 ;
  113.             }
  114.         return -3 ;
  115.      }
  116.       }
  117.    }
  118.    #endif
  119.  
  120.    base_ptr->rec_num =  rec_num ;
  121.  
  122.    #ifndef SMALL
  123.    if ( base_ptr->buf_status > 1 )
  124.    {
  125.       if ((h_ptr = d4buf_write_pos(base_ptr, rec_num)) == (char H_PTR) 0)
  126.      return -1 ;
  127.       u4huge_cpy( h_ptr, (void H_PTR) base_ptr->buffer, (long) base_ptr->buffer_len) ;
  128.  
  129.       return 0 ;
  130.    }
  131.    #endif
  132.  
  133.    /* Write the Record. */
  134.    if ( d4lseek(rec_num) < 0 )  return -1 ;
  135.    if ( write( base_ptr->file_hand, base_ptr->buffer, base_ptr->buffer_len)
  136.         !=  base_ptr->buffer_len )
  137.    {
  138.       c4ltoa( rec_num, conv_buffer, 10 ) ;
  139.       conv_buffer[10] = '\000' ;
  140.       u4error( E_WRITE, base_ptr->name, "Record Number:", conv_buffer, (char *) 0 ) ;
  141.       return( -1) ;
  142.    }
  143.  
  144.    return( 0) ;
  145. }
  146.