home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c160 / 1.ddi / SOURCE / D4USE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-19  |  4.6 KB  |  178 lines
  1.  
  2. /* d4use.c (c)Copyright Sequiter Software Inc., 1987-1990.  All rights reserved. */
  3.  
  4. #include "d4all.h"
  5. #include "u4error.h"
  6. #include "p4misc.h"
  7.  
  8. #ifndef UNIX
  9. #include <io.h>
  10. #endif
  11.  
  12. #include <string.h>
  13.  
  14. extern BASE      *v4base ;
  15. extern int       v4last_base ;
  16. extern int       v4cur_base  ;
  17. extern int       v4first, v4lock_wait ;
  18.  
  19. #define  LOCK_LEN   1L
  20.  
  21. static  int  d4use_with_flag( char *, int ) ;
  22.  
  23. d4use( char *dbf_name )
  24. {
  25.    return( d4use_with_flag( dbf_name, 0)) ;
  26. }
  27.  
  28. d4use_excl( char *dbf_name )
  29. {
  30.    int  rc ;
  31.  
  32.    if ( (rc =  d4use_with_flag( dbf_name, 4)) < 0)
  33.       return rc ;
  34.  
  35.    if ( d4lock(-1L,1) < 0 )  return -1 ;
  36.  
  37.    return( rc ) ;
  38. }
  39.  
  40. static  int  d4use_with_flag( char *dbf_name, int excl_flag )
  41. {
  42.    int      i, rc, header_len ;
  43.    unsigned count, buffer_len ;
  44.    unsigned short  us_rc ;
  45.    char    *buffer ;
  46.    char     name[90] ;
  47.  
  48.    BASE    *base_ptr ;
  49.    FIELD   *f_ptr    ;
  50.  
  51.    if ( v4first )  if ( d4init() < 0 )  return -1 ;
  52.  
  53.    u4name_full( name, dbf_name, ".DBF" ) ;
  54.    if ( (rc=d4ref(name)) >= 0 )  
  55.    {
  56.       d4select(rc) ;
  57.       return( rc ) ;
  58.    }
  59.  
  60.    v4last_base=  h4get( (char **) &v4base, v4last_base) ;
  61.    if ( v4last_base < 0 )  return -1 ;
  62.  
  63.    base_ptr =  v4base+ v4last_base ;
  64.  
  65.    strncpy( base_ptr->name, name, 64) ;
  66.    base_ptr->name[63] = '\000' ;
  67.    u4upper( base_ptr->name )  ;
  68.  
  69.    base_ptr->file_hand =  u4open( name, excl_flag ) ;
  70.  
  71.    if ( base_ptr->file_hand < 0)
  72.    {
  73.       v4last_base =  h4free ( (char **) &v4base, v4last_base ) ;
  74.       return   ( -1 ) ;
  75.    }
  76.  
  77.    lseek( base_ptr->file_hand, 0L, 0) ;
  78.    header_len =  (int) ((char *)(base_ptr+1) - &base_ptr->version) ;
  79.    rc  =  read( base_ptr->file_hand, (char *) &base_ptr->version, header_len) ;
  80.  
  81.    if ( rc != header_len || base_ptr->header_len > 0x7FFF )
  82.    {
  83.       close( base_ptr->file_hand );
  84.       v4last_base =  h4free ( (char **) &v4base, v4last_base ) ;
  85.       u4error( E_BAD_DBF, name, (char *) 0 ) ;
  86.       return( -1 ) ;
  87.    }
  88.  
  89.    buffer =  h4alloc( base_ptr->header_len ) ;
  90.    if ( buffer == (char *) 0 )  return( -1 ) ;
  91.  
  92.    lseek( base_ptr->file_hand, 0L, 0) ;
  93.    us_rc =  (unsigned short) read( base_ptr->file_hand, buffer, base_ptr->header_len ) ;
  94.  
  95.    if ( us_rc != base_ptr->header_len )
  96.    {
  97.       h4free_memory( buffer ) ;
  98.       close( base_ptr->file_hand ) ;
  99.       v4last_base =  h4free ( (char **) &v4base, v4last_base ) ;
  100.       u4error( E_BAD_DBF, name, (char *) 0 ) ;
  101.       return( -1 ) ;
  102.    }
  103.  
  104.    /* count the number of fields */
  105.    for (count=32; count <= base_ptr->header_len; count+= 32)
  106.       if ( buffer[count] ==  0xD )  break ;
  107.    base_ptr->num_fields =  (int) (count/32 - 1) ;
  108.  
  109.    f_ptr =  (FIELD *)  h4alloc( (int) sizeof(FIELD) * base_ptr->num_fields ) ;
  110.    if ( f_ptr == (FIELD *) 0 )  return( -1 ) ;
  111.  
  112.    base_ptr->fields =  f_ptr ;
  113.  
  114.    buffer_len       = 1 ;
  115.  
  116.    for (i=0; i< base_ptr->num_fields; i++)
  117.    {
  118.       memcpy( f_ptr->name,  buffer+ (i+1)*32,  11) ;
  119.  
  120.       f_ptr->type    =  buffer[ (i+1)*32 + 11 ] ;
  121.       if ( f_ptr->type == 'C' )
  122.       {
  123.          memcpy((char *) &f_ptr->width, (char *) buffer+ (i+1)*32+ 16, 2) ;
  124.          f_ptr->decimals=  0 ;
  125.       }
  126.       else
  127.       {
  128.          f_ptr->width   =  (unsigned char) buffer[ (i+1)*32 + 16 ] ;
  129.          f_ptr->decimals=  (unsigned char) buffer[ (i+1)*32 + 17 ] ;
  130.       }
  131.  
  132.       f_ptr->offset  =  buffer_len   ;
  133.       buffer_len    +=  f_ptr->width ;
  134.  
  135.       if ( buffer_len > 0x7FFF )
  136.       {
  137.      close( base_ptr->file_hand ) ;
  138.      h4free_memory( buffer ) ;
  139.      h4free_memory( f_ptr ) ;
  140.      v4last_base =  h4free ( (char **) &v4base, v4last_base ) ;
  141.      close( base_ptr->file_hand ) ;
  142.      u4error( E_REC_LENGTH, (char *) 0 ) ;
  143.      return -1 ;
  144.       }
  145.  
  146.       f_ptr ++ ;
  147.    }
  148.  
  149.    h4free_memory( buffer ) ;
  150.  
  151.    base_ptr->buffer_len    =  buffer_len ;
  152.    base_ptr->index_ref     =  -1 ;
  153.    base_ptr->current_index =  -1 ;
  154.    base_ptr->memo_file     =  -1 ;
  155.    base_ptr->relate_ref    =  -1 ;
  156.    base_ptr->filter_ref    =  -1 ;
  157.    base_ptr->buf_may_lend  =   1 ;
  158.    base_ptr->change_list   =  -1 ;
  159.    base_ptr->file_lock     =  -1 ;
  160.    base_ptr->rec_num       =   1L ;
  161.    base_ptr->eof           =   1 ;
  162.  
  163.    /* Add an extra character for a NULL to end each buffer */
  164.    base_ptr->old_buf    =  h4alloc( buffer_len * 2+ 1) ;
  165.    if ( base_ptr->old_buf == (char *) 0 )  return -1 ;
  166.  
  167.    memset( base_ptr->old_buf, (int) ' ', (size_t) (buffer_len *2 + 1) ) ;
  168.    base_ptr->buffer     =  base_ptr->old_buf + buffer_len ;
  169.    base_ptr->buffer[buffer_len]  = '\000' ;
  170.  
  171.    v4cur_base =  v4last_base ;
  172.    base_ptr->num_recs =  -1L ;
  173.  
  174.    return( v4last_base );
  175.  
  176. }  /* end of d4use() */
  177.  
  178.