vaev+karm: Update from paper-muncher.

skift-org · Feb 1, 2025 · e374efc · e374efc
1 parent 04c0f46
commit e374efc
Show file tree

Hide file tree

Showing 35 changed files with 763 additions and 645 deletions.
diff --git a/src/.clang-format b/src/.clang-format
@@ -18,6 +18,8 @@ SpaceBeforeParens: ControlStatementsExceptForEachMacros
 QualifierAlignment: Right
 AlignAfterOpenBracket: BlockIndent
 SeparateDefinitionBlocks: Always
+NamespaceIndentation: None
+PointerAlignment: Left
 
 IncludeBlocks: Regroup
 IncludeCategories:

diff --git a/src/.clang-tidy b/src/.clang-tidy
@@ -5,6 +5,9 @@ Checks: >
     modernize-use-default-member-init,
     readability-non-const-parameter,
     readability-function-cognitive-complexity,
+    readability-isolate-declaration,
+    cppcoreguidelines-pro-type-member-init,
     clang-diagnostic-*,
     llvm-*,
-    misc-*
+    misc-*,
+    -misc-non-private-member-variables-in-classes
diff --git a/src/libs/karm-base/buf.h b/src/libs/karm-base/buf.h
@@ -33,7 +33,7 @@ struct Buf {
     }
 
     Buf(Move, T* buf, usize len)
-        : _buf(buf),
+        : _buf(reinterpret_cast<Manual<T>*>(buf)),
           _cap(len),
           _len(len) {
     }

diff --git a/src/libs/karm-base/manual.h b/src/libs/karm-base/manual.h
@@ -36,5 +36,6 @@ struct Manual {
 
 static_assert(Meta::Trivial<Manual<isize>>);
 static_assert(sizeof(Manual<isize>) == sizeof(isize));
+static_assert(alignof(Manual<isize>) == alignof(isize));
 
 } // namespace Karm
