How can i read multiple lines in file.csv - c

Question

I want to read information from the file but can only read the first line in the file:
int deserialize(Contact **head) {
FILE *file = fopen("contacts.csv", "rb");
Contact *temp = (Contact *)malloc(5 * sizeof(Contact));
*head = (Contact *)malloc(50 * sizeof(Contact));
if (file == NULL)
return 0;
while (*head != NULL &&
(fscanf(file, "%d,%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%d\n",
&((*head)->id), &((*head)->firstName),
&((*head)->middleName), &((*head)->lastName),
&((*head)->company), &((*head)->phone),
&((*head)->company), &((*head)->address),
&((*head)->birthday), &((*head)->website),
&((*head)->note), &((*head)->status))) > 0)
{
printf(" head: %s\n", (*head)->firstName);
*head = (*head)->next;
}
fclose(file);
return 1;
}
My file.csv:
4,d,d,d,,,,,,,,0
3,c,c,c,,,,,,,,0
2,b,b,b,,,,,,,,0
1,a,a,a,,,,,,,,0
my output:
head: d

Answer 1

There are multiple problems in the posted code:
you have a memory leak in case of fopen failure
opening the text file in binary mode is not recommended: you will need to handle legacy line termination sequences explicitly. Better use text mode ("r") and let the library handle them.
you allocate an array of 50 contacts for head to point to, but this is not a linked list.
*head = (*head)->next has undefined behavior as (*head)->next was never set. You could instead store the next entry to (*head)[1] or use an actual pointer instead of a double pointer.
%[^,] is a risky conversion specifier: you may have a buffer overflow if the file contains a long string before the ,
%[^,] cannot parse an empty field and you have many such fields in your file
you do not check the number of conversions returned by fscanf() so you do not detect conversion error caused by the first empty field and the next call, returns 0 because the empty field cannot be converted as an integer, causing the loop to exit.
for more reliable error recovery, you should read the file one line at a time and convert the CSV line, check the result and report failures explicitly
to parse empty fields, you cannot use fscanf(), nor strtok and friends, you should instead write custom function to parse number and string fields.
Here is a safer approach, assuming string members of the Contact object are all char arrays.
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int parse_csv_number(const char **pp, int *dest) {
char *p = *pp;
char *end;
long num;
errno = 0;
num = strtol(p, &end, 10);
if (p == end)
return 1; // not a number
if (errno != 0 || num < INT_MIN || num > INT_MAX)
return 2; // number too large
if (*end == ',')
end++;
else
if (*end != '\0' && *end != '\n')
return 3; // extra characters after number
*dest = num;
return 0;
}
int parse_csv_string(const char **pp, char *dest, size_t len) {
char *p = *pp;
size_t i = 0;
p += strspn(" \t"); // skip banks
while (*p != ',' &&*p != '\n' && *p != '\0') {
if (i + 1 >= len)
return 1; // string too long
dest[i++] = *p++;
}
dest[i] = '\0';
if (*p == ',')
p++;
*pp = p;
return 0;
}
int deserialize(Contact **headp) {
const char *filename = "contacts.csv";
char buf[256];
char *p;
int count = 0;
FILE *file = fopen(filename, "rb");
if (file == NULL) {
fprintf(stderr, "cannot open %s: %s\n", filename,
strerror(errno));
return -1;
}
Contact *head = NULL;
Contact *tail = NULL;
while (fgets(buf, sizeof buf, file)) {
Contact *cp = malloc(sizeof(*cp));
if (cp == NULL) {
fprintf(stderr, "memory allocation error: %s\n", strerror(errno));
break;
}
p = buf;
if (parse_csv_number(&p, &cp->id)
|| parse_csv_string(&p, cp->firstName, sizeof cp->firstName)
|| parse_csv_string(&p, cp->middleName, sizeof cp->middleName)
|| parse_csv_string(&p, cp->lastName, sizeof cp->lastName)
|| parse_csv_string(&p, cp->phone, sizeof cp->phone)
|| parse_csv_string(&p, cp->company, sizeof cp->company)
|| parse_csv_string(&p, cp->address, sizeof cp->address)
|| parse_csv_string(&p, cp->birthday, sizeof cp->birthday)
|| parse_csv_string(&p, cp->website, sizeof cp->website)
|| parse_csv_string(&p, cp->note, sizeof cp->note)
|| parse_csv_number(&p, &cp->status)
|| p[strspn(p, " \t")] != '\n') {
fprintf(stderr, "invalid CSV line: %s\n" buf);
continue;
}
count++;
cp->next = NULL;
if (head == NULL)
tail = head = cp;
else
tail = tail->next = cp;
}
*headp = head;
fclose(file);
return count;
}
If the strings in the Contact object are string pointers (char *), you must allocate the strings. Here is a modified version:
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int parse_csv_number(const char **pp, int *dest) {
char *p = *pp;
char *end;
long num;
errno = 0;
num = strtol(p, &end, 10);
if (p == end)
return 1; // not a number
if (errno != 0 || num < INT_MIN || num > INT_MAX)
return 2; // number too large
if (*end == ',')
end++;
else
if (*end != '\0' && *end != '\n')
return 3; // extra characters after number
*dest = num;
return 0;
}
int parse_csv_string(const char **pp, char **dest) {
char *p = *pp;
char *str;
size_t i = 0, len;
p += strspn(" \t"); // skip banks
len = strcspn(p, ",\n"); // locate end of string
str = strndup(p, len);
if (str == NULL) {
fprintf(stderr, "memory allocation error: %s\n", strerror(errno));
return -1;
}
p += len;
if (*p == ',')
p++;
*dest = str;
return 0;
}
int deserialize(Contact **headp) {
const char *filename = "contacts.csv";
char buf[256];
char *p;
int count = 0;
FILE *file = fopen(filename, "rb");
if (file == NULL) {
fprintf(stderr, "cannot open %s: %s\n", filename,
strerror(errno));
return -1;
}
Contact *head = NULL;
Contact *tail = NULL;
while (fgets(buf, sizeof buf, file)) {
Contact *cp = malloc(sizeof(*cp));
if (cp == NULL) {
fprintf(stderr, "memory allocation error: %s\n", strerror(errno));
break;
}
p = buf;
if (parse_csv_number(&p, &cp->id)
|| parse_csv_string(&p, &cp->firstName)
|| parse_csv_string(&p, &cp->middleName)
|| parse_csv_string(&p, &cp->lastName)
|| parse_csv_string(&p, &cp->phone)
|| parse_csv_string(&p, &cp->company)
|| parse_csv_string(&p, &cp->address)
|| parse_csv_string(&p, &cp->birthday)
|| parse_csv_string(&p, &cp->website)
|| parse_csv_string(&p, &cp->note)
|| parse_csv_number(&p, &cp->status)
|| p[strspn(p, " \t")] != '\n') {
fprintf(stderr, "invalid CSV line: %s\n" buf);
continue;
}
count++;
cp->next = NULL;
if (head == NULL)
tail = head = cp;
else
tail = tail->next = cp;
}
*headp = head;
fclose(file);
return count;
}

