D:/COBE-Packet/cobe/system/stdio.c

gehe zur Dokumentation dieser Datei

 #include <stdio.h>
 #include <stdarg.h>
 #include <sysfunc.h>
 #include <keyboard.h>
 #include <stdarg.h>
 #include <cmos.h>
 #include <io.h>
 #include <pic.h>
 
 char *VideoMem = (char*)0xB8000;
 char color = 0x07;
 short position_x = 0;
 short position_y = 0;
 int qChar = 0;
 extern char* curr_dir;


 int kputchar(char c) {
        //----------Der Cursor wird außerhalb des Sichtbereiches gesetzt----------

        abs_pos = position_y * 80 + position_x;
        if(c == '\n') { newline(); return 0; }  //----------Newline Escape-Sequenz----------
        if(c == '\t') { for(int i = 0; i < 4; i++) kputchar(' '); return 0; }   //----------Tabulator Escape-Sequenz----------
        
        //----------Schreibe Zeichen in das erste Byte, das Aussehen in das Attribut-Byte----------
    VideoMem[2*(abs_pos)] = c;
    VideoMem[2*(abs_pos)+1] = color;
    
        position_x++;
        
        //----------Bei Überschreitung der X-Achse, gehe in neue Zeile, bei Überschreitung der Y-Achse fang wieder oben an----------
        if(position_x >= 80) newline();
        if(position_y >= 25) 
        {
                clrscr();
                setcolor(0xF2);
                kprintf("\tCOBE - Computer Betriebsystem  0.1 ALPHA  -  Shell 0.1\t\t"); time(); kprintf("\n"); 
                setcolor(0x0F);
                position_y = 2;
                position_x = 1;
        }
        return 0;
 }
 
 
 int kputx(unsigned int x, int basis) {         //Credits to pgahlen
        //----------Der Cursor wird außerhalb des Sichtbereiches gesetzt----------


        char buf[65];
    const char* digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    char* p;

    if (basis > 36) return 0;
   
    p = buf + 64;
    *p = '\0';
        if(x == 0) *--p = 0; 
    do {
        *--p = digits[x % basis];
        x /= basis;
    } while (x);
 
        kprintf(p);
        return 0;
 }
 
 
 int kputstring(char* string) {
        while(*string)  kputchar(*string++);    //----------Gibt den String im Parameter aus----------
        return 0;
 }
 
 
int kprintf(char* text, ...) {
        
        va_list arg_list;       //----------Erzeugt eine Argument-Liste----------
        va_start(arg_list, text);       //----------Der erste Argument-Eintrag ist das bekannte Argument----------
    while(*text)
    {   
                if(*text == '%')                //----------Wenn es sich im einen Platzhalter handelt----------
                {
                        text++;
                        switch(*text)
                        {
                                //----------String-Ausgabe----------
                                case 's':
                                kputstring(va_arg(arg_list, char*));
                                break;
                                
                                //----------Char-Ausgabe----------
                                case 'c':
                                kputchar(va_arg(arg_list, int));
                                break;
                                
                                //----------Hex-Zahl Ausgabe----------
                                case 'x':
                                case 'p':
                                kputx(va_arg(arg_list, unsigned long int), 16);
                                break;
                                
                                //----------Dezimal-Zahl Ausgabe----------
                                case 'd':
                                case 'u':
                                kputx(va_arg(arg_list, unsigned long int), 10);
                                break;
                                
                                //----------Prozentzeichen-Ausgabe----------
                                case '%':
                                kputchar('%');
                                break;
                                
                                //----------Ende des Strings----------
                                case '\0':
                                va_end(arg_list);
                                return 0;
                                break;
                                
                                //----------Unbekannter Platzhalter oder kein Platzhalter----------
                                default: 
                                kputchar('%');
                                kputchar(*text);
                                break;
                                
                        }
                }
                else kputchar(*text);           //----------Gibt den String aus----------
                text++;
    }
        va_end(arg_list);       //----------Ende der Argument-Liste----------
        return 0;
 }
 
 
 int kstrlen(char *Text) {
        int len = 0;
        while(Text[len] != 0)   //----------Solange die binäre Null nicht erreicht ist, erhöhe den Counter----------
        {
                len++;
        } 
        return len;
 }
 
 
void newline() {
        position_y++;
        position_x = 0;
        return;
 }