diff --git a/src/libs/karm-base/string.h b/src/libs/karm-base/string.h
@@ -108,12 +108,12 @@ struct _String {
 
     static constexpr Array<Unit, 1> _EMPTY = {0};
 
-    Unit const* _buf = nullptr;
+    Unit* _buf = nullptr;
     usize _len = 0;
 
     constexpr _String() = default;
 
-    always_inline _String(Move, Unit const* buf, usize len)
+    always_inline _String(Move, Unit* buf, usize len)
         : _buf(buf),
           _len(len) {
     }
@@ -276,6 +276,10 @@ struct _StringBuilder {
     _StringBuilder(usize cap = 16)
         : _buf(cap) {}
 
+    _StringBuilder(String&& str)
+        : _buf(MOVE, std::exchange(str._buf, nullptr), std::exchange(str._len, 0)) {
+    }
+
     void ensure(usize cap) {
         // NOTE: This way client code don't have to take
         //       the null-terminator into account
@@ -304,7 +308,7 @@ struct _StringBuilder {
         return _buf.size();
     }
 
-    _Str<E> str() lifetimebound {
+    _Str<E> str() const lifetimebound {
         return _buf;
     }
 

diff --git a/src/libs/karm-base/tests/test-opt.cpp b/src/libs/karm-base/tests/test-opt.cpp
@@ -58,4 +58,16 @@ test$("opt-take") {
     return Ok();
 }
 
+test$("opt-equal") {
+    Opt<int> opt = NONE;
+    expectEq$(opt, NONE);
+    expectNe$(opt, 42);
+
+    opt = 42;
+    expectEq$(opt, 42);
+    expectNe$(opt, NONE);
+
+    return Ok();
+}
+
 } // namespace Karm::Base::Tests
diff --git a/src/libs/karm-io/fmt.cpp b/src/libs/karm-io/fmt.cpp
@@ -5,6 +5,39 @@
 
 namespace Karm::Io {
 
+// MARK: Format ----------------------------------------------------------------
+
+Res<usize> _format(Io::TextWriter& writer, Str format, _Args& args) {
+    Io::SScan scan{format};
+    usize written = 0;
+    usize index = 0;
+
+    while (not scan.ended()) {
+        Rune c = scan.next();
+
+        if (c == '{') {
+            scan.skip(':');
+            scan.begin();
+            while (scan.peek() != '}') {
+                scan.next();
+            }
+            scan.next();
+            Io::SScan inner{scan.end()};
+            written += try$(args.format(inner, writer, index));
+            index++;
+        } else if (c == '\n') {
+            // normalize newlines
+            written += try$(writer.writeStr(Str{Sys::LINE_ENDING}));
+        } else {
+            written += try$(writer.writeRune(c));
+        }
+    }
+
+    return Ok(written);
+};
+
+// MARK: Change case -----------------------------------------------------------
+
 static auto const RE_SEP =
     Re::single(' ', '\t', '.', '_', '/', '-');
 
@@ -300,4 +333,150 @@ Res<String> changeCase(Str str, Case toCase) {
     }
 }
 
+// MARK: Number formatting -----------------------------------------------------
+
+Str NumberFormatter::formatPrefix() {
+    if (base == 16)
+        return "0x";
+
+    if (base == 8)
+        return "0o";
+
+    if (base == 2)
+        return "0b";
+
+    return "";
+}
+
+void NumberFormatter::parse(Str str) {
+    Io::SScan scan{str};
+    parse(scan);
+}
+
+void NumberFormatter::parse(Io::SScan& scan) {
+    if (scan.skip('#'))
+        prefix = true;
+
+    if (scan.skip('0'))
+        fillChar = '0';
+
+    width = atoi(scan).unwrapOr(0);
+
+    if (scan.ended())
+        return;
+
+    Rune c = scan.next();
+    switch (c) {
+    case 'b':
+        base = 2;
+        break;
+
+    case 'o':
+        base = 8;
+        break;
+
+    case 'd':
+        base = 10;
+        break;
+
+    case 'x':
+        base = 16;
+        break;
+
+    case 'p':
+        prefix = true;
+        base = 16;
+        fillChar = '0';
+        width = sizeof(usize) * 2;
+        break;
+
+    case 'c':
+        isChar = true;
+        break;
+
+    default:
+        break;
+    }
+}
+
+Res<usize> NumberFormatter::formatUnsigned(Io::TextWriter& writer, usize val) {
+    auto digit = [](usize v) {
+        if (v < 10)
+            return '0' + v;
+        return 'a' + (v - 10);
+    };
+
+    InlineVec<char, 128> buf;
+
+    do {
+        buf.pushBack(digit(val % base));
+        val /= base;
+    } while (val != 0 and buf.len() < buf.cap());
+
+    while (width > buf.len())
+        buf.pushBack(fillChar);
+
+    reverse(mutSub(buf));
+
+    usize written = 0;
+    if (prefix)
+        written += try$(writer.writeStr(formatPrefix()));
+    written += try$(writer.writeStr(Str{buf}));
+
+    return Ok(written);
+}
+
+Res<usize> NumberFormatter::formatSigned(Io::TextWriter& writer, isize val) {
+    usize written = 0;
+    if (val < 0) {
+        written += try$(writer.writeRune('-'));
+        val = -val;
+    }
+    written += try$(formatUnsigned(writer, val));
+    return Ok(written);
+}
+
+Res<usize> NumberFormatter::formatRune(Io::TextWriter& writer, Rune val) {
+    if (not prefix)
+        return writer.writeRune(val);
+
+    if (val == '\'')
+        return writer.writeStr("\\'"s);
+
+    if (val == '\"')
+        return writer.writeStr("\\\""s);
+
+    if (val == '\?')
+        return writer.writeStr("\\?"s);
+
+    if (val == '\\')
+        return writer.writeStr("\\\\"s);
+
+    if (val == '\a')
+        return writer.writeStr("\\a"s);
+
+    if (val == '\b')
+        return writer.writeStr("\\b"s);
+
+    if (val == '\f')
+        return writer.writeStr("\\f"s);
+
+    if (val == '\n')
+        return writer.writeStr("\\n"s);
+
+    if (val == '\r')
+        return writer.writeStr("\\r"s);
+
+    if (val == '\t')
+        return writer.writeStr("\\t"s);
+
+    if (val == '\v')
+        return writer.writeStr("\\v"s);
+
+    if (not isAsciiPrint(val))
+        return Io::format(writer, "\\u{x}", val);
+
+    return writer.writeRune(val);
+}
+
 } // namespace Karm::Io