Parsing and dynamically allocating substrings with inconsistant sizes using sscanf - c

Question

I implemented a read_line function:
#include<stdlib.h>
#include<stdio.h>
#include<stdbool.h>
char* read_line(){
const char UNIX_LINEBREAK = '\n';
const char WINDOWS_LINEBREAK = '\r';
const char C_STRING_TERMINATOR = '\0';
char extra_linebreak;
char current_letter;
char* line = NULL;
int position = 0;
bool reading_line = true;
while(reading_line){
scanf("%c", &current_letter);
if(current_letter == UNIX_LINEBREAK || current_letter == EOF){
reading_line = false;
}
else if(current_letter == WINDOWS_LINEBREAK) {
reading_line = false;
extra_linebreak = (char)getchar();
}
else {
line = (char*) realloc(line, sizeof(char) * (position + 1));
line[position] = current_letter;
position ++;
}
}
line = (char*) realloc(line, sizeof(char) * (position + 1));
line[position] = C_STRING_TERMINATOR;
return line;
}
Which I'm using for reading strings in the format:
operation number number
for example:
sum 13 13
However I'm implementing operations with numbers that may (and will) overflow the max int size. For example:
sum 23879238932898239832983298329839229383928329 239823983298392893289238932883290312803291832109230189
Which forces me to read them in a string format, parse them and finally work with them through a linked list (There may be better approaches but that's not the point yet). By now, I'm trying to use auxiliary buffers (operation, first_number_buffer and second_number_buffer) with sscanf for splitting the line read with read_line in three substrings.
#include <stdio.h>
#include <readline.h>
#include <stdio.h>
#include <readline.h>
int main (){
char* line = read_line();
char operation[4];
char* first_number_buffer;
char* second_number_buffer;
sscanf(line, "%s %s %s", operation, first_number_buffer, second_number_buffer);
printf("%s\n%s\n%s\n", line,first_number_buffer,second_number_buffer);
}
The code above doesn't work very well, since I'm not really allocating first_number_buffer and second_number_buffer yet. I would like to know if there's an efficient way for using sscanf in that situation. I didn't manage to find good results in google, since scanf overlaps sscanf results.
The problem seems to be: Usually, to dynamically allocate a string, one uses realloc to grow it size one by one. However sscanf tries to "throw" all the content of the parsed substring at once. Since strings have inconsistent sizes I cannot simply make them static, like I did with operation.
Yes, I could use a big static buffer but that seems to be an important task, and since I'm an undergrad I would like to know the proper way to to that. Thanks in advance!

Answer 1

I believe I manage to do what I initially intended.
It's hard to use sscanf for the task, since one would have to previously allocate the memory necessary for sscanf to use. Which, in the context of the question, is unknown.
However, #Cheatah suggested using strtok, which worked pretty fine. Here's the final version of the code, using it:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include<stdbool.h>
#include<stdlib.h>
#include<stdio.h>
char* read_line(){
const char UNIX_LINEBREAK = '\n';
const char WINDOWS_LINEBREAK = '\r';
const char C_STRING_TERMINATOR = '\0';
char extra_linebreak;
char current_letter;
char* line = NULL;
int position = 0;
bool reading_line = true;
while(reading_line){
scanf("%c", &current_letter);
if(current_letter == UNIX_LINEBREAK || current_letter == EOF){
reading_line = false;
}
else if(current_letter == WINDOWS_LINEBREAK) {
reading_line = false;
extra_linebreak = (char)getchar();
}
else {
line = (char*) realloc(line, sizeof(char) * (position + 1));
line[position] = current_letter;
position ++;
}
}
line = (char*) realloc(line, sizeof(char) * (position + 1));
line[position] = C_STRING_TERMINATOR;
return line;
}
int main (){
char* line = read_line();
char* operation;
char* first_number_buffer;
char* second_number_buffer;
char *line_split = strtok(line, " ");
operation = (char *) malloc(strlen(line_split) * sizeof(char));
strcpy(operation, line_split);
line_split = strtok(NULL, " ");
first_number_buffer = (char *) malloc(strlen(line_split) * sizeof(char));
strcpy(first_number_buffer, line_split);
line_split = strtok(NULL, " ");
second_number_buffer = (char *) malloc(strlen(line_split) * sizeof(char));
strcpy(second_number_buffer, line_split);
printf("%s\n%s\n%s\n", line,first_number_buffer,second_number_buffer);
}
input:
sum 23879238932898239832983298329839229383928329 239823983298392893289238932883290312803291832109230189
output:
sum
23879238932898239832983298329839229383928329
239823983298392893289238932883290312803291832109230189
The code can be improved in many ways. Some people pointed EOF is not properly checked within read_line(), and main can definitely be refactored in smaller functions.
However the idea of using strtok() as a substitute to sscanf() even with an indefinite number of tokens, for that case, works. See an example of a strtok inside a while: https://www.cplusplus.com/reference/cstring/strtok/