1 use proc_macro2::{Ident, Span, TokenStream};
2 
3 use common_gen::*;
4 use protocol::*;
5 use util::*;
6 use Side;
7 
generate_protocol_client(protocol: Protocol) -> TokenStream8 pub(crate) fn generate_protocol_client(protocol: Protocol) -> TokenStream {
9     let modules = protocol.interfaces.iter().map(|iface| {
10         let doc_attr = iface.description.as_ref().map(description_to_doc_attr);
11         let mod_name = Ident::new(&iface.name, Span::call_site());
12         let iface_name = Ident::new(&snake_to_camel(&iface.name), Span::call_site());
13 
14         let enums = &iface.enums;
15         let requests = gen_messagegroup(
16             &Ident::new("Request", Span::call_site()),
17             Side::Client,
18             false,
19             &iface.requests,
20             None,
21         );
22         let events = gen_messagegroup(
23             &Ident::new("Event", Span::call_site()),
24             Side::Client,
25             true,
26             &iface.events,
27             None,
28         );
29         let interface = gen_interface(
30             &iface_name,
31             &iface.name,
32             iface.version,
33             None,
34         );
35         let client_methods = gen_client_methods(&iface_name, &iface.requests);
36         let sinces = gen_since_constants(&iface.requests, &iface.events);
37 
38         quote! {
39             #doc_attr
40             pub mod #mod_name {
41                 use super::{
42                     Proxy, NewProxy, AnonymousObject, Interface, MessageGroup, MessageDesc, ArgumentType, Object,
43                     Message, Argument, ObjectMetadata,
44                 };
45 
46                 #(#enums)*
47                 #requests
48                 #events
49                 #interface
50                 #client_methods
51                 #sinces
52             }
53         }
54     });
55 
56     quote! {
57         #(#modules)*
58     }
59 }
60 
generate_protocol_server(protocol: Protocol) -> TokenStream61 pub(crate) fn generate_protocol_server(protocol: Protocol) -> TokenStream {
62     let modules = protocol
63         .interfaces
64         .iter()
65         // display and registry are handled specially
66         .filter(|iface| iface.name != "wl_display" && iface.name != "wl_registry")
67         .map(|iface| {
68             let doc_attr = iface.description.as_ref().map(description_to_doc_attr);
69             let mod_name = Ident::new(&iface.name, Span::call_site());
70 
71             let enums = &iface.enums;
72             let requests = gen_messagegroup(
73                 &Ident::new("Request", Span::call_site()),
74                 Side::Server,
75                 true,
76                 &iface.requests,
77                 None,
78             );
79             let events = gen_messagegroup(
80                 &Ident::new("Event", Span::call_site()),
81                 Side::Server,
82                 false,
83                 &iface.events,
84                 None,
85             );
86             let interface = gen_interface(
87                 &Ident::new(&snake_to_camel(&iface.name), Span::call_site()),
88                 &iface.name,
89                 iface.version,
90                 None,
91             );
92             let sinces = gen_since_constants(&iface.requests, &iface.events);
93 
94             quote! {
95                 #doc_attr
96                 pub mod #mod_name {
97                     use super::{
98                         Resource, NewResource, AnonymousObject, Interface, MessageGroup, MessageDesc,
99                         ArgumentType, Object, Message, Argument, ObjectMetadata
100                     };
101 
102                     #(#enums)*
103                     #requests
104                     #events
105                     #interface
106                     #sinces
107                 }
108             }
109         });
110 
111     quote! {
112         #(#modules)*
113     }
114 }
115