Add Windows support

.cargo/config

@@ -1,4 +1,8 @@
-[build]
 # Informs the linker that some of the symbols for Postgres won't be available
-# until runtime on the dynamic library load.
+# until runtime on the dynamic library load. Flags differ based on target family
+
+[target.'cfg(unix)']
 rustflags = "-C link-arg=-undefineddynamic_lookup"
+
+[target.'cfg(windows)']
+rustflags = "-C link-arg=/FORCE"

README.md

@@ -31,8 +31,11 @@ First install Postgres. The build should be able to find the directory for the P
 For the dynamic library to compile, your project should also have `.cargo/config` file with content:
 
 ```toml
-[build]
+[target.'cfg(unix)']
 rustflags = "-C link-arg=-undefineddynamic_lookup"
+
+[target.'cfg(windows)']
+rustflags = "-C link-arg=/FORCE"
 ```
 
 This informs the linker that some of the symbols for Postgres won't be available until runtime on the dynamic library load.

pg-extend/build.rs

@@ -38,8 +38,7 @@ fn main() {
         .collect(),
     );
 
-    let bindings = bindgen::Builder::default()
-        .clang_arg(format!("-I{}", pg_include))
+    let bindings = get_bindings(&pg_include) // Gets initial bindings that are OS-dependant
         // The input header we would like to generate
         // bindings for.
         .header("wrapper.h")
@@ -63,6 +62,95 @@ fn main() {
     println!("cargo:rustc-cfg=feature=\"{}\"", feature_version);
 }
 
