Bases of codegen & enums

wayland-client/Cargo.toml

@@ -16,6 +16,7 @@ travis-ci = { repository = "smithay/wayland-rs" }
 [dependencies]
 wayland-commons = { version = "0.20.0", path = "../wayland-commons" }
 wayland-sys = { version = "0.20.0", features = ["client"], path = "../wayland-sys", optional = true }
+bitflags = "1.0"
 libc = "0.2"
 
 [build-dependencies]

wayland-client/src/lib.rs

@@ -1,3 +1,5 @@
+#[macro_use]
+extern crate bitflags;
 extern crate libc;
 
 extern crate wayland_commons;
@@ -6,4 +8,19 @@ extern crate wayland_commons;
 extern crate wayland_sys;
 
 mod proxy;
-pub use proxy::{Proxy, NewProxy};
+pub use proxy::{NewProxy, Proxy};
+
+mod generated {
+    #![allow(dead_code, non_camel_case_types, unused_unsafe, unused_variables)]
+    #![allow(non_upper_case_globals, non_snake_case, unused_imports)]
+    #![allow(missing_docs)]
+
+    #[cfg(feature = "native_lib")]
+    mod c_interfaces {
+        include!(concat!(env!("OUT_DIR"), "/wayland_c_interfaces.rs"));
+    }
+    #[cfg(feature = "native_lib")]
+    mod c_api {
+        include!(concat!(env!("OUT_DIR"), "/wayland_c_api.rs"));
+    }
+}

wayland-scanner/src/c_code_gen.rs

@@ -1,14 +1,40 @@
 use std::io::Result as IOResult;
-use protocol::*;
 use std::cmp;
 use std::io::Write;
 
+use common_gen::*;
+use protocol::*;
+use util::*;
+
 pub(crate) fn write_protocol_client<O: Write>(protocol: Protocol, out: &mut O) -> IOResult<()> {
-    // TODO
+    write_prefix(&protocol, out)?;
+
+    for iface in &protocol.interfaces {
+        writeln!(out, "pub mod {} {{", iface.name)?;
+
+        write_enums(&iface.enums, out)?;
+
+        writeln!(out, "}}\n")?;
+    }
+
     Ok(())
 }
 
 pub(crate) fn write_protocol_server<O: Write>(protocol: Protocol, out: &mut O) -> IOResult<()> {
-    // TODO
+    write_prefix(&protocol, out)?;
+
+    for iface in &protocol.interfaces {
+        // display and registry are handled specially
+        if iface.name == "wl_display" || iface.name == "wl_registry" {
+            continue;
+        }
+
+        writeln!(out, "pub mod {} {{", iface.name)?;
+
+        write_enums(&iface.enums, out)?;
+
+        writeln!(out, "}}\n")?;
+    }
+
     Ok(())
 }

wayland-scanner/src/c_interface_gen.rs

@@ -13,8 +13,9 @@ pub(crate) fn generate_interfaces<O: Write>(protocol: Protocol, out: &mut O) ->
         writeln!(out, "/*\n{}\n*/\n", text)?;
     }
 
