diff options
Diffstat (limited to 'lib')
| -rw-r--r-- | lib/CWayland/CWayland.cc | 488 | ||||
| -rw-r--r-- | lib/CWayland/CWayland.h | 41 | ||||
| -rw-r--r-- | lib/Wayland/Native.lean | 81 |
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 |