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

#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 );
}

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.

Hi jazzz.. those code are too advance to be understand... those are optimized code which enable the machine to execute efficiently faster... why just start from the basic....

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.

If idiff = 0 check the "subcode". If that is equal, check "brandcode".

This article has been dead for over six months. Start a new discussion instead.