memory allocation problem while reading a file - c

Question

I'm trying to multiply two matrices stored in a file thus formatted:
1 2
2 3
*
-4 1
1 0
I do not know initially what the dimension of each matrix is. But I let the user define it or otherwise a default value of 100 is taken.
int maxc = argc > 2 ? atoi(argv[2]) * atoi(argv[2]) : 100;
I can already perform the calculation correctly, but I've noticed that if I enter the dimension argv[2] = "2" so that maxc = 8, (that should be enough for this example), errors are produced in reading or printing the file. But if I enter argv[2] = "3" everything works out fine for this example. Since maxc is used to allocate memory here: matrix = malloc(maxc * sizeof *matrix), I suspect the problem could be located on that line. Should I allocate memory also for size_t row; size_t col;?
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <math.h>
#include <string.h>
#define MAXNOP 50 /*Max number of operations allowed */
#define MAXNMATR 20 /*Max number of matrices */
struct m {
size_t row;
size_t col;
double *data;
};
struct m multiply(struct m *A, struct m *B);
void f(double x);
void print_matrix(struct m *A);
void read_file(int maxc, FILE *fp);
void scalar_product(double scalar, struct m *B);
void calculate(struct m *matrix, int nop, int id, char *op);
int main(int argc, char *argv[]) {
FILE *file = argc > 1 ? fopen(argv[1], "rb") : stdin;
/* define max dimension of a matrix */
int maxc = argc > 2 ? atoi(argv[2]) * atoi(argv[2]) : 100;
read_file(maxc, file);
return 0;
}
void read_file(int maxc, FILE *fp) {
struct m *matrix;
int id = 0; /* id of a matrix */
size_t ncol, nrow; /* No of columns of a matrix*/
ncol = nrow = 0;
int nop = 0; /*No of operators*/
int off = 0;
int i;
int n;
double *d;
char buf[2 * maxc]; /*to store each lines of file */
char *p = buf;
char op[MAXNOP];
for (i = 0; i < MAXNOP; i++)
op[i] = '?';
if (!(matrix = malloc(maxc * sizeof *matrix))) {
perror("malloc-matrix");
exit(1);
}
/* Read file line by line */
while (fgets(buf, maxc, fp)) {
if (nrow == 0) {
/* allocate/validate max no. of matrix */
d = matrix[id].data = malloc(sizeof(double) * MAXNMATR);
}
/* check if line contains operator */
if ((!isdigit(*buf) && buf[1] =='\n')) {
op[nop++] = *buf;
matrix[id].col = ncol;
matrix[id].row = nrow;
nrow = ncol = 0;
id++;
continue;
} else {
/* read integers in a line into d */
while (sscanf(p + off, "%lf%n", d, &n) == 1) {
d++;
if (nrow == 0)
ncol++;
off += n;
}
nrow++;
off = 0;
}
} /*end of while fgets cycle */
/* Assign last matrix No of columns and rows */
matrix[id].col = ncol;
matrix[id].row = nrow;
/* Printing the matrices and operations */
for (i = 0; i <= id; i++) {
if (op[i] == '*' || op[i] == '-' || op[i] =='+') {
print_matrix(&matrix[i]);
if (op[i-1] != 'i')
printf("%c\n", op[i]);
else
continue;
} else
if (op[i] == '?') {
print_matrix(&matrix[i]);
}
}
calculate(matrix, nop, id, op);
}
void calculate(struct m *matrix, int nop, int id, char *op) {
int i;
for (i = 0; i <= nop; i += 2) {
if (op[i] == '*' && op[i+1] == '?') {
if (matrix[i].row == 1 && matrix[i].col == 1)
scalar_product(matrix[i].data[0], &matrix[i + 1]); //Multiplication of Scalar per matrix
else {
matrix[i + 1] = multiply(&matrix[i], &matrix[i + 1]);
matrix[i + 2] = multiply(&matrix[i + 1], &matrix[i + 2]);
}
break;
}
}
printf("=\n");
print_matrix(&matrix[id]); /* Print the result */
free(matrix);
}
struct m multiply(struct m *A, struct m *B) {
size_t i, j, k;
struct m C;
C.data = malloc(sizeof(double) * A->row * B->col);
C.row = A->row;
C.col = B->col;
for (i = 0; i < C.row; i++)
for (j= 0 ; j < C.col; j++)
C.data[i * C.col + j] = 0;
// Multiplying matrix A and B and storing in C.
for (i = 0; i < A->row; ++i)
for (j = 0; j < B->col; ++j)
for (k = 0; k < A->col; ++k)
C.data[i * C.col + j] += A->data[i * A->col + k] * B->data[k * B->col + j];
return C;
}
void f(double x) {
double i, f = modf(x, &i);
if (f < .00001)
printf("%.f ", i);
else
printf("%f ", x);
}
/* printing a Matrix */
void print_matrix(struct m *A) {
size_t i, j;
double *tmp = A->data;
for (i = 0; i < A->row; i++) {
for (j = 0; j < A->col; j++) {
f(*(tmp++));
}
putchar('\n');
}
}
void scalar_product(double scalar, struct m *B) {
size_t i, j;
for (i = 0; i < B->row; i++)
for (j = 0; j < B->col; j++)
B->data[i * B->col + j] = scalar * B->data[i * B->col + j];
}
The expected result is this: https://ideone.com/Z7UtiR
here argv[2] is not read so there is enough memory to store all data.

Answer 1

Your read buffer only has room for maxc (ie. 4) characters :
char buf[maxc]; /*to store each lines of file */
You then attempt to get a line from the file into that buffer :
while (fgets (buf, maxc, fp)){
But that buffer is only large enough for 2 characters, followed by a newline, and then a '\0' terminator.
Looking at your sample file, the longest line has 4 characters : "-4 1". So, your buffer needs to at least be able to hold 6 (including the newline and '\0' terminator).
It's probably better to make your buffer quite a bit larger.

Answer 2

The problem is entirely in reading the arrays.
The maxc = 4 and the buffer char buf[maxc]; has place only for 3 characters and terminating character.
So fgets (buf, maxc, fp):
on the first will read buf = "1 2" (3 characters and zero byte)
on the second will read buf = "\n" (1 newline character, fgets terminates)
then reads buf = "2 3"
then reads buf = "\n"
buf = "*\n"
buf = "-4 "
and so on
Because of the empty line, inside this code snipped:
else /* read integers in a line into d */
{
while (sscanf (p + off, "%lf%n", d, &n) == 1) {
d++;
if(nrow == 0)
ncol++;
off += n;
}
nrow++;
off = 0;
}
The variable nrow will be incremented 4 times (2 times for rows, and 2 times for empty lines with only newlines read), which will be 2 times too many. The second matrix will have 1 column, because you will read only -4 from the line, so your while(sscanf loop will scan only one number, so ncol will be only 1.
Your fix you posted in the comment is invalid, because you only increased buffer size, but didn't increase the size argument you pass to fgets. If you did char buf[2*maxc]; you also should fgets (buf, 2 * maxc, fp), which will "fix" the current problem. I would rather re-write the whole thing or rather write fgets(buf, sizeof(buf)/sizeof(buf[0]), fp) to accommodate future changes.
Don't use VLAs ex. char buf[maxc];. For simplicity you can use arbitrary long buffer for the line, ex. #define LINE_MAX 1024 and char buf[LINE_MAX] and then fgets(buf, sizeof(buf)/sizeof(buf[0]), file). Or use or rewrite function that will dynamically resize memory and read line, like GNUs getline.