How to change the extension of the file

Question

There are similar questions but my problem is a little more specific. I have a C code that takes file.txt and returns file.txt.rle when I am encoding by using RLE algorithm. Same way I decode that and want to write from file.txt.rle and return file.txt. The following code is what I am using as I go from file.txt to file.txt.rle:

char name[NAME_SIZE];
if(sprintf(name, "%s.rle", argv[1]) >= sizeof(name)){
    fprintf(stderr, "Destination file name is too long\n");
}
while((o_fp = fopen(name, "wb")) == NULL){
    fprintf(stderr, "Can't create the file to be written\n");
      exit(1);
}

How can I accomplish to change the extension from file.txt.rle to file.txt when I decode? A full code won't help because I will use this in a code that decodes an encoded file.

Note: The given will always be in .txt.rle format and the returning file should always convert it to .txt.

Answer 1

You can simply do this with:

• strrchr to find where is the last period in string,
• strlen / malloc to allocate memory to store the new name,
• sprintf to create the new name.

---

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

/* this function will create a new name, replacing the existing extension
   by the given one.
   returned value should be `free()` after usage

   /!\ warning: 
        * validity of parameters is not tested
        * return of strdup and malloc are not tested.
   */
char *replace_ext(const char *org, const char *new_ext)
{
    char *ext;

    /* copy the original file */
    char *tmp = strdup(org);

    /* find last period in name */
    ext = strrchr(tmp , '.');

    /* if found, replace period with '\0', thus, we have a shorter string */
    if (ext) { *ext = '\0'; }

    /* compute the new name size: size of name w/o ext + size of ext + 1 
       for the final '\0' */
    size_t new_size = strlen(tmp) + strlen(new_ext) + 1;

    /* allocate memory for new name*/
    char *new_name = malloc(new_size);

    /* concatenate the two string */
    sprintf(new_name, "%s%s", tmp, new_ext);

    /* free tmp memory */
    free(tmp);

    /* return the new name */
    return new_name;
}

int main(void)
{
    int i;
    char *tests[] = { "test.ext", "test.two.ext", "test_no_ext", NULL};

    for (i = 0; tests[i]; ++i)
    {
        char *new_name = replace_ext(tests[i], ".foo");
        printf("%s --> %s\n", tests[i], new_name);
        free(new_name);
    }

    return 0;
}

Answer 2

Here is an implementation. The magic here is carried out by the change_file_name(org, dest, size, ext), that checks whether the name org ends with ext, and in that case copies the name up to that point.

Hope this helps.

 /* Changes the name of the sys input file. */

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


bool change_file_name(const char * org, char * dest, size_t max_length, const char * file_ext)
{
    bool toret = false;
    const size_t name_length = strlen( org );
    const size_t ext_length = strlen( file_ext );
    const size_t new_name_size = name_length - ext_length;

    if ( name_length > ext_length
      && name_length < max_length
      && strcmp( org + new_name_size, file_ext ) == 0 )
    {
        strncpy( dest, org, name_length - ext_length );
        *( dest + new_name_size ) = 0;
        toret = true;
    }

    return toret;
}

void convert_file(const char * org, const char * dest)
{
    printf( "Processing file '%s' into '%s'\n", org, dest );
}

int main(int argc, char *argv[])
{
    const int NAME_SIZE = 1024;
    const char * rle_ext = ".rle";
    char new_name[NAME_SIZE];
    int toret = EXIT_SUCCESS;

    if ( argc == 2 ) {
        if ( change_file_name( argv[ 1 ], new_name, NAME_SIZE, rle_ext ) ) {
            printf( "The new name is: '%s'\n", new_name );
            convert_file( argv[ 1 ], new_name );
        } else {
            toret = EXIT_FAILURE;
            fprintf( stderr,
                     "Name results empty, is not ending in '%s' or is too large: '%s'\n",
                     rle_ext,
                     argv[ 1 ] );
        }
    } else {
        toret = EXIT_FAILURE;
        fprintf( stderr, "Usage: %s <file name>.txt.rle\n", argv[ 0 ] );
    }

    return toret;
}

Answer 3

You can use strsep (successor to strtok) to tokenize your input filename and copy the parts which you are interested in and discarding the rest.

If your input filename is always of the form file.txt.rle, you can use the below code.

char *name = malloc(sizeof(char) * NAME_SIZE);
if(sprintf(name, "%s.rle", argv[1]) >= sizeof(name)){
    fprintf(stderr, "Destination file name is too long\n");
}

char *token = NULL;
char *newfilename = malloc(sizeof(char) * (NAME_SIZE-4)); //strlen(".rle") = 4
uint8_t offset = 0;
memset(newfilename, 0, (NAME_SIZE-4));

while ((token = strsep(&name, ".")) != NULL) {
    if(strcmp(token, "rle") == 0) {
        break;
    }
    strncpy(newfilename+offset, token, strlen(token));
    offset += strlen(token);
    newfilename[offset] = '.';
    offset += 1;
}
newfilename[strlen(newfilename)-1] = '\0';