Ethan

/******************************************************************************
   main.cpp
        -Kernel main program
******************************************************************************/
#ifdef __cplusplus
extern "C"
{
#endif

/* va list parameter list */
typedef unsigned char *va_list;

#ifdef __cplusplus
}
#include <bootinfo.h>
#include <hal.h>
#include <kybrd.h>
#include <string.h>
#include <stdio.h>

#include "../Hal/cpu.cpp"
#include "DebugDisplay.h"
#include "exception.h"
#include "mmngr_phys.h"
#include "mmngr_virtual.h"
extern void _cdecl kernel_panic (const char* fmt, ...);
struct memory_region {

    uint32_t    startLo;    //base address
    uint32_t    startHi;
    uint32_t    sizeLo;     //length (in bytes)
    uint32_t    sizeHi;
    uint32_t    type;
    uint32_t    acpi_3_0;
};

uint32_t kernelSize=0;
int find_substr(char *listPointer, char *itemPointer)
{
    int t;
    char *p, *p2;

    for(t=0; listPointer[t]; t++) {
        p = &listPointer[t];
        p2 = itemPointer;

        while(*p2 && *p2==*p) {
            p++;
            p2++;
        }
        if(!*p2) return t; /* 1st return */
    }
    return -1; /* 2nd return */
}
char *strstr(char *buf, char *sub)
{
    register char *bp;
    register char *sp;

    if (!*sub)
    return buf;
    while (*buf) {
    bp = buf;
    sp = sub;
    do {
        if (!*sp)
        return buf;
    } while (*bp++ == *sp++);
    buf += 1;
    }
    return 0;
}
extern void abort (void);
extern int inside_main;
char * strncpy(extern char *s1, const char *s2, unsigned int n)
{
    char *dest;
    dest = s1;
#ifdef __OPTIMIZE__
    if (inside_main)
        abort ();
#endif
    for (; *s2 && n; n--)
        *s1++ = *s2++;
    while (n--)
        return dest;
        *s1++ = 0;
    return dest;
}
int sprintf (char *buf, const char *fmt, ...)
{
  va_list ap;
  int r;
#ifdef __OPTIMIZE__
  if (inside_main)
    abort ();
#endif
  va_start (ap, fmt);
  r = vsprintf (buf, fmt, ap);
  va_end (ap);
  return r;
}
unsigned int f = 0x3f;
char *replace_str(char *str, char *orig, char *rep)
{
  static char buffer[4096];
  char *p;

  if(!(p = strstr(str, orig)))  // Is 'orig' even in 'str'?
    return str;

  strncpy(buffer, str, p-str); // Copy characters from 'str' start to 'orig' st$
  buffer[p-str] = '\0';

  sprintf(buffer+(p-str), "%s%s", rep, p+strlen(orig));

  return buffer;
}
char copytext[101];
void init (multiboot_info* bootinfo) {

    //! initialize our vmm
    vmmngr_initialize ();

    //! clear and init display
    DebugClrScr (f);
    DebugGotoXY (0,0);
    DebugSetColor (f);

    hal_initialize ();

    enable ();
    setvect (0,(void (__cdecl &)(void))divide_by_zero_fault);
    setvect (1,(void (__cdecl &)(void))single_step_trap);
    setvect (2,(void (__cdecl &)(void))nmi_trap);
    setvect (3,(void (__cdecl &)(void))breakpoint_trap);
    setvect (4,(void (__cdecl &)(void))overflow_trap);
    setvect (5,(void (__cdecl &)(void))bounds_check_fault);
    setvect (6,(void (__cdecl &)(void))invalid_opcode_fault);
    setvect (7,(void (__cdecl &)(void))no_device_fault);
    setvect (8,(void (__cdecl &)(void))double_fault_abort);
    setvect (10,(void (__cdecl &)(void))invalid_tss_fault);
    setvect (11,(void (__cdecl &)(void))no_segment_fault);
    setvect (12,(void (__cdecl &)(void))stack_fault);
    setvect (13,(void (__cdecl &)(void))general_protection_fault);
    setvect (14,(void (__cdecl &)(void))page_fault);
    setvect (16,(void (__cdecl &)(void))fpu_fault);
    setvect (17,(void (__cdecl &)(void))alignment_check_fault);
    setvect (18,(void (__cdecl &)(void))machine_check_abort);
    setvect (19,(void (__cdecl &)(void))simd_fpu_fault);

    pmmngr_init (bootinfo->m_memorySize, 0xC0000000 + kernelSize*512);

    memory_region*  region = (memory_region*)0x1000;

    for (int i=0; i<10; ++i) {

        if (region[i].type>4)
            break;

        if (i>0 && region[i].startLo==0)
            break;

        pmmngr_init_region (region[i].startLo, region[i].sizeLo);
    }
    pmmngr_deinit_region (0x100000, kernelSize*512);

    //! install the keyboard to IR 33
    kkybrd_install (33);
}

//! sleeps a little bit. This uses the HALs get_tick_count() which in turn uses the PIT
void sleep (int ms) {

    static int ticks = ms + get_tick_count ();
    while (ticks > get_tick_count ())
        ;
}

//! wait for key stroke
KEYCODE getch () {

    KEYCODE key = KEY_UNKNOWN;

    //! wait for a keypress
    while (key==KEY_UNKNOWN)
        key = kkybrd_get_last_key ();

    //! discard last keypress (we handled it) and return
    kkybrd_discard_last_key ();
    return key;
}

//! command prompt
void cmd () {

    DebugPrintf ("\n-> ");
}

