clean up argument buffers

3 files changed, 324 insertions, 286 deletions

diff --git a/lib/CWayland/CWayland.cc b/lib/CWayland/CWayland.cc
index cff3fd1..718785f 100644
--- a/lib/CWayland/CWayland.cc
+++ b/lib/CWayland/CWayland.cc
@@ -123,17 +123,7 @@ namespace
         return lean_io_result_mk_error(error);
     }
 
-    std::size_t message_argument_count(const wl_message* msg)
-    {
-        std::size_t res = 0;
-        for (char c : std::string_view{ msg->signature })
-        {
-            if (c >= 'a' && c <= 'z') { res += 1; }
-        }
-        return res;
-    }
-
-    // Global dispatcher func, assumes a user_data of type (UInt32 → ArgumentReader → EventLoop M × M)
+    // Global dispatcher func, assumes a user_data of type (UInt32 → ArgumentBuffer → EventLoop M × M)
     int dispatcher_func(const void* user_data, void* target, uint32_t opcode, const wl_message* msg, wl_argument* args);
 }
 
@@ -845,22 +835,38 @@ lean_obj_res waylean_type_map_register(b_lean_obj_arg map_obj, b_lean_obj_arg if
     return lean_io_result_mk_ok(lean_box(0));
 }
 
-// -- Argument Writer
+// -- Argument Buffer
 
 namespace
 {
-    class argument_writer
+    class argument_buffer
     {
+        enum class type { uninitialized, i32, u32, fixed, string, object, new_id, array, fd };
+        struct meta
+        {
+            type type{ type::uninitialized };
+            ref ref{};
+        };
+
         static constexpr std::size_t max_args = 64;
 
-        std::size_t used{ 0 };
+        std::size_t writer_idx{ 0 };
+        std::size_t reader_idx{ 0 };
+        std::array<meta, max_args> meta{};
         std::array<wl_argument, max_args> args{};
-        std::array<ref, max_args> refs{};
 
-        std::size_t new_arg()
+        std::size_t next_write()
         {
-            assert(used + 1 < max_args && "reached maximum number of arguments");
-            return used++;
+            assert(writer_idx < max_args && "reached maximum number of arguments");
+            return writer_idx++;
+        }
+
+        std::size_t next_read(type expected_type)
+        {
+            assert(reader_idx < writer_idx && "reached maximum number of arguments");
+            auto result = reader_idx++;
+            assert(meta[result].type == expected_type && "mismatching argument type");
+            return result;
         }
 
     public:
@@ -868,303 +874,327 @@ namespace
 
         void write_int(int32_t value)
         {
-            auto i = new_arg();
+            auto i = next_write();
             args[i].i = value;
+            meta[i].type = type::i32;
         }
 
         void write_uint(uint32_t value)
         {
-            auto i = new_arg();
+            auto i = next_write();
             args[i].u = value;
+            meta[i].type = type::u32;
         }
 
         void write_fixed(float value)
         {
-            auto i = new_arg();
+            auto i = next_write();
             args[i].f = wl_fixed_from_double(value);
+            meta[i].type = type::fixed;
         }
 
-        void write_string(b_lean_obj_arg value)
+        void write_string(ref value)
         {
-            auto i = new_arg();
-            if (lean_is_scalar(value))
-            {
-                args[i].s = nullptr;
-            }
-            else
-            {
-                lean_object* val = lean_ctor_get(value, 0);
-                args[i].s = lean_string_cstr(val);
-                refs[i] = ref{ val };
-            }
+            auto i = next_write();
+            args[i].s = option_cstr_or_null(value.get());
+            meta[i].type = type::string;
+            meta[i].ref = std::move(value);
         }
 
-        void write_object(b_lean_obj_arg value)
+        void write_object(ref value)
         {
-            auto i = new_arg();
-            if (lean_is_scalar(value))
+            auto i = next_write();
+            if (lean_is_scalar(value.get()))
             {
                 args[i].o = nullptr;
             }
             else
             {
-                lean_object* val = lean_ctor_get(value, 0);
-                args[i].o = static_cast<wl_object*>(lean_get_external_data(val));
-                refs[i] = ref{ val };
+                args[i].o = static_cast<wl_object*>(lean_get_external_data(lean_ctor_get(value.get(), 0)));
             }
+            meta[i].type = type::object;
+            meta[i].ref = std::move(value);
         }
 
-        void write_new_id(b_lean_obj_arg value)
+        void write_new_id(std::uint32_t value)
         {
-            auto i = new_arg();
-            args[i].n = wl_proxy_get_id(static_cast<wl_proxy*>(lean_get_external_data(value)));
-            refs[i] = ref{ value };
+            auto i = next_write();
+            args[i].n = value;
+            meta[i].type = type::new_id;
         }
 
-        void write_array(b_lean_obj_arg value)
+        void write_array(ref value)
         {
-            auto i = new_arg();
-            std::size_t size = lean_sarray_size(value);
+            auto i = next_write();
+            std::size_t size = lean_sarray_size(value.get());
             args[i].a->alloc = size;
             args[i].a->size = size;
-            args[i].a->data = lean_sarray_cptr(value);
-            refs[i] = ref{ value };
+            args[i].a->data = lean_sarray_cptr(value.get());
+            meta[i].type = type::array;
+            meta[i].ref = std::move(value);
         }
 
         void write_fd(int32_t value)
         {
-            auto i = new_arg();
+            auto i = next_write();
             args[i].h = value;
+            meta[i].type = type::fd;
         }
-    };
-
-    lean_external_class* waylean_argument_writer_class()
-    {
-        static lean_external_class* klass = lean_register_external_class(
-            [](void* ptr) { delete static_cast<argument_writer*>(ptr); },
-            [](void*, b_lean_obj_arg fn) { }
-        );
-        return klass;
-    }
-}
-
-// ArgumentWriter.new : IO ArgumentWriter
-lean_obj_res waylean_argument_writer_new(void)
-{
-    argument_writer* writer = new argument_writer;
-    lean_object* waylean_writer = lean_alloc_external(waylean_argument_writer_class(), writer);
-    return lean_io_result_mk_ok(waylean_writer);
-}
-
-// ArgumentWriter.writeInt : (writer : @& ArgumentWriter) → (value : Int32) → IO Unit
-lean_obj_res waylean_argument_writer_write_int(b_lean_obj_arg writer_obj, int32_t value)
-{
-    auto writer = static_cast<argument_writer*>(lean_get_external_data(writer_obj));
-    writer->write_int(value);
-    return lean_io_result_mk_ok(lean_box(0));
-}
-
-// ArgumentWriter.writeUInt : (writer : @& ArgumentWriter) → (value : UInt32) → IO Unit
-lean_obj_res waylean_argument_writer_write_uint(b_lean_obj_arg writer_obj, uint32_t value)
-{
-    auto writer = static_cast<argument_writer*>(lean_get_external_data(writer_obj));
-    writer->write_uint(value);
-    return lean_io_result_mk_ok(lean_box(0));
-}
 
