home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 568a.lha / RexxRMF_v1.1 / dumprmfdata.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-09-12  |  9.5 KB  |  298 lines
  1.  
  2. /*-------------------------------------------------------------------------*
  3.  *                                                                         *
  4.  * Prints formatted dump of data and index file.                           *
  5.  * Example of reading data and index files (if you must).                  *
  6.  *                                                                         *
  7.  * Compiles under Manx C 5.0d                                              *
  8.  *   cc -hi allprecomp -pp -wnuq -o dumprmfdata.o dumprmfdata.c            *
  9.  *   ln -o dumprmfdata dumprmfdata.o -lc                                   *
  10.  *                                                                         *
  11.  * Compile/link for Lattice 5.10                                           *
  12.  *     LC -L -Hinclude:allprecomp.q dumprmfdata                            *
  13.  *           (pre-compiled header file)                                    *
  14.  *                                                                         *
  15.  *-------------------------------------------------------------------------*/
  16.  
  17.  
  18. #include "avl.structs.h"
  19.  
  20. long getnum( void );
  21. int dump_rmf_data_index( char *datafile, char *indexfile, long s, long e );
  22.  
  23. main( int argc, char *argv[] )
  24. {
  25.     char *oldi,*oldd;
  26.     long oldnamelen,starting,ending;
  27.     
  28.     if( argc < 2 ) {
  29.         printf("\nSyntax: %s 'filename' [startrecordnum] [endrecordnum]\n", \
  30.                                                                     argv[0]);
  31.         exit( 10 );
  32.     }
  33.         
  34.     oldnamelen = strlen(argv[1]) + 50;
  35.     
  36.     oldi = AllocMem( oldnamelen, MEMF_CLEAR );
  37.     oldd = AllocMem( oldnamelen, MEMF_CLEAR );
  38.     
  39.     strcpy(oldd,argv[1]);
  40.     strcpy(oldi,argv[1]);
  41.     
  42.     strcat(oldi,".rmfindex");
  43.     
  44.     if( argc > 2 )
  45.         starting = atoi(argv[2]);
  46.     else {    
  47.         printf("\n\nEnter Starting Record: ");
  48.         starting = getnum();
  49.     }
  50.         
  51.     if( argc > 3 )    
  52.         ending = atoi(argv[3]);
  53.     else {    
  54.         printf("\n\nEnter Ending Record: ");
  55.         ending = getnum();
  56.     }
  57.     
  58.     if( starting < 1 )
  59.         starting = 1;
  60.  
  61.     if( !ending )
  62.         ending = 99999999L;
  63.     
  64.     if( ending < starting )
  65.         ending = starting;
  66.     
  67.     dump_rmf_data_index( oldi, oldd, starting, ending );
  68.     
  69.     FreeMem( oldi, oldnamelen);
  70.     FreeMem( oldd, oldnamelen);
  71.     
  72. }
  73.  
  74. char numbuf[81];
  75. long getnum()
  76. {
  77.   long num;
  78.  
  79.   gets(&numbuf[0]);
  80.   
  81.   num = atoi(&numbuf[0]);
  82.   
  83.   return(num);
  84.   
  85. }
  86.  
  87. int dump_rmf_data_index( char *indexfile, char *datafile, long start, long end )
  88. {
  89.  
  90.  
  91.    struct IndexFile      *ix;
  92.    struct DiskIndex      *dtnode; 
  93.    struct DataFileHeader *dfh;
  94.    struct RecordHeader   *rh;
  95.    char                  *keybuf,*indxbuf;
  96.    char                  *datablock,*datapointer; 
  97.    ULONG                 blocklen;
  98.    ULONG                 recaddr,recnum;
  99.    ULONG                 ifd,dfd;
  100.    long                  err,total_keylen,keyindex;
  101.    long                  blen,dlen,fieldnum;
  102.    int                   ok,i,j;
  103.  
  104.    
  105.    ifd = Open(indexfile,MODE_OLDFILE);
  106.    if( !ifd ) {
  107.        printf(" COULD NOT OPEN INDEX file %s\n",indexfile);
  108.        return( FALSE );
  109.    }
  110.    
  111.    dfd = Open(datafile,MODE_OLDFILE);
  112.    if( !ifd ) {
  113.        printf(" COULD NOT OPEN DATA file %s\n",datafile);
  114.        Close( ifd );
  115.        return( FALSE );
  116.    }
  117.    
  118.    ix      = AllocMem( sizeof(struct IndexFile), MEMF_CLEAR );
  119.    dtnode  = AllocMem( sizeof(struct DiskIndex), MEMF_CLEAR );
  120.    dfh     = AllocMem( sizeof(struct DataFileHeader), MEMF_CLEAR );
  121.    rh      = AllocMem( sizeof(struct RecordHeader), MEMF_CLEAR );
  122.    keybuf  = AllocMem( (MAXKEYLEN) + 1, MEMF_CLEAR );
  123.    indxbuf = AllocMem( 5 * ((MAXKEYLEN) + 1), MEMF_CLEAR );
  124.    if( !keybuf || !rh || !ix || !dtnode || !dfh || !indxbuf ) {
  125.        printf("\nUnable to allocate memory\n\n");
  126.        if( ix )
  127.            FreeMem( ix, sizeof(struct IndexFile) );
  128.        if( dtnode ) 
  129.            FreeMem( dtnode, sizeof(struct DiskIndex) );
  130.        if( dfh ) 
  131.            FreeMem( dfh, sizeof(struct DataFileHeader) );
  132.        if( rh ) 
  133.            FreeMem( rh, sizeof(struct RecordHeader) );
  134.        if( keybuf ) 
  135.            FreeMem( keybuf, (MAXKEYLEN)+1 );
  136.        if( indxbuf ) 
  137.            FreeMem( indxbuf, (5 * ((MAXKEYLEN)+1)) );
  138.        Close( dfd );
  139.        Close( ifd );
  140.        return( FALSE );    
  141.    }
  142.    
  143.    ok = Read(ifd,ix,sizeof(struct IndexFile));
  144.    
  145.    ok = Read(dfd,dfh,sizeof(struct DataFileHeader));
  146.  
  147.    recnum = 0;
  148.    ok = TRUE;
  149.    printf("\n\n");
  150.    while( ok ) {
  151.    
  152.       datablock = NULL;
  153.       
  154.       /* fixed portion */
  155.       err = Read(ifd,dtnode,sizeof(struct DI_Info));
  156.       if( err <= 0 ) 
  157.            break;
  158.       
  159.       total_keylen = 0;
  160.       for( i=0; i < MAXINDICES; i++ )
  161.            total_keylen = total_keylen + dtnode->di_info.keylen[i]; 
  162.            
  163.       /* read variable key portion */
  164.       err = Read(ifd,&dtnode->keydata[0],total_keylen);
  165.       
  166.       if( err <= 0 )
  167.           break;
  168.  
  169.       switch( dtnode->di_info.recstatus ) 
  170.         {
  171.           case 'D': /* dont care, plus has no record length, dont know
  172.                        how much to read in !
  173.                     */
  174.                    break;
  175.                    
  176.           case 'A':
  177.                    recaddr = dtnode->di_info.recaddr;
  178.       
  179.                    Seek(dfd,recaddr,OFFSET_BEGINNING);
  180.                    err = Read( dfd, rh, sizeof(struct RecordHeader));
  181.                    if( err <= 0 ) {
  182.                        printf("READ ERROR occured at block %d\n",recaddr);
  183.                        ok = FALSE;
  184.                        break;
  185.                    }
  186.           
  187.                    blocklen  = rh->blocklength;
  188.                    datablock = AllocMem( blocklen, MEMF_CLEAR );    
  189.                    if( !datablock ) {
  190.                        printf(" Could not allocate mem for datablock\n");
  191.                        printf("   blocklength was %-d\n",blocklen);
  192.                        ok = FALSE;
  193.                        break;
  194.                    }
  195.  
  196.                    err = Read( dfd, datablock, (blocklen));
  197.                    if( err <= 0 ) {
  198.                        printf("READ ERROR occured at block %d\n",recaddr);
  199.                        ok = FALSE;
  200.                        break;
  201.                    }
  202.                    
  203.                    
  204.                    
  205.                    ++recnum;
  206.                    if( recnum >= start && recnum <= end ) {    
  207.                    
  208.                        printf(" RECORD  #%-5d ",recnum);
  209.                        
  210.                        printf(" AT LOCATION %-5d ",recaddr);
  211.                        
  212.                        printf(" LENGTH %-5d ",rh->blocklength);
  213.                        
  214.                        printf(" FIELDS %-4d\n",rh->numberoffields);
  215.                        
  216.                        /* prime key as it is in index */
  217.                        printf(" INDXKEY- ");
  218.                        
  219.                        keyindex = 0;
  220.                        
  221.                        for( i = 0; i <= MAXINDEXNUM; i++ ) {
  222.                        
  223.                             for( j = 0; j < 10; j++ )
  224.                                  *(keybuf+j) = ' ';
  225.                             *(keybuf+j) = NULL;
  226.                             
  227.                             for(j = 0; j < dtnode->di_info.keylen[i]; j++) {
  228.                                  if( j < 9 )
  229.                                      *(keybuf+j) = dtnode->keydata[keyindex];
  230.                                  ++keyindex;
  231.                             }
  232.                                  
  233.                             if( i == 1 ) 
  234.                                 printf("\n ALTKEYS- ");
  235.                                 
  236.                             printf("%-d:%s",i,keybuf);
  237.                             
  238.                        }
  239.  
  240.                        printf("\n");
  241.                    
  242.                    
  243.  
  244.                        /* prime key is first in block */
  245.                        /* prime key as it is in datafile  */
  246.                        printf(" DATAKEY- %-10s\n ",datablock); 
  247.  
  248.                        /* skip over key values */
  249.                        blen = rh->dataoffset; /* strlen(datapointer); */
  250.                        datapointer = datablock + blen;
  251.  
  252.                        fieldnum = 0;
  253.                        while( blen < rh->recordlength ) {
  254.                    
  255.                               dlen = strlen(datapointer);
  256.                               if( !dlen )  /* means field is null length */
  257.                                   break;   /* EOR trailer                */
  258.  
  259.                               ++fieldnum;
  260.                               
  261.                               if( fieldnum == 1 )
  262.                                   printf("FIELDS - %03d:%-9.8s",fieldnum,datapointer);
  263.                               else
  264.                                   printf("%03d:%-9.8s",fieldnum,datapointer);
  265.                               if( !(fieldnum % 5) )
  266.                                   printf("\n          ");
  267.  
  268.                               blen = blen + dlen + 1;
  269.                     
  270.                               datapointer = (UBYTE *)((ULONG)datapointer + dlen + 1); 
  271.                        }
  272.                        printf("\n\n\n");
  273.                        
  274.                        if( datablock ) 
  275.                            FreeMem( datablock,blocklen);
  276.  
  277.                        break;
  278.                    }
  279.         }
  280.  
  281.    }   
  282.    
  283.    
  284.    Close( dfd );
  285.    Close( ifd );
  286.    
  287.    FreeMem( ix, sizeof(struct IndexFile) );
  288.    FreeMem( dtnode, sizeof(struct DiskIndex) );
  289.    FreeMem( dfh, sizeof(struct DataFileHeader) );
  290.    FreeMem( rh, sizeof(struct RecordHeader) );
  291.    FreeMem( keybuf, ((MAXKEYLEN) + 1) );
  292.    FreeMem( indxbuf, (5 * ((MAXKEYLEN)+1)) );
  293.    
  294.    return( !err );
  295.    
  296. }
  297.  
  298.