Open multiple files and store them in array of structures - c

Question

I need some help with my task. I have to open unknown number of files and store them in data structure at the start of program. First file contains names of two other files and so on ( this is explained more under example of first file).
Each file has same structure:
[Title of file] [name of file X][name of file Y][Text]
, for example, first file will looks like this:
File 1 file_8.txt file_25.txtText: "this is some example text, lenght is unknown so so i will have to use malloc and realloc to dynamicaly store it."
The name of first file is typed in stdin by user when starting a program
(example: ./task1 page_1.txt)
The first line stores the title of the file. The second and third lines each contain a file name of a next file that i have to read/store.If there are no further names of files on 2nd and 3rd line, both of the lines will have " -\n ". Text starts at fourth line (can have multiple lines like in example above)
My struct for now:
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
char title[1000]; // should use malloc and realloc and not this way
char file_x[1000]; // dynamically
char file_y[1000]; // dynamically
char text[10000];
} Story;
My main looks like this:
int main (int argc,char *argv[])
{
char c[100];
char buffer[100];
FILE *input = fopen(argv[1], "r");
Story *temp = (Story*) malloc(sizeof(Story) * 8);
if(input)
{
int flag = 0;
while (fgets(c, sizeof(buffer),input) != NULL)
{
if(flag == 0)
{
sscanf(c, "%s", temp->title);
}
else if(flag == 1)
{
sscanf(c, "%s", temp->file_x);
}
else if(flag == 2)
{
sscanf(c, "%s", temp->file_y);
}
else
{
while(!feof(input))
{
fread(temp->text, sizeof(Story),1,input);
}
}
flag++;
}
printf("%s\n%s\n%s\n", temp->title,
temp->file_x, temp->file_y);
}
else if (input == NULL)
{
printf("ERROR MESSAGE HERE \n");
return 1;
}
free(temp);
fclose(input);
return 0;
}
For now i managed to open first file and store it to structure. I need an idea how to open and store all other files and also have to implement it using dynamic memory allocation.
Any advice is greatly appreciated.

Answer 1