-// ArgumentWriter.writeFloat : (writer : @& ArgumentWriter) → (value : Float) → IO Unit
-lean_obj_res waylean_argument_writer_write_fixed(b_lean_obj_arg writer_obj, float value)
-{
-    auto writer = static_cast<argument_writer*>(lean_get_external_data(writer_obj));
-    writer->write_fixed(value);
-    return lean_io_result_mk_ok(lean_box(0));
-}
-
-// ArgumentWriter.writeString : (writer : @& ArgumentWriter) → (value : @& Option String) → IO Unit
-lean_obj_res waylean_argument_writer_write_string(b_lean_obj_arg writer_obj, b_lean_obj_arg value)
-{
-    auto writer = static_cast<argument_writer*>(lean_get_external_data(writer_obj));
-    writer->write_string(value);
-    return lean_io_result_mk_ok(lean_box(0));
-}
-
-// ArgumentWriter.writeObject : (writer : @& ArgumentWriter) → (value : @& Option Proxy) → IO Unit
-lean_obj_res waylean_argument_writer_write_object(b_lean_obj_arg writer_obj, b_lean_obj_arg value)
-{
-    auto writer = static_cast<argument_writer*>(lean_get_external_data(writer_obj));
-    writer->write_object(value);
-    return lean_io_result_mk_ok(lean_box(0));
-}
-
-// ArgumentWriter.writeNewID : (writer : @& ArgumentWriter) → (value : @& Proxy) → IO Unit
-lean_obj_res waylean_argument_writer_write_new_id(b_lean_obj_arg writer_obj, b_lean_obj_arg value)
-{
-    auto writer = static_cast<argument_writer*>(lean_get_external_data(writer_obj));
-    writer->write_new_id(value);
-    return lean_io_result_mk_ok(lean_box(0));
-}
-
-// ArgumentWriter.writeArray : (writer : @& ArgumentWriter) → (value : @& ByteArray) → IO Unit
-lean_obj_res waylean_argument_writer_write_array(b_lean_obj_arg writer_obj, b_lean_obj_arg value)
-{
-    auto writer = static_cast<argument_writer*>(lean_get_external_data(writer_obj));
-    writer->write_array(value);
-    return lean_io_result_mk_ok(lean_box(0));
-}
-
-// ArgumentWriter.writeFD : (writer : @& ArgumentWriter) → (value : Int32) → IO Unit
-lean_obj_res waylean_argument_writer_write_fd(b_lean_obj_arg writer_obj, int32_t value)
-{
-    auto writer = static_cast<argument_writer*>(lean_get_external_data(writer_obj));
-    writer->write_fd(value);
-    return lean_io_result_mk_ok(lean_box(0));
-}
-
-// -- Argument Reader
-
-namespace
-{
-    struct argument_reader
-    {
-        wl_argument* args{ nullptr };
-        std::size_t current{ 0 };
-
-        wl_argument next_arg()
+        void write(wl_argument arg, std::string_view signature_type)
         {
-            assert(args != nullptr && "expected argument reader to still be alive");
-            return args[current++];
+            auto i = next_write();
+            args[i] = arg;
+            if (signature_type == "i")
+            {
+                meta[i].type = type::i32;
+            }
+            else if (signature_type == "u")
+            {
+                meta[i].type = type::u32;
+            }
+            else if (signature_type == "f")
+            {
+                meta[i].type = type::fixed;
+            }
+            else if (signature_type == "s" || signature_type == "?s")
+            {
+                meta[i].type = type::string;
+                if (arg.s)
+                {
+                    auto s = std::string_view{ arg.s };
+                    auto res = ref::steal(lean_alloc_ctor(1, 1, 0));
+                    lean_ctor_set(res.get(), 0, lean_mk_string_from_bytes(s.data(), s.length()));
+                    meta[i].ref = std::move(res);
+                }
+                else
+                {
+                    meta[i].ref = ref::steal(lean_box(0));
+                }
+            }
+            else if (signature_type == "o" || signature_type == "?o")
+            {
+                meta[i].type = type::object;
+                if (arg.o)
+                {
+                    auto res = ref::steal(lean_alloc_ctor(1, 1, 0));
+                    auto proxy_obj = (lean_object*)(wl_proxy_get_listener((wl_proxy*)arg.o)); // set as dispatcher_data
+                    lean_inc(proxy_obj);
+                    lean_ctor_set(res.get(), 0, proxy_obj);
+                    meta[i].ref = std::move(res);
+                }
+                else
+                {
+                    meta[i].ref = ref::steal(lean_box(0));
+                }
+            }
+            else if (signature_type == "n")
+            {
+                meta[i].type = type::new_id;
+            }
+            else if (signature_type == "a")
+            {
+                meta[i].type = type::array;
+                auto res = ref::steal(lean_alloc_sarray(1, arg.a->size, arg.a->size));
+                std::copy_n(static_cast<uint8_t*>(arg.a->data), arg.a->size, lean_sarray_cptr(res.get()));
+                meta[i].ref = std::move(res);
+            }
+            else if (signature_type == "h")
+            {
+                meta[i].type = type::fd;
+            }
+            else
+            {
+                assert(false && "unknown argument type in signature");
+            }
         }
 
         ref read_int()
         {
-            return ref::steal(lean_box_uint32(next_arg().i));
+            auto i = next_read(type::i32);
+            return ref::steal(lean_box_uint32(args[i].i));
         }
 
         ref read_uint()
         {
-            return ref::steal(lean_box_uint32(next_arg().u));
+            auto i = next_read(type::u32);
+            return ref::steal(lean_box_uint32(args[i].u));
         }
 
         ref read_fixed()
         {
-            return ref::steal(lean_box_float(wl_fixed_to_double(next_arg().f)));
+            auto i = next_read(type::fixed);
+            return ref::steal(lean_box_float(wl_fixed_to_double(args[i].f)));
         }
 
         ref read_string()
         {
-            auto s = next_arg().s;
-            if (s)
-            {
-                auto res = ref::steal(lean_alloc_ctor(1, 1, 0));
-                lean_ctor_set(res.get(), 0, lean_mk_string_from_bytes(s, strlen(s)));
-                return res;
-            }
-            else
-            {
-                return ref::steal(lean_box(0));
-            }
+            auto i = next_read(type::string);
+            return ref{ std::move(meta[i].ref) };
         }
 
         ref read_object()
         {
-            auto o = next_arg().o;
-            if (o)
-            {
-                auto res = ref::steal(lean_alloc_ctor(1, 1, 0));
-                auto proxy_obj = (lean_object*)(wl_proxy_get_listener((wl_proxy*)o)); // set as dispatcher_data
-                lean_inc(proxy_obj);
-                lean_ctor_set(res.get(), 0, proxy_obj);
-                return res;
-            }
-            else
-            {
-                return ref::steal(lean_box(0));
-            }
+            auto i = next_read(type::object);
+            return ref{ std::move(meta[i].ref) };
         }
 
         ref read_new_id()
         {
-            return ref::steal(lean_box_uint32(next_arg().n));
+            auto i = next_read(type::new_id);
+            return ref::steal(lean_box_uint32(args[i].n));
         }
 
         ref read_array()
         {
-            auto a = next_arg().a;
-            auto res = ref::steal(lean_alloc_sarray(1, a->size, a->size));
-            std::copy_n(static_cast<uint8_t*>(a->data), a->size, lean_sarray_cptr(res.get()));
-            return res;
+            auto i = next_read(type::array);
+            return ref{ std::move(meta[i].ref) };
         }
 
         ref read_fd()
         {
-            return ref::steal(lean_box_uint32(next_arg().h));
+            auto i = next_read(type::fd);
+            return ref::steal(lean_box_uint32(args[i].h));
         }
     };
 
-    lean_external_class* waylean_argument_reader_class()
+    lean_external_class* waylean_argument_buffer_class()
     {
         static lean_external_class* klass = lean_register_external_class(
-            [](void* ptr) { delete static_cast<argument_reader*>(ptr); },
+            [](void* ptr) { delete static_cast<argument_buffer*>(ptr); },
             [](void*, b_lean_obj_arg fn) { }
         );
         return klass;
     }
 }
 
