printf limited to three characters? - c

Question

I've stripped down this function to what's causing the problem, but I'll try to give enough context to this problem without making you peruse through lines and lines of text:
Basically, I am feeding a string into the function below, and if the first character in the string is a # then I want to print the string. That's it.
However, when doing this, the strings that are printed are cut at three characters in length. So for example, where the input string is "# Hello, World!" only "# H" will get printed.
I'm getting my input strings using fgets() from the following input file:
# Testing
#######
# More
And the output is as following:
# T
###
###
#
# M
Here are the relevant, trimmed functions:
int main(int argc,char *argv[]){
FILE *input;
lineResponse response;
//If a filename was specified, the file exists, and it is openable
if(argv[1] != NULL && (input = fopen(argv[1],"r")) != NULL){
char *currentLine = "";
//Loop through the lines
while(fgets(currentLine,sizeof(input),input)){
response = parseLine(currentLine);
}
}
fclose(input);
getchar();
}
lineResponse parseLine(char *line){
lineResponse response = {0,NULL}; //0 is the default lineType, denoting a line that cannot be parsed
if(line != NULL){
if(line[0] == '#'){
printf("%s\n",line);
}
}
return response;
}
The lineResponse return is irrelevant to this problem. What could be causing the trimming? If you need a more extensive example, I can provide one.

Answer 1

char *currentLine = "";
//Loop through the lines
while(fgets(currentLine,sizeof(input),input)){
This is your problem. You are declaring a char pointer and assigning it a string literal ... then trying to read into it. You also seem to not understand the second argument of fgets; it reads one less than that number of characters and terminates the buffer with a \0. Also be aware that newlines are stored in the buffer and need to be removed if you don't want them.
This should be:
char currentLine[1024]; /* arbitrary - needs to be big enough to hold your line */
while(fgets(currentLine,1024,input)) {
String literals (e.g. char* = "This is a string literal") are immutable (read-only). They are created at compile time.

Answer 2

The problem must be in how you are reading the line. Since you comment that you are reading with fgets(), I'm going to take a guess that you're on a 32-bit machine and you have some code something like:
char buffer[128];
if (fgets(&buffer, sizeof(&buffer), stdin))
{
lineResponse r = parseLine(buffer);
...
}
There are other vaguely similar techniques:
char *buffer;
if (fgets(buffer, sizeof(buffer), stdin))
...
What's going on here is that you're giving the wrong size (and wrong address) to fgets(), and it is seeing a size of 4 total, which means it can only store 3 characters plus the terminating NUL '\0'.
Correct code might be:
char buffer[128];
if (fgets(buffer, sizeof(buffer), stdin))
{
lineResponse r = parseLine(buffer);
...
}
Or:
char *buffer = malloc(2048);
// error check memory allocation!
if (fgets(buffer, 2048, stdin))
...
Now the code is visible...
Your code is shown as:
char *currentLine = "";
//Loop through the lines
while(fgets(currentLine,sizeof(input),input)){
response = parseLine(currentLine);
This indeed corresponds (more or less) to the char *buffer; version I hypothesized. You have an added tweak that you use sizeof(input) where you declare FILE *input;. You need to adapt my second suggested alternative if you keep currentLine as a char *, or alternatively (simpler because there is no dynamically allocated memory to leak), use:
char currentLine[2048];
//Loop through the lines
while (fgets(currentLine, sizeof(currentLine), input))
{
response = parseLine(currentLine);
...
}