Fix building under windows-gnu target.

Author: crlf0710

Cargo.lock

@@ -47,7 +47,7 @@ fs2 = "^0.4"
 hyper = "^0.10"
 hyper-native-tls = "^0.2"
 libc = "^0.2"
-mkstemp-rs = "^1.0.0"
+tempfile = "^3.0"
 md-5 = "^0.7"
 sha2 = "^0.7"
 serde = "^1.0"

Cargo.toml

@@ -16,7 +16,6 @@ use std::collections::{HashMap, HashSet};
 use std::ffi::{OsStr, OsString};
 use std::fs::File;
 use std::io::Write;
-use std::os::unix::ffi::OsStrExt;
 use std::path::{Path, PathBuf};
 
 use digest::DigestData;
@@ -593,7 +592,7 @@ impl ProcessingSession {
             ctry!(write!(mf_dest, ": "); "couldn't write to Makefile-rules file");
 
             if let Some(ref pip) = self.primary_input_path {
-                ctry!(mf_dest.write_all(pip.as_os_str().as_bytes()); "couldn't write to Makefile-rules file");
+                ctry!(mf_dest.write_all(pip.to_string_lossy().as_ref().as_bytes()); "couldn't write to Makefile-rules file");
             }
 
             for (name, info) in &self.events.0 {

src/driver.rs

@@ -18,9 +18,9 @@ use md5::{Md5, Digest};
 use libc;
 use std::ffi::{CStr, OsStr, OsString};
 use std::io::{Read, SeekFrom, Write};
-use std::os::unix::ffi::OsStrExt;
 use std::path::Path;
 use std::{io, ptr, slice};
+use std::borrow::Cow;
 
 use digest::DigestData;
 use errors::{Error, ErrorKind, Result};
@@ -41,6 +41,16 @@ pub use self::tex::TexEngine;
 pub use self::xdvipdfmx::XdvipdfmxEngine;
 
 
+#[cfg(unix)]
+fn osstr_from_cstr(s: &CStr) -> Cow<OsStr> {
+	use std::os::unix::ffi::OsStrExt;
+	OsStr::from_bytes(s.to_bytes()).into()
+}
+#[cfg(windows)]
+fn osstr_from_cstr(s: &CStr) -> Cow<OsStr> {
+	Cow::Owned(OsString::from(s.to_string_lossy().to_owned().to_string()))
+}
+
 // Now, the public API.
 
 /// The IoEventBackend trait allows the program driving the TeX engines to
@@ -478,10 +488,10 @@ fn issue_error<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, text: *co
 
 fn get_file_md5<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, path: *const libc::c_char, digest: *mut u8) -> libc::c_int {
     let es = unsafe { &mut *es };
-    let rpath = OsStr::from_bytes(unsafe { CStr::from_ptr(path) }.to_bytes());
+    let rpath = osstr_from_cstr(unsafe { CStr::from_ptr(path) });
     let rdest = unsafe { slice::from_raw_parts_mut(digest, 16) };
 
-    if es.get_file_md5(rpath, rdest) {
+    if es.get_file_md5(rpath.as_ref(), rdest) {
         1
     } else {
         0
@@ -503,7 +513,7 @@ fn get_data_md5<'a, I: 'a + IoProvider>(_es: *mut ExecutionState<'a, I>, data: *
 
 fn output_open<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, name: *const libc::c_char, is_gz: libc::c_int) -> *const libc::c_void {
     let es = unsafe { &mut *es };
-    let rname = OsStr::from_bytes(unsafe { CStr::from_ptr(name) }.to_bytes());
+    let rname = osstr_from_cstr(&unsafe { CStr::from_ptr(name) });
     let ris_gz = is_gz != 0;
 
     es.output_open(&rname, ris_gz) as *const _
@@ -571,7 +581,7 @@ fn output_close<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle:
 
 fn input_open<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, name: *const libc::c_char, format: libc::c_int, is_gz: libc::c_int) -> *const libc::c_void {
     let es = unsafe { &mut *es };
-    let rname = OsStr::from_bytes(unsafe { CStr::from_ptr(name) }.to_bytes());
+    let rname = osstr_from_cstr(unsafe { CStr::from_ptr(name) });
     let rformat = c_format_to_rust(format);
     let ris_gz = is_gz != 0;
 

src/engines/mod.rs

@@ -5,7 +5,7 @@
 
 //! Code for locally caching compiled format files.
 
-use mkstemp;
+use tempfile;
 use std::ffi::{OsStr};
 use std::fs;
 use std::io::{BufReader, Write};
@@ -82,15 +82,15 @@ impl IoProvider for FormatCache {
     fn write_format(&mut self, name: &str, data: &[u8], _status: &mut StatusBackend) -> Result<()> {
         let final_path = self.path_for_format(OsStr::new(name))?;
 
-        let mut templ = self.formats_base.clone();
-        templ.push("format_XXXXXX");
+		let mut temp_dest = tempfile::Builder::new()
+			.prefix("format_")
+			.rand_bytes(6)
+			.tempfile_in(&self.formats_base)?;
 
-        let temp_path = {
-            let mut temp_dest = mkstemp::TempFile::new(&templ.to_string_lossy(), false)?;
-            temp_dest.write_all(data)?;
-            temp_dest.path().to_owned()
-        };
-
-        fs::rename(&temp_path, &final_path).map_err(|e| e.into())
+		temp_dest.write_all(data)?;
+		
+		temp_dest.persist(&final_path).map_err(|e| e.error)?;
+		
+		Ok(())
     }
 }

src/io/format_cache.rs

@@ -3,7 +3,7 @@
 // Licensed under the MIT License.
 
 use fs2::FileExt;
-use mkstemp;
+use tempfile;
 use std::collections::HashMap;
 use std::ffi::{OsStr, OsString};
 use std::fs::{self, File};
@@ -257,34 +257,30 @@ impl<B: Bundle> LocalCache<B> {
         let mut digest_builder = digest::create();
         let mut length = 0;
 
-        let temp_path = {
-            let mut templ = self.data_path.clone();
-            templ.push("download_XXXXXX");
-
-            let mut temp_dest = match mkstemp::TempFile::new(&templ.to_string_lossy(), false) {
-                Ok(f) => f,
-                Err(e) => return OpenResult::Err(e.into()),
-            };
-
-            let mut buf = [0u8; 8192];
-
-            while let Ok(nbytes) = stream.read(&mut buf) {
-                if nbytes == 0 {
-                    break;
-                }
+		let mut temp_dest = match tempfile::Builder::new()
+			.prefix("download_")
+			.rand_bytes(6)
+			.tempfile_in(&self.data_path) {
+			Ok(f) => f,
+            Err(e) => return OpenResult::Err(e.into()),
+		};
 
-                length += nbytes;
-                let chunk = &buf[..nbytes];
+		let mut buf = [0u8; 8192];
 
-                digest_builder.input(chunk);
-                if let Err(e) = temp_dest.write_all(chunk) {
-                    return OpenResult::Err(e.into());
-                }
-            }
+		while let Ok(nbytes) = stream.read(&mut buf) {
+			if nbytes == 0 {
+				break;
+			}
 
-            temp_dest.path().to_owned()
-        };
+			length += nbytes;
+			let chunk = &buf[..nbytes];
 
+			digest_builder.input(chunk);
+			if let Err(e) = temp_dest.write_all(chunk) {
+				return OpenResult::Err(e.into());
+			}
+		}
+		
         let digest = DigestData::from(digest_builder);
 
         // Now we can move it to its final destination ..
@@ -294,9 +290,9 @@ impl<B: Bundle> LocalCache<B> {
             Err(e) => return OpenResult::Err(e.into()),
         };
 
-        if let Err(e) = fs::rename(&temp_path, &final_path) {
-            return OpenResult::Err(e.into());
-        }
+		if let Err(e) = temp_dest.persist(&final_path) {
+			return OpenResult::Err(e.error.into());
+		};
 
         // Make the file readonly once it's at its final path.
         // XXX: It would be better to set these using the already-open file handle owned by the

src/io/local_cache.rs

@@ -41,7 +41,7 @@ extern crate hyper;
 extern crate hyper_native_tls;
 extern crate libc;
 extern crate md5;
-extern crate mkstemp;
+extern crate tempfile;
 #[macro_use] extern crate serde_derive;
 extern crate serde;
 extern crate sha2;

src/lib.rs

@@ -79,6 +79,10 @@ extern "C" {
 
 #ifdef _WIN32
 /* MS compiler has predefined _WIN32, so assume Windows target  */
+#ifdef INPUT
+#undef INPUT
+#endif
+
 #include <windows.h>
 #undef WINAPI
 #define WINAPI

tectonic/TECkit_Engine.h

@@ -39,6 +39,10 @@ authorization from the copyright holders.
 #include "xetex-core.h"
 #include "XeTeX_ext.h"
 
+#ifndef M_PI
+#define M_PI 3.14159265358979323846264338327950288
+#endif
+
 BEGIN_EXTERN_C
 
 void print_nl(int s);

tectonic/XeTeX_web.h

@@ -1,6 +1,9 @@
 #include "bibtex.h"
 #include "internals.h"
 
+/* hack: the name eof conflicts with other function declarations under mingw. */
+#define eof tectonic_eof
+
 /* (Re)Allocate N items of type T using xmalloc/xrealloc.  */
 #define XTALLOC(n, t) (xmalloc ((n) * sizeof (t)))