-// ArgumentReader.readInt : (reader : @& ArgumentReader) → IO Int32
-lean_obj_res waylean_argument_reader_read_int(b_lean_obj_arg reader_obj)
+// ArgumentBuffer.new : IO ArgumentBuffer
+lean_obj_res waylean_argument_buffer_new(void)
 {
-    auto reader = static_cast<argument_reader*>(lean_get_external_data(reader_obj));
-    return lean_io_result_mk_ok(reader->read_int().release());
+    argument_buffer* buffer = new argument_buffer;
+    lean_object* waylean_buffer = lean_alloc_external(waylean_argument_buffer_class(), buffer);
+    return lean_io_result_mk_ok(waylean_buffer);
 }
 
-// ArgumentReader.readUInt : (reader : @& ArgumentReader) → IO Int32
-lean_obj_res waylean_argument_reader_read_uint(b_lean_obj_arg reader_obj)
+// ArgumentBuffer.writeInt : (buffer : @& ArgumentBuffer) → (value : Int32) → IO Unit
+lean_obj_res waylean_argument_buffer_write_int(b_lean_obj_arg buffer_obj, int32_t value)
 {
-    auto reader = static_cast<argument_reader*>(lean_get_external_data(reader_obj));
-    return lean_io_result_mk_ok(reader->read_uint().release());
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    buffer->write_int(value);
+    return lean_io_result_mk_ok(lean_box(0));
 }
 
