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

C/C++ Source or Header | 1989-10-13 | 4.9 KB | 204 lines

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

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

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

#include <string.h>


extern  BASE  *v4base ;
extern  int    v4cur_base ;


static char  name_buf[sizeof(v4base->name)+2] ;

char *m4name( base_ref )
int  base_ref ;
{
   u4name_part( name_buf, v4base[base_ref].name, 1,0 ) ;
   strupr( name_buf ) ;
   u4name_full( name_buf, name_buf, ".DBT" ) ;

   return  name_buf ;
}

m4open( base_ref )
int  base_ref ;
{
   int   hand, rc ;
   char *file_name ;
   MEMO_HEADER   hdr ;

   if ( v4base[base_ref].memo_file >= 0 )
      return( v4base[base_ref].memo_file ) ;

   file_name  =  m4name(base_ref) ;
   if ( (hand =  u4open( file_name, 0 )) < 0 )  return -1 ;
   lseek( hand, 0L, 0 ) ;
   rc =   read( hand, (char *) &hdr, (unsigned int) sizeof( MEMO_HEADER ) ) ;
   if ( rc != (int) sizeof(MEMO_HEADER) )
   {
      u4error( E_READ, "MEMO File: ", file_name, (char *) 0 ) ;
      close( hand ) ;
      return -1 ;
   }

   u4name_part( file_name, file_name, 0,0 ) ;
   strupr( file_name ) ;
   if ( strncmp( file_name, hdr.file_name, 8 )  != 0 )
   {
      close( hand ) ;
      u4error( E_MEMO_NAME, "File Name: ", file_name, (char *) 0 ) ;
      return -1 ;
   }

   v4base[base_ref].memo_file =  hand ;
   v4base[base_ref].memo_size =  hdr.block_size ;

   return  hand ;
}

m4exist( field_ref )
long  field_ref ;
{
   if (  f4value(field_ref) > 0.0 )
      return 1 ;
   else
      return 0 ;
}


m4read( field_ref, rec_num, str, str_len)
long  field_ref, rec_num ;
char *str ;
int   str_len ;
{
   BASE  *base_ptr ;
   long   memo_num, memo_pos ;
   int    old_base, new_base, rc, i_read, len_data, len_read ;
   MEMO_BLOCK  memo_block ;

   old_base =  v4cur_base ;
   new_base =  (int) (field_ref >> 16) ;

   base_ptr =  v4base + new_base ;

   d4select( new_base ) ;
   if ( rec_num > d4reccount() )
   {
      d4go( 0L ) ;
      rc = 0 ;
   }
   else
      rc =  d4go( rec_num) ;

   d4select( old_base ) ;

   if ( rc < 0  ||  str_len < 0)  return -1 ;
   if ( rc == 1 )
   {
      *str =  '\0' ;
      return 0 ;
   }

   memo_num =  c4atol( f4ptr(field_ref),  f4width(field_ref) ) ;
   if ( memo_num == 0L )  return 0 ;

   if ( m4open( new_base ) < 0 )    return -1 ;

   memo_pos =  base_ptr->memo_size * memo_num ;

   if ( u4lock(base_ptr->memo_file, memo_pos, (long) str_len, 1) < 0 )
      return -1 ;

   lseek( base_ptr->memo_file, memo_pos, 0 ) ;
   if ( str_len < sizeof(memo_block) )
   {
      len_read =  read( base_ptr->memo_file, (char *) &memo_block, sizeof(memo_block)) ;
      memcpy( str, (char *) &memo_block, str_len ) ;
   }
   else
   {
      len_read =  read( base_ptr->memo_file, str, str_len ) ;
      memcpy( (char *) &memo_block, str, sizeof(memo_block) ) ;
   }

   if ( len_read < 0 )
   {
      if ( u4unlock( base_ptr->memo_file, memo_pos, (long) str_len ) < 0 )
     return -1 ;

      u4error( E_READ, m4name(new_base), (char *) 0 ) ;
      return -1 ;
   }

   if ( ((MEMO_BLOCK *) str)->minus_one != -1  || len_read < sizeof(MEMO_BLOCK) )
   {
      /* dBASE III Style Entry */
      if ( u4unlock( base_ptr->memo_file, memo_pos, (long) str_len ) < 0 )
     return -1 ;

      if ( len_read == str_len )  len_read-- ;

      for ( i_read= 0; i_read <= len_read; i_read++ )
     if ( str[i_read] == 0x1A || i_read == len_read )
     {
        str[i_read] =  '\0' ;
        return  i_read ;
     }
   }
   else
   {
      /* dBASE IV Style Header */
      if ( memo_block.num_chars > 0x7FFF )
      {
     if ( u4unlock( base_ptr->memo_file, memo_pos, (long) str_len ) < 0 )
        return -1 ;
     u4error( E_MEMO_SIZE, m4name(new_base), (char *) 0 ) ;
     return -1 ;
      }
      len_data =  (int) memo_block.num_chars - memo_block.start_pos ;
      len_read-=  memo_block.start_pos ;

      memmove( str, str+memo_block.start_pos, str_len- memo_block.start_pos ) ;

      if ( len_read >= len_data )
      {
     if ( u4unlock( base_ptr->memo_file, memo_pos, (long) str_len ) < 0 )
        return -1 ;
     str[len_data] =  '\0' ;

         return( len_data ) ;
      }

      /* Read the Extra Data into the Memory Buffer */
      lseek( base_ptr->memo_file, memo_pos+len_read+memo_block.start_pos, 0 ) ;
      rc =  read( base_ptr->memo_file, str+len_read, str_len-len_read-1 ) ;

      if ( u4unlock( base_ptr->memo_file, memo_pos, (long) str_len ) < 0 )
     return -1 ;

      if ( rc < 0 )
      {
     u4error( E_READ, m4name(new_base), (char *) 0 ) ;
     return -1 ;
      }

      len_read += rc ;
      if ( len_read > len_data )
     len_read =  len_data ;

      str[len_read] =  '\0' ;

      return( len_read ) ;
   }

   return 0 ;  /* This Line is never executed; Present to stop warning */
}