Piper's Pit BBS/FTP: ibm 0010 - 0019/ibm0010-0019/ibm0010.tar/ibm0010/CODE4-1.ZIP/SOURCE.ZIP/D4USE.C

C/C++ Source or Header | 1989-08-31 | 4.8 KB | 181 lines

/*  d4use.c   (c)Copyright Sequiter Software Inc., 1987, 1988, 1989.  All rights reserved.
*/

#include "d4base.h"
#include "u4error.h"

#include <string.h>

#ifndef UNIX
   #include <io.h>
#endif

extern BASE      *v4base ;
extern int       v4last_base ;
extern int       v4cur_base  ;
extern int       v4first ;

#define  LOCK_LEN   1L


d4use( dbf_name )
char *dbf_name ;
{
   int      i, rc, header_len ;
   unsigned count, buffer_len ;
   char    *buffer ;
   char     name[90] ;

   BASE    *base_ptr ;
   FIELD   *f_ptr    ;

   if ( v4first )  if ( d4init() < 0 )  return -1 ;

   u4name_full( name, dbf_name, ".DBF" ) ;
   if ( (rc=d4ref(name)) >= 0 )  return( rc ) ;

   v4last_base=  h4get( (char **) &v4base, v4last_base) ;
   if ( v4last_base < 0 )  return -1 ;

   base_ptr =  v4base+ v4last_base ;

   strncpy( base_ptr->name, name, 64) ;
   base_ptr->name[63] = '\0' ;
   strupr( base_ptr->name )  ;

   base_ptr->dos_file =  u4open( name, 0 ) ;

   if ( base_ptr->dos_file < 0)
   {
      v4last_base =  h4free ( (char **) &v4base, v4last_base ) ;
      return   ( -1 ) ;
   }

   if ( u4lock( base_ptr->dos_file, LOCK_START, LOCK_LEN, 1) != 0 )  return -1 ;

   lseek( base_ptr->dos_file, 0L, 0) ;
   header_len =  (int) ( (char *)(base_ptr+1) - &base_ptr->version) ;
   rc =  read( base_ptr->dos_file, &base_ptr->version, header_len) ;

   if ( rc != header_len  ||  base_ptr->header_len > 0x7FFF )
   {
      u4unlock( base_ptr->dos_file, LOCK_START, LOCK_LEN ) ;
      close( base_ptr->dos_file );
      v4last_base =  h4free ( (char **) &v4base, v4last_base ) ;
      u4error( E_BAD_DBF, name, (char *) 0 ) ;
      return( -1 ) ;
   }

   buffer =  h4alloc( base_ptr->header_len ) ;
   if ( buffer == (char *) 0 )  return( -1 ) ;

   lseek( base_ptr->dos_file, 0L, 0) ;
   rc =  read( base_ptr->dos_file, buffer, base_ptr->header_len ) ;

   if ( rc != base_ptr->header_len )
   {
      u4unlock( base_ptr->dos_file, LOCK_START, LOCK_LEN ) ;
      h4free_memory( buffer ) ;
      close( base_ptr->dos_file ) ;
      v4last_base =  h4free ( (char **) &v4base, v4last_base ) ;
      u4error( E_BAD_DBF, name, (char *) 0 ) ;
      return( -1 ) ;
   }

   /* count the number of fields */
   for (count=32; count <= base_ptr->header_len; count+= 32)
      if ( buffer[count] ==  0xD )  break ;
   base_ptr->num_fields =  (int) (count/32 - 1) ;

   f_ptr =  (FIELD *)  h4alloc( (int) sizeof(FIELD) * base_ptr->num_fields ) ;
   if ( f_ptr == (FIELD *) 0 )  return( -1 ) ;

   base_ptr->fields =  f_ptr ;

   buffer_len       = 1 ;

   for (i=0; i< base_ptr->num_fields; i++)
   {
      memcpy( f_ptr->name,  buffer+ (i+1)*32,  11) ;

      f_ptr->type    =  buffer[ (i+1)*32 + 11 ] ;
      if ( f_ptr->type == 'C' )
      {
         memcpy((char *) &f_ptr->width, (char *) buffer+ (i+1)*32+ 16, 2) ;
         f_ptr->decimals=  0 ;
      }
      else
      {
         f_ptr->width   =  (unsigned char) buffer[ (i+1)*32 + 16 ] ;
         f_ptr->decimals=  (unsigned char) buffer[ (i+1)*32 + 17 ] ;
      }

      f_ptr->offset  =  buffer_len   ;
      buffer_len    +=  f_ptr->width ;

      if ( buffer_len > 0x7FFF )
      {
     u4unlock( base_ptr->dos_file, LOCK_START, LOCK_LEN ) ;
     close( base_ptr->dos_file ) ;
     h4free_memory( buffer ) ;
     h4free_memory( f_ptr ) ;
     v4last_base =  h4free ( (char **) &v4base, v4last_base ) ;
     close( base_ptr->dos_file ) ;
     u4error( E_REC_LENGTH, (char *) 0 ) ;
     return -1 ;
      }

      f_ptr ++ ;
   }

   h4free_memory( buffer ) ;

   base_ptr->buffer_len    =  buffer_len ;
   base_ptr->index_ref     =  -1 ;
   base_ptr->current_index =  -1 ;
   base_ptr->memo_file     =  -1 ;
   base_ptr->relate_ref    =  -1 ;
   base_ptr->filter_ref    =  -1 ;

   /* Add an extra character for a NULL to end each buffer */
   base_ptr->old_buf    =  h4alloc( buffer_len * 2+ 1) ;
   if ( base_ptr->old_buf == (char *) 0 )  return -1 ;

   memset( base_ptr->old_buf, (int) ' ', (size_t) (buffer_len *2 + 1) ) ;
   base_ptr->buffer     =  base_ptr->old_buf + buffer_len ;
   base_ptr->buffer[buffer_len]  = '\0' ;

   if ( base_ptr->num_recs !=
      (filelength(base_ptr->dos_file) - base_ptr->header_len)/
       base_ptr->buffer_len )
   {
      rc =  chsize( base_ptr->dos_file, base_ptr->num_recs*base_ptr->buffer_len
                  +base_ptr->header_len+1) ;
      if ( rc != 0 )
      {
     u4unlock( base_ptr->dos_file, LOCK_START, LOCK_LEN ) ;
     u4error( E_CHANGE_SIZE, base_ptr->name, (char *) 0 ) ;
     return -1 ;
      }
   }

   v4cur_base =  v4last_base ;
   u4unlock( base_ptr->dos_file, LOCK_START, LOCK_LEN ) ;

   return( v4last_base );

}  /* end of d4use() */


d4use_excl( dbf_name )
char  *dbf_name ;
{
   int  rc ;

   rc =  d4use( dbf_name ) ;
   if ( d4lock(-1L,1) < 0 )  return -1 ;

   return( rc ) ;
}