-// ArgumentReader.readFixed : (reader : @& ArgumentReader) → IO Float
-lean_obj_res waylean_argument_reader_read_fixed(b_lean_obj_arg reader_obj)
+// ArgumentBuffer.writeUInt : (buffer : @& ArgumentBuffer) → (value : UInt32) → IO Unit
+lean_obj_res waylean_argument_buffer_write_uint(b_lean_obj_arg buffer_obj, uint32_t value)
 {
-    auto reader = static_cast<argument_reader*>(lean_get_external_data(reader_obj));
-    return lean_io_result_mk_ok(reader->read_fixed().release());
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    buffer->write_uint(value);
+    return lean_io_result_mk_ok(lean_box(0));
 }
 
-// ArgumentReader.readString : (reader : @& ArgumentReader) → IO (Option String)
-lean_obj_res waylean_argument_reader_read_string(b_lean_obj_arg reader_obj)
+// ArgumentBuffer.writeFloat : (buffer : @& ArgumentBuffer) → (value : Float) → IO Unit
+lean_obj_res waylean_argument_buffer_write_fixed(b_lean_obj_arg buffer_obj, float value)
 {
-    auto reader = static_cast<argument_reader*>(lean_get_external_data(reader_obj));
-    return lean_io_result_mk_ok(reader->read_string().release());
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    buffer->write_fixed(value);
+    return lean_io_result_mk_ok(lean_box(0));
 }
 
-// ArgumentReader.readObject : (reader : @& ArgumentReader) → IO (Option Proxy)
-lean_obj_res waylean_argument_reader_read_object(b_lean_obj_arg reader_obj)
+// ArgumentBuffer.writeString : (buffer : @& ArgumentBuffer) → (value : @& Option String) → IO Unit
+lean_obj_res waylean_argument_buffer_write_string(b_lean_obj_arg buffer_obj, b_lean_obj_arg value)
 {
-    auto reader = static_cast<argument_reader*>(lean_get_external_data(reader_obj));
-    return lean_io_result_mk_ok(reader->read_object().release());
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    buffer->write_string(ref{ value });
+    return lean_io_result_mk_ok(lean_box(0));
 }
 
-// ArgumentReader.readNewID : (reader : @& ArgumentReader) → IO UInt32
-lean_obj_res waylean_argument_reader_read_new_id(b_lean_obj_arg reader_obj)
+// ArgumentBuffer.writeObject : (buffer : @& ArgumentBuffer) → (value : @& Option Proxy) → IO Unit
+lean_obj_res waylean_argument_buffer_write_object(b_lean_obj_arg buffer_obj, b_lean_obj_arg value)
 {
-    auto reader = static_cast<argument_reader*>(lean_get_external_data(reader_obj));
-    return lean_io_result_mk_ok(reader->read_new_id().release());
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    buffer->write_object(ref{ value });
+    return lean_io_result_mk_ok(lean_box(0));
 }
 
-// ArgumentReader.readArray : (reader : @& ArgumentReader) → IO ByteArray
-lean_obj_res waylean_argument_reader_read_array(b_lean_obj_arg reader_obj)
+// ArgumentBuffer.writeNewID : (buffer : @& ArgumentBuffer) → (value : @& Proxy) → IO Unit
+lean_obj_res waylean_argument_buffer_write_new_id(b_lean_obj_arg buffer_obj, b_lean_obj_arg value)
 {
-    auto reader = static_cast<argument_reader*>(lean_get_external_data(reader_obj));
-    return lean_io_result_mk_ok(reader->read_array().release());
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    auto proxy = static_cast<wl_proxy*>(lean_get_external_data(value));
+    buffer->write_new_id(wl_proxy_get_id(proxy));
+    return lean_io_result_mk_ok(lean_box(0));
 }
 