-    writeln!(out,
-    r#"
+    writeln!(
+        out,
+        r#"
 use std::os::raw::{{c_char, c_void}};
 use wayland_sys::common::*;"#
     )?;
@@ -23,22 +24,20 @@ use wayland_sys::common::*;"#
     //
 
     let longest_nulls = protocol.interfaces.iter().fold(0, |max, interface| {
-        let request_longest_null = interface
-            .requests
-            .iter()
-            .fold(0, |max, request| if request.all_null() {
+        let request_longest_null = interface.requests.iter().fold(0, |max, request| {
+            if request.all_null() {
                 cmp::max(request.args.len(), max)
             } else {
                 max
-            });
-        let events_longest_null = interface
-            .events
-            .iter()
-            .fold(0, |max, event| if event.all_null() {
+            }
+        });
+        let events_longest_null = interface.events.iter().fold(0, |max, event| {
+            if event.all_null() {
                 cmp::max(event.args.len(), max)
             } else {
                 max
-            });
+            }
+        });
         cmp::max(max, cmp::max(request_longest_null, events_longest_null))
     });
 

wayland-scanner/src/common_gen.rs

@@ -0,0 +1,173 @@
+use std::io::Result as IOResult;
+use std::cmp;
+use std::io::Write;
+
+use protocol::*;
+use util::*;
+
+pub(crate) fn write_prefix<O: Write>(protocol: &Protocol, out: &mut O) -> IOResult<()> {
+    writeln!(
+        out,
+        r#"
+//
+// This file was auto-generated, do not edit directly.
+//
+"#
+    )?;
+    if let Some(ref text) = protocol.copyright {
+        writeln!(out, "/*\n{}\n*/\n", text)?;
+    }
+    Ok(())
+}
+
+pub(crate) fn write_enums<O: Write>(enums: &[Enum], out: &mut O) -> IOResult<()> {
+    // generate contents
+    for enu in enums {
+        if enu.bitfield {
+            writeln!(out, "    bitflags! {{")?;
+            if let Some((ref short, ref long)) = enu.description {
+                write_doc(Some(short), long, false, out, 2)?;
+            }
+            writeln!(
+                out,
+                "        pub struct {}: u32 {{",
+                snake_to_camel(&enu.name)
+            )?;
+            for entry in &enu.entries {
+                if let Some((ref short, ref long)) = entry.description {
+                    write_doc(Some(short), long, false, out, 3)?;
+                } else if let Some(ref summary) = entry.summary {
+                    writeln!(out, "            /// {}", summary)?;
+                }
+                writeln!(
+                    out,
+                    "            const {}{} = {};",
+                    if entry.name.chars().next().unwrap().is_numeric() {
+                        "_"
+                    } else {
+                        ""
+                    },
+                    snake_to_camel(&entry.name),
+                    entry.value
+                )?;
+            }
+            writeln!(out, "        }}")?;
+            writeln!(out, "    }}")?;
+            writeln!(out, "    impl {} {{", snake_to_camel(&enu.name))?;
+            writeln!(
+                out,
+                "        pub fn from_raw(n: u32) -> Option<{}> {{",
+                snake_to_camel(&enu.name)
+            )?;
+            writeln!(
+                out,
+                "            Some({}::from_bits_truncate(n))",
+                snake_to_camel(&enu.name)
+            )?;
+            writeln!(
+                out,
+                r#"
+        }}
+        pub fn to_raw(&self) -> u32 {{
+            self.bits()
+        }}
+    }}
+"#
+            )?;
+        } else {
+            // if enu.bitfield
+            if let Some((ref short, ref long)) = enu.description {
+                write_doc(Some(short), long, false, out, 1)?;
+            }
+            writeln!(
+                out,
+                r#"
+    #[repr(u32)]
+    #[derive(Copy,Clone,Debug,PartialEq)]
+    pub enum {} {{"#,
+                snake_to_camel(&enu.name)
+            )?;
+            for entry in &enu.entries {
+                if let Some((ref short, ref long)) = entry.description {
+                    write_doc(Some(short), long, false, out, 2)?;
+                } else if let Some(ref summary) = entry.summary {
+                    writeln!(out, "        /// {}", summary)?;
+                }
+                writeln!(
+                    out,
+                    "        {}{} = {},",
+                    if entry.name.chars().next().unwrap().is_numeric() {
+                        "_"
+                    } else {
+                        ""
+                    },
+                    snake_to_camel(&entry.name),
+                    entry.value
+                )?;
+            }
+            writeln!(out, "    }}")?;
+
+            writeln!(out, "    impl {} {{", snake_to_camel(&enu.name))?;
+            writeln!(
+                out,
+                "        pub fn from_raw(n: u32) -> Option<{}> {{",
+                snake_to_camel(&enu.name)
+            )?;
+            writeln!(out, "            match n {{")?;
+            for entry in &enu.entries {
+                writeln!(
+                    out,
+                    "                {} => Some({}::{}{}),",
+                    entry.value,
+                    snake_to_camel(&enu.name),
+                    if entry.name.chars().next().unwrap().is_numeric() {
+                        "_"
+                    } else {
+                        ""
+                    },
+                    snake_to_camel(&entry.name)
+                )?;
+            }
+            writeln!(
+                out,
+                r#"
+                _ => Option::None
+            }}
+        }}
+        pub fn to_raw(&self) -> u32 {{
+            *self as u32
+        }}
+    }}
+"#
+            )?;
+        }
+    }
+    Ok(())
+}
+
+pub(crate) fn write_doc<O: Write>(
+    short: Option<&str>,
+    long: &str,
+    internal: bool,
+    out: &mut O,
+    indent: usize,
+) -> IOResult<()> {
+    let p = if internal { '!' } else { '/' };
+    if let Some(txt) = short {
+        for _ in 0..indent {
+            write!(out, "    ")?
+        }
+        writeln!(out, "//{} {}", p, txt)?;
+        for _ in 0..indent {
+            write!(out, "    ")?
+        }
+        writeln!(out, "//{}", p)?;
+    }
+    for l in long.lines() {
+        for _ in 0..indent {
+            write!(out, "    ")?
+        }
+        writeln!(out, "//{} {}", p, l.trim())?;
+    }
+    Ok(())
+}

wayland-scanner/src/lib.rs

@@ -111,6 +111,7 @@ mod util;
 mod parse;
 mod protocol;
 mod side;
+mod common_gen;
 mod c_interface_gen;
 mod c_code_gen;
 

wayland-server/Cargo.toml

@@ -16,6 +16,7 @@ travis-ci = { repository = "smithay/wayland-rs" }
 [dependencies]
 wayland-commons = { version = "0.20.0", path = "../wayland-commons" }
 wayland-sys = { version = "0.20.0", features = ["server"], path = "../wayland-sys", optional = true }
+bitflags = "1.0"
 libc = "0.2"
 
 [build-dependencies]

wayland-server/src/lib.rs

@@ -1,3 +1,5 @@
+#[macro_use]
+extern crate bitflags;
 extern crate libc;
 
 extern crate wayland_commons;
@@ -6,6 +8,21 @@ extern crate wayland_commons;
 extern crate wayland_sys;
 
 mod resource;
-pub use resource::{Resource, NewResource};
+pub use resource::{NewResource, Resource};
 
 struct Client;
+
+mod generated {
+    #![allow(dead_code, non_camel_case_types, unused_unsafe, unused_variables)]
+    #![allow(non_upper_case_globals, non_snake_case, unused_imports)]
+    #![allow(missing_docs)]
+
+    #[cfg(feature = "native_lib")]
+    mod c_interfaces {
+        include!(concat!(env!("OUT_DIR"), "/wayland_c_interfaces.rs"));
+    }
+    #[cfg(feature = "native_lib")]
+    mod c_api {
+        include!(concat!(env!("OUT_DIR"), "/wayland_c_api.rs"));
+    }
+}