Implementing getchar issue in C - c

Question

I'm implementing getchar(), I have two issues with the BUFF_SIZE, when I use 1024 my getchar() reads all the characters and return one character discards the rest. This doesn't work inside a loop.
#ifndef BUFF_SIZE
#define BUFF_SIZE 1024
#endif
int my_getchar(void)
{
static char buff[BUFF_SIZE];
static char *chr;
int ret;
if ((ret = read(STDIN_FILENO, buff, BUFF_SIZE)) > 0)
{
chr = buff;
return (*chr);
}
return (EOF);
}
int get_line(char **line)
{
char *text = malloc(sizeof(char) * 4092);
int position = 0;
int c;
if (!text)
return (-1);
while (1)
{
c = my_getchar();
if (c == EOF || c == '\n')
{
text[position] = '\0';
*line = text;
return (1);
}
else
text[position] = c;
position++;
}
return (0);
}
When I set BUFF_SIZE to 1, it works fine inside a loop, and doesn't work well outside a loop. How can I solve this?
int main()
{
//comment out to test.
//char *sp;
//sp = (char *)malloc(sizeof(char) * 4092);
//get_line(&sp); // this function calls my_getchar inside a while loop.
printf("%c\n", my_getchar()); //calling my_getchar() outside a loop
// printf("%s\n", sp);
return 0;
}

Answer 1

Your my_getchar() skips BUF_SIZE - 1 characters on each invokation. Every time you call it - it reads BUF_SIZE characters from stdin (or less if we are at the end of the file) and returns the first character. All other are dropped, because when you call it next time it reads BUF_SIZE chars again instead of returning of the next char from previously read buffer.

Answer 2

When you set BUFF_SIZE to 1, you are calling read like this:
read(STDIN, buff, 1)
But, since STDIN is connected to a terminal, read() is allowed to wait for a line to be typed in before returning the first character. So, the function is behaving correctly (as written).
The good news is that if you use printf("%c\n", getchar());, you will see that getchar() behaves in the same way.
The main problem with your version is that it is built on top of read() -- the real getchar() is in <stdio.h> and meant to be mixable with the calls in there that use FILE* and its buffering. So, unless you are reimplementing all of stdio, it probably makes sense to build it on its primitives (e.g. fread).
If you are reimplementing all of <stdio>, then you should be implementing some equivalent to FILE, which is where the buffers would live (not in static variables inside of functions).

Answer 3

OP's code reads BUFF_SIZE chars, and returns only 1.
Need to selectively read. Only read when previous characters are comsumed.
Note: Better to pass in a structure pointer to the state (buff, index,count) than to use static variables, but staying with OP's approach:
int my_getchar(void) {
static unsigned char buff[BUFF_SIZE];
static int index = 0;
static int count = 0;
if (index >= count) {
index = 0;
count = read(STDIN_FILENO, buff, BUFF_SIZE);
if (count == 0) return EOF; // end-of-file
if (count < 0) return EOF; // I/O error
}
return buff[index++];
}
Note: important to read an unsigned char buffer to distinguish EOF from input charterers.
Depending on STDIN_FILENO attributes, a return value of 0 from read() may simple imply input not presently available. Then use
// count = read(STDIN_FILENO, buff, BUFF_SIZE);
// if (count == 0) return EOF; // end-of-file
do {
count = read(STDIN_FILENO, buff, BUFF_SIZE);
} while (count == 0);

Answer 4

There is issue in your my_getchar function. Issue is here:
/* When you do return *char only first char is returned */
if ((ret = read(STDIN_FILENO, buff, BUFF_SIZE)) > 0)
{
chr = buff;
return (*chr);
}
There you are doing return (*chr); you return only the first char in buff, so that way a \n is not returned and so your get_line is affected as it depends on a \n returned. This can be fixed this by adding an additional static variable to track the position of latest char returned, as below.
int my_getchar(void)
{
static char buff[BUFF_SIZE];
static char *chr;
static int pos = 0; /* New static variable to track position */
static int ret = 0; /* Changed this to static */
if (pos >= ret) { /* if all data in buffer has been returned */
if ((ret = read(STDIN_FILENO, buff, BUFF_SIZE)) > 0)
{
chr = buff;
pos = 0;
return *(chr + pos++); /* return one char and update pos */
} else { /* if no more to read from stdin */
return EOF;
}
} else { /* if data still in buffer */
return *(chr + pos++); /* return one char and update pos */
}
}
Now, my_getchar will return a \n when pos reaches the postition of \n in the buffer, so get_line will get all characters before the new line character.

Answer 5

Your code reads as many characters as possible:
read(STDIN_FILENO, buff, BUFF_SIZE)
up to BUFF_SIZE and then only returns the first character.
For that to work as intended, your buffer size needs to be 1.