apps/ls.cpp

@@ -8,7 +8,6 @@
 #include <os/FileSystem.h>
 #include <os/Mode.h>
 #include <pwd.h>
-#include <unistd.h>
 
 void find_user_and_group(struct stat& st, StringView& owner, StringView& group)
 {
@@ -48,46 +47,18 @@ int sort_reverse(const os::Directory::Entry* a, const os::Directory::Entry* b)
     return 0;
 }
 
-#define RESET_COLORS "\x1b[m"
-#define SYMLINK_COLOR "\x1b[36m"
-#define FILE_COLOR "\x1b[1;32m"
-#define DIR_COLOR "\x1b[1;34m"
-#define SOCKET_COLOR "\x1b[33m"
-#define SPECIAL_COLOR "\x1b[35m"
-#define STICKY_COLOR "\x1b[30;1;42m"
-#define SETUID_COLOR "\x1b[30;1;41m"
-#define EXEC_COLOR "\x1b[1;31m"
-
-static const char* file_type_color(const os::Directory::Entry& entry)
-{
-    if (entry.mode & S_ISVTX) return STICKY_COLOR;
-    if (entry.mode & S_ISUID || entry.mode & S_ISGID) return SETUID_COLOR;
-
-    switch (entry.mode & S_IFMT)
-    {
-    case S_IFREG: return entry.mode & S_IXUSR ? EXEC_COLOR : FILE_COLOR;
-    case S_IFDIR: return DIR_COLOR;
-    case S_IFLNK: return SYMLINK_COLOR;
-    case S_IFSOCK: return SOCKET_COLOR;
-    default: return SPECIAL_COLOR;
-    }
-}
-
-static Result<String> entry_join(const Vector<os::Directory::Entry>& vec, StringView delim, bool colors)
+static Result<String> entry_join(const Vector<os::Directory::Entry>& vec, StringView delim)
 {
     if (vec.size() == 0) return String {};
+    if (vec.size() == 1) return vec[0].name.clone();
 
     StringBuilder sb;
-    if (colors) TRY(sb.add(StringView { file_type_color(vec[0]) }));
     TRY(sb.add(vec[0].name));
-    if (colors) TRY(sb.add(StringView { RESET_COLORS }));
 
     for (usize i = 1; i < vec.size(); i++)
     {
         TRY(sb.add(delim));
-        if (colors) TRY(sb.add(StringView { file_type_color(vec[i]) }));
         TRY(sb.add(vec[i].name));
-        if (colors) TRY(sb.add(StringView { RESET_COLORS }));
     }
 
     return sb.string();
@@ -104,7 +75,6 @@ Result<int> luna_main(int argc, char** argv)
     bool follow_symlink_args { false };
     bool one_per_line { false };
     bool list_directories { false };
-    bool no_colors { false };
 
     StringView sort_type { "name" };
 
@@ -128,8 +98,6 @@ Result<int> luna_main(int argc, char** argv)
     parser.add_switch_argument(list_directories, 'd', "directory"_sv, "list directories instead of their contents"_sv);
     parser.add_value_argument(sort_type, ' ', "sort"_sv, "sort by name, size or time"_sv);
     parser.add_switch_argument(reverse_sort, 'r', "reverse"_sv, "reverse order while sorting"_sv);
-    parser.add_switch_argument(no_colors, ' ', "no-colors"_sv,
-                               "disable coloring of output (defaults to true when not in a TTY)"_sv);
     parser.parse(argc, argv);
 
     Vector<os::Directory::Entry> files;
@@ -186,13 +154,11 @@ Result<int> luna_main(int argc, char** argv)
 
     if (!long_list)
     {
-        auto list = TRY(entry_join(files, one_per_line ? "\n"_sv : " "_sv, !no_colors && isatty(STDIN_FILENO)));
+        auto list = TRY(entry_join(files, one_per_line ? "\n"_sv : " "_sv));
         if (!list.is_empty()) os::println("%s", list.chars());
     }
     else
     {
-        bool colors = !no_colors && isatty(STDIN_FILENO);
-
         for (const auto& file : files)
         {
             struct stat st;
@@ -210,32 +176,14 @@ Result<int> luna_main(int argc, char** argv)
 
             if (!human_readable && !si)
             {
-                if (colors)
-                {
-                    os::println("%s %u %4s %4s %10lu %s%s" RESET_COLORS "%s" SYMLINK_COLOR "%s" RESET_COLORS,
-                                formatted_mode, st.st_nlink, owner.chars(), group.chars(), st.st_size,
-                                file_type_color(file), file.name.chars(), link.is_empty() ? "" : " -> ", link.chars());
-                }
-                else
-                {
-                    os::println("%s %u %4s %4s %10lu %s%s%s", formatted_mode, st.st_nlink, owner.chars(), group.chars(),
-                                st.st_size, file.name.chars(), link.is_empty() ? "" : " -> ", link.chars());
-                }
+                os::println("%s %u %4s %4s %10lu %s%s%s", formatted_mode, st.st_nlink, owner.chars(), group.chars(),
+                            st.st_size, file.name.chars(), link.is_empty() ? "" : " -> ", link.chars());
             }
             else
             {
                 auto size = TRY(to_dynamic_unit(st.st_size, 10, false, si ? Unit::SI : Unit::Binary, false));
-                if (colors)
-                {
-                    os::println("%s %u %4s %4s %6s %s%s" RESET_COLORS "%s" SYMLINK_COLOR "%s" RESET_COLORS,
-                                formatted_mode, st.st_nlink, owner.chars(), group.chars(), size.chars(),
-                                file_type_color(file), file.name.chars(), link.is_empty() ? "" : " -> ", link.chars());
-                }
-                else
-                {
-                    os::println("%s %u %4s %4s %6s %s%s%s", formatted_mode, st.st_nlink, owner.chars(), group.chars(),
-                                size.chars(), file.name.chars(), link.is_empty() ? "" : " -> ", link.chars());
-                }
+                os::println("%s %u %4s %4s %6s %s%s%s", formatted_mode, st.st_nlink, owner.chars(), group.chars(),
+                            size.chars(), file.name.chars(), link.is_empty() ? "" : " -> ", link.chars());
             }
         }
     }

kernel/src/video/TextConsole.cpp

@@ -3,7 +3,6 @@
 #include "video/Framebuffer.h"
 #include <luna/CString.h>
 #include <luna/CType.h>
-#include <luna/EscapeSequence.h>
 #include <luna/Format.h>
 #include <luna/Result.h>
 #include <luna/ScopeGuard.h>
@@ -14,27 +13,8 @@ extern const BOOTBOOT bootboot;
 
 #include "video/BuiltinFont.h"
 
-// Default text color.
-static constexpr u32 WHITE = 0xffffffff;
-
-// xterm color palette.
 static constexpr u32 BLACK = 0xff000000;
-static constexpr u32 RED = 0xffcd0000;
-static constexpr u32 GREEN = 0xff00cd00;
-static constexpr u32 YELLOW = 0xffcdcd00;
-static constexpr u32 BLUE = 0xff0000ee;
-static constexpr u32 MAGENTA = 0xffcd00cd;
-static constexpr u32 CYAN = 0xff00cdcd;
-static constexpr u32 GRAY = 0xffe5e5e5;
-
-static constexpr u32 BRIGHT_BLACK = 0xff7f7f7f;
-static constexpr u32 BRIGHT_RED = 0xffff0000;
-static constexpr u32 BRIGHT_GREEN = 0xff00ff00;
-static constexpr u32 BRIGHT_YELLOW = 0xffffff00;
-static constexpr u32 BRIGHT_BLUE = 0xff5c5cff;
-static constexpr u32 BRIGHT_MAGENTA = 0xffff00ff;
-static constexpr u32 BRIGHT_CYAN = 0xff00ffff;
-static constexpr u32 BRIGHT_GRAY = 0xffffffff;
+static constexpr u32 WHITE = 0xffffffff;
 
 static u32 g_background_color = BLACK;
 static u32 g_foreground_color = WHITE;
@@ -42,15 +22,11 @@ static u32 g_foreground_color = WHITE;
 static constexpr u32 FONT_HEIGHT = 16;
 static constexpr u32 FONT_WIDTH = 8;
 
-static bool bold = false;
-
 static u32 g_x_position = 0;
 static u32 g_y_position = 0;
 
 static Utf8StateDecoder utf8_decoder;
 
-static Option<EscapeSequenceParser> escape_sequence_parser;
-
 static void putwchar_at(wchar_t c, u32 x, u32 y)
 {
     const u8* glyph = &font[c * 16];
@@ -111,206 +87,6 @@ static bool at_end_of_screen()
     return (g_x_position + FONT_WIDTH) > Framebuffer::width();
 }
 
-static bool handle_escape_sequence(wchar_t c)
-{
-    auto rc = escape_sequence_parser->advance(static_cast<u8>(c));
-    if (rc.has_error())
-    {
-        escape_sequence_parser = Option<EscapeSequenceParser> {};
-        return false;
-    }
-    if (!rc.value()) return true;
-    if (!escape_sequence_parser->valid())
-    {
-        escape_sequence_parser = Option<EscapeSequenceParser> {};
-        return false;
-    }
-
-    const auto& params = escape_sequence_parser->parameters();
-    switch (escape_sequence_parser->code())
-    {
-    case EscapeCode::CursorUp: {
-        int lines = params.size() ? params[0] : 1;
-        int pixels = lines * FONT_HEIGHT;
-        if ((u32)pixels > g_y_position) g_y_position = 0;
-        else
-            g_y_position -= pixels;
-    };
-    break;
-    case EscapeCode::CursorDown: {
-        int lines = params.size() ? params[0] : 1;
-        int pixels = lines * FONT_HEIGHT;
-        if (pixels + g_y_position >= Framebuffer::height()) g_y_position = Framebuffer::height() - FONT_HEIGHT;
-        else
-            g_y_position += pixels;
-    };
-    break;
-    case EscapeCode::CursorBack: {
-        int chars = params.size() ? params[0] : 1;
-        int pixels = chars * FONT_WIDTH;
-        if ((u32)pixels > g_x_position) g_x_position = 0;
-        else
-            g_x_position -= pixels;
-    };
-    break;
-    case EscapeCode::CursorForward: {
-        int chars = params.size() ? params[0] : 1;
-        int pixels = chars * FONT_WIDTH;
-        if (pixels + g_x_position >= Framebuffer::width()) g_x_position = Framebuffer::width() - FONT_WIDTH;
-        else
-            g_x_position += pixels;
-    };
-    break;
-    case EscapeCode::CursorNextLine: {
-        int lines = params.size() ? params[0] : 1;
-        int pixels = lines * FONT_HEIGHT;
-        if ((u32)pixels > g_y_position) g_y_position = 0;
-        else
-            g_y_position -= pixels;
-        g_x_position = 0;
-    };
-    break;
-    case EscapeCode::CursorPreviousLine: {
-        int lines = params.size() ? params[0] : 1;
-        int pixels = lines * FONT_HEIGHT;
-        if (pixels + g_y_position >= Framebuffer::height()) g_y_position = Framebuffer::height() - FONT_HEIGHT;
-        else
-            g_y_position += pixels;
-        g_x_position = 0;
-    };
-    break;
-    case EscapeCode::CursorHorizontalAbsolute: {
-        int line = (params.size() ? params[0] : 1) - 1;
-        if (line < 0) break;
-        u32 position = line * FONT_HEIGHT;
-        if (position >= Framebuffer::height()) position = Framebuffer::height() - FONT_HEIGHT;
-        g_y_position = position;
-    };
-    break;
-    case EscapeCode::SetCursorPosition: {
-        int x = (params.size() ? params[0] : 1) - 1;
-        int y = (params.size() > 1 ? params[1] : 1) - 1;
-        if (x < 0 || y < 0) break;
-        u32 x_position = x * FONT_WIDTH;
-        if (x_position >= Framebuffer::width()) x_position = Framebuffer::width() - FONT_HEIGHT;
-        g_x_position = x_position;
-        u32 y_position = y * FONT_HEIGHT;
-        if (y_position >= Framebuffer::height()) y_position = Framebuffer::height() - FONT_HEIGHT;
-        g_y_position = y_position;
-    };
-    break;
-    case EscapeCode::SelectGraphicRendition: {
-        if (!params.size())
-        {
-            g_foreground_color = WHITE;
-            g_background_color = BLACK;
-            bold = false;
-            break;
-        }
-
-        for (usize i = 0; i < params.size(); i++)
-        {
-            int arg = params[i];
-            switch (arg)
-            {
-            case 0: {
-                g_foreground_color = BLACK;
-                g_background_color = WHITE;
-                bold = false;
-                break;
-            }
-            case 1: {
-                bold = true;
-                break;
-            }
-            case 22: {
-                bold = false;
-                break;
-            }
-            case 30: {
-                g_foreground_color = bold ? BRIGHT_BLACK : BLACK;
-                break;
-            }
-            case 31: {
-                g_foreground_color = bold ? BRIGHT_RED : RED;
-                break;
-            }
-            case 32: {
-                g_foreground_color = bold ? BRIGHT_GREEN : GREEN;
-                break;
-            }
-            case 33: {
-                g_foreground_color = bold ? BRIGHT_YELLOW : YELLOW;
-                break;
-            }
-            case 34: {
-                g_foreground_color = bold ? BRIGHT_BLUE : BLUE;
-                break;
-            }
-            case 35: {
-                g_foreground_color = bold ? BRIGHT_MAGENTA : MAGENTA;
-                break;
-            }
-            case 36: {
-                g_foreground_color = bold ? BRIGHT_CYAN : CYAN;
-                break;
-            }
-            case 37: {
-                g_foreground_color = bold ? BRIGHT_GRAY : GRAY;
-                break;
-            }
-            case 39: {
-                g_foreground_color = WHITE;
-                break;
-            }
-            case 40: {
-                g_background_color = bold ? BRIGHT_BLACK : BLACK;
-                break;
-            }
-            case 41: {
-                g_background_color = bold ? BRIGHT_RED : RED;
-                break;
-            }
-            case 42: {
-                g_background_color = bold ? BRIGHT_GREEN : GREEN;
-                break;
-            }
-            case 43: {
-                g_background_color = bold ? BRIGHT_YELLOW : YELLOW;
-                break;
-            }
-            case 44: {
-                g_background_color = bold ? BRIGHT_BLUE : BLUE;
-                break;
-            }
-            case 45: {
-                g_background_color = bold ? BRIGHT_MAGENTA : MAGENTA;
-                break;
-            }
-            case 46: {
-                g_background_color = bold ? BRIGHT_CYAN : CYAN;
-                break;
-            }
-            case 47: {
-                g_background_color = bold ? BRIGHT_GRAY : GRAY;
-                break;
-            }
-            case 49: {
-                g_background_color = BLACK;
-                break;
-            }
-            default: break;
-            }
-        }
-    }
-    break;
-    default: break;
-    }
-
-    escape_sequence_parser = Option<EscapeSequenceParser> {};
-    return true;
-}
-
 namespace TextConsole
 {
     void putwchar(wchar_t c)
@@ -318,11 +94,6 @@ namespace TextConsole
         // Unprintable (not in the built-in font) characters get represented as a box
         if (c > (wchar_t)255) c = (wchar_t)256;
 
-        if (escape_sequence_parser.has_value())
-        {
-            if (handle_escape_sequence(c)) return;
-        }
-
         switch (c)
         {
         case L'\n': {
@@ -342,10 +113,6 @@ namespace TextConsole
                 erase_current_char();
             }
             break;
-        case L'\x1b':
-        case L'\x9b':
-        case L'\x90':
-        case L'\x9d': escape_sequence_parser = EscapeSequenceParser { (u8)c }; break;
         default: {
             if (_iscntrl(c)) return;
             putwchar_at(c, g_x_position, g_y_position);

libc/CMakeLists.txt

@@ -20,6 +20,7 @@ set(SOURCES
     src/pwd.cpp
     src/grp.cpp
     src/locale.cpp
+    src/scanf.cpp
     src/signal.cpp
     src/termios.cpp
     src/utime.cpp

libc/src/scanf.cpp

@@ -0,0 +1,263 @@
+#include <errno.h>
+#include <luna/CType.h>
+#include <luna/NumberParsing.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define FLAG_DISCARD (1 << 0)
+#define FLAG_ALLOC (1 << 1)
+#define FLAG_WIDTH (1 << 2)
+#define FLAG_LONG (1 << 3)
+#define FLAG_LONG_LONG (1 << 4)
+#define FLAG_SHORT (1 << 5)
+#define FLAG_CHAR (1 << 6)
+
+static int parse_flags(const char** format)
+{
+    int result = 0;
+
+    while (true)
+    {
+        switch (**format)
+        {
+        case '*':
+            result |= FLAG_DISCARD;
+            (*format)++;
+            break;
+        case 'm':
+            result |= FLAG_ALLOC;
+            (*format)++;
+            break;
+        default: return result;
+        }
+    }
+}
+
+static size_t parse_width(const char** format, int& flags)
+{
+    size_t result = 0;
+
+    if (_isdigit(**format))
+    {
+        result = scan_unsigned_integer(format);
+        flags |= FLAG_WIDTH;
+    }
+
+    return result;
+}
+
+static void parse_type(const char** format, int& flags)
+{
+    // FIXME: Support %j (intmax_t/uintmax_t)
+    switch (**format)
+    {
+    case 'h':
+        flags |= FLAG_SHORT;
+        (*format)++;
+        if (**format == 'h')
+        {
+            flags |= FLAG_CHAR;
+            (*format)++;
+        }
+        break;
+    case 'l':
+        flags |= FLAG_LONG;
+        (*format)++;
+        if (**format == 'l')
+        {
+            flags |= FLAG_LONG_LONG;
+            (*format)++;
+        }
+        break;
+    case 't':
+        flags |= (sizeof(ptrdiff_t) == sizeof(long)) ? FLAG_LONG : FLAG_LONG_LONG;
+        (*format)++;
+        break;
+    case 'z':
+        flags |= (sizeof(size_t) == sizeof(long)) ? FLAG_LONG : FLAG_LONG_LONG;
+        (*format)++;
+        break;
+    default: break;
+    }
+}
+
+static void write_parsed_signed_integer(ssize_t value, int flags, va_list ap)
+{
+    if (flags & FLAG_LONG_LONG) *va_arg(ap, signed long long*) = (signed long long)value;
+    else if (flags & FLAG_LONG)
+        *va_arg(ap, signed long*) = (signed long)value;
+    else if (flags & FLAG_SHORT)
+        *va_arg(ap, signed int*) = (signed short)value;
+    else if (flags & FLAG_CHAR)
+        *va_arg(ap, signed int*) = (signed char)value;
+    else
+        *va_arg(ap, signed int*) = (signed int)value;
+}
+
+static void write_parsed_unsigned_integer(size_t value, int flags, va_list ap)
+{
+    if (flags & FLAG_LONG_LONG) *va_arg(ap, unsigned long long*) = (unsigned long long)value;
+    else if (flags & FLAG_LONG)
+        *va_arg(ap, unsigned long*) = (unsigned long)value;
+    else if (flags & FLAG_SHORT)
+        *va_arg(ap, unsigned int*) = (unsigned short)value;
+    else if (flags & FLAG_CHAR)
+        *va_arg(ap, unsigned int*) = (unsigned char)value;
+    else
+        *va_arg(ap, unsigned int*) = (unsigned int)value;
+}
+
+#define WHITESPACE_CHARACTERS " \t\f\r\n\v"
+
+static void skip_whitespace(const char** str)
+{
+    *str += strspn(*str, WHITESPACE_CHARACTERS);
+}
+
+extern "C"
+{
+    int vsscanf(const char* str, const char* format, va_list ap)
+    {
+        int parsed = 0;
+        const char* s = str; // Keep a pointer to the beginning of the string for %n
+
+        if (*str == 0) return EOF;
+
+        while (*format)
+        {
+            if (*format != '%')
+            {
+            normal:
+                if (!_isspace(*format))
+                {
+                    if (*str != *format) return parsed;
+                    str++;
+                    format++;
+                    if (*str == 0) return parsed;
+                    continue;
+                }
+
+                skip_whitespace(&format);
+                skip_whitespace(&str);
+                if (*str == 0) return parsed;
+                continue;
+            }
+            else
+            {
+                format++;
+                if (*format == '%')
+                {
+                    skip_whitespace(&str);
+                    goto normal;
+                }
+
+                int flags = parse_flags(&format);
+                size_t width = parse_width(&format, flags);
+                parse_type(&format, flags);
+                char specifier = *format++;
+                if (!specifier) return parsed;
+
+                switch (specifier)
+                {
+                case 's': {
+                    skip_whitespace(&str);
+                    size_t chars = strcspn(str, WHITESPACE_CHARACTERS);
+                    if (!chars) return parsed;
+                    if ((flags & FLAG_WIDTH) && chars > width) chars = width;
+                    if (!(flags & FLAG_DISCARD))
+                    {
+                        char* ptr;
+                        if (flags & FLAG_ALLOC)
+                        {
+                            ptr = (char*)malloc(chars + 1);
+                            if (!ptr) return parsed;
+                            *va_arg(ap, char**) = ptr;
+                        }
+                        else
+                            ptr = va_arg(ap, char*);
+                        memcpy(ptr, str, chars);
+                        ptr[chars] = 0;
+                    }
+                    str += chars;
+                    parsed++;
+                    break;
+                }
+                case 'c': {
+                    if (strlen(str) < width) return parsed;
+                    if (!(flags & FLAG_WIDTH)) width = 1;
+                    if (!(flags & FLAG_DISCARD))
+                    {
+                        char* ptr;
+                        if (flags & FLAG_ALLOC)
+                        {
+                            ptr = (char*)malloc(width);
+                            if (!ptr) return parsed;
+                            *va_arg(ap, char**) = ptr;
+                        }
+                        else
+                            ptr = va_arg(ap, char*);
+                        memcpy(ptr, str, width);
+                    }
+                    str += width;
+                    parsed++;
+                    break;
+                }
+                case 'd': {
+                    skip_whitespace(&str);
+                    ssize_t value = scan_signed_integer(&str, 10);
+                    if (!(flags & FLAG_DISCARD)) write_parsed_signed_integer(value, flags, ap);
+                    parsed++;
+                    break;
+                }
+                case 'i': {
+                    skip_whitespace(&str);
+                    ssize_t value = scan_signed_integer(&str, 0);
+                    if (!(flags & FLAG_DISCARD)) write_parsed_signed_integer(value, flags, ap);
+                    parsed++;
+                    break;
+                }
+                case 'o': {
+                    skip_whitespace(&str);
+                    size_t value = scan_unsigned_integer(&str, 8);
+                    if (!(flags & FLAG_DISCARD)) write_parsed_unsigned_integer(value, flags, ap);
+                    parsed++;
+                    break;
+                }
+                case 'u': {
+                    skip_whitespace(&str);
+                    size_t value = scan_unsigned_integer(&str, 10);
+                    if (!(flags & FLAG_DISCARD)) write_parsed_unsigned_integer(value, flags, ap);
+                    parsed++;
+                    break;
+                }
+                case 'X':
+                case 'x': {
+                    skip_whitespace(&str);
+                    size_t value = scan_unsigned_integer(&str, 16);
+                    if (!(flags & FLAG_DISCARD)) write_parsed_unsigned_integer(value, flags, ap);
+                    parsed++;
+                    break;
+                }
+                case 'p': {
+                    skip_whitespace(&str);
+                    size_t value = scan_unsigned_integer(&str, 16);
+                    if (!(flags & FLAG_DISCARD)) *va_arg(ap, void**) = (void*)value;
+                    parsed++;
+                    break;
+                }
+                case 'n': {
+                    if (!(flags & FLAG_DISCARD)) *va_arg(ap, int*) = (int)(str - s);
+                    break;
+                }
+                default: {
+                    fprintf(stderr, "vsscanf: unknown conversion specifier: %%%c\n", specifier);
+                    return parsed;
+                }
+                }
+            }
+        }
+
+        return parsed;
+    }
+}

libc/src/stdio.cpp

@@ -2,7 +2,6 @@
 #include <fcntl.h>
 #include <luna/Common.h>
 #include <luna/Format.h>
-#include <luna/Scanf.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -619,17 +618,12 @@ extern "C"
         return rc;
     }
 
-    int vsscanf(const char* str, const char* format, va_list ap)
-    {
-        return scanf_impl(str, format, ap);
-    }
-
     int sscanf(const char* str, const char* format, ...)
     {
         va_list ap;
         va_start(ap, format);
 
-        int rc = scanf_impl(str, format, ap);
+        int rc = vsscanf(str, format, ap);
 
         va_end(ap);
 
@@ -640,7 +634,7 @@ extern "C"
     {
         char buf[BUFSIZ];
         if (!fgets(buf, sizeof(buf), stream)) return EOF;
-        return scanf_impl(buf, format, ap);
+        return vsscanf(buf, format, ap);
     }
 
     int fscanf(FILE* stream, const char* format, ...)

libluna/CMakeLists.txt

@@ -5,7 +5,6 @@ file(GLOB HEADERS include/luna/*.h)
 set(FREESTANDING_SOURCES
     ${HEADERS}
     src/CRC32.cpp
-    src/EscapeSequence.cpp
     src/Format.cpp
     src/Sort.cpp
     src/NumberParsing.cpp
@@ -15,7 +14,6 @@ set(FREESTANDING_SOURCES
     src/SystemError.cpp
     src/Bitmap.cpp
     src/Buffer.cpp
-    src/Scanf.cpp
     src/Stack.cpp
     src/String.cpp
     src/StringBuilder.cpp

libluna/include/luna/EscapeSequence.h

@@ -1,67 +0,0 @@
-/**
- * @file EscapeSequence.h
- * @author apio (cloudapio.eu)
- * @brief ANSI escape sequence parsing.
- *
- * @copyright Copyright (c) 2023, the Luna authors.
- *
- */
-
-#pragma once
-#include <luna/Vector.h>
-
-enum class EscapeCode
-{
-    SaveCursor,
-    RestoreCursor,
-    CursorUp,
-    CursorDown,
-    CursorForward,
-    CursorBack,
-    CursorNextLine,
-    CursorPreviousLine,
-    CursorHorizontalAbsolute,
-    SetCursorPosition,
-    SelectGraphicRendition,
-};
-
-class EscapeSequenceParser
-{
-  public:
-    EscapeSequenceParser(u8 begin);
-
-    Result<bool> advance(u8 byte);
-
-    bool valid() const
-    {
-        return m_valid;
-    }
-
-    const Vector<int>& parameters() const
-    {
-        return m_parameters;
-    }
-
-    EscapeCode code() const
-    {
-        return m_escape_code;
-    }
-
-  private:
-    enum class SequenceType
-    {
-        ESC,
-        CSI,
-        DCS,
-        OSC,
-    };
-
-    Vector<u8> m_parameter;
-    Vector<int> m_parameters;
-
-    SequenceType m_sequence_type;
-    bool m_parsing_parameter { false };
-    bool m_valid { false };
-
-    EscapeCode m_escape_code;
-};

libluna/include/luna/Scanf.h

@@ -1,21 +0,0 @@
-/**
- * @file Scanf.h
- * @author apio (cloudapio.eu)
- * @brief Scanf implementation.
- *
- * @copyright Copyright (c) 2023, the Luna authors.
- *
- */
-
-#pragma once
-#include <stdarg.h>
-
-/**
- * @brief scanf() implementation.
- *
- * @param str The string to read input from.
- * @param format The format string.
- * @param ap The variadic argument list.
- * @return int The number of arguments read, or -1 if the string was empty.
- */
-int scanf_impl(const char* str, const char* format, va_list ap);

libluna/src/EscapeSequence.cpp

@@ -1,146 +0,0 @@
-/**
- * @file EscapeSequence.cpp
- * @author apio (cloudapio.eu)
- * @brief ANSI escape sequence parsing.
- *
- * @copyright Copyright (c) 2023, the Luna authors.
- *
- */
-
-#include <luna/CType.h>
-#include <luna/Check.h>
-#include <luna/EscapeSequence.h>
-#include <luna/NumberParsing.h>
-
-EscapeSequenceParser::EscapeSequenceParser(u8 begin)
-{
-    switch (begin)
-    {
-    case 0x1b: m_sequence_type = SequenceType::ESC; break;
-    case 0x9b: m_sequence_type = SequenceType::CSI; break;
-    case 0x90: m_sequence_type = SequenceType::DCS; break;
-    case 0x9d: m_sequence_type = SequenceType::OSC; break;
-    default: fail("Unrecognized escape sequence type");
-    }
-}
-
-Result<bool> EscapeSequenceParser::advance(u8 byte)
-{
-    switch (m_sequence_type)
-    {
-    case SequenceType::ESC: {
-        switch (byte)
-        {
-        case '[': {
-            m_sequence_type = SequenceType::CSI;
-            return false;
-        };
-        case 'P': {
-            m_sequence_type = SequenceType::DCS;
-            return false;
-        };
-        case ']': {
-            m_sequence_type = SequenceType::OSC;
-            return false;
-        };
-        case '7': {
-            m_escape_code = EscapeCode::SaveCursor;
-            m_valid = true;
-            return true;
-        };
-        case '8': {
-            m_escape_code = EscapeCode::RestoreCursor;
-            m_valid = true;
-            return true;
-        };
-        default: {
-            m_valid = false;
-            return true;
-        }
-        }
-    };
-    break;
-    case SequenceType::CSI: {
-        if (_isdigit(byte))
-        {
-            m_parsing_parameter = true;
-            TRY(m_parameter.try_append(byte));
-            return false;
-        }
-
-        if (!m_parsing_parameter && byte == ';')
-        {
-            TRY(m_parameters.try_append(0));
-            return false;
-        }
-
-        if (m_parsing_parameter)
-        {
-            TRY(m_parameter.try_append(0));
-            int value = static_cast<int>(parse_unsigned_integer((const char*)m_parameter.data(), nullptr, 10));
-            m_parameter.clear();
-            TRY(m_parameters.try_append(value));
-        }
-
-        switch (byte)
-        {
-        case 'A': {
-            m_escape_code = EscapeCode::CursorUp;
-            m_valid = true;
-            return true;
-        };
-        case 'B': {
-            m_escape_code = EscapeCode::CursorDown;
-            m_valid = true;
-            return true;
-        };
-        case 'C': {
-            m_escape_code = EscapeCode::CursorForward;
-            m_valid = true;
-            return true;
-        };
-        case 'D': {
-            m_escape_code = EscapeCode::CursorBack;
-            m_valid = true;
-            return true;
-        };
-        case 'E': {
-            m_escape_code = EscapeCode::CursorNextLine;
-            m_valid = true;
-            return true;
-        };
-        case 'F': {
-            m_escape_code = EscapeCode::CursorPreviousLine;
-            m_valid = true;
-            return true;
-        };
-        case 'G': {
-            m_escape_code = EscapeCode::CursorHorizontalAbsolute;
-            m_valid = true;
-            return true;
-        };
-        case 'H': {
-            m_escape_code = EscapeCode::SetCursorPosition;
-            m_valid = true;
-            return true;
-        };
-        case 'm': {
-            m_escape_code = EscapeCode::SelectGraphicRendition;
-            m_valid = true;
-            return true;
-        };
-        case ';': {
-            return false;
-        };
-        default: {
-            m_valid = false;
-            return true;
-        }
-        }
-    };
-    break;
-    case SequenceType::DCS: todo();
-    case SequenceType::OSC: todo();
-    default: todo();
-    }
-}

libluna/src/Scanf.cpp

@@ -1,270 +0,0 @@
-/**
- * @file Scanf.cpp
- * @author apio (cloudapio.eu)
- * @brief Scanf implementation.
- *
- * @copyright Copyright (c) 2023, the Luna authors.
- *
- */
-
-#include <luna/CString.h>
-#include <luna/CType.h>
-#include <luna/DebugLog.h>
-#include <luna/Heap.h>
-#include <luna/NumberParsing.h>
-#include <luna/SystemError.h>
-#include <sys/types.h>
-
-#define FLAG_DISCARD (1 << 0)
-#define FLAG_ALLOC (1 << 1)
-#define FLAG_WIDTH (1 << 2)
-#define FLAG_LONG (1 << 3)
-#define FLAG_LONG_LONG (1 << 4)
-#define FLAG_SHORT (1 << 5)
-#define FLAG_CHAR (1 << 6)
-
-static int parse_flags(const char** format)
-{
-    int result = 0;
-
-    while (true)
-    {
-        switch (**format)
-        {
-        case '*':
-            result |= FLAG_DISCARD;
-            (*format)++;
-            break;
-        case 'm':
-            result |= FLAG_ALLOC;
-            (*format)++;
-            break;
-        default: return result;
-        }
-    }
-}
-
-static size_t parse_width(const char** format, int& flags)
-{
-    size_t result = 0;
-
-    if (_isdigit(**format))
-    {
-        result = scan_unsigned_integer(format);
-        flags |= FLAG_WIDTH;
-    }
-
-    return result;
-}
-
-static void parse_type(const char** format, int& flags)
-{
-    // FIXME: Support %j (intmax_t/uintmax_t)
-    switch (**format)
-    {
-    case 'h':
-        flags |= FLAG_SHORT;
-        (*format)++;
-        if (**format == 'h')
-        {
-            flags |= FLAG_CHAR;
-            (*format)++;
-        }
-        break;
-    case 'l':
-        flags |= FLAG_LONG;
-        (*format)++;
-        if (**format == 'l')
-        {
-            flags |= FLAG_LONG_LONG;
-            (*format)++;
-        }
-        break;
-    case 't':
-        flags |= (sizeof(ptrdiff_t) == sizeof(long)) ? FLAG_LONG : FLAG_LONG_LONG;
-        (*format)++;
-        break;
-    case 'z':
-        flags |= (sizeof(size_t) == sizeof(long)) ? FLAG_LONG : FLAG_LONG_LONG;
-        (*format)++;
-        break;
-    default: break;
-    }
-}
-
-static void write_parsed_signed_integer(ssize_t value, int flags, va_list ap)
-{
-    if (flags & FLAG_LONG_LONG) *va_arg(ap, signed long long*) = (signed long long)value;
-    else if (flags & FLAG_LONG)
-        *va_arg(ap, signed long*) = (signed long)value;
-    else if (flags & FLAG_SHORT)
-        *va_arg(ap, signed int*) = (signed short)value;
-    else if (flags & FLAG_CHAR)
-        *va_arg(ap, signed int*) = (signed char)value;
-    else
-        *va_arg(ap, signed int*) = (signed int)value;
-}
-
-static void write_parsed_unsigned_integer(size_t value, int flags, va_list ap)
-{
-    if (flags & FLAG_LONG_LONG) *va_arg(ap, unsigned long long*) = (unsigned long long)value;
-    else if (flags & FLAG_LONG)
-        *va_arg(ap, unsigned long*) = (unsigned long)value;
-    else if (flags & FLAG_SHORT)
-        *va_arg(ap, unsigned int*) = (unsigned short)value;
-    else if (flags & FLAG_CHAR)
-        *va_arg(ap, unsigned int*) = (unsigned char)value;
-    else
-        *va_arg(ap, unsigned int*) = (unsigned int)value;
-}
-
-#define WHITESPACE_CHARACTERS " \t\f\r\n\v"
-
-static void skip_whitespace(const char** str)
-{
-    *str += strspn(*str, WHITESPACE_CHARACTERS);
-}
-
-int scanf_impl(const char* str, const char* format, va_list ap)
-{
-    int parsed = 0;
-    const char* s = str; // Keep a pointer to the beginning of the string for %n
-
-    if (*str == 0) return -1;
-
-    while (*format)
-    {
-        if (*format != '%')
-        {
-        normal:
-            if (!_isspace(*format))
-            {
-                if (*str != *format) return parsed;
-                str++;
-                format++;
-                if (*str == 0) return parsed;
-                continue;
-            }
-
-            skip_whitespace(&format);
-            skip_whitespace(&str);
-            if (*str == 0) return parsed;
-            continue;
-        }
-        else
-        {
-            format++;
-            if (*format == '%')
-            {
-                skip_whitespace(&str);
-                goto normal;
-            }
-
-            int flags = parse_flags(&format);
-            size_t width = parse_width(&format, flags);
-            parse_type(&format, flags);
-            char specifier = *format++;
-            if (!specifier) return parsed;
-
-            switch (specifier)
-            {
-            case 's': {
-                skip_whitespace(&str);
-                size_t chars = strcspn(str, WHITESPACE_CHARACTERS);
-                if (!chars) return parsed;
-                if ((flags & FLAG_WIDTH) && chars > width) chars = width;
-                if (!(flags & FLAG_DISCARD))
-                {
-                    char* ptr;
-                    if (flags & FLAG_ALLOC)
-                    {
-                        ptr = (char*)malloc_impl(chars + 1).value_or(nullptr);
-                        if (!ptr) return parsed;
-                        *va_arg(ap, char**) = ptr;
-                    }
-                    else
-                        ptr = va_arg(ap, char*);
-                    memcpy(ptr, str, chars);
-                    ptr[chars] = 0;
-                }
-                str += chars;
-                parsed++;
-                break;
-            }
-            case 'c': {
-                if (strlen(str) < width) return parsed;
-                if (!(flags & FLAG_WIDTH)) width = 1;
-                if (!(flags & FLAG_DISCARD))
-                {
-                    char* ptr;
-                    if (flags & FLAG_ALLOC)
-                    {
-                        ptr = (char*)malloc_impl(width).value_or(nullptr);
-                        if (!ptr) return parsed;
-                        *va_arg(ap, char**) = ptr;
-                    }
-                    else
-                        ptr = va_arg(ap, char*);
-                    memcpy(ptr, str, width);
-                }
-                str += width;
-                parsed++;
-                break;
-            }
-            case 'd': {
-                skip_whitespace(&str);
-                ssize_t value = scan_signed_integer(&str, 10);
-                if (!(flags & FLAG_DISCARD)) write_parsed_signed_integer(value, flags, ap);
-                parsed++;
-                break;
-            }
-            case 'i': {
-                skip_whitespace(&str);
-                ssize_t value = scan_signed_integer(&str, 0);
-                if (!(flags & FLAG_DISCARD)) write_parsed_signed_integer(value, flags, ap);
-                parsed++;
-                break;
-            }
-            case 'o': {
-                skip_whitespace(&str);
-                size_t value = scan_unsigned_integer(&str, 8);
-                if (!(flags & FLAG_DISCARD)) write_parsed_unsigned_integer(value, flags, ap);
-                parsed++;
-                break;
-            }
-            case 'u': {
-                skip_whitespace(&str);
-                size_t value = scan_unsigned_integer(&str, 10);
-                if (!(flags & FLAG_DISCARD)) write_parsed_unsigned_integer(value, flags, ap);
-                parsed++;
-                break;
-            }
-            case 'X':
-            case 'x': {
-                skip_whitespace(&str);
-                size_t value = scan_unsigned_integer(&str, 16);
-                if (!(flags & FLAG_DISCARD)) write_parsed_unsigned_integer(value, flags, ap);
-                parsed++;
-                break;
-            }
-            case 'p': {
-                skip_whitespace(&str);
-                size_t value = scan_unsigned_integer(&str, 16);
-                if (!(flags & FLAG_DISCARD)) *va_arg(ap, void**) = (void*)value;
-                parsed++;
-                break;
-            }
-            case 'n': {
-                if (!(flags & FLAG_DISCARD)) *va_arg(ap, int*) = (int)(str - s);
-                break;
-            }
-            default: {
-                dbgln("vsscanf: unknown conversion specifier: %%%c\n", specifier);
-                return parsed;
-            }
-            }
-        }
-    }
-
-    return parsed;
-}

shell/main.cpp

@@ -133,8 +133,7 @@ Result<int> luna_main(int argc, char** argv)
         if (interactive)
         {
             auto cwd = TRY(os::FileSystem::working_directory());
-            os::print("\x1b[%dm%s\x1b[m@\x1b[36m%s\x1b[m:\x1b[1;34m%s\x1b[m%c ", getuid() == 0 ? 31 : 35, username,
-                      hostname, cwd.chars(), prompt_end);
+            os::print("%s@%s:%s%c ", username, hostname, cwd.chars(), prompt_end);
         }
 
         auto maybe_cmd = input_file->read_line();