//! gets next command
void get_cmd (char* buf, int n) {

    cmd ();

    KEYCODE key = KEY_UNKNOWN;
    bool    BufChar;

    //! get command string
    int i=0;
    while ( i < n ) {

        //! buffer the next char
        BufChar = true;

        //! grab next char
        key = getch ();

        //! end of command if enter is pressed
        if (key==KEY_RETURN)
            break;

        //! backspace
        if (key==KEY_BACKSPACE) {

            //! dont buffer this char
            BufChar = false;

            if (i > 0) {

                //! go back one char
                unsigned y, x;
                DebugGetXY (&x, &y);
                if (x>0)
                    DebugGotoXY (--x, y);
                else {
                    //! x is already 0, so go back one line
                    y--;
                    x = DebugGetHorz ();
                }

                //! erase the character from display
                DebugPutc (' ');
                DebugGotoXY (x, y);

                //! go back one char in cmd buf
                i--;
            }
        }

        //! only add the char if it is to be buffered
        if (BufChar) {

            //! convert key to an ascii char and put it in buffer
            char c = kkybrd_key_to_ascii (key);
            if (c != 0) { //insure its an ascii char

                DebugPutc (c);
                buf [i++] = c;
            }
        }

        //! wait for next key. You may need to adjust this to suit your needs
        sleep (10);
    }

    //! null terminate the string
    buf [i] = '\0';
}

//! our simple command parser
bool run_cmd (char* cmd_buf) {

    //! exit command
    if (strcmp (cmd_buf, "exit") == 0) {
        return true;
    }
    else if (find_substr (cmd_buf, "print") != -1) {
        if (strcmp (cmd_buf, "print") == 0) {
            DebugPrintf ("\nInvalid string");
        }
        else if (find_substr (cmd_buf, "print") != -1) {
            DebugPrintf ("\n");
            DebugPrintf (replace_str (cmd_buf, "print", "\0"));
        }
    }

    //! clear screen
    else if (strcmp (cmd_buf, "cls") == 0) {
        DebugClrScr (f);
    }
    else if (find_substr (cmd_buf, "color") != -1) {
        if (strcmp (cmd_buf, "color") == 0) {
            DebugPrintf ("\nColor table:\n\n0 = Black\t8 = Gray\n1 = Blue\t9 = Light Blue\n2 = Green\tA = Light Green\n3 = Aqua\tB = Light Aqua\n4 = Red\t\tC = Light Red\n5 = Purple\tD = Light Purple\n6 = Yellow\tE = Light Yellow\n7 = White\tF = Bright White\n");
        }
        else if (find_substr (cmd_buf, "color ") != -1) {
            f = int(replace_str (cmd_buf, "color ", "\0"));
            DebugPrintf ("\n");
            DebugClrScr (f);
            DebugSetColor (f);
        }
        //DebugSetColor (0x3f);
    }
    else if (strcmp (cmd_buf, "clear") == 0) {
        DebugClrScr (f);
    }
    else if (strcmp (cmd_buf, "sysinfo") == 0) {
        DebugPuts("\n");
        DebugPuts(i86_cpu_get_vender());
    }
    else if (strcmp (cmd_buf, "test error") == 0) {
        kernel_panic("Test error initiated by the user");
    }
    else if (find_substr (cmd_buf, "copy") != -1) {
        if (strcmp (cmd_buf, "copy") == 0) {
            DebugPrintf ("\nInvalid String");
        }
        else if (find_substr (cmd_buf, "copy") != -1) {
            strncpy(copytext, replace_str (cmd_buf, "copy", "\0"), 100);
            DebugPrintf ("\nString copied.");
        }
    }
    else if (strcmp (cmd_buf, "paste") == 0) {
        DebugPrintf ("\n");
        DebugPrintf (copytext);
    }

    //! help
    else if (strcmp (cmd_buf, "help") == 0) {

        DebugPuts ("\nThis is my Operating System");
        DebugPuts ("\nwith a basic Command Line Interface (CLI)\n\n");
        DebugPuts ("Supported commands:\n");
        DebugPuts (" - exit: quits and halts the system\n");
        DebugPuts (" - cls: clears the display\n");
        DebugPuts (" - help: displays this message\n");
        DebugPuts (" - clear: clears the display\n");
        DebugPuts (" - print [string]: displays [string]");
    }
    else if (strcmp (cmd_buf, "test") == 0) {
        unsigned char* p1 = (unsigned char*) 0x50000;
        unsigned char* p2 = (unsigned char*) 0x500000;
        p1[3] = 0;
        p2[3] = 0;
        DebugPrintf ("%s", p1);
        DebugPrintf ("%s", p2);

    }

    //! invalid command
    else {
        DebugPrintf ("\nUnkown command");
    }

    return false;
}

void run () {

    //! command buffer
    char    cmd_buf [100];

    while (1) {

        //! get command
        get_cmd (cmd_buf, 98);

        //! run command
        if (run_cmd (cmd_buf) == true)
            break;
    }
}

bool floppyMotorStart(void) {
    _asm    mov     al,01ch
    _asm    mov     dx,03f2h
    _asm    out     dx,al
    return true;
}

bool floppyMotorReset(void) {
    _asm    mov     al,0
    _asm    mov     dx,03f2h
    _asm    out     dx,al
    return true;
}

int _cdecl kmain (multiboot_info* bootinfo) {

    _asm    mov word ptr [kernelSize], dx
    init (bootinfo);

    DebugGotoXY (0,0);
    //pmmngr_paging_enable (true);
    DebugPuts ("+------------------------------------------+\n");
    DebugPuts ("| Jandekk J-OS Version 0.0.16 (Build 52)   |\n");
    DebugPuts ("| Copyright Jandekk Corporation, 2007-2009 |\n");
    DebugPuts ("+------------------------------------------+\n");

    run ();

    //DebugPrintf ("\nExit command recieved; OS halted");
    //for (;;);
    return 0;
}
#endif