I suspect your lesson is covering recursion as with each element in your array of story you will need to branch an unknown number of times to read file_x and file_y (each of which can contain additional file_x and file_y within). Your procedural option is to follow down the trail of all file_x and then return to each file_y repeating the process until you reach the final files in each chain where file_x and file_y are empty.
Before determining which approach you will take, you simply need a way to read one file, extract the title, file_x, file_y and allocate and store text. This is a fairly straight-forward process where your primary task is to validate each step so you have confidence that you are processing actual data and are not invoking Undefined Behavior by reading from a file that isn't actually open or attempting to write (or read) beyond the bounds of your storage.
Here is a short example that takes a pointer to story to fill and the filename to read from. You will note a repetitive process involved. (read the string with fgets, get the length, validate the last char read was '\n' indicating you read the whole line, and finally trimming the '\n' by either overwriting with a nul-terminating character so you don't have newlines dangling off the end of your stored string, or overwriting with a ' ' (space) in the case of text where you are concatenating lines together.
note: below, realloc is never called directly on the pointer to text. Instead a tmp pointer is used with realloc to validate realloc succeeds before assigning the new block to text. (otherwise you will lose your pointer to text if realloc fails -- because it returns NULL)
/* read values into struct story 's' from 'filename' */
int read_file (story *s, char *filename)
{
size_t len = 0, /* var for strlen */
text_size = 0, /* total text_size */
nul_char = 0; /* flag for +1 on first allocation */
char buf[TITLE_MAX] = ""; /* read buffer for 'text' */
FILE *fp = fopen (filename, "r"); /* file pointer */
if (!fp) /* validate file open for reading */
return 0; /* or return silently indicating no file_x or file_y */
if (fgets (s->title, TITLE_MAX, fp) == 0) { /* read title */
fprintf (stderr, "error: failed to read title from '%s'.\n",
filename);
fclose(fp);
return 0;
}
len = strlen (s->title); /* get title length */
if (len && s->title[len - 1] == '\n') /* check last char is '\n' */
s->title[--len] = 0; /* overwrite with nul-character */
else { /* handle error if line too long */
fprintf (stderr, "error: title too long, filename '%s'.\n",
filename);
fclose(fp);
return 0;
}
if (fgets (s->file_x, PATH_MAX, fp) == 0) { /* same for file_x */
fprintf (stderr, "error: failed to read file_x from '%s'.\n",
filename);
fclose(fp);
return 0;
}
len = strlen (s->file_x);
if (len && s->file_x[len - 1] == '\n')
s->file_x[--len] = 0;
else {
fprintf (stderr, "error: file_x too long, filename '%s'.\n",
filename);
fclose(fp);
return 0;
}
if (fgets (s->file_y, PATH_MAX, fp) == 0) { /* same for file_y */
fprintf (stderr, "error: failed to read file_y from '%s'.\n",
filename);
fclose(fp);
return 0;
}
len = strlen (s->file_y);
if (len && s->file_y[len - 1] == '\n')
s->file_y[--len] = 0;
else {
fprintf (stderr, "error: file_y too long, filename '%s'.\n",
filename);
fclose(fp);
return 1;
}
while (fgets (buf, TITLE_MAX, fp)) { /* read text in TITLE_MAX chunks */
len = strlen (buf);
if (len && buf[len - 1] == '\n') /* check for '\n' */
buf[len - 1] = ' '; /* overwrite with ' ' for concat */
if (text_size == 0)
nul_char = 1; /* account for space for '\0' when empty, and */
else /* use a flag to set new block to empty-string */
nul_char = 0;
void *tmp = realloc (s->text, text_size + len + nul_char); /* allocate */
if (!tmp) { /* validate realloc succeeded */
fprintf (stderr, "error: realloc failed, filename '%s'.\n",
filename);
break;
}
s->text = tmp; /* assign new block to s->text */
if (nul_char) /* if first concatenation */
*(s)->text = 0; /* initialize s->text to empty-string */
strcat (s->text, buf); /* concatenate buf with s->text */
text_size += (len + 1); /* update text_size total */
}
fclose (fp); /* close file */
return 1;
}
With this, you will need to design a way to work through all file_x and file_y filenames. As mentioned above, this likely lends itself to a recursive function, or you can work your way down the file_x tree and circle back and pick up all the file_y additions. Note, you need to account for the new addition of story each time either file_x or file_y are followed.
Below is a short example that follows through all file_x additions and comes back and follow through only the 1st file_y branch. It is intended to shown you how to handle the calling and filling from both a file_x and file_y rather than write the final code for you. If you add the following above the read_file function, you will have a working example:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h> /* for PATH_MAX */
enum { STORY_MAX = 12, TITLE_MAX = 1024 };
typedef struct
{
char title[TITLE_MAX],
file_x[PATH_MAX],
file_y[PATH_MAX],
*text;
} story;
int read_file (story *s, char *filename);
int main (int argc, char **argv) {
int n = 0, storycnt = 0;
story stories[STORY_MAX] = {{ .title = "" }};
char *filename = argv[1];
/* read all file_x filenames */
while (n < STORY_MAX && read_file (&stories[n], filename)) {
filename = stories[n++].file_x;
}
storycnt = n; /* current story count of all file_x */
for (int i = 0; i < storycnt; i++) /* find all file_y files */
while (n < STORY_MAX && read_file (&stories[n], stories[i].file_y)) {
filename = stories[i++].file_y;
n++;
}
for (int i = 0; i < n; i++) { /* output stories content */
printf ("\ntitle : %s\nfile_x: %s\nfile_y: %s\ntext : %s\n",
stories[i].title, stories[i].file_x,
stories[i].file_y, stories[i].text);
free (stories[i].text); /* don't forget to free memory */
}
return 0;
}
Example Input Files
$ cat file_1.txt
File 1
file_8.txt
file_25.txt
Text: "this is some example text, lenght is unknown
so i will have to use malloc and realloc to
dynamicaly store it."
$ cat file_8.txt
file_8
This is the text from file 8. Not much,
just some text.
$ cat file_25.txt
file_25
This is the text from file 25. Not much,
just some text.
Example Use/Output
$ ./bin/rdstories file_1.txt
title : File 1
file_x: file_8.txt
file_y: file_25.txt
text : Text: "this is some example text, lenght is unknown so i will
have to use malloc and realloc to dynamicaly store it."
title : file_8
file_x:
file_y:
text : This is the text from file 8. Not much, just some text.
title : file_25
file_x:
file_y:
text : This is the text from file 25. Not much, just some text.
Memory Use/Error Check
In any code you write that dynamically allocates memory, you have 2 responsibilities regarding any block of memory allocated: (1) always preserve a pointer to the starting address for the block of memory so, (2) it can be freed when it is no longer needed.
For Linux valgrind is the normal choice. There are similar memory checkers for every platform. They are all simple to use, just run your program through it.
$ valgrind ./bin/rdstories file_1.txt
==9488== Memcheck, a memory error detector
==9488== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==9488== Using Valgrind-3.11.0 and LibVEX; rerun with -h for copyright info
==9488== Command: ./bin/rdstories file_1.txt
==9488==
title : File 1
file_x: file_8.txt
file_y: file_25.txt
text : Text: "this is some example text, lenght is unknown so i will
have to use malloc and realloc to dynamicaly store it."
title : file_8
file_x:
file_y:
text : This is the text from file 8. Not much, just some text.
title : file_25
file_x:
file_y:
text : This is the text from file 25. Not much, just some text.
==9488==
==9488== HEAP SUMMARY:
==9488== in use at exit: 0 bytes in 0 blocks
==9488== total heap usage: 13 allocs, 13 frees, 3,353 bytes allocated
==9488==
==9488== All heap blocks were freed -- no leaks are possible
==9488==
==9488== For counts of detected and suppressed errors, rerun with: -v
==9488== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Always confirm that you have freed all memory you have allocated and that there are no memory errors.
Look things over and let me know if you have questions.