On a larger note, the design you have chosen is, to my mind, problematic.
- You never declare the sizes of _kdata[] and i[]. AFAIK, this shouldn't even compile as it is; while an implicit array size can be used when using an initialization, when declaring an extern variable, or when passing an array as a function argument, it shouldn't work as the actual declaration of a static array. The only thing I can think of is that it is automatically devolving to a pointer, but if so, what is it pointing at?
- You never check whether you have overrun the buffers, either. The conventional implementation of a keyboard buffer is as a ring buffer; this avoids the question of what to do if the keyboard buffer is overrun, at the slight risk of losing some typed characters. Since you do need to check the input buffer to make sure that you don't scribble on some other data, adding the code to wrap around to the head of the buffer is a minor addition.
- The tests in the implementation of kflush() are redundant; they are more costly than the unnecessary assignment operations you are trying to avoid. Just set the values regardless of what they are now, and don't worry about it. The same applies to the test inside the while() loop in gets(). Furthermore, if you change _kdata so that it is handled as a ring buffer, then you wouldn't need to reset _TMP_ at all; you would simply keep reading into the buffer and letting it wrap around. OTOH, you want to assign the current _kdata[_TMP_] to a newline (since that is what you are testing for in gets()), not zero.
- The return value for gets() makes no sense; it is returning the address of the _kdata array (which is a constant) after casting it to an int. What is this supposed to accomplish?
- Your gets() works with only a single implicit input buffer and a single implicit destination buffer. You may find that it makes more sense to handle the buffers explicitly, more like fgets() does, with a buffer pointer and size for each. While you may not expect to need multiple keyboard buffers for the kernel, you may find that you will want them or even need them at some point. More important is the destination buffer. You presumably want to be able to read from the keyboard buffer into different C-strings, correct? If so, then what you are doing now makes little sense, as a) you are copying into a fixed buffer, which you then would have to copy from again to put it into your working strings, and b) you are overwriting it on every gets() call, making it, in effect, the same as the keyboard buffer. This doesn't make sense to me.
