Processing file extensions in C

Question

I'm developing some code in C that reads a file extension and stores it as a code in a byte together whether a text file or binary file is being processed. Later I wish to recover the file extension that is encoded in a byte.

As a test I created a loop in the main function where I can test out the function fileExtenCode(), which is in the second listing.

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

#define EXLEN 9
#define EXNUM 8

typedef unsigned char BYTE;

bool fileExtenCode(char*, BYTE*, int*);

int main(void) {
  char fileExten[EXLEN];
  BYTE code;
  int bin;

  for (;;) {
    printf("Type file extension: ");
    scanf_s("%s", fileExten, EXLEN);
    if (fileExten[0] == '.') break;
    printf("%s\n", fileExten);
    code = 0;
    bin = 0;
    bool extFound = fileExtenCode(fileExten, &code, &bin); // <== (1)
    if (extFound) printf("Extension found: TRUE\n");
    else          printf("Extension found: FALSE\n");
    printf("%s%d", "Code: ", code);
    if (bin) printf("  binary file\n");
    else     printf("  text file\n");
    printf("\n");

    printf("Type code: ");
    int icode;
    scanf_s("%d", &icode);
    code = icode;
    bin = -1;
    fileExtenCode(fileExten, &code, &bin); // <== (2)
    printf("%s", fileExten);               // <== (5)
    printf("\n");
  }
  return 0;
}

The function that I'm trying to test is as follows:

bool fileExtenCode(char* ext, BYTE* code, int* binary) {
  char *fileEx[EXNUM] = {
    "jpg1", "txt0", "html0", "xml0", "exe1", "bmp1", "gif1", "png1"};

  if (*binary < 0) {       // <== (3)
    ext = fileEx[*code];   // <== (4)
    return true;
  }

  size_t extLen = strlen(ext);
  for (BYTE i = 0; i < EXNUM; i++) {
    if (strncmp(fileEx[i], ext, extLen) == 0) {
        *binary = (fileEx[i][extLen] == '1') ? 1 : 0;
        *code = i;
        return true;
    }
  }
  return false;
}

The idea is that you pass a string with the file extension to fileExtenCode() in statement (1) in main, and the function searched for that extension in an array, and if found returns true together with the code argument indicating the position in array of file extensions and the binary flag as 0 or 1 indicating if the file is text or binary. A '0' or '1' immediately follows file extension in the array. If the extension is not found, the function returns with false and the return values in the arguments have no meaning.

So far so good, and this part works correctly. However, in using the function in reverse to recover the file extension given the input value of code, it fails when called with statement (2) in main. In this case binary is set to -1, and then the function is called and the condition at (3) is now true and ext in (4) recovers the file extension. This is confirmed when inserting a temporary print statement immediately after (4), but this value is not returned in (5) back in main, and an old input value is instead printed.

Obviously there is a problem with pointers, but I cannot see an obvious way of fixing it. My question is how to correct this without messing up the rest of the code, which is working correctly? Note that char* ext and BYTE* code are used for both input and output, whilst int* binary is used as an input flag and returns no useful value when set to -1.

Once this problem is fixed, then it should be relatively easy to separate the binary flag from the extension when the binary flag is set to -1. Eventually I plan to have many more file extensions, but not until this is working correctly with a sample of 8.

Getting help in fixing this problem would be most appreciated.

Have you tried to use a [*debugger*](https://stackoverflow.com/questions/25385173/what-is-a-debugger-and-how-can-it-help-me-diagnose-problems) to step through the code statement by statement while monitoring variables and their values, to see what happens? — Some programmer dude, May 22 '22 at 06:58
I also recommend that you don't use a single function for multiple functionality. [Separation of concern](https://en.wikipedia.org/wiki/Separation_of_concerns) is a nice principle to strive for. Use two different functions instead. That usually makes it easier to debug as well (and often makes the code easier to read, understand and maintain). — Some programmer dude, May 22 '22 at 07:01
(4) `strcpy(ext, fileEx[*code]);` because the array `fileEx` does not exist outside the function. — pmg, May 22 '22 at 07:01
Finally a hint about your problem: Remember that in C arguments are passed *by value*. Which means that the value used in the call is copied into the functions local argument variables. The life-time of local variables (including arguments) ends when the function ends. All changes (for example *assignments*) to such variables will be lost when the function returns. — Some programmer dude, May 22 '22 at 07:02

score 0 · Answer 1 · answered May 22 '22 at 15:25

OK, many thanks pmg, that works, except that I have to use:

strcpy_s(ext, EXLEN, fileEx[*code]);

as the Visual Studio 2022 compiler flags an error. This also solves a warning I was getting when I declared the array *fileEx[EXNUM] with the const keyword.

In my haste last night I omitted to include the statement:

if (*code >= EXNUM) return false;

immediately after (3) to trap the case when *code goes out of bounds of *fileEx[EXNUM].

Processing file extensions in C

1 Answers1