From 4f942e014dab44ccb8850c5921b81d4bd777d831 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Fri, 20 Mar 2026 11:19:05 +0100
Subject: kstd: rework formatting to be closer to std

---
 kernel/kstd/print.cpp | 137 ++++++++++++++++++++++++++++++++------------------
 1 file changed, 88 insertions(+), 49 deletions(-)

(limited to 'kernel/kstd/print.cpp')

diff --git a/kernel/kstd/print.cpp b/kernel/kstd/print.cpp
index c7d26ba..44f80a7 100644
--- a/kernel/kstd/print.cpp
+++ b/kernel/kstd/print.cpp
@@ -70,74 +70,113 @@ namespace kstd::os
     auto writer = write_buffer{(sink == print_sink::stderr) ? kapi::cio::output_stream::stderr
                                                             : kapi::cio::output_stream::stdout};
     auto context = kstd::format_context{.writer = write_buffer::callback, .user_data = &writer};
+    auto parse_context = kstd::format_parse_context{format, args.size()};
 
-    auto current = format.begin();
-    auto end = format.end();
-    auto next_automatic_index = 0uz;
+    auto it = parse_context.begin();
+    auto end = parse_context.end();
 
-    while (current != end)
+    while (it != end)
     {
-      if (*current != '{')
+      if (*it != '{' && *it != '}')
       {
-        auto start = current;
-        while (current != end && *current != '{')
+        auto start = it;
+        while (it != end && *it != '{' && *it != '}')
         {
-          std::advance(current, 1);
+          std::advance(it, 1);
         }
-        context.push(std::string_view(start, current - start));
+        parse_context.advance_to(it);
+        context.push(std::string_view(start, it - start));
         continue;
       }
 
-      if (std::next(current) != end && *(std::next(current)) == '{')
+      if (*it == '{')
       {
-        context.push('{');
-        std::advance(current, 2);
-        continue;
-      }
+        std::advance(it, 1);
+        if (it != end && *it == '{')
+        {
+          context.push('{');
+          std::advance(it, 1);
+          parse_context.advance_to(it);
+          continue;
+        }
 
-      std::advance(current, 1);
+        parse_context.advance_to(it);
+        auto index = 0uz;
 
-      auto index = 0uz;
-      if (current != end && *current >= '0' && *current <= '9')
-      {
-        while (current != end && *current >= '0' && *current <= '9')
+        if (it != end && *it >= '0' && *it <= '9')
         {
-          index = index * 10 + static_cast<std::size_t>(*current - '0');
-          std::advance(current, 1);
+          while (it != end && *it >= '0' && *it <= '9')
+          {
+            index = index * 10 + static_cast<std::size_t>(*it - '0');
+            std::advance(it, 1);
+          }
+          parse_context.check_arg_id(index);
+        }
+        else
+        {
+          index = parse_context.next_arg_id();
         }
-      }
-      else
-      {
-        index = next_automatic_index++;
-      }
 
-      auto remaining_fmt = std::string_view{current, static_cast<std::size_t>(std::distance(current, end))};
+        if (it != end && *it == ':')
+        {
+          std::advance(it, 1);
+        }
 
-      auto const arg = args.get(index);
-      if (arg.format)
-      {
-        auto const after_specs = arg.format(arg.value, remaining_fmt, context);
-        auto const consumed = remaining_fmt.size() - after_specs.size();
-        std::advance(current, consumed);
-      }
-      else
-      {
-        context.push("{?}");
-        while (current != end && *current != '}')
-          std::advance(current, 1);
-      }
+        parse_context.advance_to(it);
 
-      if (current != end && *current == '}')
-      {
-        std::advance(current, 1);
+        if (index < args.size())
+        {
+          auto const & arg = args[index];
+          if (arg.format_function)
+          {
+            arg.format_function(arg.value_pointer, parse_context, context);
+          }
+          else
+          {
+            context.push("{?}");
+          }
+        }
+        else
+        {
+          context.push("{fmt-err: bound}");
+        }
+
+        it = parse_context.begin();
+
+        if (it != end && *it == '}')
+        {
+          std::advance(it, 1);
+          parse_context.advance_to(it);
+        }
+        else
+        {
+          context.push("{fmt-err: unconsumed}");
+          while (it != end && *it != '}')
+          {
+            std::advance(it, 1);
+          }
+
+          if (it != end)
+          {
+            std::advance(it, 1);
+            parse_context.advance_to(it);
+          }
+        }
       }
-      else
+      else if (*it == '}')
       {
-        context.push("{fmt-err}");
-        while (current != end && *current != '}')
-          std::advance(current, 1);
-        if (current != end)
-          std::advance(current, 1);
+        std::advance(it, 1);
+        if (it != end && *it == '}')
+        {
+          context.push('}');
+          std::advance(it, 1);
+          parse_context.advance_to(it);
+        }
+        else
+        {
+          context.push("{fmt-err: unescaped}");
+          parse_context.advance_to(it);
+        }
       }
     }
   }
