os/kernel64/src/console.c at main · reindeer002/os · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
#include <stdarg.h>
#include "console.h"
#include "keyboard.h"
#include "utility.h"

CONSOLEMANAGER gs_stConsoleManager = { 0 };

void kInitializeConsole(int iX, int iY) {
    kMemSet(&gs_stConsoleManager, 0, sizeof(gs_stConsoleManager));
    kSetCursor(iX, iY);
}

void kSetCursor(int iX, int iY) {
    int iLinearValue;
    iLinearValue = iY * CONSOLE_WIDTH + iX;
    kOutPortByte(VGA_PORT_INDEX, VGA_INDEX_UPPERCURSOR);
    kOutPortByte(VGA_PORT_DATA, (iLinearValue >> 8));
    kOutPortByte(VGA_PORT_INDEX, VGA_INDEX_LOWERCURSOR);
    kOutPortByte(VGA_PORT_DATA, (iLinearValue & 0xFF));

    gs_stConsoleManager.iCurrentPrintOffset = iLinearValue;
}

void kGetCursor(int* piX, int* piY) {
    *piX = gs_stConsoleManager.iCurrentPrintOffset % CONSOLE_WIDTH;
    *piY = gs_stConsoleManager.iCurrentPrintOffset / CONSOLE_WIDTH;
}

void kPrintf(const char* pcFormatString, ...) {
    va_list ap;
    char vcBuffer[1024];
    int iNextPrintOffset;

    va_start(ap, pcFormatString);
    kVsprintf(vcBuffer, pcFormatString, ap);
    va_end(ap);

    iNextPrintOffset = kConsolePrintString(vcBuffer);
    kSetCursor(iNextPrintOffset % CONSOLE_WIDTH, iNextPrintOffset / CONSOLE_WIDTH);
}

int kConsolePrintString(const char* pcBuffer) {
    CHARACTER* pstScreen = (CHARACTER*) CONSOLE_VIDEOMEMORYADDRESS;
    int iLength;
    int iPrintOffset;

    iPrintOffset = gs_stConsoleManager.iCurrentPrintOffset;
    iLength = kStrLen(pcBuffer);
    for (int i = 0; i < iLength; i++) {
        if(pcBuffer[i] == '\n') {
            iPrintOffset += (CONSOLE_WIDTH - iPrintOffset % CONSOLE_WIDTH);
        } else if (pcBuffer[i] == '\t') {
            iPrintOffset += (8 - iPrintOffset % 8);
        } else {
            pstScreen[iPrintOffset].bCharacter = pcBuffer[i];
            pstScreen[iPrintOffset].bAttribute = CONSOLE_DEFAULTTEXTCOLOR;
            iPrintOffset++;
        }

        if(iPrintOffset >= (CONSOLE_WIDTH * CONSOLE_HEIGHT)) {
            kMemCpy(
                (void*) CONSOLE_VIDEOMEMORYADDRESS,
                (void*) CONSOLE_VIDEOMEMORYADDRESS + CONSOLE_WIDTH * sizeof(CHARACTER),
                (CONSOLE_HEIGHT - 1) * CONSOLE_WIDTH * sizeof(CHARACTER)
            );
            for(int j = (CONSOLE_HEIGHT - 1) * (CONSOLE_WIDTH); j < (CONSOLE_HEIGHT * CONSOLE_WIDTH); j++) {
                pstScreen[j].bCharacter = ' ';
                pstScreen[j].bAttribute = CONSOLE_DEFAULTTEXTCOLOR;
            }
            iPrintOffset = (CONSOLE_HEIGHT - 1) * CONSOLE_WIDTH;
        }
    }
    return iPrintOffset;
}

void kClearScreen() {
    CHARACTER* pstScreen = (CHARACTER*) CONSOLE_VIDEOMEMORYADDRESS;
    for(int i = 0; i < CONSOLE_WIDTH * CONSOLE_HEIGHT; i++) {
        pstScreen[i].bCharacter = ' ';
        pstScreen[i].bAttribute = CONSOLE_DEFAULTTEXTCOLOR;
    }
    kSetCursor(0, 0);
}

BYTE kGetCh() {
    KEYDATA stData;
    while(1) {
        while(kGetKeyFromKeyQueue(&stData) == FALSE) {}
        if(stData.bFlags & KEY_FLAGS_DOWN) {
            return stData.bASCIICode;
        }
    }
}

void kPrintStringXY(int iX, int iY, const char* pcString) {
    CHARACTER* pstScreen = (CHARACTER*) CONSOLE_VIDEOMEMORYADDRESS;
    pstScreen += (iY * 80) + iX;
    for(int i = 0; pcString[i] != 0; i++) {
        pstScreen[i].bCharacter = pcString[i];
        pstScreen[i].bAttribute = CONSOLE_DEFAULTTEXTCOLOR;
    }
}