blob: d9ff8932b492661841c8202e23402b4379eee01e [file] [log] [blame] [edit]
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);
}