-- 
cgit v1.2.3


From d7147ddd7416a6cce874d290d1615527f4d7cdb9 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Fri, 20 Mar 2026 12:01:22 +0100
Subject: kstd/format: implement dynamic width support

---
 kernel/kstd/print.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'kernel/kstd/print.cpp')

diff --git a/kernel/kstd/print.cpp b/kernel/kstd/print.cpp
index 44f80a7..db03816 100644
--- a/kernel/kstd/print.cpp
+++ b/kernel/kstd/print.cpp
@@ -69,7 +69,7 @@ namespace kstd::os
   {
     auto writer = write_buffer{(sink == print_sink::stderr) ? kapi::cio::output_stream::stderr
                                                             : kapi::cio::output_stream::stdout};
-    auto context = kstd::format_context{.writer = write_buffer::callback, .user_data = &writer};
+    auto context = kstd::format_context{.writer = write_buffer::callback, .user_data = &writer, .args = args};
     auto parse_context = kstd::format_parse_context{format, args.size()};
 
     auto it = parse_context.begin();
-- 
cgit v1.2.3


From 8ae0f5a9a83aa58f2bd9eacfb51369b0bf966809 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Fri, 20 Mar 2026 15:22:37 +0100
Subject: kstd/format: use tagged union to reduce template bloat

---
 kernel/kstd/print.cpp | 80 +++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 74 insertions(+), 6 deletions(-)

(limited to 'kernel/kstd/print.cpp')

diff --git a/kernel/kstd/print.cpp b/kernel/kstd/print.cpp
index db03816..beee2e5 100644
--- a/kernel/kstd/print.cpp
+++ b/kernel/kstd/print.cpp
@@ -127,13 +127,81 @@ namespace kstd::os
         if (index < args.size())
         {
           auto const & arg = args[index];
-          if (arg.format_function)
+          switch (arg.type)
           {
-            arg.format_function(arg.value_pointer, parse_context, context);
-          }
-          else
-          {
-            context.push("{?}");
+            case kstd::bits::format::arg_type::boolean:
+            {
+              auto fmt = kstd::formatter<bool>{};
+              auto const parsed = fmt.parse(parse_context);
+              parse_context.advance_to(parsed);
+              fmt.format(arg.value.boolean, context);
+              break;
+            }
+            case kstd::bits::format::arg_type::character:
+            {
+              auto fmt = kstd::formatter<char>{};
+              auto const parsed = fmt.parse(parse_context);
+              parse_context.advance_to(parsed);
+              fmt.format(arg.value.character, context);
+              break;
+            }
+            case kstd::bits::format::arg_type::integer:
+            {
+              auto fmt = kstd::formatter<long long>{};
+              auto const parsed = fmt.parse(parse_context);
+              parse_context.advance_to(parsed);
+              fmt.format(arg.value.integer, context);
+              break;
+            }
+            case kstd::bits::format::arg_type::unsigned_integer:
+            {
+              auto fmt = kstd::formatter<unsigned long long>{};
+              auto const parsed = fmt.parse(parse_context);
+              parse_context.advance_to(parsed);
+              fmt.format(arg.value.unsigned_integer, context);
+              break;
+            }
+            case kstd::bits::format::arg_type::string_view:
+            {
+              auto fmt = kstd::formatter<std::string_view>{};
+              auto const parsed = fmt.parse(parse_context);
+              parse_context.advance_to(parsed);
+              fmt.format(arg.value.string_view, context);
+              break;
+            }
+            case kstd::bits::format::arg_type::c_string:
+            {
+              auto fmt = kstd::formatter<char const *>{};
+              auto const parsed = fmt.parse(parse_context);
+              parse_context.advance_to(parsed);
+              fmt.format(arg.value.c_string, context);
+              break;
+            }
+            case kstd::bits::format::arg_type::pointer:
+            {
+              auto fmt = kstd::formatter<void const *>{};
+              auto const parsed = fmt.parse(parse_context);
+              parse_context.advance_to(parsed);
+              fmt.format(arg.value.pointer, context);
+              break;
+            }
+            case kstd::bits::format::arg_type::user_defined:
+            {
+              if (arg.value.user_defined.format)
+              {
+                arg.value.user_defined.format(arg.value.user_defined.pointer, parse_context, context);
+              }
+              else
+              {
+                context.push("{?}");
+              }
+              break;
+            }
+            default:
+            {
+              context.push("{fmt-err: unknown-type}");
+              break;
+            }
           }
         }
         else
-- 
cgit v1.2.3


From 98fc294deb6f7c27eda3f9ed3b616572a1ab2009 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Mon, 13 Apr 2026 14:37:20 +0200
Subject: kstd/format: hook up vformat_to

---
 kernel/kstd/print.cpp | 381 +++++++++++++++++++++++++-------------------------
 1 file changed, 192 insertions(+), 189 deletions(-)

(limited to 'kernel/kstd/print.cpp')

diff --git a/kernel/kstd/print.cpp b/kernel/kstd/print.cpp
index beee2e5..a0bb7d6 100644
--- a/kernel/kstd/print.cpp
+++ b/kernel/kstd/print.cpp
@@ -1,12 +1,13 @@
 #include "kapi/cio.hpp"
 
+#include <kstd/bits/format/output_buffer.hpp>
 #include <kstd/format>
 #include <kstd/os/print.hpp>
 #include <kstd/print>
 
+#include <algorithm>
 #include <array>
 #include <cstddef>
-#include <iterator>
 #include <string_view>
 
 namespace kstd::os
@@ -14,7 +15,7 @@ namespace kstd::os
 
   namespace
   {
-    struct write_buffer
+    struct write_buffer final : kstd::bits::format::output_buffer
     {
       using output_stream = kapi::cio::output_stream;
 
@@ -29,7 +30,7 @@ namespace kstd::os
           : m_stream{stream}
       {}
 
-      ~write_buffer() noexcept
+      ~write_buffer() noexcept final
       {
         flush();
       }
@@ -44,17 +45,18 @@ namespace kstd::os
         }
       }
 
-      auto static callback(void * object, std::string_view text) -> void
+      auto push(std::string_view text) -> void final
       {
-        auto * self = static_cast<write_buffer *>(object);
-        for (char const character : text)
+        std::ranges::for_each(text, [this](auto c) { this->push(c); });
+      }
+
+      auto push(char character) -> void final
+      {
+        if (m_position >= size)
         {
-          if (self->m_position >= size)
-          {
-            self->flush();
-          }
-          self->m_buffer.at(self->m_position++) = character;
+          flush();
         }
+        m_buffer.at(m_position++) = character;
       }
 
     private:
@@ -69,184 +71,185 @@ namespace kstd::os
   {
     auto writer = write_buffer{(sink == print_sink::stderr) ? kapi::cio::output_stream::stderr
                                                             : kapi::cio::output_stream::stdout};
-    auto context = kstd::format_context{.writer = write_buffer::callback, .user_data = &writer, .args = args};
-    auto parse_context = kstd::format_parse_context{format, args.size()};
-
-    auto it = parse_context.begin();
-    auto end = parse_context.end();
-
-    while (it != end)
-    {
-      if (*it != '{' && *it != '}')
-      {
-        auto start = it;
-        while (it != end && *it != '{' && *it != '}')
-        {
-          std::advance(it, 1);
-        }
-        parse_context.advance_to(it);
-        context.push(std::string_view(start, it - start));
-        continue;
-      }
-
-      if (*it == '{')
-      {
-        std::advance(it, 1);
-        if (it != end && *it == '{')
-        {
-          context.push('{');
-          std::advance(it, 1);
-          parse_context.advance_to(it);
-          continue;
-        }
-
-        parse_context.advance_to(it);
-        auto index = 0uz;
-
-        if (it != end && *it >= '0' && *it <= '9')
-        {
-          while (it != end && *it >= '0' && *it <= '9')
-          {
-            index = index * 10 + static_cast<std::size_t>(*it - '0');
-            std::advance(it, 1);
-          }
-          parse_context.check_arg_id(index);
-        }
-        else
-        {
-          index = parse_context.next_arg_id();
-        }
-
-        if (it != end && *it == ':')
-        {
-          std::advance(it, 1);
-        }
-
-        parse_context.advance_to(it);
-
-        if (index < args.size())
-        {
-          auto const & arg = args[index];
-          switch (arg.type)
-          {
-            case kstd::bits::format::arg_type::boolean:
-            {
-              auto fmt = kstd::formatter<bool>{};
-              auto const parsed = fmt.parse(parse_context);
-              parse_context.advance_to(parsed);
-              fmt.format(arg.value.boolean, context);
-              break;
-            }
-            case kstd::bits::format::arg_type::character:
-            {
-              auto fmt = kstd::formatter<char>{};
-              auto const parsed = fmt.parse(parse_context);
-              parse_context.advance_to(parsed);
-              fmt.format(arg.value.character, context);
-              break;
-            }
-            case kstd::bits::format::arg_type::integer:
-            {
-              auto fmt = kstd::formatter<long long>{};
-              auto const parsed = fmt.parse(parse_context);
-              parse_context.advance_to(parsed);
-              fmt.format(arg.value.integer, context);
-              break;
-            }
-            case kstd::bits::format::arg_type::unsigned_integer:
-            {
-              auto fmt = kstd::formatter<unsigned long long>{};
-              auto const parsed = fmt.parse(parse_context);
-              parse_context.advance_to(parsed);
-              fmt.format(arg.value.unsigned_integer, context);
-              break;
-            }
-            case kstd::bits::format::arg_type::string_view:
-            {
-              auto fmt = kstd::formatter<std::string_view>{};
-              auto const parsed = fmt.parse(parse_context);
-              parse_context.advance_to(parsed);
-              fmt.format(arg.value.string_view, context);
-              break;
-            }
-            case kstd::bits::format::arg_type::c_string:
-            {
-              auto fmt = kstd::formatter<char const *>{};
-              auto const parsed = fmt.parse(parse_context);
-              parse_context.advance_to(parsed);
-              fmt.format(arg.value.c_string, context);
-              break;
-            }
-            case kstd::bits::format::arg_type::pointer:
-            {
-              auto fmt = kstd::formatter<void const *>{};
-              auto const parsed = fmt.parse(parse_context);
-              parse_context.advance_to(parsed);
-              fmt.format(arg.value.pointer, context);
-              break;
-            }
-            case kstd::bits::format::arg_type::user_defined:
-            {
-              if (arg.value.user_defined.format)
-              {
-                arg.value.user_defined.format(arg.value.user_defined.pointer, parse_context, context);
-              }
-              else
-              {
-                context.push("{?}");
-              }
-              break;
-            }
-            default:
-            {
-              context.push("{fmt-err: unknown-type}");
-              break;
-            }
-          }
-        }
-        else
-        {
-          context.push("{fmt-err: bound}");
-        }
-
-        it = parse_context.begin();
-
-        if (it != end && *it == '}')
-        {
-          std::advance(it, 1);
-          parse_context.advance_to(it);
-        }
-        else
-        {
-          context.push("{fmt-err: unconsumed}");
-          while (it != end && *it != '}')
-          {
-            std::advance(it, 1);
-          }
-
-          if (it != end)
-          {
-            std::advance(it, 1);
-            parse_context.advance_to(it);
-          }
-        }
-      }
-      else if (*it == '}')
-      {
-        std::advance(it, 1);
-        if (it != end && *it == '}')
-        {
-          context.push('}');
-          std::advance(it, 1);
-          parse_context.advance_to(it);
-        }
-        else
-        {
-          context.push("{fmt-err: unescaped}");
-          parse_context.advance_to(it);
-        }
-      }
-    }
+    kstd::bits::format::vformat_to(writer, format, args);
+    // auto context = kstd::format_context{.writer = write_buffer::callback, .user_data = &writer, .args = args};
+    // auto parse_context = kstd::format_parse_context{format, args.size()};
+
+    // auto it = parse_context.begin();
+    // auto end = parse_context.end();
+
+    // while (it != end)
+    // {
+    //   if (*it != '{' && *it != '}')
+    //   {
+    //     auto start = it;
+    //     while (it != end && *it != '{' && *it != '}')
+    //     {
+    //       std::advance(it, 1);
+    //     }
+    //     parse_context.advance_to(it);
+    //     context.push(std::string_view(start, it - start));
+    //     continue;
+    //   }
+
+    //   if (*it == '{')
+    //   {
+    //     std::advance(it, 1);
+    //     if (it != end && *it == '{')
+    //     {
+    //       context.push('{');
+    //       std::advance(it, 1);
+    //       parse_context.advance_to(it);
+    //       continue;
+    //     }
+
+    //     parse_context.advance_to(it);
+    //     auto index = 0uz;
+
+    //     if (it != end && *it >= '0' && *it <= '9')
+    //     {
+    //       while (it != end && *it >= '0' && *it <= '9')
+    //       {
+    //         index = index * 10 + static_cast<std::size_t>(*it - '0');
+    //         std::advance(it, 1);
+    //       }
+    //       parse_context.check_arg_id(index);
+    //     }
+    //     else
+    //     {
+    //       index = parse_context.next_arg_id();
+    //     }
+
+    //     if (it != end && *it == ':')
+    //     {
+    //       std::advance(it, 1);
+    //     }
+
+    //     parse_context.advance_to(it);
+
+    //     if (index < args.size())
+    //     {
+    //       auto const & arg = args[index];
+    //       switch (arg.type)
+    //       {
+    //         case kstd::bits::format::arg_type::boolean:
+    //         {
+    //           auto fmt = kstd::formatter<bool>{};
+    //           auto const parsed = fmt.parse(parse_context);
+    //           parse_context.advance_to(parsed);
+    //           fmt.format(arg.value.boolean, context);
+    //           break;
+    //         }
+    //         case kstd::bits::format::arg_type::character:
+    //         {
+    //           auto fmt = kstd::formatter<char>{};
+    //           auto const parsed = fmt.parse(parse_context);
+    //           parse_context.advance_to(parsed);
+    //           fmt.format(arg.value.character, context);
+    //           break;
+    //         }
+    //         case kstd::bits::format::arg_type::integer:
+    //         {
+    //           auto fmt = kstd::formatter<long long>{};
+    //           auto const parsed = fmt.parse(parse_context);
+    //           parse_context.advance_to(parsed);
+    //           fmt.format(arg.value.integer, context);
+    //           break;
+    //         }
+    //         case kstd::bits::format::arg_type::unsigned_integer:
+    //         {
+    //           auto fmt = kstd::formatter<unsigned long long>{};
+    //           auto const parsed = fmt.parse(parse_context);
+    //           parse_context.advance_to(parsed);
+    //           fmt.format(arg.value.unsigned_integer, context);
+    //           break;
+    //         }
+    //         case kstd::bits::format::arg_type::string_view:
+    //         {
+    //           auto fmt = kstd::formatter<std::string_view>{};
+    //           auto const parsed = fmt.parse(parse_context);
+    //           parse_context.advance_to(parsed);
+    //           fmt.format(arg.value.string_view, context);
+    //           break;
+    //         }
+    //         case kstd::bits::format::arg_type::c_string:
+    //         {
+    //           auto fmt = kstd::formatter<char const *>{};
+    //           auto const parsed = fmt.parse(parse_context);
+    //           parse_context.advance_to(parsed);
+    //           fmt.format(arg.value.c_string, context);
+    //           break;
+    //         }
+    //         case kstd::bits::format::arg_type::pointer:
+    //         {
+    //           auto fmt = kstd::formatter<void const *>{};
+    //           auto const parsed = fmt.parse(parse_context);
+    //           parse_context.advance_to(parsed);
+    //           fmt.format(arg.value.pointer, context);
+    //           break;
+    //         }
+    //         case kstd::bits::format::arg_type::user_defined:
+    //         {
+    //           if (arg.value.user_defined.format)
+    //           {
+    //             arg.value.user_defined.format(arg.value.user_defined.pointer, parse_context, context);
+    //           }
+    //           else
+    //           {
+    //             context.push("{?}");
+    //           }
+    //           break;
+    //         }
+    //         default:
+    //         {
+    //           context.push("{fmt-err: unknown-type}");
+    //           break;
+    //         }
+    //       }
+    //     }
+    //     else
+    //     {
+    //       context.push("{fmt-err: bound}");
+    //     }
+
+    //     it = parse_context.begin();
+
+    //     if (it != end && *it == '}')
+    //     {
+    //       std::advance(it, 1);
+    //       parse_context.advance_to(it);
+    //     }
+    //     else
+    //     {
+    //       context.push("{fmt-err: unconsumed}");
+    //       while (it != end && *it != '}')
+    //       {
+    //         std::advance(it, 1);
+    //       }
+
+    //       if (it != end)
+    //       {
+    //         std::advance(it, 1);
+    //         parse_context.advance_to(it);
+    //       }
+    //     }
+    //   }
+    //   else if (*it == '}')
+    //   {
+    //     std::advance(it, 1);
+    //     if (it != end && *it == '}')
+    //     {
+    //       context.push('}');
+    //       std::advance(it, 1);
+    //       parse_context.advance_to(it);
+    //     }
+    //     else
+    //     {
+    //       context.push("{fmt-err: unescaped}");
+    //       parse_context.advance_to(it);
+    //     }
+    //   }
+    // }
   }
 
 }  // namespace kstd::os
