3:44 a.m.
All handle calls which has the `modifies_fd` flag set to [true] will be
excluded from `AsyncHandle` (the asynchronous handle in the rust
bindings). This is a better approach then listing all calls that should
be excluded in Rust.ml explicetly.
---
generator/Rust.ml | 63 ++++++++++++++++++++++-------------------------
1 file changed, 30 insertions(+), 33 deletions(-)
diff --git a/generator/Rust.ml b/generator/Rust.ml
index adc7ffa..4d81e3f 100644
--- a/generator/Rust.ml
+++ b/generator/Rust.ml
@@ -597,19 +597,21 @@ let generate_rust_bindings () =
(*********************************************************)
let excluded_handle_calls : NameSet.t =
+ let modifies_fd =
+ handle_calls
+ |> List.filter (fun (_, { modifies_fd }) -> modifies_fd)
+ |> List.map (fun (name, _) -> name)
+ in
NameSet.of_list
- [
- "aio_get_fd";
- "aio_get_direction";
- "aio_notify_read";
- "aio_notify_write";
- "clear_debug_callback";
- "get_debug";
- "poll";
- "poll2";
- "set_debug";
- "set_debug_callback";
- ]
+ (modifies_fd
+ @ [
+ "aio_get_fd";
+ "aio_get_direction";
+ "clear_debug_callback";
+ "get_debug";
+ "set_debug";
+ "set_debug_callback";
+ ])
(* A mapping with names as keys. *)
module NameMap = Map.Make (String)
@@ -620,16 +622,16 @@ let strip_aio name : string =
String.sub name 4 (String.length name - 4)
else failwithf "Asynchronous call %s must begin with aio_" name
-(* A map with all asynchronous handle calls. The keys are names with "aio_"
- stripped, the values are a tuple with the actual name (with "aio_"), the
- [call] and the [async_kind]. *)
+(* A map with all asynchronous handle calls. The keys are names, the values
+ are tuples of: the name with "aio_" stripped, the [call] and the
+ [async_kind]. *)
let async_handle_calls : ((string * call) * async_kind) NameMap.t =
handle_calls
|> List.filter (fun (n, _) -> not (NameSet.mem n excluded_handle_calls))
|> List.filter_map (fun (name, call) ->
call.async_kind
|> Option.map (fun async_kind ->
- (strip_aio name, ((name, call), async_kind))))
+ (name, ((strip_aio name, call), async_kind))))
|> List.to_seq |> NameMap.of_seq
(* A mapping with all synchronous (not asynchronous) handle calls. Excluded
@@ -639,11 +641,7 @@ let async_handle_calls : ((string * call) * async_kind) NameMap.t =
let sync_handle_calls : call NameMap.t =
handle_calls
|> List.filter (fun (n, _) -> not (NameSet.mem n excluded_handle_calls))
- |> List.filter (fun (name, _) ->
- (not (NameMap.mem name async_handle_calls))
- && not
- (String.starts_with ~prefix:"aio_" name
- && NameMap.mem (strip_aio name) async_handle_calls))
+ |> List.filter (fun (n, _) -> not (NameMap.mem n async_handle_calls))
|> List.to_seq |> NameMap.of_seq
(* Get the Rust type for an argument in the asynchronous API. Like
@@ -688,7 +686,7 @@ let print_rust_sync_handle_call (name : string) (call : call) =
(* Print the Rust function for an asynchronous handle call with a completion
callback. (Note that "callback" might be abbreviated with "cb" in
the
following code. *)
-let print_rust_async_handle_call_with_completion_cb name (aio_name, call) =
+let print_rust_async_handle_call_with_completion_cb aio_name (name, call) =
(* An array of all optional arguments. Useful because we need to deel with
the index of the completion callback. *)
let optargs = Array.of_list call.optargs in
@@ -760,7 +758,7 @@ let print_rust_async_handle_call_with_completion_cb name (aio_name,
call) =
completion by changing state. The predicate is a call like
"aio_is_connecting" which should get the value (like false) for the call to
be complete. *)
-let print_rust_async_handle_call_changing_state name (aio_name, call)
+let print_rust_async_handle_call_changing_state aio_name (name, call)
(predicate, value) =
let value = if value then "true" else "false" in
print_rust_handle_call_comment call;
@@ -784,16 +782,15 @@ let print_rust_async_handle_call_changing_state name (aio_name,
call)
(* Print an impl with all handle calls. *)
let print_rust_async_handle_impls () =
pr "impl AsyncHandle {\n";
- NameMap.iter print_rust_sync_handle_call sync_handle_calls;
- NameMap.iter
- (fun name (call, async_kind) ->
- match async_kind with
- | WithCompletionCallback ->
- print_rust_async_handle_call_with_completion_cb name call
- | ChangesState (predicate, value) ->
- print_rust_async_handle_call_changing_state name call
- (predicate, value))
- async_handle_calls;
+ sync_handle_calls |> NameMap.iter print_rust_sync_handle_call;
+ async_handle_calls
+ |> NameMap.iter (fun name (call, async_kind) ->
+ match async_kind with
+ | WithCompletionCallback ->
+ print_rust_async_handle_call_with_completion_cb name call
+ | ChangesState (predicate, value) ->
+ print_rust_async_handle_call_changing_state name call
+ (predicate, value));
pr "}\n\n"
let print_rust_async_imports () =
--
2.41.0