Segmentation fault storing input in an array - c

Question

I have written a C program that takes multiple inputs in the following format: rounds -> rows -> col -> array initial values
I have no issue with the following input: 2 2 2 0 0 0 0
but once put into the other format which looks like this
2
2 2
0 0
0 0
I get a segmentation fault, which I'm not sure why. I feel like I have newlines accounted for. Here is a snippet of my code where I think the error is happening:
int counter = 1;
char *num;
char *str;
long nums;
char line[BUFFER];
fgets (line, BUFFER, stdin);
num = strtok(line, " "); //getting first input that is separated by a space
int rounds = atoi(num); //changes input into a number
num = strtok(NULL, " ");
int row = atoi(num);
num = strtok(NULL, " ");
int col = atoi(num);
int grid[row][col];
for (int i = 0; i < row && !stop; i++){
for (int j = 0; j < col && !stop; j++){
num = strtok(NULL, " \n");
if (num == NULL){ //if the next character after whitespace is null/eof
printf("Invalid input 1");
stop = true;
}else{
nums = strtol(num, &str, 10);
if (*str != '\0' && *str != '\n'){
printf("Invalid input\n");
return 1;
}
int curr = nums;
grid[i][j] = curr;
}
}
}
EDIT: I realize the problem here now, but how would I distinguish if the input is put in the format of a single line vs if the input were on multiple lines so I could use fgets?

Answer 1

If one doesn't care about whitespace, one could completely decouple the input from the parsing. In this modified code, number takes a Buffer, and calls next_int; if this fails, (it will the first time because the buffer is empty,) the line buffer is refilled by calling next_line until it gets at least one number. In this way, it's kind of a singleton producer-consumer pattern.
#include <stdlib.h> /* EXIT malloc free strtol */
#include <stdio.h> /* printf fgets perror */
#include <assert.h> /* assert */
#include <errno.h> /* errno */
#include <string.h> /* strlen */
#include <limits.h> /* INT LONG */
#include <ctype.h> /* isspace */
/** Returns true if `line` was filled up, at most to `size` from `stdin`, thus
this limits the input we can get from `stdin` on top of `fgets`, (embedded
NULs don't work.) If false, `errno` will be set. */
static int next_line(char *line, const size_t size) {
assert(line && size > 2);
if(!fgets(line, size, stdin)) {
if(!ferror(stdin)) fprintf(stderr, "Not enough numbers.\n");
if(!errno) errno = EDOM; /* This is an error in this application. */
return 0;
}
if(line[0] == '\0' || line[strlen(line) - 1] != '\n')
return errno = ERANGE, 0; /* Line too long. */
return 1;
}
/** If EOF, line contained no non-whitespace characters, otherwise, if true,
`*input_ptr` is a whitespace and then number in the range of
`[MIN_INT, MAX_INT]`; it gets moved ahead that amount and `*output_ptr`
contains the number. If false, `errno` will be set. */
static int next_int(char **const input_ptr, int *const output_ptr) {
long l;
assert(input_ptr && output_ptr);
/* We could skip this, but then `errno` would possibly be set. */
while(isspace(**input_ptr)) (*input_ptr)++;
if(**input_ptr == '\0') return EOF;
/* Perform the conversion to `int` using a `long`. */
errno = 0;
l = strtol(*input_ptr, input_ptr, 0);
if((l == 0 || l == LONG_MAX || l == LONG_MIN) && errno) return 0;
if(l > INT_MAX || l < INT_MIN) return errno = ERANGE, 0;
*output_ptr = (int)l;
return 1;
}
/* `sizeof str` is the maximum line. */
struct Buffer { char str[256], *line; };
/** A true return means that we filled the buffer `in` as needed to get an
input `int` which is stored in `no`. Otherwise, `errno`. */
static int number(struct Buffer *const in, int *const no) {
int success;
assert(in && in->line >= in->str && in->line <= in->str + sizeof in->str);
while((success = next_int(&in->line, no)) == EOF) {
if(!next_line(in->str, sizeof in->str)) return 0;
in->line = in->str;
}
return success;
}
int main(void) {
int success = EXIT_FAILURE;
int row, col, *array = 0, i, j;
size_t n = 0, n_max;
struct Buffer in = { "", 0 };
in.line = in.str; /* Complete the `struct Buffer` contract. */
if(!number(&in, &row) || !number(&in, &col)) goto catch;
if(row <= 0 || col <= 0
|| (size_t)row > (size_t)-1 / col
|| (size_t)row * col > (size_t)-1 / sizeof *array)
{ errno = ERANGE; goto catch; } /* Overflow data types. */
n_max = row * col;
if(!(array = malloc(sizeof *array * n_max))) goto catch;
for(n = 0; n < n_max; n++) if(!number(&in, array + n)) goto catch;
for(j = 0; j < col; j++) {
for(i = 0; i < row; i++) {
printf("%s%4d", i ? ", " : "", array[j * row + i]);
}
fputc('\n', stdout);
}
success = EXIT_SUCCESS;
goto finally;
catch:
perror("array");
finally:
free(array);
return success;
}
Also changed,
strtol is used instead of atoi, which is equivalent, but it updates the pointer, has more error reporting, and can handle octal and hex.
C99 varible-length arrays are going to cause stack overflow if one makes them too big. In C17, they are optional. The code above uses malloc instead.