-- 
cgit v1.2.3


From 45091789eb9e49856ea6c2f3606639d43f4584e7 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Mon, 13 Apr 2026 14:56:39 +0200
Subject: kstd: move formatting implementation to kstd

---
 kernel/kstd/print.cpp | 198 +++-----------------------------------------------
 1 file changed, 10 insertions(+), 188 deletions(-)

(limited to 'kernel/kstd/print.cpp')

diff --git a/kernel/kstd/print.cpp b/kernel/kstd/print.cpp
index a0bb7d6..7854027 100644
--- a/kernel/kstd/print.cpp
+++ b/kernel/kstd/print.cpp
@@ -35,16 +35,6 @@ namespace kstd::os
         flush();
       }
 
-      auto flush() noexcept -> void
-      {
-        if (m_position > 0)
-        {
-          std::string_view chunk{m_buffer.data(), m_position};
-          kapi::cio::write(m_stream, chunk);
-          m_position = 0;
-        }
-      }
-
       auto push(std::string_view text) -> void final
       {
         std::ranges::for_each(text, [this](auto c) { this->push(c); });
@@ -60,6 +50,16 @@ namespace kstd::os
       }
 
     private:
+      auto flush() noexcept -> void
+      {
+        if (m_position > 0)
+        {
+          std::string_view chunk{m_buffer.data(), m_position};
+          kapi::cio::write(m_stream, chunk);
+          m_position = 0;
+        }
+      }
+
       output_stream m_stream;
       std::array<char, size> m_buffer{};
       std::size_t m_position{};