-// ArgumentReader.readFD : (reader : @& ArgumentReader) → IO Int32
-lean_obj_res waylean_argument_reader_read_fd(b_lean_obj_arg reader_obj)
+// ArgumentBuffer.writeArray : (buffer : @& ArgumentBuffer) → (value : @& ByteArray) → IO Unit
+lean_obj_res waylean_argument_buffer_write_array(b_lean_obj_arg buffer_obj, b_lean_obj_arg value)
 {
-    auto reader = static_cast<argument_reader*>(lean_get_external_data(reader_obj));
-    return lean_io_result_mk_ok(reader->read_fd().release());
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    buffer->write_array(ref{ value });
+    return lean_io_result_mk_ok(lean_box(0));
+}
+
+// ArgumentBuffer.writeFD : (buffer : @& ArgumentBuffer) → (value : Int32) → IO Unit
+lean_obj_res waylean_argument_buffer_write_fd(b_lean_obj_arg buffer_obj, int32_t value)
+{
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    buffer->write_fd(value);
+    return lean_io_result_mk_ok(lean_box(0));
+}
+
+// ArgumentBuffer.readInt : (buffer : @& ArgumentBuffer) → IO Int32
+lean_obj_res waylean_argument_buffer_read_int(b_lean_obj_arg buffer_obj)
+{
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    return lean_io_result_mk_ok(buffer->read_int().release());
+}
+
+// ArgumentBuffer.readUInt : (buffer : @& ArgumentBuffer) → IO Int32
+lean_obj_res waylean_argument_buffer_read_uint(b_lean_obj_arg buffer_obj)
+{
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    return lean_io_result_mk_ok(buffer->read_uint().release());
+}
+
+// ArgumentBuffer.readFixed : (buffer : @& ArgumentBuffer) → IO Float
+lean_obj_res waylean_argument_buffer_read_fixed(b_lean_obj_arg buffer_obj)
+{
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    return lean_io_result_mk_ok(buffer->read_fixed().release());
+}
+
+// ArgumentBuffer.readString : (buffer : @& ArgumentBuffer) → IO (Option String)
+lean_obj_res waylean_argument_buffer_read_string(b_lean_obj_arg buffer_obj)
+{
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    return lean_io_result_mk_ok(buffer->read_string().release());
+}
+
+// ArgumentBuffer.readObject : (buffer : @& ArgumentBuffer) → IO (Option Proxy)
+lean_obj_res waylean_argument_buffer_read_object(b_lean_obj_arg buffer_obj)
+{
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    return lean_io_result_mk_ok(buffer->read_object().release());
+}
+
+// ArgumentBuffer.readNewID : (buffer : @& ArgumentBuffer) → IO UInt32
+lean_obj_res waylean_argument_buffer_read_new_id(b_lean_obj_arg buffer_obj)
+{
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    return lean_io_result_mk_ok(buffer->read_new_id().release());
+}
+
+// ArgumentBuffer.readArray : (buffer : @& ArgumentBuffer) → IO ByteArray
+lean_obj_res waylean_argument_buffer_read_array(b_lean_obj_arg buffer_obj)
+{
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    return lean_io_result_mk_ok(buffer->read_array().release());
+}
+
+// ArgumentBuffer.readFD : (buffer : @& ArgumentBuffer) → IO Int32
+lean_obj_res waylean_argument_buffer_read_fd(b_lean_obj_arg buffer_obj)
+{
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    return lean_io_result_mk_ok(buffer->read_fd().release());
 }
 
 // -- Proxy
@@ -1176,19 +1206,33 @@ namespace
         if (!user_data) { return 0; }
 
         auto handler = ref{ (lean_object*)user_data };
-        auto reader = new argument_reader;
-        auto reader_obj = ref::steal(lean_alloc_external(waylean_argument_reader_class(), reader));
+        
+        auto buffer = new argument_buffer;
+        auto buffer_obj = ref::steal(lean_alloc_external(waylean_argument_buffer_class(), buffer));
+        auto signature_it = msg->signature;
+        auto arg_it = args;
+        while (auto c = *signature_it)
+        {
+            if (c >= '0' && c <= '9')
+            {
+                signature_it += 1;
+                continue;
+            }
+            
+            auto item_length = (c == '?') ? 2 : 1;
+            auto item = std::string_view(signature_it, item_length);
+            signature_it += item_length;
+            
+            buffer->write(*(arg_it++), item);
+        }
 
-        reader->args = args;
         auto tuple = ref::steal(
             lean_apply_2(
                 std::move(handler).release(),
                 lean_box_uint32(opcode),
-                std::move(reader_obj).release()
+                std::move(buffer_obj).release()
             )
         );
-        // TODO: Won't work because reader is only used in the event loop.
-        reader->args = nullptr;
 
         auto loop_obj = lean_ctor_get(tuple.get(), 0);
         auto loop = static_cast<event_loop*>(lean_get_external_data(loop_obj));
@@ -1240,16 +1284,16 @@ lean_obj_res waylean_proxy_new(b_lean_obj_arg factory_obj, b_lean_obj_arg map_ob
     return lean_io_result_mk_ok(waylean_res);
 }
 