Answer 2

The hard-coded file name ("contacts.csv") doesn't match the file name you claim "file.csv". This appears to be an error in your question.
You probably don't want to open a text .csv file in binary mode.
fscanf() returns number of fields matched which in this case 4, and it would not match the last status field. > 0 is a defective test of success.
%[,] "Matches a nonempty sequence of characters from the specified set" but you have an empty set so it doesn't match. You cannot use fscanf() to match empty fields.
(*head)->next is not initialized to an address and quite possibly NULL which would terminate your loop. After your malloc() your array you would have loop through the .next pointer to the following entry in the array. Or just use the array and forget about the linked list:
for(size_t i = 0; i < 50; i++) {
(*head)[i].id ...
}
Always specify a maximum field when reading strings to avoid buffer overflows.
I suggest you use an existing csv library.
If you need to write a parser yourself then I I suggest you use fgets() to read a line from your file then use strchr() to find the next separator. Remember to strdup() each field values as the line read would change for each loop iteration. Here's a sample to get your started:
#define _POSIX_C_SOURCE 200809L
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define LINE_LEN 100
typedef struct Contact {
int id;
char *firstName;
char *middleName;
char *lastName;
char *company;
char *phone;
char *address;
char *birthday;
char *website;
char *note;
int status;
} Contact;
const char *parse_chr(const char *s, char chr) {
if(*s == chr)
return s + 1;
return NULL;
}
const char *parse_int(const char *s, int *d, int fallback) {
char *next;
long l = strtol(s, &next, 10);
if(l > INT_MAX || l < INT_MIN || s == next) {
*d = fallback;
return NULL;
}
*d = l;
return next;
}
const char *parse_str(const char *s, char **v, char *fallback) {
size_t n = strcspn(s, ",");
if(!n)
*v = fallback ? strdup(fallback) : fallback;
else
*v = strndup(s, n);
return s + n;
}
#define PARSE_CHR(CHR) \
next = parse_chr(s, CHR);\
if(!next)\
goto err;\
s = next
#define PARSE_INT(NAME) \
next = parse_int(s, &(*c)[*n].id, -1);\
if(next)\
s = next
#define PARSE_STR(NAME) \
next = parse_str(s, &(*c)[*n].NAME, NULL);\
if(next)\
s = next
int deserialize(FILE *f, Contact **c, size_t *n) {
if(!f)
return EXIT_FAILURE;
for(*c = NULL, *n = 0;; (*n)++) {
char line[LINE_LEN];
if(!fgets(line, LINE_LEN, f))
break;
Contact *tmp = realloc(*c, (*n + 1) * sizeof **c);
if(!tmp)
return EXIT_FAILURE;
*c = tmp;
const char *s = line;
const char *next;
PARSE_INT(id); PARSE_CHR(',');
PARSE_STR(firstName); PARSE_CHR(',');
PARSE_STR(middleName); PARSE_CHR(',');
PARSE_STR(lastName); PARSE_CHR(',');
PARSE_STR(company); PARSE_CHR(',');
PARSE_STR(phone); PARSE_CHR(',');
PARSE_STR(company); PARSE_CHR(',');
PARSE_STR(address); PARSE_CHR(',');
PARSE_STR(birthday); PARSE_CHR(',');
PARSE_STR(website); PARSE_CHR(',');
PARSE_STR(note); PARSE_CHR(',');
PARSE_INT(status); PARSE_CHR('\n');
continue;
err:
printf("Could not parse %s\n", line);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int main() {
Contact *c;
size_t n;
deserialize(fopen("contacts.csv", "r"), &c, &n);
for(size_t i = 0; i < n; i++) {
printf(
"%d, %s, %s, %s, %s, %s, %s, %s, %s, %s, %d\n",
c[i].id,
c[i].firstName,
c[i].middleName,
c[i].lastName,
c[i].company,
c[i].phone,
c[i].address,
c[i].birthday,
c[i].website,
c[i].note,
c[i].status
);
free(c[i].firstName);
free(c[i].middleName);
free(c[i].lastName);
free(c[i].company);
free(c[i].phone);
free(c[i].address);
free(c[i].birthday);
free(c[i].website);
free(c[i].note);
}
free(c);
}
and example output:
4, d, d, d, (null), (null), (null), (null), (null), (null), 0
3, c, c, c, (null), (null), (null), (null), (null), (null), 0
2, b, b, b, (null), (null), (null), (null), (null), (null), 0
1, a, a, a, (null), (null), (null), (null), (null), (null), 0
PARSE_INT() and PARSE_STR() considers their respective field values optional. PARSE_CHR() is required. The underlying functions support optional values with fallback or required values.