+#[cfg(windows)]
+fn get_bindings(pg_include: &str) -> bindgen::Builder {
+    // Compilation in windows requires these extra inclde paths
+    let pg_include_win32_msvc = format!("{}\\port\\win32_msvc", pg_include);
+    let pg_include_win32 = format!("{}\\port\\win32", pg_include);
+    // The `pg_include` path comes in the format og "includes/server", but we also need
+    // the parent folder, so we remove the "/server" part at the end
+    let pg_include_parent = pg_include[..(pg_include.len() - 7)].to_owned();
+
+    bindgen::Builder::default()
+        .clang_arg(format!("-I{}", pg_include_win32_msvc))
+        .clang_arg(format!("-I{}", pg_include_win32))
+        .clang_arg(format!("-I{}", pg_include))
+        .clang_arg(format!("-I{}", pg_include_parent))
+        // Whitelist all PG-related functions
+        .whitelist_function("pg.*")
+        // Whitelist used functions
+        .whitelist_function("longjmp")
+        .whitelist_function("_setjmp")
+        .whitelist_function("cstring_to_text")
+        .whitelist_function("text_to_cstring")
+        .whitelist_function("errmsg")
+        .whitelist_function("errstart")
+        .whitelist_function("errfinish")
+        .whitelist_function("pfree")
+        // Whitelist all PG-related types
+        .whitelist_type("PG.*")
+        // Whitelist used types
+        .whitelist_type("jmp_buf")
+        .whitelist_type("text")
+        .whitelist_type("varattrib_1b")
+        .whitelist_type("varattrib_4b")
+        // Whitelist PG-related values
+        .whitelist_var("PG.*")
+        // Whitelist log-level values
+        .whitelist_var("DEBUG.*")
+        .whitelist_var("LOG.*")
+        .whitelist_var("INFO")
+        .whitelist_var("NOTICE")
+        .whitelist_var("WARNING")
+        .whitelist_var("ERROR")
+        .whitelist_var("FATAL")
+        .whitelist_var("PANIC")
+        // Whitelist misc values
+        .whitelist_var("CurrentMemoryContext")
+        .whitelist_var("FUNC_MAX_ARGS")
+        .whitelist_var("INDEX_MAX_KEYS")
+        .whitelist_var("NAMEDATALEN")
+        .whitelist_var("USE_FLOAT.*")
+
+        // FDW whitelisting
+        .whitelist_function("pstrdup")
+        .whitelist_function("lappend")
+        .whitelist_function("makeTargetEntry")
+        .whitelist_function("makeVar")
+        .whitelist_function("ExecStoreTuple")
+        .whitelist_function("heap_form_tuple")
+        .whitelist_function("ExecClearTuple")
+        .whitelist_function("slot_getallattrs")
+        .whitelist_function("get_rel_name")
+        .whitelist_function("GetForeignTable")
+        .whitelist_function("make_foreignscan")
+        .whitelist_function("extract_actual_clauses")
+        .whitelist_function("add_path")
+        .whitelist_function("create_foreignscan_path")
+        .whitelist_type("ImportForeignSchemaStmt")
+        .whitelist_type("ResultRelInfo")
+        .whitelist_type("EState")
+        .whitelist_type("ModifyTableState")
+        .whitelist_type("Relation")
+        .whitelist_type("RangeTblEntry")
+        .whitelist_type("Query")
+        .whitelist_type("ForeignScanState")
+        .whitelist_type("InvalidBuffer")
+        .whitelist_type("RelationData")
+        .whitelist_type("ForeignScan")
+        .whitelist_type("Plan")
+        .whitelist_type("ForeignPath")
+        .whitelist_type("RelOptInfo")
+        .whitelist_type("Form_pg_attribute")
+        .whitelist_var("InvalidBuffer")
+}
+
+#[cfg(unix)]
+fn get_bindings(pg_include: &str) -> bindgen::Builder {
+    bindgen::Builder::default()
+        .clang_arg(format!("-I{}", pg_include))
+}
+
 fn include_dir() -> Result<String, env::VarError> {
     env::var("PG_INCLUDE_PATH").or_else(|err| {
         match Command::new("pg_config")

pg-extend/src/lib.rs

@@ -122,7 +122,7 @@ pub fn register_panic_handler() {
 
             // the panic came from a pg longjmp... so unwrap it and rethrow
             unsafe {
-                pg_sys::siglongjmp(
+                pg_sys_longjmp(
                     pg_sys::PG_exception_stack as *mut _,
                     panic_context.jump_value,
                 );
@@ -136,6 +136,16 @@ pub fn register_panic_handler() {
     }));
 }
 
+#[cfg(windows)]
+unsafe fn pg_sys_longjmp(_buf: *mut pg_sys::_JBTYPE, _value: ::std::os::raw::c_int) {
+    pg_sys::longjmp(_buf, _value);
+}
+
+#[cfg(unix)]
+unsafe fn pg_sys_longjmp(_buf: *mut pg_sys::_JBTYPE, _value: ::std::os::raw::c_int) {
+    pg_sys::siglongjmp(_buf, _value);
+}
+
 /// Provides a barrier between Rust and Postgres' usage of the C set/longjmp
 ///
 /// In the case of a longjmp being caught, this will convert that to a panic. For this to work
@@ -144,6 +154,7 @@ pub fn register_panic_handler() {
 ///   this is already handled.
 ///
 /// See the man pages for info on setjmp http://man7.org/linux/man-pages/man3/setjmp.3.html
+#[cfg(unix)]
 #[inline(never)]
 pub(crate) unsafe fn guard_pg<R, F: FnOnce() -> R>(f: F) -> R {
     // setup the check protection
@@ -179,6 +190,49 @@ pub(crate) unsafe fn guard_pg<R, F: FnOnce() -> R>(f: F) -> R {
     result
 }
 
+/// Provides a barrier between Rust and Postgres' usage of the C set/longjmp
+///
+/// In the case of a longjmp being caught, this will convert that to a panic. For this to work
+///   properly, there must be a Rust panic handler (see crate::register_panic_handler).PanicContext
+///   If the `pg_exern` attribute macro is used for exposing Rust functions to Postgres, then
+///   this is already handled.
+///
+/// See the man pages for info on setjmp http://man7.org/linux/man-pages/man3/setjmp.3.html
+#[cfg(windows)]
+#[inline(never)]
+pub(crate) unsafe fn guard_pg<R, F: FnOnce() -> R>(f: F) -> R {
+    // setup the check protection
+    let original_exception_stack: *mut pg_sys::jmp_buf = pg_sys::PG_exception_stack;
+    let mut local_exception_stack: mem::MaybeUninit<pg_sys::jmp_buf> =
+        mem::MaybeUninit::uninit();
+    let jumped = pg_sys::_setjmp(
+        // grab a mutable reference, cast to a mutabl pointr, then case to the expected erased pointer type
+        local_exception_stack.as_mut_ptr() as *mut pg_sys::jmp_buf as *mut _,
+    );
+    // now that we have the local_exception_stack, we set that for any PG longjmps...
+
+    if jumped != 0 {
+        notice!("PG longjmped: {}", jumped);
+        pg_sys::PG_exception_stack = original_exception_stack;
+
+        // The C Panicked!, handling control to Rust Panic handler
+        compiler_fence(Ordering::SeqCst);
+        panic!(JumpContext { jump_value: jumped });
+    }
+
+    // replace the exception stack with ours to jump to the above point
+    pg_sys::PG_exception_stack = local_exception_stack.as_mut_ptr() as *mut _;
+
+    // enforce that the setjmp is not reordered, though that's probably unlikely...
+    compiler_fence(Ordering::SeqCst);
+    let result = f();
+
+    compiler_fence(Ordering::SeqCst);
+    pg_sys::PG_exception_stack = original_exception_stack;
+
+    result
+}
+
 /// auto generate function to output a SQL create statement for the function
 ///
 /// Until concat_ident! stabilizes, this requires the name to passed with the appended sctring
@@ -214,6 +268,9 @@ macro_rules! pg_create_stmt_bin {
         #[cfg(target_os = "macos")]
         const DYLIB_EXT: &str = "dylib";
 
+        #[cfg(target_os = "windows")]
+        const DYLIB_EXT: &str = "dll";
+
         fn main() {
             const LIB_NAME: &str = env!("CARGO_PKG_NAME");