Se viene nuevo kernel

Off Topic Promociones y Spam
1

he creado un kernel llamado ModuKernel, esta en ErickStudios/ModuKernel: un kernel modular con un ecosistema modular completamente documentado en español

este kernel aunque es joven ya tiene

  • Archivos de ejemplo
  • Una tabla de servicios del sistema modular y estructurada
  • Una shell basica
  • Un gdt
  • manejo de excepciones
  • Modulos
  • Sistema de archivos FAT12
  • Sistema de carpetas virtuales
  • Interrupciones
  • Contador de tick PIC
  • Un script de shell
  • Una animacion de logo
  • Soporte muy basico para red
  • su propia paleta de colores
  • Modo texto personalizado
  • Soporte para C++
  • Libreria avanzada C++
  • Drivers

y estoy creando mi propio compilador para un lenguaje llamado ModuCandy que sera directamente integrado en el kernel que vendra como uno de los modulos, no compila C si no algo mas parecido a esto

// mi variable
Build_InInt32 let MiVariable

// no necesita un entry point, puede ser plano

// setea la variable MiVariable
r1<=MiVariable                                      // carga la direccion de la variable en eax
r2=5                                                // mueve el valor 5 a ecx
unsafe "mov [eax],ecx"                              // setea la direccion a la que apunta eax con el valor de ecx como dword

// obtener el valor
r1<=MiVariable                                      // carga la direccion de la variable en eax
unsafe "mov eax,[eax]"                              // obtiene en eax el valor dword al que apunta eax (donde cargo la variable)
return                                              // hace ret, en ModuCandy el return no lleva ningun parametro, el valor de retorno esta en r1 (eax) que es donde se guarda el valor de retorno en C cuando se usa un (int)funcion()

genera algo como

call DATA_MODUCANDY_DATA
mov ebx,0
add eax,ebx
mov ecx,5
mov [eax],ecx
call DATA_MODUCANDY_DATA
mov ebx,0
add eax,ebx
mov eax,[eax]
ret
ret
call FUNCION
DATA_MODUCANDY_DATA:
   call DATA_MODUCANDY_DATA_GETEIP
   ret
   ;datas
   ret ;place for variable (u/i32)
   ret ;place for variable (u/i32)
   ret ;place for variable (u/i32)
   ret ;place for variable (u/i32)
; ModuCandy: eip get runtime for data calc
DATA_MODUCANDY_DATA_GETEIP:
   pop eax
   push eax
   inc eax
   ret

y eso en el compilador luego se compila a codigo i386

tambien se puede llamar al programa en el kernel con

kernel/mcandy /ruta/a/archivo.cdy

o abrir la version interactiva

kernel/mcandy --s

Hablando de la version interactiva

en esa version lo que haces es escribir codigo en tiempo real, con el comando :cls eliminas todas las lineas de codigo que hiciste y empiezas desde 0, con :asm puedes ver el codigo que genera tu programa al convertirse a ensamblador, pero sin compilarlo, con :run compilas el programa y lo ejecutas asi sin restricciones y en ring 0, por que todo mi kernel se ejecuta en ring 0, con :q sales de la aplicacion

donde intervienes tu

que les parece?, que me recomienda mejorar?, que añadirian ustedes?, los leo en los comentarios

7 Me gusta
2

Chicos pienso hacer de ModuKernel un ecosistema completo, con apps, compilador, ensamblador y mucho mas, para que las personas que quieran puedan basarse en el repo de ModuKernel y mejorar, cualquier colaboracion, mejora o caracteristica que me recomienden contacten a los pull request en Pull requests · ErickStudios/ModuKernel

cualquier ayuda o caracteristica que sugieran sera bienvenida, has de este sistema un ecosistema mejor, se que podemos juntos hacer crecer el kernel, con su ayuda y apoyo, gracias por leer chicos

1 me gusta
3

Holaa @ErickCraftStudios :smiley:

Me parece increible la iniciativa, interés y ambición que tienes, es un proyecto muy interesante.

Ahora mismo no se me ocurren muchas ideas, pero voy a guardar este post, también voy a tratar de hacerme un hueco en estos días para compilarlo y probarlo :b

4

justo fijate que estoy haciendo un editor de texto tipo vi para ModuKernel

aqui hay un prototipo

#include "../../library/lib.hpp"

/// @brief el ErickMain
/// @param Services los servicios
/// @return 
extern "C" KernelStatus ErickMain(KernelServices* Services) {
    ModuLibCpp::String Text{""};
    ModuLibCpp::Array<char*> Lines = Text / '\n';
}
3 Me gusta
5

el editor tipo vi ha sido construido

#include "../../library/lib.hpp"

/**
 * @dead beef
 */
#define MAX_VIEW_LINES 27

/// @brief scroll de la linea
int ScrollLine = 0;

/// @brief la linea actual
int CurrentLine = 0;

