add overloads for bse::string

c_os/devices/CGA.cc

@@ -95,7 +95,7 @@ void CGA::show(unsigned int x, unsigned int y, char character, unsigned char att
  *      n           Laenger der Zeichenkette                                 *
  *      attrib      Attributbyte fuer alle Zeichen der Zeichenkette          *
  *****************************************************************************/
-void CGA::print(char* string, unsigned int n, unsigned char attrib) {
+void CGA::print(const char* string, unsigned int n, unsigned char attrib) {
 
     /* Hier muess Code eingefuegt werden */
 
@@ -142,6 +142,10 @@ void CGA::print(char* string, unsigned int n, unsigned char attrib) {
     setpos(cursor_x, cursor_y);
 }
 
+void CGA::print(const bse::string& string, unsigned int n, unsigned char attrib) {
+    print((const char*)string, n, attrib);
+}
+
 /*****************************************************************************
  * Methode:         CGA::scrollup                                            *
  *---------------------------------------------------------------------------*

c_os/devices/CGA.h

@@ -16,6 +16,7 @@
 
 #include "kernel/IOport.h"
 #include "user/lib/Array.h"
+#include "user/lib/String.h"
 
 class CGA {
 private:
@@ -61,19 +62,19 @@ public:
            COLUMNS = 80 };
 
     // Easier access to memory (also easier copying of lines/pages etc)
-    typedef struct {
+    struct cga_char_t {
         char cga_char;
         unsigned char cga_attribute;
-    } cga_char_t;
+    };
 
-    typedef struct {
+    struct cga_line_t {
         // Can use these arrays since they don't have memory overhead (except for the methods that are elsewhere)
         bse::array<cga_char_t, COLUMNS> cga_line;
-    } cga_line_t;
+    };
 
-    typedef struct {
+    struct cga_page_t {
         bse::array<cga_line_t, ROWS> cga_page;
-    } cga_page_t;
+    };
 
     // Setzen des Cursors in Spalte x und Zeile y.
     void setpos(unsigned int x, unsigned int y);
@@ -85,7 +86,8 @@ public:
     static void show(unsigned int x, unsigned int y, char character, unsigned char attrib = STD_ATTR);
 
     // Anzeige mehrerer Zeichen ab der aktuellen Cursorposition
-    virtual void print(char* string, unsigned int n, unsigned char attrib = STD_ATTR);
+    void print(const char* string, unsigned int n, unsigned char attrib = STD_ATTR);
+    void print(const bse::string& string, unsigned int n, unsigned char attrib = STD_ATTR);
 
     // Verschiebt den Bildschirminhalt um eine Zeile nach oben.
     // Neue Zeile am unteren Bildrand mit Leerzeichen fuellen

c_os/devices/CGA_Stream.cc

@@ -24,7 +24,7 @@
  *                  verwendet werden, um eine Ausgabe zu erzwingen.          *
  *****************************************************************************/
 void CGA_Stream::flush() {
-    print(buffer, pos, attribute(color_bg, color_fg, blink));
+    print(&buffer, pos, attribute(color_bg, color_fg, blink));
 
     // Flushing resets attributes
     blink = false;

c_os/lib/OutStream.h

@@ -23,6 +23,7 @@
 #define __OutStream_include__
 
 #include "lib/StringBuffer.h"
+#include "user/lib/String.h"
 
 // Some basic width formatting
 class fillw {
@@ -82,14 +83,21 @@ public:
 
     // Darstellung einer nullterminierten Zeichenkette
     template<typename T>
-    friend T& operator<<(T& os, char* string) {
+    friend T& operator<<(T& os, const char* string) {
-
+        const char* pos = string;
-        char* pos = string;
         while (*pos) {
             os.put(*pos);
             pos++;
         }
-        os.fill_finalize();  // NOTE: I added this
+
+        os.fill_finalize();
+        return os;
+    }
+
+    // Can not use this exclusively for strings as these are heap allocated
+    template<typename T>
+    friend T& operator<<(T& os, const bse::string& string) {
+        os << (const char*)string;
         return os;
     }
 

c_os/lib/StringBuffer.cc

@@ -31,7 +31,7 @@
 void StringBuffer::put(char c) {
     buffer[pos] = c;
     pos++;
-    if (pos == sizeof(buffer)) {
+    if (pos == buffer.size()) {
         flush();
     }
 }

c_os/lib/StringBuffer.h

@@ -18,8 +18,9 @@
 #ifndef __StringBuffer_include__
 #define __StringBuffer_include__
 
-class StringBuffer {
+#include "user/lib/Array.h"
 
+class StringBuffer {
 private:
     StringBuffer(const StringBuffer& copy);  // Verhindere Kopieren
 
@@ -30,13 +31,12 @@ private:
     // werden und kann dann auch public werden.
 
 protected:
-    char buffer[80];
+    bse::array<char, 80> buffer;
     int pos;
 
     // StringBuffer: Im Konstruktor wird der Puffer als leer markiert.
     StringBuffer() : pos(0) {}
 
-    // NOTE: I changed this
     // Fuegt ein Zeichen in den Puffer ein. Wenn der Puffer
     virtual void put(char c);
 

c_os/user/devices/SerialOut.cc

@@ -1,5 +1,4 @@
 #include "user/devices/SerialOut.h"
-#include "kernel/Globals.h"
 
 int SerialOut::init() const {
     // NOTE: I could add different ports for every register but this was easier as it's that way on OSDev
@@ -37,15 +36,19 @@ char SerialOut::read() {
     return com1.inb();
 }
 
-void SerialOut::write(char a) {
+void SerialOut::write(const char a) {
     while (is_transmit_empty() == 0) {}
     com1.outb(a);
 }
 
-void SerialOut::write(char* a) {
+void SerialOut::write(const char* a) {
-    char* current = a;
+    const char* current = a;
     do {
         this->write(*current);
         current = current + 1;
     } while (*current != '\0');
 }
+
+void SerialOut::write(const bse::string& a) {
+    write((const char*)a);
+}

c_os/user/devices/SerialOut.h

@@ -1,8 +1,8 @@
 #ifndef __SerialOut_Include_H_
 #define __SerialOut_Include_H_
 
-#include "kernel/interrupts/ISR.h"
 #include "kernel/IOport.h"
+#include "user/lib/String.h"
 
 // NOTE: I took this code from https://wiki.osdev.org/Serial_Ports
 
@@ -24,7 +24,8 @@ public:
 
     char read();
     void write(char a);
-    void write(char* a);
+    void write(const char* a);
+    void write(const bse::string& a);
 };
 
 #endif

c_os/user/lib/Logger.cc

@@ -4,20 +4,19 @@
 SpinLock Logger::sem;
 bool Logger::kout_enabled = true;
 bool Logger::serial_enabled = true;
-// const Semaphore Logger::sem = Semaphore(1);
 
 Logger::LogLevel Logger::level = Logger::ERROR;
 
-constexpr char* ansi_red = "\033[1;31m";
+constexpr const char* ansi_red = "\033[1;31m";
-constexpr char* ansi_green = "\033[1;32m";
+constexpr const char* ansi_green = "\033[1;32m";
-constexpr char* ansi_yellow = "\033[1;33m";
+constexpr const char* ansi_yellow = "\033[1;33m";
-constexpr char* ansi_blue = "\033[1;34m";
+constexpr const char* ansi_blue = "\033[1;34m";
-constexpr char* ansi_magenta = "\033[1;35m";
+constexpr const char* ansi_magenta = "\033[1;35m";
-constexpr char* ansi_cyan = "\033[1;36m";
+constexpr const char* ansi_cyan = "\033[1;36m";
-constexpr char* ansi_white = "\033[1;37m";
+constexpr const char* ansi_white = "\033[1;37m";
-constexpr char* ansi_default = "\033[0;39m ";
+constexpr const char* ansi_default = "\033[0;39m ";
 
-void Logger::log(char* message, CGA::color col) const {
+void Logger::log(const char* message, CGA::color col) const {
     if (Logger::kout_enabled) {
         CGA::color old_col = kout.color_fg;
         kout << fgc(col)
@@ -55,16 +54,16 @@ void Logger::flush() {
 
     switch (this->current_message_level) {
     case Logger::TRACE:
-        this->trace(this->buffer);
+        this->trace(&buffer);
         break;
     case Logger::DEBUG:
-        this->debug(this->buffer);
+        this->debug(&buffer);
         break;
     case Logger::ERROR:
-        this->error(this->buffer);
+        this->error(&buffer);
         break;
     case Logger::INFO:
-        this->info(this->buffer);
+        this->info(&buffer);
         break;
     }
 
@@ -73,29 +72,41 @@ void Logger::flush() {
     Logger::unlock();
 }
 
-void Logger::trace(char* message) const {
+void Logger::trace(const char* message) const {
     if (Logger::level <= Logger::TRACE) {
         this->log(message, CGA::WHITE);
     }
 }
+void Logger::trace(const bse::string& message) const {
+    trace((const char*)message);
+}
 
-void Logger::debug(char* message) const {
+void Logger::debug(const char* message) const {
     if (Logger::level <= Logger::DEBUG) {
         this->log(message, CGA::LIGHT_MAGENTA);
     }
 }
+void Logger::debug(const bse::string& message) const {
+    debug((const char*)message);
+}
 
-void Logger::error(char* message) const {
+void Logger::error(const char* message) const {
     if (Logger::level <= Logger::ERROR) {
         this->log(message, CGA::LIGHT_RED);
     }
 }
+void Logger::error(const bse::string& message) const {
+    error((const char*)message);
+}
 
-void Logger::info(char* message) const {
+void Logger::info(const char* message) const {
     if (Logger::level <= Logger::INFO) {
         this->log(message, CGA::LIGHT_BLUE);
     }
 }
+void Logger::info(const bse::string& message) const {
+    info((const char*)message);
+}
 
 // Manipulatoren
 Logger& TRACE(Logger& log) {

c_os/user/lib/Logger.h

@@ -4,6 +4,7 @@
 #include "devices/CGA.h"
 #include "lib/OutStream.h"
 #include "lib/SpinLock.h"
+#include "user/lib/String.h"
 
 class Logger : public OutStream {
 public:
@@ -20,12 +21,14 @@ private:
     static bool kout_enabled;
     static bool serial_enabled;
 
-    void log(char* message, CGA::color col) const;
+    void log(const char* message, CGA::color col) const;
 
     friend class NamedLogger;  // Allow NamedLogger to lock/unlock
     static SpinLock sem;
     static void lock() { Logger::sem.acquire(); }
     static void unlock() { Logger::sem.release(); }
+    // static void lock() {}
+    // static void unlock() {}
 
 public:
     enum LogLevel {
@@ -39,10 +42,14 @@ public:
 
     void flush() override;
 
-    void trace(char* message) const;
+    void trace(const char* message) const;
-    void debug(char* message) const;
+    void trace(const bse::string& message) const;
-    void error(char* message) const;
+    void debug(const char* message) const;
-    void info(char* message) const;
+    void debug(const bse::string& message) const;
+    void error(const char* message) const;
+    void error(const bse::string& message) const;
+    void info(const char* message) const;
+    void info(const bse::string& message) const;
 
     // TODO: Make level change accessible over menu
     static void set_level(LogLevel level) {
@@ -84,10 +91,10 @@ Logger& INFO(Logger& log);
 
 class NamedLogger {
 private:
-    char* name;
+    const char* name;
 
 public:
-    NamedLogger(char* name) : name(name) {}
+    NamedLogger(const char* name) : name(name) {}
 
     Logger& trace() {
         Logger::lock();