Using strtok( ) to extract substring from double quotes - c

Question

I'm trying to make a code, that should read all of the columns, row by row in csv file; then storing them under a struct array, that is called movies in this code. I actually managed to store the data, but just because of picking the parameter of delimater in strtok lines, some of my movies' data has missing;
Example: Row in the file:
Synecdoche, New York - Charlie Kaufman - 2008 - Drama
has to be stored as;
id = 37
name = Synecdoche, New York
directorName = Charlie Kaufman
year = 2008
genre = Drama
but it is stored as;
id = 37
name = Synecdoche
directorName = New York
year = Charlie Kaufman
genre = 2008
I am aware that this is because the string of characters I need to separate contains a comma; but I couldn't find how to solve it. So how can I make the strtok only split the string inside the double quotes?
I don't know if anyone can understand; but still I leave my code like this below;
#include <conio.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct movie{
int id;
char name[100];
char directorName[100];
int year;
char genre[30];
} movie;
movie movies[100];
void remove_all_chars(char* str, char c) {
char *pr = str, *pw = str;
while (*pr) {
*pw = *pr++;
pw += (*pw != c);
}
*pw = '\0';
}
void fillMovies(FILE *filePointer)
{
char line[150];
int id = 1;
int arrIndex = 0;
while(!feof(filePointer))
{
fgets(line, sizeof(line), filePointer);
puts(line);
//sleep(1);
int i = 1;
char* value = strtok(line, ",");
struct movie movie = {
id,
"",
"",
0,
""
};
while(value != NULL)
{
//remove_all_chars(value, '\"');
printf("%s ", value);
if(i == 1)
{
//movie.name = value;
strcat(movie.name, value);
//movie.name += value;
i++;
value = strtok(NULL, ",");
continue;
}
if(i == 2)
{
//movie.directorName = value;
strcat(movie.directorName, value);
//movie.directorName += value;
i++;
value = strtok(NULL, ",");
continue;
}
if(i == 3)
{
movie.year = atoi(value);
i++;
value = strtok(NULL, ",");
continue;
}
if(i == 4)
{
//movie.genre = value;
strcat(movie.genre, value);
movies[arrIndex] = movie;
arrIndex++;
id++;
value = strtok(NULL, ",");
break;
}
}
printf("\n");
}
// Close the file
fclose(filePointer);
}
void printMovie(int i)
{
sleep(1);
printf("%d. ", movies[i].id);
printf("%s", movies[i].name);
printf(", ");
printf("%s", movies[i].directorName);
printf(", ");
printf("%d", movies[i].year);
printf(", ");
printf("%s", movies[i].genre);
}
// close, stringleri nasýl eþitleyeceðini bul.
int main()
{
// Buraya kendi dosya pathini lütfen yaz.
FILE* filePointer = fopen("movies.csv", "r");
if (!filePointer)
{
printf("Can't open file\n");
} else {
fillMovies(filePointer);
int i = 0;
while(i < 60){
printMovie(i);
i++;
}
}
return 0;
}

Answer 1

One of the sad truths to CSV files is that they look simple, and promise simplicity, but very quickly become nightmares to read. For any truly non-trivial CSV file, you need to build a state machine.
However, if we can put three significant constraints on your input then we can make life a whole easier:
Each record in your CSV is exactly N fields long
No quoted field will embed the quote character itself
Each field is known to be quoted or unquoted
No field is empty
If that is the case then you really only need a function to read characters from a file until one of a set of delimiters is encountered. That is fortunately very easy.
The other disheartening truth (and this applies to all computer languages) is that user input is really, really hard. Here is a function that crosses all the important ‘t’s and dots the ‘i’s.
int read_delimited( FILE * f, char * s, int n, const char * cs )
//
// Get text from a file.
//
// f File to read
// s Buffer to store characters read from f.
// The resulting buffer will always be null-terminated.
// May not be NULL.
// n Size of buffer. Must be at least 1.
// cs Delimiters.
// May not be NULL. (But it may be empty.)
//
// Read terminates only when EOF or one of the delimiters is read.
// Read does not terminate when the buffer fills up! If your buffer
// is too small the entire field is still read, but only (n-1)
// characters from the file are stored.
//
// Returns the last character read (either EOF or a delimiter).
//
{
int count = 0;
while (true)
{
int c = fgetc( f );
if ((c == EOF) or strchr( cs, c )) break;
if (count < n) s[count++] = c;
}
s[count] = '\0';
return c;
}
You can then use this and a little helper function in a loop to collect all your data for each record.
int skip_chars( FILE * f, const char * cs )
//
// Skips all characters in cs[].
// Returns the character last read (EOF or something not in cs[]).
//
{
int c;
do c = fgetc( f );
while ((c != EOF) and !!strchr( cs, c ));
return c;
}
bool read_movie( FILE * f, movie * m )
{
char s[100];
int c = skip_chars( f, " \t\n" ); // skip whitespace, including newlines
if (c == EOF) return false;
read_delimited( f, s, sizeof(s), "," );
m->id = atoi( s );
skip_chars( f, " \t" ); // skip leading ws
read_delimited( f, m->name, sizeof(m->name), "\"" );
skip_chars( f, " \t," ); // skip ws and trailing ,
read_delimited( f, m->directorName, sizeof(m->directorName), "\"" );
skip_chars( f, " \t," ); // skip trailing ws, trailing comma, leading ws
read_delimited( f, s, sizeof(s), "," );
m->year = atoi( s );
skip_chars( f, " \t" ); // skip leading ws
read_delimited( f, m->genre, sizeof(m->genre), "\n" );
return m->genre[0] != '\0';
}
After that you just need a loop to read all the records:
const int max_movies = 100;
movie movies[max_movies];
int num_movies = 0;
while ((num_movies < max_movies) and read_movie( f, &movies[num_movies] ))
{
num_movies += 1;
}
As you can see, it gets less-than-one-line really fast. But I don’t think you can really make it any simpler.
Another useful option, if it is available to you, is to use a TAB character instead of a comma to separate fields. I assume that you are given to handle a CSV, though, and cannot change that.