HeeroYui/HexViewer
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Offset available in the start of file ==> error while searchir error (no check of the ofset ...

Browse Source
This commit is contained in:
Edouard Dupin 2012-02-10 18:06:39 +01:00
parent f8a3ab2db8
commit ef3750600d
5 changed files with 309 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

210
display.c
View File

@ -26,15 +26,69 @@
extern FILE *filePointer[2]; extern FILE *filePointer[2];
extern char fileName[2][2096]; extern char fileName[2][2096];
void drawLine(void)
{
showTypeSize_te mySize = getTypeSize();
showType_te myType = getType();
switch(myType)
{
case SHOW_TYPE_DECIMAL_SIGNED:
case SHOW_TYPE_DECIMAL_UNSIGNED:
switch(mySize)
{
case SHOW_TYPE_SIZE_8:
printf("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n"COLOR_NORMAL);
break;
case SHOW_TYPE_SIZE_16:
printf("-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n"COLOR_NORMAL);
break;
case SHOW_TYPE_SIZE_32:
printf("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n"COLOR_NORMAL);
break;
case SHOW_TYPE_SIZE_64:
printf("-------------------------------------------------------------------------------------------------------------------------------------------\n"COLOR_NORMAL);
break;
default:
break;
}
break;
case SHOW_TYPE_HEX:
default :
switch(mySize)
{
case SHOW_TYPE_SIZE_8:
printf("---------------------------------------------------------------------------------------------------------------------------------------------------\n"COLOR_NORMAL);
break;
case SHOW_TYPE_SIZE_16:
printf("-----------------------------------------------------------------------------------------------------------------------------------\n"COLOR_NORMAL);
break;
case SHOW_TYPE_SIZE_32:
printf("---------------------------------------------------------------------------------------------------------------------------\n"COLOR_NORMAL);
break;
case SHOW_TYPE_SIZE_64:
printf("-----------------------------------------------------------------------------------------------------------------------\n"COLOR_NORMAL);
break;
default:
break;
}
break;
}
}
void showConfiguration(void) void showConfiguration(void)
{ {
showType_te myType = getType(); showType_te myType = getType();
showTypeSize_te mySize = getTypeSize(); showTypeSize_te mySize = getTypeSize();
printf(GO_TOP); printf(GO_TOP);
printf(COLOR_BOLD_GREEN"----------------------------------------------------------------------------------------------------------------------------\n"COLOR_NORMAL); printf(COLOR_BOLD_GREEN);
drawLine();
printf(COLOR_GREEN); printf(COLOR_GREEN);
printf("| hewViewer | ofset : %7d octets | ", (int)getOfsetFile()); printf("| hexViewer | offset : %7d octets | ", (int)getOfsetFile());
printf(" Type (t) : "); printf(" Type (t) : ");
switch(myType) switch(myType)
{ {
@ -78,7 +132,8 @@ void showConfiguration(void)
printf(COLOR_GREEN"| File Left << | " COLOR_BOLD_GREEN "%s\n" COLOR_NORMAL, fileName[0]); printf(COLOR_GREEN"| File Left << | " COLOR_BOLD_GREEN "%s\n" COLOR_NORMAL, fileName[0]);
printf(COLOR_GREEN"| File Right >> | " COLOR_BOLD_GREEN "%s\n"COLOR_NORMAL, fileName[1]); printf(COLOR_GREEN"| File Right >> | " COLOR_BOLD_GREEN "%s\n"COLOR_NORMAL, fileName[1]);
printf(COLOR_BOLD_GREEN"----------------------------------------------------------------------------------------------------------------------------\n"COLOR_NORMAL); printf(COLOR_BOLD_GREEN);
drawLine();
} }
void printNoElement(showType_te localType, showTypeSize_te localSize) void printNoElement(showType_te localType, showTypeSize_te localSize)
@ -209,7 +264,8 @@ typedef union {
uint64_t data_64 [2]; uint64_t data_64 [2];
}inputData_tu; }inputData_tu;
void compareFile(FILE *filePointer1, FILE *filePointer2 ,int32_t CurentFilePosition)
void compareFile(FILE *filePointer1, FILE *filePointer2 ,int32_t curentFilePosition, int32_t currentPadding)
{ {
inputData_tu data1; inputData_tu data1;
inputData_tu data2; inputData_tu data2;
@ -222,43 +278,29 @@ void compareFile(FILE *filePointer1, FILE *filePointer2 ,int32_t CurentFilePosit
showType_te myType = getType(); showType_te myType = getType();
// Display the main show // Display the main show
printf(COLOR_BOLD_YELLOW"Ofset : | | "); printf(COLOR_BOLD_YELLOW" File offset | ");
switch(myType) switch(myType)
{ {
case SHOW_TYPE_DECIMAL_SIGNED: case SHOW_TYPE_DECIMAL_SIGNED:
case SHOW_TYPE_DECIMAL_UNSIGNED: case SHOW_TYPE_DECIMAL_UNSIGNED:
for (i = 0 ; i<2 ; i++ ) for (i = 0 ; i<2 ; i++ ) {
{
switch(mySize) switch(mySize)
{ {
case SHOW_TYPE_SIZE_8: case SHOW_TYPE_SIZE_8:
for (j=0; j<2 ; j++ ) {
printf(" +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +A +B +C +D +E +F | "); printf(" +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +A +B +C +D +E +F | ");
}
break; break;
case SHOW_TYPE_SIZE_16: case SHOW_TYPE_SIZE_16:
for (j=0; j<2 ; j++ ) {
printf(" +0 +2 +4 +6 +8 +A +C +E | "); printf(" +0 +2 +4 +6 +8 +A +C +E | ");
}
break; break;
case SHOW_TYPE_SIZE_32: case SHOW_TYPE_SIZE_32:
for (j=0; j<2 ; j++ ) {
printf(" +0 +4 +8 +C | "); printf(" +0 +4 +8 +C | ");
}
break; break;
case SHOW_TYPE_SIZE_64: case SHOW_TYPE_SIZE_64:
for (j=0; j<2 ; j++ ) {
printf(" +0 +8 | "); printf(" +0 +8 | ");
}
break; break;
default: default:
break; break;
} }
if (i == 0)
{
printf(COLOR_NORMAL"\n");
printf(COLOR_BOLD_MAGENTA" | ofset | ");
}
} }
break; break;
case SHOW_TYPE_HEX: case SHOW_TYPE_HEX:
@ -267,58 +309,80 @@ void compareFile(FILE *filePointer1, FILE *filePointer2 ,int32_t CurentFilePosit
switch(mySize) switch(mySize)
{ {
case SHOW_TYPE_SIZE_8: case SHOW_TYPE_SIZE_8:
for (j=0; j<2 ; j++ ) {
printf("+0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +A +B +C +D +E +F | "); printf("+0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +A +B +C +D +E +F | ");
}
break; break;
case SHOW_TYPE_SIZE_16: case SHOW_TYPE_SIZE_16:
for (j=0; j<2 ; j++ ) {
printf(" +0 +2 +4 +6 +8 +A +C +E | "); printf(" +0 +2 +4 +6 +8 +A +C +E | ");
}
break; break;
case SHOW_TYPE_SIZE_32: case SHOW_TYPE_SIZE_32:
for (j=0; j<2 ; j++ ) {
printf(" +0 +4 +8 +C | "); printf(" +0 +4 +8 +C | ");
}
break; break;
case SHOW_TYPE_SIZE_64: case SHOW_TYPE_SIZE_64:
for (j=0; j<2 ; j++ ) {
printf(" +0 +8 | "); printf(" +0 +8 | ");
}
break; break;
default: default:
break; break;
} }
if (i == 0)
{
printf(COLOR_NORMAL"\n");
printf(COLOR_BOLD_MAGENTA" | ofset | ");
}
} }
break; break;
} }
printf(COLOR_BOLD_YELLOW" File offset | ");
printf(COLOR_NORMAL"\n"); printf(COLOR_NORMAL"\n");
// Display the main show // Display the main show
printf(COLOR_BOLD_YELLOW"----------------------------------------------------------------------------------------------------------------------------"); printf(COLOR_BOLD_YELLOW);
printf(COLOR_NORMAL"\n"); drawLine();
for (j=0; j < NB_MAX_LINE; j++) { for (j=0; j < NB_MAX_LINE; j++) {
uint32_t readFile1 = 0; uint32_t readFile1 = 0;
uint32_t readFile2 = 0; uint32_t readFile2 = 0;
uint32_t lineNumber = 0; int32_t lineNumber = 0;
uint32_t numberOfCycle; uint32_t numberOfCycle;
// read data in files : // read data in files :
memset(data1.data_8, 0, 16 * sizeof(uint8_t)); memset(data1.data_8, 0, 16 * sizeof(uint8_t));
memset(data2.data_8, 0, 16 * sizeof(uint8_t)); memset(data2.data_8, 0, 16 * sizeof(uint8_t));
// Generate the ofset in the file
int32_t positionStartDisplayFile1 = curentFilePosition + j*NB_DATA_PER_LINE*4;
int32_t positionStartDisplayFile2 = curentFilePosition + j*NB_DATA_PER_LINE*4;
if (currentPadding < 0) {
positionStartDisplayFile1 += currentPadding;
} else {
positionStartDisplayFile2 -= currentPadding;
}
readFile1 = 0;
int32_t readStartFile1 = 16;
if (filePointer1 != NULL) { if (filePointer1 != NULL) {
if (positionStartDisplayFile1 >= 0) {
fseek(filePointer1 , positionStartDisplayFile1 , SEEK_SET );
readFile1 = fread(data1.data_8, sizeof(uint8_t), 16, filePointer1); readFile1 = fread(data1.data_8, sizeof(uint8_t), 16, filePointer1);
readStartFile1 = 0;
} else if (positionStartDisplayFile1 > -NB_DATA_PER_LINE*4) {
fseek(filePointer1 , 0 , SEEK_SET );
// Special case of the partial display ...
readFile1 = fread(data1.data_8 - positionStartDisplayFile1, sizeof(uint8_t), NB_DATA_PER_LINE*4 + positionStartDisplayFile1, filePointer1);
readStartFile1 = NB_DATA_PER_LINE*4 - readFile1;
readFile1 = 16;
} }
}
readFile2 = 0;
int32_t readStartFile2 = 16;
if (filePointer2 != NULL) { if (filePointer2 != NULL) {
if (positionStartDisplayFile2 >= 0) {
fseek(filePointer2 , positionStartDisplayFile2 , SEEK_SET );
readFile2 = fread(data2.data_8, sizeof(uint8_t), 16, filePointer2); readFile2 = fread(data2.data_8, sizeof(uint8_t), 16, filePointer2);
readStartFile2 = 0;
} else if (positionStartDisplayFile2 > -NB_DATA_PER_LINE*4) {
fseek(filePointer2 , 0 , SEEK_SET );
// Special case of the partial display ...
readFile2 = fread(data2.data_8 - positionStartDisplayFile2, sizeof(uint8_t), NB_DATA_PER_LINE*4 + positionStartDisplayFile2, filePointer2);
readStartFile2 = NB_DATA_PER_LINE*4 - readFile2;
readFile2 = 16;
} }
}
// display the line number // display the line number
lineNumber = j * (NB_DATA_PER_LINE*4) + CurentFilePosition; lineNumber = positionStartDisplayFile1;
if (lineNumber+NB_DATA_PER_LINE*4-1 >= 0) {
printf(COLOR_BOLD_YELLOW"0x%08x | "COLOR_NORMAL, (unsigned int)lineNumber); printf(COLOR_BOLD_YELLOW"0x%08x | "COLOR_NORMAL, (unsigned int)lineNumber);
switch(mySize) switch(mySize)
{ {
@ -337,6 +401,9 @@ void compareFile(FILE *filePointer1, FILE *filePointer2 ,int32_t CurentFilePosit
default: default:
break; break;
} }
} else {
printf(COLOR_BOLD_YELLOW" | "COLOR_BOLD_MAGENTA" | "COLOR_NORMAL);
}
if (readFile1 == 0) { if (readFile1 == 0) {
switch(mySize) switch(mySize)
{ {
@ -371,8 +438,8 @@ void compareFile(FILE *filePointer1, FILE *filePointer2 ,int32_t CurentFilePosit
case SHOW_TYPE_SIZE_8: case SHOW_TYPE_SIZE_8:
numberOfCycle = 16; numberOfCycle = 16;
for (i = 0; i< numberOfCycle; i++) { for (i = 0; i< numberOfCycle; i++) {
if (readFile1 >= (i+1)) { if (readFile1 >= (i+1) && readStartFile1 <= (int32_t)i ) {
bool OutOfRange = (readFile2 >= (i+1)); bool OutOfRange = (readFile2 >= (i+1) && readStartFile2 <= (int32_t)i);
bool identic = (data1.data_8[i] != data2.data_8[i]); bool identic = (data1.data_8[i] != data2.data_8[i]);
printElement((uint64_t)data1.data_8[i], myType, mySize, identic, OutOfRange); printElement((uint64_t)data1.data_8[i], myType, mySize, identic, OutOfRange);
} else { } else {
@ -383,8 +450,8 @@ void compareFile(FILE *filePointer1, FILE *filePointer2 ,int32_t CurentFilePosit
case SHOW_TYPE_SIZE_16: case SHOW_TYPE_SIZE_16:
numberOfCycle = 8; numberOfCycle = 8;
for (i = 0; i< numberOfCycle; i++) { for (i = 0; i< numberOfCycle; i++) {
if ((readFile1/2) >= (i+1)) { if ((readFile1/2) >= (i+1) && readStartFile1/2 <= (int32_t)i) {
bool OutOfRange = ((readFile2/2) >= (i+1)); bool OutOfRange = ((readFile2/2) >= (i+1) && readStartFile2/2 <= (int32_t)i);
bool identic = (data1.data_16[i] != data2.data_16[i]); bool identic = (data1.data_16[i] != data2.data_16[i]);
printElement((uint64_t)data1.data_16[i], myType, mySize, identic, OutOfRange); printElement((uint64_t)data1.data_16[i], myType, mySize, identic, OutOfRange);
} else { } else {
@ -395,8 +462,8 @@ void compareFile(FILE *filePointer1, FILE *filePointer2 ,int32_t CurentFilePosit
case SHOW_TYPE_SIZE_32: case SHOW_TYPE_SIZE_32:
numberOfCycle = 4; numberOfCycle = 4;
for (i = 0; i< numberOfCycle; i++) { for (i = 0; i< numberOfCycle; i++) {
if ((readFile1/4) >= (i+1)) { if ((readFile1/4) >= (i+1) && readStartFile1/4 <= (int32_t)i) {
bool OutOfRange = ((readFile2/4) >= (i+1)); bool OutOfRange = ((readFile2/4) >= (i+1) && readStartFile2/4 <= (int32_t)i);
bool identic = (data1.data_32[i] != data2.data_32[i]); bool identic = (data1.data_32[i] != data2.data_32[i]);
printElement((uint64_t)data1.data_32[i], myType, mySize, identic, OutOfRange); printElement((uint64_t)data1.data_32[i], myType, mySize, identic, OutOfRange);
} else { } else {
@ -407,8 +474,8 @@ void compareFile(FILE *filePointer1, FILE *filePointer2 ,int32_t CurentFilePosit
case SHOW_TYPE_SIZE_64: case SHOW_TYPE_SIZE_64:
numberOfCycle = 2; numberOfCycle = 2;
for (i = 0; i< numberOfCycle; i++) { for (i = 0; i< numberOfCycle; i++) {
if ((readFile1/8) >= (i+1)) { if ((readFile1/8) >= (i+1) && readStartFile1/8 <= (int32_t)i) {
bool OutOfRange = ((readFile2/8) >= (i+1)); bool OutOfRange = ((readFile2/8) >= (i+1) && readStartFile2/8 <= (int32_t)i);
bool identic = (data1.data_64[i] != data2.data_64[i]); bool identic = (data1.data_64[i] != data2.data_64[i]);
printElement((uint64_t)data1.data_64[i], myType, mySize, identic, OutOfRange); printElement((uint64_t)data1.data_64[i], myType, mySize, identic, OutOfRange);
} else { } else {
@ -457,8 +524,8 @@ void compareFile(FILE *filePointer1, FILE *filePointer2 ,int32_t CurentFilePosit
case SHOW_TYPE_SIZE_8: case SHOW_TYPE_SIZE_8:
numberOfCycle = 16; numberOfCycle = 16;
for (i = 0; i< numberOfCycle; i++) { for (i = 0; i< numberOfCycle; i++) {
if (readFile2 >= (i+1)) { if (readFile2 >= (i+1) && readStartFile2 <= (int32_t)i ) {
bool OutOfRange = (readFile1 >= (i+1)); bool OutOfRange = (readFile1 >= (i+1) && readStartFile1 <= (int32_t)i);
bool identic = (data1.data_8[i] != data2.data_8[i]); bool identic = (data1.data_8[i] != data2.data_8[i]);
printElement((uint64_t)data2.data_8[i], myType, mySize, identic, OutOfRange); printElement((uint64_t)data2.data_8[i], myType, mySize, identic, OutOfRange);
} else { } else {
@ -469,8 +536,8 @@ void compareFile(FILE *filePointer1, FILE *filePointer2 ,int32_t CurentFilePosit
case SHOW_TYPE_SIZE_16: case SHOW_TYPE_SIZE_16:
numberOfCycle = 8; numberOfCycle = 8;
for (i = 0; i< numberOfCycle; i++) { for (i = 0; i< numberOfCycle; i++) {
if ((readFile2/2) >= (i+1)) { if ((readFile2/2) >= (i+1) && readStartFile2/2 <= (int32_t)i ) {
bool OutOfRange = ((readFile1/2) >= (i+1)); bool OutOfRange = ((readFile1/2) >= (i+1) && readStartFile1/2 <= (int32_t)i);
bool identic = (data1.data_16[i] != data2.data_16[i]); bool identic = (data1.data_16[i] != data2.data_16[i]);
printElement((uint64_t)data2.data_16[i], myType, mySize, identic, OutOfRange); printElement((uint64_t)data2.data_16[i], myType, mySize, identic, OutOfRange);
} else { } else {
@ -481,8 +548,8 @@ void compareFile(FILE *filePointer1, FILE *filePointer2 ,int32_t CurentFilePosit
case SHOW_TYPE_SIZE_32: case SHOW_TYPE_SIZE_32:
numberOfCycle = 4; numberOfCycle = 4;
for (i = 0; i< numberOfCycle; i++) { for (i = 0; i< numberOfCycle; i++) {
if ((readFile2/4) >= (i+1)) { if ((readFile2/4) >= (i+1) && readStartFile2/4 <= (int32_t)i ) {
bool OutOfRange = ((readFile1/4) >= (i+1)); bool OutOfRange = ((readFile1/4) >= (i+1) && readStartFile1/4 <= (int32_t)i);
bool identic = (data1.data_32[i] != data2.data_32[i]); bool identic = (data1.data_32[i] != data2.data_32[i]);
printElement((uint64_t)data2.data_32[i], myType, mySize, identic, OutOfRange); printElement((uint64_t)data2.data_32[i], myType, mySize, identic, OutOfRange);
} else { } else {
@ -493,8 +560,8 @@ void compareFile(FILE *filePointer1, FILE *filePointer2 ,int32_t CurentFilePosit
case SHOW_TYPE_SIZE_64: case SHOW_TYPE_SIZE_64:
numberOfCycle = 2; numberOfCycle = 2;
for (i = 0; i< numberOfCycle; i++) { for (i = 0; i< numberOfCycle; i++) {
if ((readFile2/8) >= (i+1)) { if ((readFile2/8) >= (i+1) && readStartFile2/8 <= (int32_t)i ) {
bool OutOfRange = ((readFile1/8) >= (i+1)); bool OutOfRange = ((readFile1/8) >= (i+1) && readStartFile1/8 <= (int32_t)i);
bool identic = (data1.data_64[i] != data2.data_64[i]); bool identic = (data1.data_64[i] != data2.data_64[i]);
printElement((uint64_t)data2.data_64[i], myType, mySize, identic, OutOfRange); printElement((uint64_t)data2.data_64[i], myType, mySize, identic, OutOfRange);
} else { } else {
@ -509,7 +576,31 @@ void compareFile(FILE *filePointer1, FILE *filePointer2 ,int32_t CurentFilePosit
i++; i++;
} }
} }
printf(COLOR_NORMAL" |\n");
lineNumber = positionStartDisplayFile2;
if (lineNumber+NB_DATA_PER_LINE*4-1 >= 0) {
switch(mySize)
{
case SHOW_TYPE_SIZE_8:
printf(COLOR_BOLD_MAGENTA" | %7d ", (int)(lineNumber));
break;
case SHOW_TYPE_SIZE_16:
printf(COLOR_BOLD_MAGENTA" | %7d ", (int)(lineNumber/2));
break;
case SHOW_TYPE_SIZE_32:
printf(COLOR_BOLD_MAGENTA" | %7d ", (int)(lineNumber/4));
break;
case SHOW_TYPE_SIZE_64:
printf(COLOR_BOLD_MAGENTA" | %7d ", (int)(lineNumber/8));
break;
default:
break;
}
printf(COLOR_BOLD_YELLOW"| 0x%08x"COLOR_NORMAL " |\n", (unsigned int)lineNumber);
} else {
printf(COLOR_BOLD_MAGENTA" | "COLOR_BOLD_YELLOW"| "COLOR_NORMAL " |\n");
}
} }
} }
@ -526,14 +617,9 @@ void * threadDisplay (void * p_data)
while (1) while (1)
{ {
if (getParamModification()) { if (getParamModification()) {
uint32_t CurentFilePosition = getOfsetFile(); uint32_t curentFilePosition = getOfsetFile();
if (filePointer[0] != NULL) { uint32_t curentFilePadding = getPaddingOffsetFile();
fseek ( filePointer[0] , CurentFilePosition , SEEK_SET ); compareFile(filePointer[0],filePointer[1], curentFilePosition, curentFilePadding);
}
if (NULL != filePointer[1]) {
fseek ( filePointer[1] , CurentFilePosition , SEEK_SET );
}
compareFile(filePointer[0],filePointer[1], CurentFilePosition);
} else { } else {
usleep(10000); usleep(10000);
} }

2
generalDefine.h
View File

@ -82,7 +82,7 @@ typedef signed long long int int64_t;
#define NB_DATA_PER_LINE (4) #define NB_DATA_PER_LINE (4)
#define NB_MAX_LINE (50) #define NB_MAX_LINE (45)

142
main.c
View File

@ -30,6 +30,7 @@
bool filePresent[2] = {false, false};
FILE *filePointer[2] = {NULL, NULL}; FILE *filePointer[2] = {NULL, NULL};
uint32_t filesize[2] = {0, 0}; uint32_t filesize[2] = {0, 0};
char fileName[2][2096] = {"",""}; char fileName[2][2096] = {"",""};
@ -52,6 +53,7 @@ void usage(void)
printf("\t\t[LEFT] Go up 50 line in the view (one screen)\n"); printf("\t\t[LEFT] Go up 50 line in the view (one screen)\n");
printf("\t\t[RIGHT] Go down 50 line in the view (one screen)\n"); printf("\t\t[RIGHT] Go down 50 line in the view (one screen)\n");
printf("\t\n"); printf("\t\n");
/*
printf("\tTODO : \n"); printf("\tTODO : \n");
printf("\t\t- The print of 128 bytes\n"); printf("\t\t- The print of 128 bytes\n");
printf("\t\t- The print in Octal\n"); printf("\t\t- The print in Octal\n");
@ -67,6 +69,7 @@ void usage(void)
printf("\t\t- Add to the croling bar the differences in the two files\n"); printf("\t\t- Add to the croling bar the differences in the two files\n");
printf("\t\t- The research of a sequency in the two files ==> [R]\n"); printf("\t\t- The research of a sequency in the two files ==> [R]\n");
printf("\t\t- The jump to an offset directly ==> [J] \n"); printf("\t\t- The jump to an offset directly ==> [J] \n");
*/
/*printf("\t\t- \n");*/ /*printf("\t\t- \n");*/
} }
@ -87,16 +90,70 @@ int32_t findFirstDiff(void)
|| NULL == filePointer[1] ) { || NULL == filePointer[1] ) {
return 0; return 0;
} }
if(NULL != filePointer[0]) {
fseek ( filePointer[0] , 0 , SEEK_SET );
}
if(NULL != filePointer[1]) {
fseek ( filePointer[1] , 0 , SEEK_SET );
}
while ( fread(&data1, sizeof(uint8_t), 1, filePointer[0]) == 1 while ( fread(&data1, sizeof(uint8_t), 1, filePointer[0]) == 1
&& fread(&data2, sizeof(uint8_t), 1, filePointer[1]) == 1) && fread(&data2, sizeof(uint8_t), 1, filePointer[1]) == 1)
{ {
offset ++; offset ++;
if (data1 != data2) if (data1 != data2) {
return offset;
}
}
return offset;
}
void UpdateFilesSize(void)
{ {
return offset; // get size file 1
if ( NULL != filePointer[0]) {
fseek ( filePointer[0] , 0 , SEEK_END );
filesize[0] = ftell (filePointer[0]);
fseek ( filePointer[0] , 0 , SEEK_SET );
}
// get size file 2
if ( NULL != filePointer[1]) {
fseek ( filePointer[1] , 0 , SEEK_END );
filesize[1] = ftell (filePointer[1]);
fseek ( filePointer[1] , 0 , SEEK_SET );
} }
} }
return offset;
void OpenFiles(void) {
filePointer[0] = NULL;
filePointer[1] = NULL;
filesize[0] = 0;
filesize[1] = 0;
if (true == filePresent[0]) {
// Open file 1
filePointer[0] = fopen(fileName[0], "rb");
if ( NULL == filePointer[0]) {
printf("Can not Open [File_1] = %s\n", fileName[0]);
}
}
if (true == filePresent[1]) {
// open File 2
filePointer[1] = fopen(fileName[1], "rb");
if ( NULL == filePointer[1]) {
printf("Can not Open [File_2] = %s\n", fileName[1]);
}
}
UpdateFilesSize();
}
void CloseFiles(void) {
if (NULL != filePointer[0]) {
fclose(filePointer[0]);
filePointer[0] = NULL;
} if (NULL != filePointer[1]) {
fclose(filePointer[1]);
filePointer[1] = NULL;
}
} }
@ -105,51 +162,27 @@ int main (int argc, char**argv)
int32_t first_Error = 0; int32_t first_Error = 0;
filePointer[0] = NULL; filePointer[0] = NULL;
filePointer[1] = NULL; filePointer[1] = NULL;
filesize[0] = 0;
filesize[1] = 0;
strcpy(fileName[0], "No-File"); strcpy(fileName[0], "No-File");
strcpy(fileName[1], "No-File"); strcpy(fileName[1], "No-File");
// check error
if (3 < argc || argc < 2) { if (3 < argc || argc < 2) {
printf("You set more than 3 argument at the commande line\n"); printf("You set more than 3 argument at the commande line\n");
usage(); usage();
return -1; return -1;
} }
// one file
if (2 <= argc) { if (2 <= argc) {
// Open file 1
filePointer[0] = fopen(argv[1], "rb");
strcpy(fileName[0], argv[1]); strcpy(fileName[0], argv[1]);
if ( NULL == filePointer[0]) { filePresent[0] = true;
printf("Can not Open [File_1] = %s\n", fileName[0]);
}
// get size file 1
if ( NULL != filePointer[0]) {
fseek ( filePointer[0] , 0 , SEEK_END );
filesize[0] = ftell (filePointer[0]);
fseek ( filePointer[0] , 0 , SEEK_SET );
} else {
filesize[0] = 0;
}
} }
// a second file
if (3 <= argc) { if (3 <= argc) {
// open File 2
filePointer[1] = fopen(argv[2], "rb");
strcpy(fileName[1], argv[2]); strcpy(fileName[1], argv[2]);
if ( NULL == filePointer[1]) { filePresent[1] = true;
printf("Can not Open [File_2] = %s\n", fileName[1]);
} }
// get size file 2 // open the files
if ( NULL != filePointer[1]) { OpenFiles();
fseek ( filePointer[1] , 0 , SEEK_END );
filesize[1] = ftell (filePointer[1]);
fseek ( filePointer[1] , 0 , SEEK_SET );
} else {
filesize[1] = 0;
}
}
// try to find the first error...
first_Error = findFirstDiff();
// rendre la lecture des données non canonique // rendre la lecture des données non canonique
system("stty -icanon"); system("stty -icanon");
@ -214,7 +247,10 @@ int main (int argc, char**argv)
// find the first ERROR // find the first ERROR
case 'f': case 'f':
case 'F': case 'F':
setOfsetFile((first_Error/16)*16 - 256); // try to find the first error...
first_Error = findFirstDiff();
setOfsetFile((first_Error/16)*16 - 128);
needRedraw();
break; break;
// find the first ERROR // find the first ERROR
case 'a': case 'a':
@ -225,6 +261,7 @@ int main (int argc, char**argv)
case 'z': case 'z':
case 'Z': case 'Z':
{ {
UpdateFilesSize();
static bool whichElement = false; static bool whichElement = false;
if (whichElement == false) { if (whichElement == false) {
whichElement = true; whichElement = true;
@ -235,6 +272,35 @@ int main (int argc, char**argv)
} }
} }
break; break;
// Reload the 2 files
case 'r':
case 'R':
CloseFiles();
OpenFiles();
needRedraw();
break;
// Add padding offset between left an right file
case 'o':
case 'O':
displayPaddingOffset(1);
break;
case 'l':
case 'L':
displayPaddingOffset(-1);
break;
case 'p':
case 'P':
displayPaddingOffset(16);
break;
case 'm':
case 'M':
displayPaddingOffset(-16);
break;
// Clear the padding
case 'k':
case 'K':
displayPaddingOffsetClear();
break;
} }
} }
} else { } else {
@ -242,11 +308,7 @@ int main (int argc, char**argv)
} }
exit_programme : exit_programme :
if (NULL != filePointer[0]) { CloseFiles();
fclose(filePointer[0]);
} if (NULL != filePointer[1]) {
fclose(filePointer[1]);
}
// remettre la lecture des données canonique // remettre la lecture des données canonique
system("stty icanon"); system("stty icanon");

27
parameter.c
View File

@ -27,6 +27,7 @@
// Parameter Local Value : // Parameter Local Value :
static uint32_t fileOfset = 0; static uint32_t fileOfset = 0;
static uint32_t paddingOffset = 0;
static bool parmamModifier = true; static bool parmamModifier = true;
@ -68,6 +69,24 @@ uint32_t getOfsetFile(void)
return fileOfset; return fileOfset;
} }
void displayPaddingOffset(int32_t size)
{
paddingOffset += size;
parmamModifier = true;
}
void displayPaddingOffsetClear(void)
{
paddingOffset = 0;
parmamModifier = true;
}
int32_t getPaddingOffsetFile(void)
{
return paddingOffset;
}
bool getParamModification() bool getParamModification()
{ {
if (parmamModifier == true) { if (parmamModifier == true) {
@ -78,7 +97,9 @@ bool getParamModification()
} }
} }
void needRedraw(void) {
parmamModifier = true;
}
void nextType(void) void nextType(void)
{ {
@ -137,3 +158,7 @@ showTypeSize_te getTypeSize(void)
{ {
return curentTypeSize; return curentTypeSize;
} }

5
parameter.h
View File

@ -35,12 +35,15 @@ void upDownOfsetFile(int32_t offset);
uint32_t getOfsetFile(void); uint32_t getOfsetFile(void);
bool getParamModification(); bool getParamModification();
void needRedraw(void);
void nextType(void); void nextType(void);
showType_te getType(void); showType_te getType(void);
void nextTypeSize(void); void nextTypeSize(void);
showTypeSize_te getTypeSize(void); showTypeSize_te getTypeSize(void);
void displayPaddingOffset(int32_t size);
void displayPaddingOffsetClear(void);
int32_t getPaddingOffsetFile(void);
#endif #endif