help in explaining the program

This is a discussion on help in explaining the program within the C Programming forums, part of the General Programming Boards category; Hi, Iam new to programming. Can anyone explain the following program? Code: #include "stdafx.h" FILE *fp_dump; /*----- Layer -----*/ /* ...

  1. #1
    Registered User
    Join Date
    May 2006
    Posts
    3

    help in explaining the program

    Hi,

    Iam new to programming. Can anyone explain the following program?



    Code:
    #include "stdafx.h"
    
    FILE	*fp_dump;
    
    /*----- Layer -----*/
    /* layer Record*/
    typedef struct {
        USHORT          usCode;         	/*LayerCode*/
        USHORT          usSubCode;          	/*SubCode*/
        USHORT          usBrandCode;      	/*BrandCode*/
        USHORT          usStartY;           	/*Latitude*/
        USHORT          usStartX;           	/*Longitude*/
        UINT                uiAR_DA;            	/*Offset*/
        USHORT          usCellSize;         	/*Cell Size*/
        USHORT          usDS;               	/*Relative offset*/
        USHORT	    usKey;		/*SortKey*/
    } stRec_t;
    
    /*Layer*/
    typedef struct {
        USHORT          usRecCnt;           /*Number of DataRecord*/
        stRec_t     *pstRec;        /*Layer Record*/
    } stLayer_t;
    
    
    static int iGetLayerFile( char*, stLayer_t* );
    static int iCodeSort(const void *, const void * );
    static int iWriteLayerFile( char *, stLayer_t * );
    
    /******* Sample main function ********/
    int main( int argc, char **argv ) {
    
    	int	 i,j,k,l,m,sMax,dMax;
    	int    cnt;
    
      	SearchFiles_T stSearch;
      	SearchFiles _T stSearchFiles;
      	stLayer_t stILF;
    
    	DIR* dir;
    		
    	char   acFileName[128],cmd[128];
    	char   *temp, *pch;
    
    	char   acILFDir[128];                
    	char   acNewILFDir[128];
      	char   dirPath[128];         
    
    	if (argv[1] == NULL || argv[2] == NULL)
    	{
    	    printf("\n<Usage>\nLayerFileSort source dest\n\n");
    	    exit( NG );
    	} 
    
    	sMax = strlen(argv[1]);
      	dMax = strlen(argv[2]);
    	memcpy(acILFDir, argv[1],sMax+2);
     	memmove(acILFDir+sMax,"/\0",2);
    	memcpy(acNewILFDir, argv[2],dMax+2);
      	memmove(acNewILFDir+dMax,"/\0",2);
     
    	if ((fp_dump=fopen("LayerFile.txt", "w")) == NULL) {
            		printf( "LogFile Open error\n" );
            		exit( NG );
    	}
    
      	memset(&stFinds, 0, sizeof(SearchFiles_T));
    
    	/*Search ILF directories*/
        	if ((FindFiles(acILFDir, &stFinds)) == NG) {
            		exit( NG );
        	}
        	for (i=0 ; i<stFinds.iFileCnt ; i++) {
    		memset(&stFindsFiles, 0, sizeof(SearchFiles _T));
    		
    		/*Search ILF files*/
    		if ((FindFiles(stFinds.pcPathName[i], &stFindsFiles)) == NG) {
    	        	exit( NG );
    		}
    		for (j=0 ; j<stFindsFiles.iFileCnt ; j++) {
    	
    			printf("%5d: %s\n", i, stFindsFiles.pcPathName[j] );
    			
    			/*get ILF*/
    			if( iGetLayerFile( stFindsFiles.pcPathName[j], &stILF ) != OK ){
    				printf("ILF reading error : %s\n",stFindsFiles.pcPathName[j] );
    				exit( NG );
    			}
    
    			/*sort ILF*/
    
    			qsort(stILF.pstRec,stILF.usRecCnt,sizeof(stRec_t),iCodeSort);
    
    			/*get filename*/
    			memcpy( acFileName, acNewILFDir,strlen(acNewILFDir));
    
    			for ( m = (int)strlen ( acNewILFDir ),l = (int)strlen ( acILFDir ); 
    				l < (int)strlen( stFindsFiles.pcPathName[j] ); l++, m++ )
    				acFileName[m] = stFindsFiles.pcPathName[j][l];
    
    			acFileName[m] = '\0';
    		
    			temp = (char *)malloc(strlen(acFileName)+1);
    			if ( NULL == temp )
    			{
    				printf ("temp malloc error!");
    				exit (NG);
    			}
    
    			memcpy(temp,acFileName,strlen(acFileName)+1); 
    			pch = (char *)malloc(strlen(acFileName)+1);
    			if ( NULL == pch )
    		  	{
    				printf("pch malloc error!");
    				exit (NG);
    			}
    			memcpy(pch,acFileName,strlen(acFileName)+1);
    			pch = strrchr(temp,'/');
    			cnt = pch - temp + 1;
    
    			memcpy(dirPath,temp,cnt);
    			
    			dirPath[cnt] = '\0';
    
      			dir = opendir(dirPath);
    			if (!dir) 
    			{
    				  sprintf(cmd,"mkdir -m 755 -p %s",dirPath);  
    				  printf("Making directory :%s\n",dirPath);  
    				/*	  printf("cmd:%s\n",cmd);  */
    				  system (cmd);           
    			} 
    			
    			else closedir(dir); 
    		 
    			/*write ILF(finshed sortting)*/                              
    			if( iWriteLayerFile ( acFileName, &stILF ) != OK ){
    				printf("ILF writing error : %s\n",acFileName );
    				exit( NG );
    			}
    		
    			/*		dump list */
    			for ( k = 0; k < stILF.usRecCnt; k++ ){
    fprintf(fp_dump, "%s,%d,%d,%d,0x%04x,0x%04x,0x%04x,0x%02x,0x%02x,%d\n",
    				stFindsFiles.pcPathName[j],
    				stILF.pstRec[k].usCode,
    				stILF.pstRec[k].usSubCode,
    				stILF.pstRec[k].usBrandCode,
    				stILF.pstRec[k].usStartX,
    				stILF.pstRec[k].usStartY,
    				stILF.pstRec[k].uiAR_DA,
    				stILF.pstRec[k].usCellSize,
    				stILF.pstRec[k].usDS,
    				stILF.pstRec[k].usKey);
    			}     
    
    			if(stILF.usRecCnt != 0) free (stILF.pstRec);		
    		}
    	    FindFree(&stFindsFiles);
    	}
        	FindFree(&stFinds);		
    	fclose(fp_dump);
     
    	free(temp);
    	free(pch);
    	printf("Done!\n");
     	exit( OK );
    }
    /*=====================
         FUNCTION     : Get LayerFile
         INPUT        : char*			-FileName
    					stLayer_t	-Layer
         RETURN       : OK / NG
    =======================*/
    static int iGetLayerFile( char *acFileName, stLayer_t *pstILF)
    {
    	FILE	*fp;
    	int	  i,j;
    	USHORT	usSortKey[SORT_REC] = {9126,7328,7373,7315,7387,7314,7313,7369,9999,7395,7311,7321};
    	
    	pstILF->usRecCnt = 0;
    
    	if ((fp=fopen(acFileName, "rb")) == NULL) {
    		return ( NG );
    	}
    	fread(&pstILF->usRecCnt, 2, 1, fp);  
        	if( pstILF->usRecCnt != 0 ){
            	pstILF->pstRec =
                    (stRec_t*)calloc(pstILF->usRecCnt,sizeof(stRec_t) );
    	}
    
    	for( i = 0; i < (int)pstILF->usRecCnt; i++ ){
    		fread(&pstILF->pstRec[i].usCode, 2, 1, fp);			/* Layer Code*/
    		fread(&pstILF->pstRec[i].usSubCode, 2, 1, fp);		/* Sub Code*/
    		fread(&pstILF->pstRec[i].usBrandCode, 2, 1, fp);		/* Brand Code*/
    
    		fread(&pstILF->pstRec[i].usStartY, 2, 1, fp);		/* Lat*/
    		fread(&pstILF->pstRec[i].usStartX, 2, 1, fp);		/* Long*/
    		fread(&pstILF->pstRec[i].uiAR_DA, 4, 1, fp);		/* Offset*/
    		fread(&pstILF->pstRec[i].usCellSize, 2, 1, fp);		/* CellSize*/
    		fread(&pstILF->pstRec[i].usDS, 2, 1, fp);			/* RelativeOffset*/
    
    		pstILF->pstRec[i].usKey = 0;					/* Sort Key */
    		for ( j = 0; j < SORT_REC; j++ ){
    			if( pstILF->pstRec[i].usCode == usSortKey[j] ){
    				pstILF->pstRec[i].usKey = j + 1;		/* Sort Key*/
    				break;
    			}
    		}
    	}
      
    	fclose( fp );
    
    	return( OK );
    }
    /*=====================
         FUNCTION     : Write LayerFile
         INPUT        : char*			-FileName
    					stLayer_t	-Layer
         RETURN       : OK / NG
    =======================*/
    static int iWriteLayerFile( char *acFileName, stLayer_t *pstILF)
    {
    	FILE	*fp;
    	int		i;
    	
    	if ((fp=fopen(acFileName, "wb")) == NULL) {
    		return ( NG );
    	}
    	fwrite(&pstILF->usRecCnt, 2, 1, fp);  	
    	for( i = 0; i < (int)pstILF->usRecCnt; i++ ){
    		fwrite(&pstILF->pstRec[i].usCode, 2, 1, fp);			/* Layer Code*/
    		fwrite(&pstILF->pstRec[i].usSubCode, 2, 1, fp);		/* Sub Code*/
    		fwrite(&pstILF->pstRec[i].usBrandCode, 2, 1, fp);		/* Brand Code*/
    		fwrite(&pstILF->pstRec[i].usStartY, 2, 1, fp);		/* Lat*/
    		fwrite(&pstILF->pstRec[i].usStartX, 2, 1, fp);		/* Long*/
    		fwrite(&pstILF->pstRec[i].uiAR_DA, 4, 1, fp);		/* Offset*/
    		fwrite(&pstILF->pstRec[i].usCellSize, 2, 1, fp);		/* CellSize*/
    		fwrite(&pstILF->pstRec[i].usDS, 2, 1, fp);			/* RelativeOffset*/
    		
    	};
    	fclose( fp );
    
    	return( OK );
    }
    /*===================
         FUNCTION     : iCodeSort
         INPUT        : stLayer_t	-Layer
    					stLayer_t	-Layer
         RETURN       : OK / NG
    ====================*/
    
    static int iCodeSort(const void *data1, const void *data2 )
    {
    	stRec_t     *pst1;
    	stRec_t     *pst2;
    	int             iDiff;
    
    	pst1 = (stRec_t*)data1;
    	pst2 = (stRec_t*)data2;
    
    	iDiff = (int)pst1->usKey - (int)pst2->usKey;
    
    	return( iDiff );
    }

  2. #2
    Tropical Coder Darryl's Avatar
    Join Date
    Mar 2005
    Location
    Cayman Islands
    Posts
    503
    Well, just glancing over it, it takes 2 parameters from the command line, an input file and an output file, it sorts the input file and outputs the result to the output file.

  3. #3
    Registered User
    Join Date
    May 2006
    Posts
    3
    Hi Darryl,

    Thankx for the reply, in the code i see that it sorts accodring to "code", how can i modify the program so that it sorts even according to "subcode" and "brandcode";

    i.e., code as primary key, subcode as secondary key and brandcode as third key; here, each code has a subcode and each subcode has a brandcode.

    Hope u can help me out with this.
    thank you.
    Last edited by jazzz; 05-23-2006 at 01:05 AM.

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Need help with a program, theres something in it for you
    By engstudent363 in forum C Programming
    Replies: 1
    Last Post: 02-29-2008, 12:41 PM
  2. Replies: 4
    Last Post: 02-21-2008, 09:39 AM
  3. Using variables in system()
    By Afro in forum C Programming
    Replies: 8
    Last Post: 07-03-2007, 12:27 PM
  4. Replies: 3
    Last Post: 03-04-2005, 01:46 PM
  5. My program, anyhelp
    By @licomb in forum C Programming
    Replies: 14
    Last Post: 08-14-2001, 10:04 PM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21