home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c160 / 1.ddi / SOURCE / D4CREATE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-19  |  5.4 KB  |  225 lines
  1.  
  2. /*  d4create.c   (C)Copyright  Sequiter Software Inc., 1987-1990.  All rights reserved.
  3.  
  4.     Creates a database file.
  5. */
  6.  
  7. #include "d4all.h"
  8. #include "u4error.h"
  9. #include "m4.h"
  10. #include "p4misc.h"
  11.  
  12. #include <time.h>
  13. #include <string.h>
  14. #ifndef UNIX
  15. #include <io.h>
  16. #endif
  17.  
  18. extern   int     v4first ;
  19.  
  20. typedef  struct  base_header_st
  21. {
  22.    char version ;
  23.    char yy ;
  24.    char mm ;
  25.    char dd ;
  26.    long num_recs ;
  27.    unsigned short  header_len ;
  28.    unsigned short  record_width ;
  29.    char filler[20] ;
  30. }  BASE_HEADER ;
  31.  
  32. typedef  struct base_field_st
  33. {
  34.    char       name[11] ;
  35.    char       type ;
  36.    char       filler[4] ;
  37.    unsigned char  width ;
  38.    unsigned char  decimals ;
  39.    char       filler2[14] ;
  40. }  BASE_FIELD ;
  41.  
  42.  
  43. FIELD *d4fields()
  44. {
  45.    return( d4ptr()->fields ) ;
  46. }
  47.  
  48. d4create( char *name, int num, FIELD *fields, int safety )
  49. {
  50.    BASE_HEADER *header ;
  51.    BASE_FIELD  *b_field ;
  52.    char     full_name[90], on_char ;
  53.    int      rc, i, j, file_hand, rec_width, is_memo ;
  54.    long     time_val, long_header_len ;
  55.    struct tm   *tm_ptr ;
  56.  
  57.    if ( v4first )  if ( d4init() < 0 )  return -1 ;
  58.  
  59.    long_header_len =  (long)num * 32  + 34 ;
  60.    if ( long_header_len > 0x7fff ) 
  61.    {
  62.       u4error( E_CREATE, "Too Many Fields", name, (char *) 0 ) ;
  63.       return -1 ;
  64.    }
  65.  
  66.    u4name_full( full_name, name, ".DBF" ) ;
  67.    rc =  d4ref( full_name ) ;
  68.    if ( rc >= 0 )
  69.    {
  70.       if ( safety )
  71.       {
  72.      u4error( E_CREATE, full_name, (char *) 0 ) ;
  73.      return( -1 ) ;
  74.       }
  75.       else
  76.       {
  77.      d4select( rc ) ;
  78.      if ( d4select( rc ) != rc )  return( -1 ) ;
  79.      if ( d4close() < 0 )  return( -1 ) ;
  80.       }
  81.    }
  82.  
  83.    header  =  (BASE_HEADER *) h4alloc( (int) long_header_len ) ;
  84.    if ( header == (BASE_HEADER *) 0 )  return( -1 ) ;
  85.  
  86.    b_field =  (BASE_FIELD *)  header ;
  87.    b_field++ ;
  88.    rec_width =  0 ;
  89.    is_memo   =  0 ;
  90.  
  91.    for ( i=0; i< num; i++ )
  92.    {
  93.       memcpy( b_field->name, fields->name, sizeof(b_field->name) ) ;
  94.       b_field->type     =  fields->type ;
  95.       u4upper( &b_field->type ) ;
  96.  
  97.       if ( b_field->type == 'C' )
  98.          memcpy( (char *) &b_field->width, (char *) &fields->width, 2) ;
  99.       else
  100.       {
  101.          b_field->decimals =  (unsigned char) fields->decimals ;
  102.          b_field->width    =  (unsigned char) fields->width ;
  103.       }
  104.  
  105.       if ( fields->width < 1 )    b_field->width = 1 ;
  106.  
  107.       u4upper( b_field->name ) ;
  108.  
  109.       for ( j=0; j< 10; j++ )
  110.       {
  111.      on_char =  b_field->name[j] ;
  112.      if ( on_char >= 'A' && on_char <= 'Z' )  continue ;
  113.      if ( on_char >= '0' && on_char <= '9' )  continue ;
  114.      if ( on_char == '_' ) continue ;
  115.  
  116.      memset( b_field->name+j, 0, (size_t) (10-j) ) ;
  117.      break ;
  118.       }
  119.       b_field->name[10] = '\000' ;
  120.  
  121.       if ( b_field->type != 'D' && b_field->type != 'L' &&
  122.        b_field->type != 'N' && b_field->type != 'M' &&
  123.        b_field->type != 'F' )
  124.      b_field->type =  'C' ;
  125.  
  126.       if ( b_field->type == 'L' )  b_field->width =  1 ;
  127.       if ( b_field->type == 'D' )  b_field->width =  8 ;
  128.       if ( b_field->type == 'M' )
  129.       {
  130.      b_field->width =  10 ;
  131.      is_memo =  1 ;
  132.       }
  133.       if ( b_field->type == 'N' || b_field->type == 'F' )
  134.       {
  135.      if ( b_field->width > 19 )  b_field->width =  19 ;
  136.      if ( b_field->width <  1 )  b_field->width =   1 ;
  137.      if ( b_field->width <= 2 )
  138.         b_field->decimals =  0 ;
  139.      else
  140.      {
  141.         if ( b_field->decimals >= b_field->width - (unsigned char) 1 )
  142.          b_field->decimals =  b_field->width - (unsigned char) 2 ;
  143.      }
  144.       }
  145.  
  146.       rec_width +=  b_field->width ;
  147.  
  148.       b_field++ ;
  149.       fields++ ;
  150.    }
  151.    memcpy( (char *) b_field, "\015\032", 2 ) ;
  152.  
  153.    if ( safety ) 
  154.       file_hand =  u4open( full_name, 1 ) ;
  155.    else
  156.       file_hand =  u4open( full_name, 2 ) ;
  157.  
  158.    if ( file_hand < 0 )  
  159.    {
  160.       h4free_memory( (char *) header ) ;
  161.       return -1 ;
  162.    }
  163.  
  164.    if ( is_memo )
  165.       header->version =  (char) 0x83 ;
  166.    else
  167.       header->version =  3;
  168.  
  169.    time( (time_t *) &time_val ) ;
  170.    tm_ptr     =  localtime( (time_t *) &time_val ) ;
  171.    header->yy =  (char) tm_ptr->tm_year ;
  172.    header->mm =  (char) tm_ptr->tm_mon+ (char) 1 ;
  173.    header->dd =  (char) tm_ptr->tm_mday ;
  174.  
  175.    header->header_len =  (unsigned short) (32*(num+1) + 1) ;
  176.    header->record_width =  (unsigned short) (rec_width + 1) ;
  177.  
  178.    lseek( file_hand, 0L, 0 ) ;
  179.    rc =  write( file_hand, (char *) header, 32*num+34 ) ;
  180.    h4free_memory( (char *) header ) ;
  181.    if ( rc != 32*num+34 )
  182.    {
  183.       u4error( E_WRITE, full_name, (char *) 0) ;
  184.       return( -1 ) ;
  185.    }
  186.  
  187.    close( file_hand ) ;
  188.  
  189.    if ( is_memo ) 
  190.    {
  191.       char   memo_name[90] ;
  192.       int    memo_file ;
  193.       MEMO_HEADER  m_hdr ;
  194.  
  195.       u4name_part( memo_name, full_name, 1,0 ) ;
  196.       u4name_full( memo_name, memo_name, ".DBT" ) ;
  197.  
  198.       if ( safety )
  199.      memo_file =  u4open( memo_name, 1 ) ;
  200.       else
  201.      memo_file =  u4open( memo_name, 2 ) ;
  202.  
  203.       if ( memo_file < 0 )  return -1 ;
  204.  
  205.       memset( (char *) &m_hdr, 0, sizeof(m_hdr) ) ;
  206.       m_hdr.next_block =     1L ;
  207.       u4name_part( m_hdr.file_name, full_name, 0,0 ) ;
  208.       m_hdr.x102       =  0x102 ;
  209.       m_hdr.block_size =  0x200 ;  /* 512 */
  210.  
  211.       lseek( memo_file, 0L, 0 ) ;
  212.       if ( write( memo_file, (char *) &m_hdr, (unsigned int) sizeof(m_hdr))
  213.                     != (int) sizeof(m_hdr) ) 
  214.       {
  215.      close( memo_file ) ;
  216.      u4error( E_WRITE, memo_name, (char *) 0 ) ;
  217.      return( -1 ) ;
  218.       }
  219.  
  220.       close( memo_file ) ;
  221.    }
  222.  
  223.    return( d4use(full_name) ) ;
  224. }
  225.