char* kgets(char* buf) {
        pic_mask_irqs(0x0);     //----------Schaltet die Tastatur frei----------
        caps = 0;
        string_i = 0;
        endgets = 0;
        string[0] = '\0';

        move_cursor(position_y,position_x);
        move_cursor(5,5);
        while(1) {
                if(endgets == 1)
                {
                        position_x = 0;
                        position_y++;
                        move_cursor(-1,-1);
                        pic_mask_irqs(0x2);                     //----------Sperrt die Tastatur----------
                        string[string_i] = '\0';
                        kstrcpy(string, buf);                   //----------Die Eingabe wird in den angegebenen Buffer kopiert----------
                        return string;
                }
        }
        return 0;
}


void *kmemset(void *ptr, int val, size_t num) {
        size_t i;
        uint8_t *byte_ptr = (uint8_t*) ptr;
        for(i = 0; i < num; i++)        //----------Der Anzahl num nach, wird die Konstante val in den angegebenen Speicher geschrieben----------
        {
                byte_ptr[i] = val;
        }
        return ptr;
}  


void *kmemcpy(void* dest_ptr, const void* val_ptr, size_t num) {
        uint8_t* dest = dest_ptr;
        const uint8_t* val = val_ptr;
        while(num--) *dest++ = *val++;  //----------Solange num nicht 0 ist, kopiere den Inhalt von val in dest und erhöhe beide Pointer----------
        return dest_ptr;
}


int kstrcmp(char *a, char *b) {
        while(*a && *b)         //----------Solange einer der beiden Strings nicht 0 ist, prüfe ob beide Werte gleich sind, wenn nicht, gib 1 zurück. Wenn doch erhöhe die Pointer----------
        {
                if(*a != *b) return 1;
                a++; b++;
        }
        return 0;
}


void setcolor(char settedcolor) { color = settedcolor; return;}


char getkey_oncursor(int x, int y) {
        int temp1 = position_x; 
        int temp2 = position_y;

        position_x = x;
        position_y = y;
        abs_pos = position_y * 80 + position_x;

        char zeichen = VideoMem[2*(abs_pos)];
        position_x = temp1;
        position_y = temp2;
        return zeichen;
}


int kstr2int(char* zahl) {
        int wert = 0;
        while(*zahl) wert = (wert*10) + (int)(*zahl - '0');
        return wert;
}


void kstrcpy(char* source, char* dest) {
        while(*source) {        //----------Solange die source nicht 0 ist, kopiere source in dest, danach erhöhe beide Pointer----------
        *dest = *source;
        source++; dest++;
        }
        *dest = '\0';
        return;
}


void activate_16background() {
inb(0x3DA); uint8_t temp = inb(0x3C0); outb(0x3C0,0x10); uint8_t ModeSelectReg = inb(0x3C1); ModeSelectReg &= ~(1 << 3); outb(0x3C0,ModeSelectReg); outb(0x3C0,temp); inb(0x3D4);
}


void deactivate_16background() {
inb(0x3DA); uint8_t temp = inb(0x3C0); outb(0x3C0,0x10); uint8_t ModeSelectReg = inb(0x3C1); ModeSelectReg |= (1 << 3); outb(0x3C0,ModeSelectReg); outb(0x3C0,temp); inb(0x3D4);
}


void move_cursor(int y, int x) {
uint16_t position = (y* 80) + x;
outb(0x3D4, 15);
outb(0x3D5, (uint8_t)position);
outb(0x3D4, 14);
outb(0x3D5, (uint8_t)position >> 8);
}


void delete_rep_character(char* string, char chara, bool back) {
        if(back == true) for(uint32_t i = kstrlen(string); i > 0; i--) if(string[i] == chara) string[i] = '\0'; else return;
        else for(uint32_t i = 0; i < kstrlen(string); i++) if(string[i] == chara) string[i] = string[i+1]; else return;
}


void low_to_up(char* string) {
        for(uint32_t i = 0; i < kstrlen(string); i++) {
                if(string[i] < 0x7B && string[i] > 0x60) string[i] = (string[i] - 0x20);
        }
}


void up_to_low(char* string) {
        for(uint32_t i = 0; i < kstrlen(string); i++) {
                if(string[i] < 0x5B && string[i] > 0x40) string[i] = (string[i] + 0x20);
        }
}