ISAR/rusqlite
3
0
Fork 0
mirror of https://github.com/isar/rusqlite.git synced 2024-10-23 15:01:08 +08:00
Code Issues Packages Projects Releases Wiki Activity

Allow build time bindgen of bundled SQLite

Browse Source 
Rewrite https://github.com/jgallagher/rusqlite/pull/320
This commit is contained in:
gwenn 2018-10-28 18:16:48 +01:00
parent ebf98b4241
commit e5b1af51ab
1 changed files with 132 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

254
libsqlite3-sys/build.rs
View File

@ -1,22 +1,34 @@
use std::env;
use std::path::Path;
fn main() { fn main() {
build::main(); let out_dir = env::var("OUT_DIR").unwrap();
let out_path = Path::new(&out_dir).join("bindgen.rs");
build::main(&out_dir, &out_path);
} }
#[cfg(feature = "bundled")] #[cfg(feature = "bundled")]
mod build { mod build {
extern crate cc; extern crate cc;
use std::path::Path; use std::path::Path;
use std::{env, fs};
pub fn main() { pub fn main(out_dir: &str, out_path: &Path) {
if cfg!(feature = "sqlcipher") { if cfg!(feature = "sqlcipher") {
panic!("Builds with bundled SQLCipher are not supported"); panic!("Builds with bundled SQLCipher are not supported");
} }
let out_dir = env::var("OUT_DIR").unwrap(); #[cfg(feature = "buildtime_bindgen")]
let out_path = Path::new(&out_dir).join("bindgen.rs"); {
fs::copy("sqlite3/bindgen_bundled_version.rs", out_path) use super::{bindings, HeaderLocation};
.expect("Could not copy bindings to output directory"); let header = HeaderLocation::FromPath("sqlite3/sqlite3.h".to_owned());
bindings::write_to_out_dir(header, out_path);
}
#[cfg(not(feature = "buildtime_bindgen"))]
{
use std::fs;
fs::copy("sqlite3/bindgen_bundled_version.rs", out_path)
.expect("Could not copy bindings to output directory");
}
let mut cfg = cc::Build::new(); let mut cfg = cc::Build::new();
cfg.file("sqlite3/sqlite3.c") cfg.file("sqlite3/sqlite3.c")
@ -48,6 +60,38 @@ mod build {
} }
} }
fn env_prefix() -> &'static str {
if cfg!(feature = "sqlcipher") {
"SQLCIPHER"
} else {
"SQLITE3"
}
}
pub enum HeaderLocation {
FromEnvironment,
Wrapper,
FromPath(String),
}
impl From<HeaderLocation> for String {
fn from(header: HeaderLocation) -> String {
match header {
HeaderLocation::FromEnvironment => {
let prefix = env_prefix();
let mut header = env::var(format!("{}_INCLUDE_DIR", prefix)).expect(&format!(
"{}_INCLUDE_DIR must be set if {}_LIB_DIR is set",
prefix, prefix
));
header.push_str("/sqlite3.h");
header
}
HeaderLocation::Wrapper => "wrapper.h".into(),
HeaderLocation::FromPath(path) => path,
}
}
}
#[cfg(not(feature = "bundled"))] #[cfg(not(feature = "bundled"))]
mod build { mod build {
extern crate pkg_config; extern crate pkg_config;
@ -55,35 +99,13 @@ mod build {
#[cfg(all(feature = "vcpkg", target_env = "msvc"))] #[cfg(all(feature = "vcpkg", target_env = "msvc"))]
extern crate vcpkg; extern crate vcpkg;
use super::{bindings, env_prefix, HeaderLocation};
use std::env; use std::env;
use std::path::Path;
pub enum HeaderLocation { pub fn main(_out_dir: &str, out_path: &Path) {
FromEnvironment,
Wrapper,
FromPath(String),
}
impl From<HeaderLocation> for String {
fn from(header: HeaderLocation) -> String {
match header {
HeaderLocation::FromEnvironment => {
let prefix = env_prefix();
let mut header = env::var(format!("{}_INCLUDE_DIR", prefix)).expect(&format!(
"{}_INCLUDE_DIR must be set if {}_LIB_DIR is set",
prefix, prefix
));
header.push_str("/sqlite3.h");
header
}
HeaderLocation::Wrapper => "wrapper.h".into(),
HeaderLocation::FromPath(path) => path,
}
}
}
pub fn main() {
let header = find_sqlite(); let header = find_sqlite();
bindings::write_to_out_dir(header); bindings::write_to_out_dir(header, out_path);
} }
// Prints the necessary cargo link commands and returns the path to the header. // Prints the necessary cargo link commands and returns the path to the header.
@ -122,8 +144,8 @@ mod build {
Err(_) => { Err(_) => {
// No env var set and pkg-config couldn't help; just output the link-lib // No env var set and pkg-config couldn't help; just output the link-lib
// request and hope that the library exists on the system paths. We used to // request and hope that the library exists on the system paths. We used to
// output /usr/lib explicitly, but that can introduce other linking problems; see // output /usr/lib explicitly, but that can introduce other linking problems;
// https://github.com/jgallagher/rusqlite/issues/207. // see https://github.com/jgallagher/rusqlite/issues/207.
println!("cargo:rustc-link-lib={}", link_lib); println!("cargo:rustc-link-lib={}", link_lib);
HeaderLocation::Wrapper HeaderLocation::Wrapper
} }
@ -147,14 +169,6 @@ mod build {
None None
} }
fn env_prefix() -> &'static str {
if cfg!(feature = "sqlcipher") {
"SQLCIPHER"
} else {
"SQLITE3"
}
}
fn link_lib() -> &'static str { fn link_lib() -> &'static str {
if cfg!(feature = "sqlcipher") { if cfg!(feature = "sqlcipher") {
"sqlcipher" "sqlcipher"
@ -162,88 +176,84 @@ mod build {
"sqlite3" "sqlite3"
} }
} }
}
#[cfg(not(feature = "buildtime_bindgen"))] #[cfg(all(not(feature = "buildtime_bindgen"), not(feature = "bundled")))]
mod bindings { mod bindings {
use super::HeaderLocation; use super::HeaderLocation;
use std::path::Path; use std::fs;
use std::{env, fs}; use std::path::Path;
static PREBUILT_BINDGEN_PATHS: &'static [&'static str] = &[ static PREBUILT_BINDGEN_PATHS: &'static [&'static str] = &[
"bindgen-bindings/bindgen_3.6.8.rs", "bindgen-bindings/bindgen_3.6.8.rs",
#[cfg(feature = "min_sqlite_version_3_6_23")] #[cfg(feature = "min_sqlite_version_3_6_23")]
"bindgen-bindings/bindgen_3.6.23.rs", "bindgen-bindings/bindgen_3.6.23.rs",
#[cfg(feature = "min_sqlite_version_3_7_7")] #[cfg(feature = "min_sqlite_version_3_7_7")]
"bindgen-bindings/bindgen_3.7.7.rs", "bindgen-bindings/bindgen_3.7.7.rs",
]; ];
pub fn write_to_out_dir(_header: HeaderLocation) { pub fn write_to_out_dir(_header: HeaderLocation, out_path: &Path) {
let out_dir = env::var("OUT_DIR").unwrap(); let in_path = PREBUILT_BINDGEN_PATHS[PREBUILT_BINDGEN_PATHS.len() - 1];
let out_path = Path::new(&out_dir).join("bindgen.rs"); fs::copy(in_path, out_path).expect("Could not copy bindings to output directory");
let in_path = PREBUILT_BINDGEN_PATHS[PREBUILT_BINDGEN_PATHS.len() - 1]; }
fs::copy(in_path, out_path).expect("Could not copy bindings to output directory"); }
}
} #[cfg(feature = "buildtime_bindgen")]
mod bindings {
#[cfg(feature = "buildtime_bindgen")] extern crate bindgen;
mod bindings {
extern crate bindgen; use self::bindgen::callbacks::{IntKind, ParseCallbacks};
use super::HeaderLocation;
use self::bindgen::callbacks::{IntKind, ParseCallbacks};
use super::HeaderLocation; use std::fs::OpenOptions;
use std::io::Write;
use std::env; use std::path::Path;
use std::fs::OpenOptions;
use std::io::Write; #[derive(Debug)]
use std::path::Path; struct SqliteTypeChooser;
#[derive(Debug)] impl ParseCallbacks for SqliteTypeChooser {
struct SqliteTypeChooser; fn int_macro(&self, _name: &str, value: i64) -> Option<IntKind> {
if value >= i32::min_value() as i64 && value <= i32::max_value() as i64 {
impl ParseCallbacks for SqliteTypeChooser { Some(IntKind::I32)
fn int_macro(&self, _name: &str, value: i64) -> Option<IntKind> { } else {
if value >= i32::min_value() as i64 && value <= i32::max_value() as i64 { None
Some(IntKind::I32) }
} else { }
None }
}
} pub fn write_to_out_dir(header: HeaderLocation, out_path: &Path) {
} let header: String = header.into();
let mut output = Vec::new();
pub fn write_to_out_dir(header: HeaderLocation) { bindgen::builder()
let header: String = header.into(); .header(header.clone())
let out_dir = env::var("OUT_DIR").unwrap(); .parse_callbacks(Box::new(SqliteTypeChooser))
let mut output = Vec::new(); .rustfmt_bindings(true)
bindgen::builder() .generate()
.header(header.clone()) .expect(&format!("could not run bindgen on header {}", header))
.parse_callbacks(Box::new(SqliteTypeChooser)) .write(Box::new(&mut output))
.rustfmt_bindings(true) .expect("could not write output of bindgen");
.generate() let mut output = String::from_utf8(output).expect("bindgen output was not UTF-8?!");
.expect(&format!("could not run bindgen on header {}", header))
.write(Box::new(&mut output)) // rusqlite's functions feature ors in the SQLITE_DETERMINISTIC flag when it
.expect("could not write output of bindgen"); // can. This flag was added in SQLite 3.8.3, but oring it in in prior
let mut output = String::from_utf8(output).expect("bindgen output was not UTF-8?!"); // versions of SQLite is harmless. We don't want to not build just
// because this flag is missing (e.g., if we're linking against
// rusqlite's functions feature ors in the SQLITE_DETERMINISTIC flag when it can. This flag // SQLite 3.7.x), so append the flag manually if it isn't present in bindgen's
// was added in SQLite 3.8.3, but oring it in in prior versions of SQLite is harmless. We // output.
// don't want to not build just because this flag is missing (e.g., if we're linking against if !output.contains("pub const SQLITE_DETERMINISTIC") {
// SQLite 3.7.x), so append the flag manually if it isn't present in bindgen's output. output.push_str("\npub const SQLITE_DETERMINISTIC: i32 = 2048;\n");
if !output.contains("pub const SQLITE_DETERMINISTIC") { }
output.push_str("\npub const SQLITE_DETERMINISTIC: i32 = 2048;\n");
} let mut file = OpenOptions::new()
.write(true)
let path = Path::new(&out_dir).join("bindgen.rs"); .truncate(true)
.create(true)
let mut file = OpenOptions::new() .open(out_path.clone())
.write(true) .expect(&format!("Could not write to {:?}", out_path));
.truncate(true)
.create(true) file.write_all(output.as_bytes())
.open(path.clone()) .expect(&format!("Could not write to {:?}", out_path));
.expect(&format!("Could not write to {:?}", path));
file.write_all(output.as_bytes())
.expect(&format!("Could not write to {:?}", path));
}
} }
} }