@@ -72,184 +72,6 @@ namespace kstd::os
     auto writer = write_buffer{(sink == print_sink::stderr) ? kapi::cio::output_stream::stderr
                                                             : kapi::cio::output_stream::stdout};
     kstd::bits::format::vformat_to(writer, format, args);
-    // auto context = kstd::format_context{.writer = write_buffer::callback, .user_data = &writer, .args = args};
-    // auto parse_context = kstd::format_parse_context{format, args.size()};
-
-    // auto it = parse_context.begin();
-    // auto end = parse_context.end();
-
-    // while (it != end)
-    // {
-    //   if (*it != '{' && *it != '}')
-    //   {
-    //     auto start = it;
-    //     while (it != end && *it != '{' && *it != '}')
-    //     {
-    //       std::advance(it, 1);
-    //     }
-    //     parse_context.advance_to(it);
-    //     context.push(std::string_view(start, it - start));
-    //     continue;
-    //   }
-
-    //   if (*it == '{')
-    //   {
-    //     std::advance(it, 1);
-    //     if (it != end && *it == '{')
-    //     {
-    //       context.push('{');
-    //       std::advance(it, 1);
-    //       parse_context.advance_to(it);
-    //       continue;
-    //     }
-
-    //     parse_context.advance_to(it);
-    //     auto index = 0uz;
-
-    //     if (it != end && *it >= '0' && *it <= '9')
-    //     {
-    //       while (it != end && *it >= '0' && *it <= '9')
-    //       {
-    //         index = index * 10 + static_cast<std::size_t>(*it - '0');
-    //         std::advance(it, 1);
-    //       }
-    //       parse_context.check_arg_id(index);
-    //     }
-    //     else
-    //     {
-    //       index = parse_context.next_arg_id();
-    //     }
-
-    //     if (it != end && *it == ':')
-    //     {
-    //       std::advance(it, 1);
-    //     }
-
-    //     parse_context.advance_to(it);
-
-    //     if (index < args.size())
-    //     {
-    //       auto const & arg = args[index];
-    //       switch (arg.type)
-    //       {
-    //         case kstd::bits::format::arg_type::boolean:
-    //         {
-    //           auto fmt = kstd::formatter<bool>{};
-    //           auto const parsed = fmt.parse(parse_context);
-    //           parse_context.advance_to(parsed);
-    //           fmt.format(arg.value.boolean, context);
-    //           break;
-    //         }
-    //         case kstd::bits::format::arg_type::character:
-    //         {
-    //           auto fmt = kstd::formatter<char>{};
-    //           auto const parsed = fmt.parse(parse_context);
-    //           parse_context.advance_to(parsed);
-    //           fmt.format(arg.value.character, context);
-    //           break;
-    //         }
-    //         case kstd::bits::format::arg_type::integer:
-    //         {
-    //           auto fmt = kstd::formatter<long long>{};
-    //           auto const parsed = fmt.parse(parse_context);
-    //           parse_context.advance_to(parsed);
-    //           fmt.format(arg.value.integer, context);
-    //           break;
-    //         }
-    //         case kstd::bits::format::arg_type::unsigned_integer:
-    //         {
-    //           auto fmt = kstd::formatter<unsigned long long>{};
-    //           auto const parsed = fmt.parse(parse_context);
-    //           parse_context.advance_to(parsed);
-    //           fmt.format(arg.value.unsigned_integer, context);
-    //           break;
-    //         }
-    //         case kstd::bits::format::arg_type::string_view:
-    //         {
-    //           auto fmt = kstd::formatter<std::string_view>{};
-    //           auto const parsed = fmt.parse(parse_context);
-    //           parse_context.advance_to(parsed);
-    //           fmt.format(arg.value.string_view, context);
-    //           break;
-    //         }
-    //         case kstd::bits::format::arg_type::c_string:
-    //         {
-    //           auto fmt = kstd::formatter<char const *>{};
-    //           auto const parsed = fmt.parse(parse_context);
-    //           parse_context.advance_to(parsed);
-    //           fmt.format(arg.value.c_string, context);
-    //           break;
-    //         }
-    //         case kstd::bits::format::arg_type::pointer:
-    //         {
-    //           auto fmt = kstd::formatter<void const *>{};
-    //           auto const parsed = fmt.parse(parse_context);
-    //           parse_context.advance_to(parsed);
-    //           fmt.format(arg.value.pointer, context);
-    //           break;
-    //         }
-    //         case kstd::bits::format::arg_type::user_defined:
-    //         {
-    //           if (arg.value.user_defined.format)
-    //           {
-    //             arg.value.user_defined.format(arg.value.user_defined.pointer, parse_context, context);
-    //           }
-    //           else
-    //           {
-    //             context.push("{?}");
-    //           }
-    //           break;
-    //         }
-    //         default:
-    //         {
-    //           context.push("{fmt-err: unknown-type}");
-    //           break;
-    //         }
-    //       }
-    //     }
-    //     else
-    //     {
-    //       context.push("{fmt-err: bound}");
-    //     }
-
-    //     it = parse_context.begin();
-
-    //     if (it != end && *it == '}')
-    //     {
-    //       std::advance(it, 1);
-    //       parse_context.advance_to(it);
-    //     }
-    //     else
-    //     {
-    //       context.push("{fmt-err: unconsumed}");
-    //       while (it != end && *it != '}')
-    //       {
-    //         std::advance(it, 1);
-    //       }
-
-    //       if (it != end)
-    //       {
-    //         std::advance(it, 1);
-    //         parse_context.advance_to(it);
-    //       }
-    //     }
-    //   }
-    //   else if (*it == '}')
-    //   {
-    //     std::advance(it, 1);
-    //     if (it != end && *it == '}')
-    //     {
-    //       context.push('}');
-    //       std::advance(it, 1);
-    //       parse_context.advance_to(it);
-    //     }
-    //     else
-    //     {
-    //       context.push("{fmt-err: unescaped}");
-    //       parse_context.advance_to(it);
-    //     }
-    //   }
-    // }
   }
 
 }  // namespace kstd::os
