Support %s and %p

examples/PoolBox/application/src/font_writer.cpp

@@ -21,9 +21,11 @@ void font_writer_setup() {
 }
 
 void font_writer_update() {
+    static const char*const Text[2] = {"Planschi", "Becken"};
+
     auto state = JabyEngine::State::create(JabyEngine::Make::PositionI16(8, 8), wiggle_count);
     new_font_writer.write(state, "012345 ABCDEFGHIJKL\nabcedfghijkl\n", JabyEngine::GPU::Color24::Blue(), &wiggle);
-    new_font_writer.write(state, "Wiggle Count: %i", JabyEngine::GPU::Color24::Green(), &wiggle, wiggle_count);
+    new_font_writer.write(state, "%i (0x%p)\nWiggle (%s)", JabyEngine::GPU::Color24::Green(), &wiggle, wiggle_count, 0xAABBCCDD, Text[wiggle_count&0x1]);
 
     if(timer.is_expired_for(50_ms)) {
         timer.reset();

support/src/FontWriter/src/font_writer.cpp

@@ -4,28 +4,46 @@
 #include <stdio.h>
 
 namespace JabyEngine {
-    static const char* simple_itoa(char (&buffer)[32], int value, int base) {
+    static constexpr auto ITOABufferSize = 32;
-        const bool is_neg = value < 0;
-        int        i      = 32 - 2;
 
-        if(is_neg) {
+    static char* simple_itoa(char (&buffer)[ITOABufferSize], bool is_neg, uint32_t value, uint32_t base) {
-            value *= -1;
+        //                       v terminating 0 and space for sign
-        }
+        int i = ITOABufferSize - 2;
     
         for(; value && i; i--, value /= base) {
             char chr = '0' + value%base;
             if(chr > '9') {
-                chr += ('A' - '9');
+                chr += ('A' - '9' - 1);
             }
             buffer[i] = chr;
         }
 
-        buffer[32 - 1] = '\0';
+        buffer[ITOABufferSize - 1] = '\0';
         if(is_neg) {
             buffer[i] = '-';
             return &buffer[i];
         }
-        return &buffer[i+1];
+        return &buffer[i + 1];
+    }
+
+    static const char* simple_itoa(char (&buffer)[ITOABufferSize], int32_t value, uint32_t base) {
+        const auto is_neg = value < 0;
+        if(is_neg) {
+            value *= -1;
+        }
+        return simple_itoa(buffer, is_neg, value, base);
+    }
+
+    static const char* simple_ptoa(char (&buffer)[ITOABufferSize], void* value) {
+        //                                                     v terminating 0
+        static constexpr auto BufferStartID = ITOABufferSize - 1 - 8;
+
+        char* str = simple_itoa(buffer, false, reinterpret_cast<int>(value), 16);
+        while(str > &buffer[BufferStartID]) {
+            str--;
+            *str = '0';
+        }
+        return &buffer[BufferStartID];
     }
 
     void FontWriter :: setup(const FontBufferInfo& buffer_info, const SimpleTIM& vram_dst, const GPU::SizeI16& font_size) {
@@ -44,6 +62,10 @@ namespace JabyEngine {
     }
 
     void FontWriter :: write(State& state, const char* str, GPU::Color24 color, Wiggle* wiggle, va_list list) {
+        static const auto exchang_str = [](const char* str, const char* new_str) -> pair<const char*, const char*> {
+            return {str + 1, new_str};
+        };
+
         const auto* primitive_end = &this->prim_buffer.double_buffer[GPU::Display::current_id][this->prim_buffer.single_buffer_length];
         const auto  font_size     = this->prim_buffer.double_buffer[0][0]->size;
         const auto  row_count     = 256/font_size.width;
@@ -89,14 +111,21 @@ namespace JabyEngine {
 
                 case '%':
                     switch(*str) {
-                        case 'i':
-                            prev_str = str + 1;
-                            str = simple_itoa(buffer, va_arg(list, int), 10);
-                            continue;
-
                         case '%':
                             str++;
                             break;
+
+                        case 'i':
+                            tie(prev_str, str) = exchang_str(str, simple_itoa(buffer, va_arg(list, int), 10));
+                            continue;
+
+                        case 'p':
+                            tie(prev_str, str) = exchang_str(str, simple_ptoa(buffer, va_arg(list, void*)));
+                            continue;
+
+                        case 's':
+                            tie(prev_str, str) = exchang_str(str, va_arg(list, const char*));
+                            continue;
                     }
 
                 default: