home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS 1992 September / Simtel20_Sept92.cdr / msdos / clipper / nannws22.arc / LCPACK.C < prev    next >
Text File  |  1987-12-08  |  11KB  |  412 lines
  1. /***************************************************************/
  2. /* lcpack.c memo file packing program                          */
  3. /* for Lattice C 3.1 and Clipper                               */
  4. /* Author: Don L. Powells                                      */
  5. /* Purpose: Function to pack .dbt files                        */
  6. /* Usage: In Clipper program the function can be invoked as a  */
  7. /*        User-defined Function.                               */
  8. /*        Example: errcode=mpack(dbf_name)                     */
  9. /***************************************************************/
  10.  
  11. /* Include the necessary header files */ 
  12. #include "stdio.h" 
  13. #include "string.h" 
  14. #include "fcntl.h" 
  15. #include "extend.h" 
  16.  
  17. /* Define program constants */ 
  18. #define DBT_EXT ".dbt" 
  19. #define DBF_EXT ".dbf" 
  20. #define SIZE 512 
  21. #define MODE 0 
  22. #define MAXFIELDS 1024 
  23. #define ONE_A '\032' 
  24. #define SPACE " " 
  25.  
  26. /* Declare variables and functions*/ 
  27. int  fieldlen[MAXFIELDS]; 
  28. int  memofields[MAXFIELDS]; 
  29. int  offset[MAXFIELDS]; 
  30. int packmem(); 
  31. void reterr(); 
  32.  
  33. /************* Function mpack **********/ 
  34. /* Purpose: Receives the parameter and checks to see if it */
  35. /*          has an extension */ 
  36.  
  37. void mpack() 
  38. { 
  39.    char *parm; 
  40.    int error; 
  41.    int i; 
  42.  
  43.    /* CHECK to be sure that a file name was passed */ 
  44.    if (PCOUNT != 1 || !ISCHAR(1)) 
  45.       _retni(1); 
  46.  
  47.    /* Use Clipper Extend system to get filename off stack */ 
  48.    parm = _parc(1); 
  49.  
  50.    /* Truncate the extension off the filename if passed */ 
  51.    i=0; 
  52.    while(parm[i] != 0L) 
  53.       { 
  54.       if(parm[i] == '.') 
  55.           parm[i] = 0L; 
  56.        ++i; 
  57.        } 
  58.  
  59.    /* Call the memo packing function and return the error code */
  60.    /* to Clipper */ 
  61.    error = packmem(parm); 
  62.    _retni(error); 
  63. } 
  64.  
  65. /************* Function packmem **********/ 
  66. /* Purpose: To pack dbt files by writing only the current, */ 
  67. /*          usable memos to another file, updating the dbf */
  68. /*          pointers and deleting the old dbt file.        */
  69.  
  70. packmem(filename) 
  71. char *filename; 
  72. { 
  73. char dbf_name[64]; 
  74. char dbt_name[64]; 
  75. int  old_dbt; 
  76. int  dbf; 
  77. int  new_dbt; 
  78. unsigned char buffer[513]; 
  79. int count; 
  80. long apos; 
  81. long rpos; 
  82. long reccnt; 
  83. unsigned int hdrsize; 
  84. unsigned int recsize; 
  85. int  numofflds; 
  86. int  numofmems; 
  87. int  numflds2add; 
  88. unsigned int nextblk; 
  89. int  i; 
  90. int  j; 
  91. int  k; 
  92. int  m; 
  93. char blk_num[11]; 
  94. int  curr_blk; 
  95. int  onea_found; 
  96. char lead_spc[10]; 
  97.  
  98. typedef struct 
  99. { 
  100.    char sign; 
  101.    char date[3]; 
  102.    long recc; 
  103.    unsigned int data_off; 
  104.    unsigned int rec_size; 
  105.    char pad[20]; 
  106. } DBF_HEADER; 
  107.  
  108. DBF_HEADER head; 
  109.  
  110. struct 
  111.    { 
  112.    char  fieldname[11]; 
  113.    char  field_type; 
  114.    char  fpad[4]; 
  115.    char  field_len; 
  116.    char  field_dec; 
  117.    char  res_bytes[14]; 
  118.    }field_def; 
  119.  
  120. /* Concatenate extensions to passed name */ 
  121. strcpy(dbf_name,filename); 
  122. strcpy(dbt_name,filename); 
  123. strcat(dbf_name,DBF_EXT); 
  124. strcat(dbt_name,DBT_EXT); 
  125.  
  126. printf("DP & Associates "); 
  127. for (i=1;i < 25;i++) 
  128.    printf("\n"); 
  129. printf("            Packing %s. Please wait a moment.",dbt_name);
  130. for (i=1;i < 12;i++) 
  131.    printf("\n"); 
  132.  
  133. /* OPEN the dbf file */ 
  134. if ((dbf = open(dbf_name,O_RDWR | O_RAW)) == -1) 
  135.    { 
  136.    return(2); 
  137.    } 
  138.  
  139. /* READ first byte of the dbf file and if it is !=83H then */
  140. /*      give an error message saying this is not a dbf */
  141. /*      file with a memo field */ 
  142. if ((count = read(dbf,buffer,1)) < 1) 
  143.    { 
  144.    /* CLOSE the dbf file */ 
  145.    close(dbf); 
  146.    return(3); 
  147.    } 
  148. else 
  149.    if (buffer[0] != 0x83) 
  150.    { 
  151.    /* CLOSE the dbf file */ 
  152.    close(dbf); 
  153.    return(4); 
  154.    } 
  155.  
  156. /* RENAME original dbt file as temp (cpackmem.bak) */ 
  157. if (rename(dbt_name,"cpackmem.bak") == -1) 
  158.    { 
  159.    /* CLOSE the dbf file */ 
  160.    close(dbf); 
  161.    return(5); 
  162.    } 
  163.  
  164. /* OPEN the temp dbt file */ 
  165. if ((old_dbt = open("cpackmem.bak",O_RDONLY | O_RAW)) == -1) 
  166.    { 
  167.    /* CLOSE the dbf file */ 
  168.    close(dbf); 
  169.    rename("cpackmem.bak",dbt_name); 
  170.    return(6); 
  171.    } 
  172.  
  173. /* CREATe the new dbt file with original name */ 
  174. if ((new_dbt = open(dbt_name,O_RDWR | O_TRUNC | O_RAW | O_CREAT, 
  175.    S_IREAD | S_IWRITE)) == -1) 
  176.    { 
  177.    /* CLOSE the dbf file */ 
  178.    close(dbf); 
  179.    rename("cpackmem.bak",dbt_name); 
  180.    return(7); 
  181.    } 
  182.  
  183. /* READ the first 512 byte block from cpackmem.bak and WRITE */
  184. /* to new dbt */ 
  185. if ((count = read(old_dbt,buffer,SIZE)) < SIZE) 
  186.    { 
  187.    reterr(dbt_name); 
  188.    return(8); 
  189.    } 
  190.  
  191. if ((count = write(new_dbt,buffer,SIZE)) < SIZE) 
  192.    { 
  193.    reterr(dbt_name); 
  194.    return(9); 
  195.    } 
  196.  
  197. /***************************************************************/ 
  198. /* READ the dbf header to find out how many memo fields there  */
  199. /*      are and what their offsets are. */ 
  200.  
  201. if ((apos = lseek(dbf,0L,MODE)) == -1) 
  202.    { 
  203.    reterr(dbt_name); 
  204.    return(10); 
  205.    } 
  206.  
  207. if ((count = read(dbf,(char *) &head,sizeof(head))) < 32) 
  208.    { 
  209.    reterr(dbt_name); 
  210.    return(11); 
  211.    } 
  212.  
  213. /* LSEEK and READ bytes 4-7 to get number of records and store */
  214. /*      in a memory variable reccnt */ 
  215.  
  216. reccnt = head.recc; 
  217.  
  218. /* LSEEK and READ bytes 8-9 to get the number of bytes in the  */
  219. /*    header and store in a memory variable hdrsize */ 
  220.  
  221. hdrsize = head.data_off; 
  222.  
  223. /* LSEEK and READ bytes 10-11 to get the number of bytes in */
  224. /*    the record and store in a memory variable recsize */ 
  225.  
  226. recsize = head.rec_size; 
  227.  
  228. /* LSEEK byte 32 the first field descriptor */ 
  229.  
  230. rpos = 32; 
  231. if ((apos = lseek(dbf,rpos,MODE)) == -1) 
  232.    { 
  233.    reterr(dbt_name); 
  234.    return(12); 
  235.    } 
  236.  
  237. numofflds = 0; 
  238. numofmems = 0; 
  239.  
  240. /*    READ the 32 byte field descriptor into the buffer */ 
  241. if ((count = read(dbf,(char *) &field_def,sizeof(field_def)))<32) 
  242.    { 
  243.    reterr(dbt_name); 
  244.    return(13); 
  245.    } 
  246.  
  247. /* WHILE buffer[1] != 0DH */ 
  248. while(field_def.fieldname[0] != 0x0D) 
  249.    { 
  250.    /*    numofflds = numofflds + 1 */ 
  251.    numofflds ++; 
  252.  
  253.    /*    IF buffer[11] (fieldtype) is M */ 
  254.    /*       INCrement numofmems */ 
  255.    /*       add field num to */
  256.    /*         memofield array {memofield[numofmems]=numofflds} */
  257.    /*    ENDIF (fieldtype=M) */ 
  258.  
  259.    if (field_def.field_type == 'M') 
  260.       { 
  261.       numofmems++; 
  262.       memofields[numofmems] = numofflds; 
  263.       } 
  264.  
  265.    /*    LSEEK byte 16 to get field length and add to */
  266.    /*       fieldlen array */
  267.    /*    fieldlen[numofflds] = buffer[16] */ 
  268.    fieldlen[numofflds] = field_def.field_len; 
  269.  
  270.    /*    READ the 32 byte field descriptor into the buffer */ 
  271.    if ((count = read(dbf,(char *) &field_def,sizeof(field_def))) 
  272.       <32) 
  273.    { 
  274.    reterr(dbt_name); 
  275.    return(14); 
  276.    } 
  277.    } 
  278.  
  279. /********* Build offset array **********************************/ 
  280. /* FOR i=1 to numofmems */ 
  281. for (i=1;i<=numofmems;i++) 
  282. { 
  283.    /*    numflds2add = memofields[i] - 1 */ 
  284.    numflds2add = memofields[i] - 1; 
  285.  
  286.    offset[i] = 1; 
  287.    /*    FOR j=1 to numflds2add */ 
  288.    for (j=1;j<=numflds2add;j++) 
  289.    { 
  290.       /*       offset[i] = offset[i] + fieldlen[j] */ 
  291.       offset[i] = offset[i] + fieldlen[j]; 
  292.    /*    NEXT (fieldlen to add) */ 
  293.    } 
  294. /* NEXT (memo field) */ 
  295. } 
  296. /* ******* Process memo data ***********************************/ 
  297. nextblk = 1; 
  298. /* FOR i=1 to reccnt */ 
  299. for (i=1;i<=reccnt;i++) 
  300. { 
  301.    /* FOR j=1 to number of memo fields (numofmems) in dbf file */
  302.    for (j=1;j<=numofmems;j++) 
  303.    { 
  304.    /*       find pointer (512 byte block#) to memo field */ 
  305.    /*       LSEEK (hdrsize + (i-1) * recsize + offset[j]) and */
  306.    /*       READ 10 bytes*/ 
  307.    rpos = hdrsize + (i-1) * recsize + offset[j]; 
  308.    apos = lseek(dbf,rpos,MODE); 
  309.  
  310.    blk_num[10] = '\0'; 
  311.  
  312.    count = read(dbf,blk_num,10); 
  313.  
  314.    curr_blk = atoi(blk_num); 
  315.  
  316.    if (curr_blk != 0) 
  317.      { 
  318.          /* LSEEK -10 bytes and WRITE new pointer # in dbf file*/
  319.          rpos = -10; 
  320.          apos = lseek(dbf,rpos,1); 
  321.  
  322.          sprintf(blk_num,"%d",nextblk); 
  323.          if ((count = strlen(blk_num)) < 10) 
  324.             { 
  325.             strcpy(lead_spc,SPACE); 
  326.             for (m = 1;m < (10 - count);m++) 
  327.                { 
  328.                strcat(lead_spc,SPACE); 
  329.                } 
  330.             strcat(lead_spc,blk_num); 
  331.             } 
  332.          strcpy(blk_num,lead_spc); 
  333.  
  334.          count = write(dbf,blk_num,10); 
  335.  
  336.      /*       LSEEK proper dbt block ((pointer)* 512) */ 
  337.       rpos = (long) curr_blk * SIZE; 
  338.       apos = lseek(old_dbt,rpos,MODE); 
  339.  
  340.       /*       READ 512 bytes into the buffer */ 
  341.       count = read(old_dbt,buffer,SIZE); 
  342.  
  343.  
  344.       /*       do while not eomemo (1A1A not found) */ 
  345.       onea_found = 0; 
  346.       do 
  347.          { 
  348.  
  349.          /*          WRITE buffer to temp file */ 
  350.          count = write(new_dbt,buffer,SIZE); 
  351.  
  352.          apos = lseek(new_dbt,0L,1); 
  353.  
  354.          /*      increment temp file pointer # memory variable */
  355.          ++nextblk; 
  356.          k=0; 
  357.          while(k<=512) 
  358.             { 
  359.             if (buffer[k] ==  ONE_A) 
  360.                onea_found =1; 
  361.  
  362.             /*       endo (1A1A found) */ 
  363.             ++k; 
  364.             } 
  365.             /*          READ 512 bytes into the buffer */ 
  366.             if (!onea_found) 
  367.                count = read(old_dbt,buffer,SIZE); 
  368.          }while(!onea_found); 
  369.  
  370.      } 
  371. /*    NEXT J (memo field) */ 
  372.    } 
  373. /* NEXT I (record) */ 
  374. } 
  375.  
  376. /* WRITE next available block in temp dbt as */
  377. /* pointer # memory variable + 1 */ 
  378. apos = lseek(new_dbt,0L,MODE); 
  379.  
  380. rpos = (long) nextblk; 
  381.  
  382. count = write(new_dbt,(char *) &rpos,4); 
  383.  
  384. /*                                                             */
  385. /************* TERMINATE ***************************************/ 
  386. /* CLOSE the temp dbt file */ 
  387. close(new_dbt); 
  388. /* CLOSE the dbf file */ 
  389. close(dbf); 
  390. /* CLOSE the original dbt file */ 
  391. close(old_dbt); 
  392. /* UNLINK (delete) original dbt file */ 
  393. unlink("cpackmem.bak"); 
  394. /* RETURN to calling program with code 0=successful */
  395. /*    2=file not found 4=too many files open 29=write error */
  396. /*    30=read error */ 
  397.  
  398. return(0); 
  399. } 
  400.  
  401. /************* Function ERRor **********/ 
  402. /* Purpose:To delete new dbt and rename old dbt to */
  403. /* itself when function can not successfully complete */
  404. /* the packing. */
  405. void reterr(dbt_file) 
  406. char dbt_file[64]; 
  407. { 
  408. unlink(dbt_file); 
  409. rename("cpackmem.bak",dbt_file); 
  410. return; 
  411. } 
  412.