-- 
cgit v1.2.3


From 2d8fed40bd0d0f8144783b6b344dc79944291b72 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Thu, 23 Apr 2026 13:31:17 +0200
Subject: chore: organize includes

---
 kernel/kstd/print.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'kernel/kstd/print.cpp')

diff --git a/kernel/kstd/print.cpp b/kernel/kstd/print.cpp
index 7854027..a2e7fe7 100644
--- a/kernel/kstd/print.cpp
+++ b/kernel/kstd/print.cpp
@@ -1,8 +1,9 @@
+#include <kstd/os/print.hpp>
+
 #include "kapi/cio.hpp"
 
 #include <kstd/bits/format/output_buffer.hpp>
 #include <kstd/format>
-#include <kstd/os/print.hpp>
 #include <kstd/print>
 
 #include <algorithm>
-- 
cgit v1.2.3


From f6f10575f75ac23d06e1d94f7861611503daa7af Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Thu, 23 Apr 2026 14:03:28 +0200
Subject: chore: banish relative includes

---
 kernel/kstd/print.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'kernel/kstd/print.cpp')

diff --git a/kernel/kstd/print.cpp b/kernel/kstd/print.cpp
index a2e7fe7..d0611b2 100644
--- a/kernel/kstd/print.cpp
+++ b/kernel/kstd/print.cpp
@@ -1,6 +1,6 @@
 #include <kstd/os/print.hpp>
 
-#include "kapi/cio.hpp"
+#include <kapi/cio.hpp>
 
 #include <kstd/bits/format/output_buffer.hpp>
 #include <kstd/format>
-- 
cgit v1.2.3