| extern crate cc; |
| extern crate wayland_scanner; |
| |
| use rayon::prelude::*; |
| use std::env; |
| use std::fs::File; |
| use std::io::ErrorKind; |
| use std::io::Write; |
| use std::path::Path; |
| use std::path::PathBuf; |
| use std::process::Command; |
| use wayland_scanner::*; |
| |
| fn run_bindgen(header: &str, output: &str) { |
| let out_path = PathBuf::from(env::var("OUT_DIR").unwrap()); |
| |
| let sysroot = env::var("SYSROOT").unwrap_or("/".to_string()); |
| |
| let status = Command::new("bindgen") |
| .args(&["-o", out_path.join(output).to_str().unwrap()]) |
| .arg("--no-doc-comments") |
| .arg("--no-layout-tests") |
| .args(&["--new-type-alias", "wl_fixed_t"]) |
| .args(&["--default-enum-style", "rust_non_exhaustive"]) |
| .args(&["--bitfield-enum", "weston_keyboard_modifier"]) |
| .args(&["--bitfield-enum", "weston_activate_flag"]) |
| .args(&["--bitfield-enum", "wl_event_mask"]) |
| .args(&["--no-copy", "shell_surface"]) |
| .arg(header) |
| .arg("--") |
| .arg(format!("--sysroot={}", sysroot)) |
| .arg("-I./wayland-server") |
| .arg("-I/usr/include/pixman-1") |
| .arg("-I./weston/include") |
| .arg("-I./bindgen/block") |
| .status() |
| .unwrap(); |
| |
| assert!(status.success()) |
| } |
| |
| struct ConfigHeader { |
| contents: String, |
| } |
| |
| impl ConfigHeader { |
| fn new() -> ConfigHeader { |
| ConfigHeader { |
| contents: "/* automatically generated header */\n\n".to_string(), |
| } |
| } |
| |
| fn define(&mut self, name: &str, value: impl std::fmt::Display) -> &mut Self { |
| self.contents |
| .push_str(&format!("#define {} {}\n", name, value.to_string())); |
| |
| self |
| } |
| |
| fn define_escaped(&mut self, name: &str, value: impl std::fmt::Display) -> &mut Self { |
| self.define(name, format!("\"{}\"", value)); |
| |
| self |
| } |
| |
| fn build(&self, path: &str, name: &str) { |
| File::create(format!("{}/{}", path, name)) |
| .unwrap() |
| .write(self.contents.as_bytes()) |
| .unwrap(); |
| } |
| } |
| |
| fn generate_header_files(config: &Config) { |
| ConfigHeader::new() |
| .define("HAVE_ACCEPT4", 1) |
| .define("HAVE_MEMFD_CREATE", 1) |
| .define_escaped("LIBWESTON_MODULEDIR", "/dev/null") |
| .define_escaped("DATADIR", &config.data_dir) |
| .define("_GNU_SOURCE", 1) |
| .define("_ALL_SOURCE", 1) |
| .define("MAJOR_IN_SYSMACROS", 1) |
| .build(&config.out_path, "config.h"); |
| |
| ConfigHeader::new() |
| .define("BUILD_ID", "c001bead") |
| .build(&config.out_path, "git-version.h"); |
| |
| std::fs::create_dir(format!("{}/libweston", config.out_path)) |
| .or_else(|e| { |
| if e.kind() == ErrorKind::AlreadyExists { |
| Ok(()) |
| } else { |
| Err(e) |
| } |
| }) |
| .unwrap(); |
| |
| ConfigHeader::new() |
| .define("WESTON_VERSION_MAJOR", 9) |
| .define("WESTON_VERSION_MINOR", 0) |
| .define("WESTON_VERSION_MICRO", 0) |
| .define_escaped("WESTON_VERSION", "9.0.0") |
| .build(&config.out_path, "libweston/version.h"); |
| } |
| |
| fn generate_rust_protocol_code(config: &Config) { |
| let protocols = [ |
| "wayland", |
| "xdg-shell", |
| "weston-screenshooter", |
| "linux-dmabuf-unstable-v1", |
| "croscomp", |
| "alpha-compositing-unstable-v1", |
| "aura-shell", |
| "cursor-shapes-unstable-v1", |
| "gaming-input-unstable-v2", |
| "keyboard-configuration-unstable-v1", |
| "keyboard-extension-unstable-v1", |
| "pointer-gestures-unstable-v1", |
| "remote-shell-unstable-v1", |
| "secure-output-unstable-v1", |
| "stylus-tools-unstable-v1", |
| "stylus-unstable-v2", |
| "vsync-feedback-unstable-v1", |
| ]; |
| |
| let out_dir = Path::new(&config.out_path); |
| |
| protocols.par_iter().for_each(|e| { |
| let spec = Path::new("protocol").join(e).with_extension("xml"); |
| let out = out_dir.join(e).with_extension("rs"); |
| println!("cargo:rerun-if-changed={}", spec.to_str().unwrap()); |
| generate_code_with_destructor_events(spec, out, Side::Server, &[("wl_callback", "done")]); |
| }); |
| } |
| |
| fn generate_protocol_code(config: &Config) -> Vec<String> { |
| let wp = "/usr/share/wayland-protocols"; |
| |
| let stable = ["viewporter", "presentation-time", "xdg-shell"]; |
| |
| let unstable = [ |
| ("input-method", 1), |
| ("input-timestamps", 1), |
| ("linux-dmabuf", 1), |
| ("linux-explicit-synchronization", 1), |
| ("xdg-output", 1), |
| ("relative-pointer", 1), |
| ("pointer-constraints", 1), |
| ("fullscreen-shell", 1), |
| ]; |
| |
| let internal = [ |
| "wayland", |
| "weston-content-protection", |
| "weston-touch-calibration", |
| "weston-debug", |
| "weston-direct-display", |
| "text-cursor-position", |
| ]; |
| |
| let protocols = stable |
| .iter() |
| .map(|name| { |
| ( |
| format!("{}/stable/{}/{}.xml", wp, name, name), |
| format!("{}/{}", config.out_path, name), |
| ) |
| }) |
| .chain(unstable.iter().map(|(name, version)| { |
| ( |
| format!( |
| "{}/unstable/{}/{}-unstable-v{}.xml", |
| wp, name, name, version |
| ), |
| format!("{}/{}-unstable-v{}", config.out_path, name, version), |
| ) |
| })) |
| .chain(internal.iter().map(|name| { |
| ( |
| format!("protocol/{}.xml", name), |
| format!("{}/{}", config.out_path, name), |
| ) |
| })); |
| |
| fn generate(xml: &str, output: &str) -> String { |
| for (t, suffix) in [ |
| ("client-header", "client-protocol.h"), |
| ("server-header", "server-protocol.h"), |
| ("private-code", "protocol.c"), |
| ] { |
| let output_file = format!("{}-{}", output, suffix); |
| Command::new("wayland-scanner") |
| .args([t, &xml, &output_file]) |
| .status() |
| .unwrap(); |
| } |
| |
| format!("{}-protocol.c", output) |
| } |
| |
| protocols |
| .map(|(xml, output)| generate(&xml, &output)) |
| .collect() |
| } |
| |
| struct Files { |
| files: Vec<String> |
| } |
| |
| impl Files { |
| fn new() -> Files { |
| Files { files: Vec::new() } |
| } |
| |
| fn subdir<A: std::fmt::Display>(&mut self, prefix: &str, iter: impl IntoIterator<Item = A>) { |
| self.files.extend( |
| iter.into_iter() |
| .map(|f| format!("{}/{}", prefix, f))); |
| } |
| |
| fn metadata(&self) { |
| for f in &self.files { |
| println!("cargo:rerun-if-changed={}", f); |
| } |
| } |
| } |
| |
| fn build_libweston(config: &Config) { |
| generate_header_files(&config); |
| |
| let protocol_c_files = generate_protocol_code(&config); |
| |
| let mut builder = cc::Build::new(); |
| |
| let mut files = Files::new(); |
| |
| let mut deps = vec!["libdrm", "pixman-1", "xkbcommon", "libffi"]; |
| |
| files.subdir( |
| "weston/libweston", |
| [ |
| "animation.c", |
| "bindings.c", |
| "clipboard.c", |
| "compositor.c", |
| "content-protection.c", |
| "data-device.c", |
| "input.c", |
| "linux-dmabuf.c", |
| "linux-explicit-synchronization.c", |
| "linux-sync-file.c", |
| "log.c", |
| "noop-renderer.c", |
| "pixel-formats.c", |
| "pixman-renderer.c", |
| "plugin-registry.c", |
| "screenshooter.c", |
| "timeline.c", |
| "touch-calibration.c", |
| "weston-log-wayland.c", |
| "weston-log-file.c", |
| "weston-log-flight-rec.c", |
| "weston-log.c", |
| "weston-direct-display.c", |
| "zoom.c", |
| ]); |
| files.subdir( |
| "weston/shared", |
| [ |
| "file-util.c", |
| "image-loader.c", |
| "matrix.c", |
| "os-compatibility.c", |
| ]); |
| |
| // Internal wayland-server |
| files.subdir( |
| "wayland-server", |
| [ |
| "wayland-server.c", |
| "wayland-shm.c", |
| "event-loop.c", |
| "connection.c", |
| "wayland-os.c", |
| "wayland-util.c", |
| ]); |
| |
| #[cfg(feature = "wayland-backend")] |
| { |
| files.subdir("weston/libweston/backend-wayland", ["wayland.c"]); |
| files.subdir("weston/shared", ["frame.c", "cairo-util.c"]); |
| deps.extend(["wayland-client", "wayland-cursor", "cairo", "libpng"]) |
| } |
| |
| #[cfg(feature = "drm-backend")] |
| { |
| files.subdir( |
| "weston/libweston/backend-drm", |
| &[ |
| "drm.c", |
| "fb.c", |
| "modes.c", |
| "kms.c", |
| "state-helpers.c", |
| "state-propose.c", |
| "libbacklight.c", |
| ]); |
| files.subdir( |
| "weston/libweston", |
| &[ |
| "launcher-direct.c", |
| "launcher-util.c", |
| "launcher-weston-launch.c", |
| "libinput-device.c", |
| "libinput-seat.c", |
| ]); |
| |
| deps.extend(["libinput", "libevdev", "libudev"]); |
| } |
| |
| files.metadata(); |
| |
| builder |
| .cargo_metadata(false) |
| .files(files.files) |
| .files(protocol_c_files) |
| .extra_warnings(false) |
| .flag("-std=gnu99") |
| .include("weston/include") |
| .include("weston/libweston") |
| .include("weston") |
| .include(&config.out_path); |
| |
| // builder.compile() normally prints these, but we need to list |
| // them now so that croscomp-libweston will appear before the |
| // pkg-config shared libraries on the link line. |
| println!("cargo:rustc-link-lib=static=croscomp-libweston"); |
| println!("cargo:rustc-link-search=native={}", config.out_path); |
| |
| for d in deps { |
| let lib = pkg_config::probe_library(d).unwrap(); |
| builder.includes(&lib.include_paths); |
| } |
| |
| builder.compile("croscomp-libweston"); |
| } |
| |
| struct Config { |
| out_path: String, |
| data_dir: String, |
| } |
| |
| fn main() { |
| let config = Config { |
| out_path: env::var("OUT_DIR").unwrap(), |
| data_dir: "/usr/share".to_string(), |
| }; |
| |
| build_libweston(&config); |
| |
| run_bindgen("/usr/include/linux/input.h", "input.rs"); |
| run_bindgen("./weston/croscomp_weston.h", "croscomp_weston.rs"); |
| |
| generate_rust_protocol_code(&config); |
| } |