-// Proxy.send : (proxy : @& Proxy) → (opcode : UInt32) → (argumentWriter : @& ArgumentWriter) → IO Unit
-lean_obj_res waylean_proxy_send(b_lean_obj_arg proxy_obj, uint32_t opcode, b_lean_obj_arg writer_obj)
+// Proxy.send : (proxy : @& Proxy) → (opcode : UInt32) → (argumentBuffer : @& ArgumentBuffer) → IO Unit
+lean_obj_res waylean_proxy_send(b_lean_obj_arg proxy_obj, uint32_t opcode, b_lean_obj_arg buffer_obj)
 {
     auto proxy = static_cast<wl_proxy*>(lean_get_external_data(proxy_obj));
-    auto writer = static_cast<argument_writer*>(lean_get_external_data(writer_obj));
-    wl_proxy_marshal_array(proxy, opcode, writer->get_args());
+    auto buffer = static_cast<argument_buffer*>(lean_get_external_data(buffer_obj));
+    wl_proxy_marshal_array(proxy, opcode, buffer->get_args());
     return lean_io_result_mk_ok(lean_box(0));
 }
 
-// Proxy.listen : (proxy : @& Proxy) → (handler : UInt32 → ArgumentReader → EventLoop M × M) → IO Unit
+// Proxy.listen : (proxy : @& Proxy) → (handler : UInt32 → ArgumentBuffer → EventLoop M × M) → IO Unit
 lean_obj_res waylean_proxy_listen(b_lean_obj_arg proxy_obj, lean_obj_arg handler)
 {
     auto proxy = static_cast<wl_proxy*>(lean_get_external_data(proxy_obj));
diff --git a/lib/CWayland/CWayland.h b/lib/CWayland/CWayland.h
index 852cc7c..fbfea9b 100644
--- a/lib/CWayland/CWayland.h
+++ b/lib/CWayland/CWayland.h
@@ -41,36 +41,33 @@ lean_obj_res waylean_type_map_contains(b_lean_obj_arg type_map,
 lean_obj_res waylean_type_map_register(b_lean_obj_arg type_map,
                                        b_lean_obj_arg iface_desc);
 
-// -- Argument Writer
+// -- Argument Buffer
 
-lean_obj_res waylean_argument_writer_new         (void);
-lean_obj_res waylean_argument_writer_write_int   (b_lean_obj_arg writer,
+lean_obj_res waylean_argument_buffer_new         (void);
+lean_obj_res waylean_argument_buffer_write_int   (b_lean_obj_arg writer,
                                                   int32_t        value);
-lean_obj_res waylean_argument_writer_write_uint  (b_lean_obj_arg writer,
+lean_obj_res waylean_argument_buffer_write_uint  (b_lean_obj_arg writer,
                                                   uint32_t       value);
-lean_obj_res waylean_argument_writer_write_fixed (b_lean_obj_arg writer,
+lean_obj_res waylean_argument_buffer_write_fixed (b_lean_obj_arg writer,
                                                   float          value);
-lean_obj_res waylean_argument_writer_write_string(b_lean_obj_arg writer,
+lean_obj_res waylean_argument_buffer_write_string(b_lean_obj_arg writer,
                                                   b_lean_obj_arg value);
-lean_obj_res waylean_argument_writer_write_object(b_lean_obj_arg writer,
+lean_obj_res waylean_argument_buffer_write_object(b_lean_obj_arg writer,
                                                   b_lean_obj_arg value);
-lean_obj_res waylean_argument_writer_write_new_id(b_lean_obj_arg writer,
+lean_obj_res waylean_argument_buffer_write_new_id(b_lean_obj_arg writer,
                                                   b_lean_obj_arg value);
-lean_obj_res waylean_argument_writer_write_array (b_lean_obj_arg writer,
+lean_obj_res waylean_argument_buffer_write_array (b_lean_obj_arg writer,
                                                   b_lean_obj_arg value);
-lean_obj_res waylean_argument_writer_write_fd    (b_lean_obj_arg writer,
+lean_obj_res waylean_argument_buffer_write_fd    (b_lean_obj_arg writer,
                                                   int32_t        value);
-
-// -- Argument Reader
-
-lean_obj_res waylean_argument_reader_read_int   (b_lean_obj_arg reader);
-lean_obj_res waylean_argument_reader_read_uint  (b_lean_obj_arg reader);
-lean_obj_res waylean_argument_reader_read_fixed (b_lean_obj_arg reader);
-lean_obj_res waylean_argument_reader_read_string(b_lean_obj_arg reader);
-lean_obj_res waylean_argument_reader_read_object(b_lean_obj_arg reader);
-lean_obj_res waylean_argument_reader_read_new_id(b_lean_obj_arg reader);
-lean_obj_res waylean_argument_reader_read_array (b_lean_obj_arg reader);
-lean_obj_res waylean_argument_reader_read_fd    (b_lean_obj_arg reader);
+lean_obj_res waylean_argument_buffer_read_int   (b_lean_obj_arg reader);
+lean_obj_res waylean_argument_buffer_read_uint  (b_lean_obj_arg reader);
+lean_obj_res waylean_argument_buffer_read_fixed (b_lean_obj_arg reader);
+lean_obj_res waylean_argument_buffer_read_string(b_lean_obj_arg reader);
+lean_obj_res waylean_argument_buffer_read_object(b_lean_obj_arg reader);
+lean_obj_res waylean_argument_buffer_read_new_id(b_lean_obj_arg reader);
+lean_obj_res waylean_argument_buffer_read_array (b_lean_obj_arg reader);
+lean_obj_res waylean_argument_buffer_read_fd    (b_lean_obj_arg reader);
 
 // -- Proxy
 
@@ -80,7 +77,7 @@ lean_obj_res waylean_proxy_new         (b_lean_obj_arg factory,
                                         b_lean_obj_arg iface_name);
 lean_obj_res waylean_proxy_send        (b_lean_obj_arg proxy,
                                         uint32_t       opcode,
-                                        b_lean_obj_arg argument_writer);
+                                        b_lean_obj_arg argument_buffer);
 lean_obj_res waylean_proxy_listen      (b_lean_obj_arg proxy,
                                         lean_obj_arg   handler);
 
diff --git a/lib/Wayland/Native.lean b/lib/Wayland/Native.lean
index 909cde4..9eb8398 100644
--- a/lib/Wayland/Native.lean
+++ b/lib/Wayland/Native.lean
@@ -17,24 +17,21 @@ private opaque DisplayP : NonemptyType
 private opaque EventLoopP (M : Type) : NonemptyType
 private opaque EventSourceP : NonemptyType
 private opaque TypeMapP : NonemptyType
-private opaque ArgumentReaderP : NonemptyType
-private opaque ArgumentWriterP : NonemptyType
+private opaque ArgumentBufferP : NonemptyType
 private opaque ProxyP : NonemptyType
 
 def Display : Type := DisplayP.type
 def EventLoop (M : Type) : Type := (EventLoopP M).type
 def EventSource : Type := EventSourceP.type
 def TypeMap : Type := TypeMapP.type
-def ArgumentReader : Type := ArgumentReaderP.type
-def ArgumentWriter : Type := ArgumentWriterP.type
+def ArgumentBuffer : Type := ArgumentBufferP.type
 def Proxy : Type := ProxyP.type
 
 instance : Nonempty Display := DisplayP.property
 instance : Nonempty (EventLoop M) := (EventLoopP M).property
 instance : Nonempty EventSource := EventSourceP.property
 instance : Nonempty TypeMap := TypeMapP.property
-instance : Nonempty ArgumentReader := ArgumentReaderP.property
-instance : Nonempty ArgumentWriter := ArgumentWriterP.property
+instance : Nonempty ArgumentBuffer := ArgumentBufferP.property
 instance : Nonempty Proxy := ProxyP.property
 
 @[extern "waylean_SIGINT"]
@@ -79,56 +76,56 @@ opaque TypeMap.contains : (typeMap : @& TypeMap) → (ifaceName : @& String) →
 @[extern "waylean_type_map_register"]
 opaque TypeMap.register : (typeMap : @& TypeMap) → (ifaceDesc : @& Interface) → IO Unit
 
-@[extern "waylean_argument_writer_new"]
-opaque ArgumentWriter.new : IO ArgumentWriter
+@[extern "waylean_argument_buffer_new"]
+opaque ArgumentBuffer.new : IO ArgumentBuffer
 
-@[extern "waylean_argument_writer_write_int"]
-opaque ArgumentWriter.writeInt : (writer : @& ArgumentWriter) → (value : Int32) → IO Unit
+@[extern "waylean_argument_buffer_write_int"]
+opaque ArgumentBuffer.writeInt : (writer : @& ArgumentBuffer) → (value : Int32) → IO Unit
 
-@[extern "waylean_argument_writer_write_uint"]
-opaque ArgumentWriter.writeUInt : (writer : @& ArgumentWriter) → (value : UInt32) → IO Unit
+@[extern "waylean_argument_buffer_write_uint"]
+opaque ArgumentBuffer.writeUInt : (writer : @& ArgumentBuffer) → (value : UInt32) → IO Unit
 
-@[extern "waylean_argument_writer_write_fixed"]
-opaque ArgumentWriter.writeFloat : (writer : @& ArgumentWriter) → (value : Float) → IO Unit
+@[extern "waylean_argument_buffer_write_fixed"]
+opaque ArgumentBuffer.writeFloat : (writer : @& ArgumentBuffer) → (value : Float) → IO Unit
 
-@[extern "waylean_argument_writer_write_string"]
-opaque ArgumentWriter.writeString : (writer : @& ArgumentWriter) → (value : @& Option String) → IO Unit
+@[extern "waylean_argument_buffer_write_string"]
+opaque ArgumentBuffer.writeString : (writer : @& ArgumentBuffer) → (value : @& Option String) → IO Unit
 
-@[extern "waylean_argument_writer_write_object"]
-opaque ArgumentWriter.writeObject : (writer : @& ArgumentWriter) → (value : @& Option Proxy) → IO Unit
+@[extern "waylean_argument_buffer_write_object"]
+opaque ArgumentBuffer.writeObject : (writer : @& ArgumentBuffer) → (value : @& Option Proxy) → IO Unit
 
-@[extern "waylean_argument_writer_write_new_id"]
-opaque ArgumentWriter.writeNewID : (writer : @& ArgumentWriter) → (value : @& Proxy) → IO Unit
+@[extern "waylean_argument_buffer_write_new_id"]
+opaque ArgumentBuffer.writeNewID : (writer : @& ArgumentBuffer) → (value : @& Proxy) → IO Unit
 
-@[extern "waylean_argument_writer_write_array"]
-opaque ArgumentWriter.writeArray : (writer : @& ArgumentWriter) → (value : @& ByteArray) → IO Unit
+@[extern "waylean_argument_buffer_write_array"]
+opaque ArgumentBuffer.writeArray : (writer : @& ArgumentBuffer) → (value : @& ByteArray) → IO Unit
 
-@[extern "waylean_argument_writer_write_fd"]
-opaque ArgumentWriter.writeFD : (writer : @& ArgumentWriter) → (value : Int32) → IO Unit
+@[extern "waylean_argument_buffer_write_fd"]
+opaque ArgumentBuffer.writeFD : (writer : @& ArgumentBuffer) → (value : Int32) → IO Unit
 
-@[extern "waylean_argument_reader_read_int"]
-opaque ArgumentReader.readInt : (reader : @& ArgumentReader) → IO Int32
+@[extern "waylean_argument_buffer_read_int"]
+opaque ArgumentBuffer.readInt : (reader : @& ArgumentBuffer) → IO Int32
 
-@[extern "waylean_argument_reader_read_uint"]
-opaque ArgumentReader.readUInt : (reader : @& ArgumentReader) → IO Int32
+@[extern "waylean_argument_buffer_read_uint"]
+opaque ArgumentBuffer.readUInt : (reader : @& ArgumentBuffer) → IO Int32
 
-@[extern "waylean_argument_reader_read_fixed"]
-opaque ArgumentReader.readFixed : (reader : @& ArgumentReader) → IO Float
+@[extern "waylean_argument_buffer_read_fixed"]
+opaque ArgumentBuffer.readFixed : (reader : @& ArgumentBuffer) → IO Float
 
-@[extern "waylean_argument_reader_read_string"]
-opaque ArgumentReader.readString : (reader : @& ArgumentReader) → IO (Option String)
+@[extern "waylean_argument_buffer_read_string"]
+opaque ArgumentBuffer.readString : (reader : @& ArgumentBuffer) → IO (Option String)
 
-@[extern "waylean_argument_reader_read_object"]
-opaque ArgumentReader.readObject : (reader : @& ArgumentReader) → IO (Option Proxy)
+@[extern "waylean_argument_buffer_read_object"]
+opaque ArgumentBuffer.readObject : (reader : @& ArgumentBuffer) → IO (Option Proxy)
 
-@[extern "waylean_argument_reader_read_new_id"]
-opaque ArgumentReader.readNewID : (reader : @& ArgumentReader) → IO UInt32
+@[extern "waylean_argument_buffer_read_new_id"]
+opaque ArgumentBuffer.readNewID : (reader : @& ArgumentBuffer) → IO UInt32
 
-@[extern "waylean_argument_reader_read_array"]
-opaque ArgumentReader.readArray : (reader : @& ArgumentReader) → IO ByteArray
+@[extern "waylean_argument_buffer_read_array"]
+opaque ArgumentBuffer.readArray : (reader : @& ArgumentBuffer) → IO ByteArray
 
-@[extern "waylean_argument_reader_read_fd"]
-opaque ArgumentReader.readFD : (reader : @& ArgumentReader) → IO Int32
+@[extern "waylean_argument_buffer_read_fd"]
+opaque ArgumentBuffer.readFD : (reader : @& ArgumentBuffer) → IO Int32
 
 @[extern "waylean_proxy_from_display"]
 opaque Proxy.fromDisplay : (display : Display) → IO Proxy
@@ -137,9 +134,9 @@ opaque Proxy.fromDisplay : (display : Display) → IO Proxy
 opaque Proxy.new : (factory : @& Proxy) → (typeMap : @& TypeMap) → (ifaceName : @& String) → IO Proxy
 
 @[extern "waylean_proxy_send"]
-opaque Proxy.send : (proxy : @& Proxy) → (opcode : UInt32) → (argumentWriter : @& ArgumentWriter) → IO Unit
+opaque Proxy.send : (proxy : @& Proxy) → (opcode : UInt32) → (argumentBuffer : @& ArgumentBuffer) → IO Unit
 
 @[extern "waylean_proxy_listen"]
-opaque Proxy.listen : (proxy : @& Proxy) → (handler : UInt32 → ArgumentReader → EventLoop M × M) → IO Unit
+opaque Proxy.listen : (proxy : @& Proxy) → (handler : UInt32 → ArgumentBuffer → EventLoop M × M) → IO Unit
 
 end Wayland.Native