Reading Input in BIOS-Level Assembly?

Question

I am creating a very low-level application, and I have the bootloader ready. I essentially have to rebuild the scanf() function, as I cannot use any libraries in the project. What would be a good, basic application in Assembly that can read input? I can handle reading it into a C char[] or whatever other data type I want, I just need to figure out how to read input without any system calls.

Answer 1

It appears you are writing code for real mode. You don't say which C compiler you are using, but your own answer suggests you are in fact in real mode. I recommend WATCOM's C compiler as it can generate true 16-bit code. If you are using GCC with the -m16 option I don't recommend it for 16-bit code. I have another Stackoverflow answer that discusses some GCC issues.

The best source of DOS and BIOS interrupt information is Ralph Brown's Interrupt List. The information about getting a single keystroke via Int 16h/AH=00 is:

KEYBOARD - GET KEYSTROKE

AH = 00h

Return:

AH = BIOS scan code
AL = ASCII character

This BIOS function won't echo characters so another useful BIOS function is Int 10h/AH=0eh is displaying a single character to the terminal:

VIDEO - TELETYPE OUTPUT

AH = 0Eh
AL = character to write
BH = page number
BL = foreground color (graphics modes only)

Return:

Nothing

Desc: Display a character on the screen, advancing the cursor and scrolling the screen as necessary

To print a character in text mode you can place BX into 0, the character to print in AL and call the interrupt.

---

Using the information above you can write some simple wrappers around both BIOS interrupts using inline assembly. In GCC you can use Extended Inline Assembly templates. They could look like this:

#include <stdint.h>

static inline void
printch (char outchar, uint16_t attr)
{
   __asm__ ("int $0x10\n\t"
            :
            : "a"((0x0e << 8) | outchar),
              "b"(attr));
}

static inline char
getch (void)
{
   uint16_t inchar;

   __asm__ __volatile__ ("int $0x16\n\t"
            : "=a"(inchar)
            : "0"(0x0));

   return ((char)inchar);
}

In Watcom C you can create functions with #pragma aux:

#include <stdint.h>

void printch(char c, uint16_t pageattr);
char getch(void);

#pragma aux printch = \
    "mov ah, 0x0e" \
    "int 0x10" \
     parm [al] [bx] nomemory \
     modify [ah] nomemory

#pragma aux getch = \
    "xor ah, ah" \
    "int 0x16" \
     parm [] nomemory \
     modify [ah] nomemory \
     value [al]

With these basic functions you only need to write a function that gets a string from the user, echoes the characters back as they are input, and stores them in a buffer. The ASCII character getch returns for a newline is the carriage return \r (0x0d). When we reach the maximum number of characters requested or a newline is encountered we stop and NUL terminate the string. Such a function could look like:

/* Get string up to maxchars. NUL terminate string.
   Ensure inbuf has enough space for NUL.
   Carriage return is stripped from string.
   Return a pointer to the buffer passed in.
*/
char *getstr_echo(char *inbuf, int maxchars)
{
    char *bufptr = inbuf;

    while(bufptr < (inbuf + maxchars) && (*bufptr = getch()) != '\r')
        printch(*bufptr++, 0);

    *bufptr = '\0';
    return inbuf;
}

If you don't wish to use inline assembly you can create an assembly module with getch and printch done in pure assembly. This is less efficient than the code that can be generated with inline assembly but it is far less error prone.

---

The getstr_echo function is not feature complete and is meant to be used as a starting point for your own code. It doesn't properly handle things like backspace.