/// @brief dibja el editor
/// @param Lines las lineas
void DrawEditor(ModuLibCpp::Array<ModuLibCpp::String>& Lines) {
    gDS->clearScreen();
    // asegurarse de no pasar del final
    for (int i = ScrollLine; ScrollLine + MAX_VIEW_LINES; i++) {
        if (i > ScrollLine + MAX_VIEW_LINES) break;
        auto line = Lines[i].InternalString;

        if (i < Lines.size()) ModuLibCpp::Display::Print(line);
        else ModuLibCpp::Display::Print(".");
        if (i == (CurrentLine)) {
            gDS->DrawLetter(gDS->CurrentCharacter / 2, gDS->CurrentLine, '_', 0b11101011, 0,1);
        }
        ModuLibCpp::Display::Print("\n");

    }
}

KernelStatus Editor(ModuLibCpp::String& Text, ModuLibCpp::String& outtext) {
    
    /// @brief si esta en modo editor
    bool InEditMode = false;

    ModuLibCpp::Array<char*> LinesReal = Text / '\n';
    ModuLibCpp::Array<ModuLibCpp::String> Lines{};

    for (auto line : LinesReal) Lines.push(ModuLibCpp::String{line});
    
    while (true) {
        DrawEditor(Lines);
        unsigned char key = gIOS->WaitKey();

        char k[2] = {key, 0};

        if (key == EscaneoFlechaArriba && InEditMode == false) 
           CurrentLine--;
        else if (key == EscaneoFlechaAbajo && InEditMode == false) 
            CurrentLine++;
        else if (key == '\n' && InEditMode == false) 
            InEditMode = true;
        else if (key == KernelSimpleIoFuncKey(1) && InEditMode) 
            InEditMode = false;
        else if (key == ':' && InEditMode == false)
        {
            gDS->printg(":");
            char* Command = gIOS->ReadLine();

            if (StrCmp(Command, "q") == 0)
            {
                return KernelStatusDisaster;
            }
            else if (StrCmp(Command, "qs") == 0)
            {
                ModuLibCpp::String LinesCombined{};
                
                for (auto& line : Lines)
                {
                    LinesCombined << line << "\n";
                }
                LinesCombined.RemoveLastChar();
                outtext.SetString(LinesCombined.InternalString);
                return KernelStatusSuccess;
            }
        }
        else if (key == '\b' && InEditMode) 
        {
            if (StrLen(Lines[CurrentLine].InternalString) == 0) Lines.remove((CurrentLine--));
            else Lines[CurrentLine].RemoveLastChar();
        }
        else if (key == '\n' && InEditMode)
            Lines.insert((CurrentLine++)+1, ModuLibCpp::String{""});
        else if (InEditMode) { 
            // get started
            if (Lines.getCount() == 0 && CurrentLine == 0)
            {
                Lines.push(ModuLibCpp::String{""});
            }
            // ya hay texto
            Lines[CurrentLine].AddChar(key); 
        }

        // ajustar scroll
        if (CurrentLine >= ScrollLine + MAX_VIEW_LINES) {
            ScrollLine = CurrentLine - MAX_VIEW_LINES + 1;
        }
        else if (CurrentLine < ScrollLine) {
            ScrollLine = CurrentLine;
        }

    }
}

/// @brief el ErickMain
/// @param Services los servicios
/// @return 
extern "C" KernelStatus ErickMain(KernelServices* Services) {
    InitializeLibrary(Services);

    // argumentos
    GetArgs(Services, count);

    // archivo
    char* file = nullptr;

    // recorrer parametros
    for (int i = 1; i < count; i++) {
        // argumento
        char* arg = (char*)Services->Misc->Paramaters[i + 2];

        // si el parametro es el primero, es el archivo
        if (i == 1) 
            file = arg;
    }

    ModuLibCpp::File<char*> File{file};

    // si no se pudo abrir
    if (File.data() == nullptr) {
        ModuLibCpp::String Text{};
        Editor(Text, Text);
        return KernelStatusSuccess;
    }

    // el archivo
    ModuLibCpp::String FileContent = ModuLibCpp::String{};

    File >> FileContent.InternalString;

    ModuLibCpp::String ContentView{};
    KernelStatus Ed = Editor(FileContent, ContentView);

    if (Ed == KernelStatusSuccess)
    {
        ModuLibCpp::Display::Print(ContentView.InternalString);
        int Size = StrLen(ContentView.InternalString) + 1;
        File << ModuLibCpp::Pair<char*, int>{ContentView.InternalString, Size};
    }
    return KernelStatusSuccess;
}
4 Me gusta
6

Me parece una buena idea, pero porque la etiqueta off topic, en un foro sobre software libre me parece raro que no entre en la categoria de software libre o similares, pero aun asi buen proyecto, bueno ver este tipo de iniciativas pues asi se mejora y se aprende