Merge pull request #73 from rekka/feat-synctex

Add the --synctex command line option

Author: pkgw

src/cli_driver.rs

@@ -260,6 +260,7 @@ struct ProcessingSession {
     keep_intermediates: bool,
     keep_logs: bool,
     noted_tex_warnings: bool,
+    synctex_enabled: bool,
 }
 
 
@@ -345,6 +346,7 @@ impl ProcessingSession {
             keep_intermediates: args.is_present("keep_intermediates"),
             keep_logs: args.is_present("keep_logs"),
             noted_tex_warnings: false,
+            synctex_enabled: args.is_present("synctex"),
         })
     }
 
@@ -636,10 +638,10 @@ impl ProcessingSession {
 
         let result = {
             let mut stack = self.io.as_stack(false);
-            let mut engine = TexEngine::new();
-            engine.set_halt_on_error_mode(true);
-            engine.set_initex_mode(true);
-            engine.process(&mut stack, &mut self.events, status, "UNUSED.fmt.gz",
+            TexEngine::new()
+                    .halt_on_error_mode(true)
+                    .initex_mode(true)
+                    .process(&mut stack, &mut self.events, status, "UNUSED.fmt.gz",
                            &format!("tectonic-format-{}.tex", stem))
         };
 
@@ -697,16 +699,18 @@ impl ProcessingSession {
     fn tex_pass(&mut self, rerun_explanation: Option<&str>, status: &mut TermcolorStatusBackend) -> Result<i32> {
         let result = {
             let mut stack = self.io.as_stack(true);
-            let mut engine = TexEngine::new();
-            engine.set_halt_on_error_mode(true);
-            engine.set_initex_mode(self.output_format == OutputFormat::Format);
             if let Some(s) = rerun_explanation {
                 status.note_highlighted("Rerunning ", "TeX", &format!(" because {} ...", s));
             } else {
                 status.note_highlighted("Running ", "TeX", " ...");
             }
-            engine.process(&mut stack, &mut self.events, status,
-                           &self.format_path, &self.tex_path)
+
+            TexEngine::new()
+                    .halt_on_error_mode(true)
+                    .initex_mode(self.output_format == OutputFormat::Format)
+                    .synctex(self.synctex_enabled)
+                    .process(&mut stack, &mut self.events, status,
+                               &self.format_path, &self.tex_path)
         };
 
         match result {
@@ -848,6 +852,9 @@ fn main() {
         .arg(Arg::with_name("keep_logs")
              .long("keep-logs")
              .help("Keep the log files generated during processing."))
+        .arg(Arg::with_name("synctex")
+             .long("synctex")
+             .help("Generate SyncTeX data."))
         .arg(Arg::with_name("hide")
              .long("hide")
              .value_name("PATH")

src/engines/tex.rs

@@ -21,29 +21,48 @@ pub enum TexResult {
     Errors,
 }
 
-
+#[derive(Debug)]
 pub struct TexEngine {
     // One day, the engine will hold its own state. For the time being,
     // though, it's just a proxy for the global constants in the C code.
+
+    halt_on_error: bool,
+    initex_mode: bool,
+    synctex_enabled: bool,
 }
 
+impl Default for TexEngine {
+    fn default() -> Self {
+        TexEngine {
+            halt_on_error: true,
+            initex_mode: false,
+            synctex_enabled: false,
+        }
+    }
+}
 
 impl TexEngine {
     pub fn new () -> TexEngine {
-        TexEngine {}
+        TexEngine::default()
     }
 
-    pub fn set_halt_on_error_mode (&mut self, halt_on_error: bool) {
-        let v = if halt_on_error { 1 } else { 0 };
-        unsafe { super::tt_set_int_variable(b"halt_on_error_p\0".as_ptr(), v); }
+    pub fn halt_on_error_mode (&mut self, halt_on_error: bool) -> &mut Self {
+        self.halt_on_error = halt_on_error;
+        self
     }
 
     /// Configure the engine to run in "initex" mode, in which it generates a
     /// "format" file that serializes the engine state rather than a PDF
     /// document.
-    pub fn set_initex_mode (&mut self, initex: bool) {
-        let v = if initex { 1 } else { 0 };
-        unsafe { super::tt_set_int_variable(b"in_initex_mode\0".as_ptr(), v); }
+    pub fn initex_mode (&mut self, initex: bool) -> &mut Self {
+        self.initex_mode = initex;
+        self
+    }
+
+    /// Configure the engine to produce SyncTeX data.
+    pub fn synctex (&mut self, synctex_enabled: bool) -> &mut Self {
+        self.synctex_enabled = synctex_enabled;
+        self
     }
 
     // This function can't be generic across the IoProvider trait, for now,
@@ -60,6 +79,14 @@ impl TexEngine {
         let /*mut*/ state = ExecutionState::new(io, events, status);
         let bridge = TectonicBridgeApi::new(&state);
 
+        // initialize globals
+        let v = if self.halt_on_error { 1 } else { 0 };
+        unsafe { super::tt_set_int_variable(b"halt_on_error_p\0".as_ptr(), v); }
+        let v = if self.initex_mode { 1 } else { 0 };
+        unsafe { super::tt_set_int_variable(b"in_initex_mode\0".as_ptr(), v); }
+        let v = if self.synctex_enabled { 1 } else { 0 };
+        unsafe { super::tt_set_int_variable(b"synctex_enabled\0".as_ptr(), v); }
+
         unsafe {
             match super::tex_simple_main(&bridge, cformat.as_ptr(), cinput.as_ptr()) {
                 0 => Ok(TexResult::Spotless),

tectonic/engine-interface.c

@@ -17,6 +17,8 @@ tt_set_int_variable (char *var_name, int value)
         halt_on_error_p = value;
     else if (STREQ (var_name, "in_initex_mode"))
         in_initex_mode = (value != 0);
+    else if (STREQ (var_name, "synctex_enabled"))
+        synctex_enabled = (value != 0);
     else
         return 1; /* Uh oh: unrecognized variable */
 

tectonic/synctex.c

@@ -151,7 +151,11 @@ synctex_init_command(void)
     synctex_ctxt.flags.warn = 0;
     synctex_ctxt.flags.output_p = 0;
 
-    INTPAR(synctex) = 0; /* \synctex=0 : don't record stuff */
+    if (synctex_enabled) {
+        INTPAR(synctex) = 1;
+    } else {
+        INTPAR(synctex) = 0; /* \synctex=0 : don't record stuff */
+    }
 }
 
 
@@ -233,10 +237,11 @@ synctex_dot_open(void)
                             + 1);
     strcpy(the_name, tmp);
     strcat(the_name, synctex_suffix);
+    strcat(the_name, synctex_suffix_gz);
     free(tmp);
     tmp = NULL;
 
-    synctex_ctxt.file = ttstub_output_open(the_name, 0);
+    synctex_ctxt.file = ttstub_output_open(the_name, 1);
     if (synctex_ctxt.file == NULL)
         goto fail;
 

tectonic/xetexd.h

@@ -687,6 +687,7 @@ scaled base_x_height;
 scaled base_width, base_height;
 scaled accent_width, accent_height;
 scaled delta;
+int synctex_enabled;
 
 /*:1683*/
 

tests/formats.rs

@@ -111,10 +111,10 @@ fn test_format_generation(subdir: &str, texname: &str, fmtname: &str, sha256: &s
             ])
         };
 
-        let mut e = TexEngine::new();
-        e.set_initex_mode(true);
-        e.process(&mut io, &mut events,
-                  &mut NoopStatusBackend::new(), "unused.fmt.gz", texname).unwrap();
+        TexEngine::new()
+            .initex_mode(true)
+            .process(&mut io, &mut events,
+                      &mut NoopStatusBackend::new(), "unused.fmt.gz", texname).unwrap();
     }
 
     // Did we get what we expected?

tests/tex-outputs.rs

@@ -1,9 +1,11 @@
 // Copyright 2016-2017 the Tectonic Project
 // Licensed under the MIT License.
 
+extern crate flate2;
 #[macro_use] extern crate lazy_static;
 extern crate tectonic;
 
+use flate2::read::GzDecoder;
 use std::collections::HashSet;
 use std::ffi::OsStr;
 use std::fs::File;
@@ -44,11 +46,11 @@ fn set_up_format_file(tests_dir: &Path) -> Result<SingleInputFileIo> {
                 &mut fs,
             ]);
 
-            let mut e = TexEngine::new();
-            e.set_halt_on_error_mode(true);
-            e.set_initex_mode(true);
-            e.process(&mut io, &mut NoopIoEventBackend::new(),
-                      &mut NoopStatusBackend::new(), "UNUSED.fmt.gz", "plain.tex")?;
+            TexEngine::new()
+                .halt_on_error_mode(true)
+                .initex_mode(true)
+                .process(&mut io, &mut NoopIoEventBackend::new(),
+                          &mut NoopStatusBackend::new(), "UNUSED.fmt.gz", "plain.tex")?;
         }
 
         let mut fmt_file = File::create(&fmt_path)?;
@@ -131,10 +133,9 @@ fn do_one(stem: &str, check_synctex: bool) {
             &mut tex,
             &mut fmt,
         ]);
-        let mut e = TexEngine::new();
-        e.set_initex_mode(false); // TODO: this shouldn't be necessary
-        e.process(&mut io, &mut NoopIoEventBackend::new(),
-                  &mut NoopStatusBackend::new(), "plain.fmt.gz", &texname).unwrap();
+        TexEngine::new()
+            .process(&mut io, &mut NoopIoEventBackend::new(),
+                      &mut NoopStatusBackend::new(), "plain.fmt.gz", &texname).unwrap();
     }
 
     // Check that log and xdv match expectations.
@@ -148,11 +149,16 @@ fn do_one(stem: &str, check_synctex: bool) {
     test_file(&xdvname, &expected_xdv, observed_xdv);
 
     if check_synctex {
-        p.set_extension("synctex");
-        let expected_synctex = read_file(&p);
+        p.set_extension("synctex.gz");
+        // Gzipped files seem to be platform dependent and so we decompress them first.
+        let mut expected_synctex = Vec::new();
+        GzDecoder::new(File::open(&p).unwrap()).unwrap()
+            .read_to_end(&mut expected_synctex).unwrap();
         let synctexname = p.file_name().unwrap().to_owned();
-        let observed_synctex = files.get(&synctexname).unwrap();
-        test_file(&synctexname, &expected_synctex, observed_synctex);
+        let mut observed_synctex = Vec::new();
+        GzDecoder::new(&files.get(&synctexname).unwrap()[..]).unwrap()
+            .read_to_end(&mut observed_synctex).unwrap();
+        test_file(&synctexname, &expected_synctex, &observed_synctex);
     }
 }
 

tests/tex-outputs/synctex.synctex

@@ -118,11 +118,11 @@ fn trip_test() {
             &mut tex,
             &mut tfm,
         ]);
-        let mut e = TexEngine::new();
-        e.set_halt_on_error_mode(false);
-        e.set_initex_mode(true);
-        e.process(&mut io, &mut NoopIoEventBackend::new(),
-                  &mut NoopStatusBackend::new(), "INITEX", "trip").unwrap();
+        TexEngine::new()
+            .halt_on_error_mode(false)
+            .initex_mode(true)
+            .process(&mut io, &mut NoopIoEventBackend::new(),
+                      &mut NoopStatusBackend::new(), "INITEX", "trip").unwrap();
     }
 
     // Second pass -- process it
@@ -132,11 +132,11 @@ fn trip_test() {
             &mut tex,
             &mut tfm,
         ]);
-        let mut e = TexEngine::new();
-        e.set_halt_on_error_mode(false);
-        e.set_initex_mode(false);
-        e.process(&mut io, &mut NoopIoEventBackend::new(),
-                  &mut NoopStatusBackend::new(), "trip.fmt.gz", "trip").unwrap();
+        TexEngine::new()
+            .halt_on_error_mode(false)
+            .initex_mode(false)
+            .process(&mut io, &mut NoopIoEventBackend::new(),
+                      &mut NoopStatusBackend::new(), "trip.fmt.gz", "trip").unwrap();
     }
 
     // Check that outputs match expectations.
@@ -183,11 +183,11 @@ fn etrip_test() {
             &mut tex,
             &mut tfm,
         ]);
-        let mut e = TexEngine::new();
-        e.set_halt_on_error_mode(false);
-        e.set_initex_mode(true);
-        e.process(&mut io, &mut NoopIoEventBackend::new(),
-                  &mut NoopStatusBackend::new(), "INITEX", "etrip").unwrap();
+        TexEngine::new()
+            .halt_on_error_mode(false)
+            .initex_mode(true)
+            .process(&mut io, &mut NoopIoEventBackend::new(),
+                      &mut NoopStatusBackend::new(), "INITEX", "etrip").unwrap();
     }
 
     // Second pass -- process it
@@ -197,11 +197,11 @@ fn etrip_test() {
             &mut tex,
             &mut tfm,
         ]);
-        let mut e = TexEngine::new();
-        e.set_halt_on_error_mode(false);
-        e.set_initex_mode(false);
-        e.process(&mut io, &mut NoopIoEventBackend::new(),
-                  &mut NoopStatusBackend::new(), "etrip.fmt.gz", "etrip").unwrap();
+        TexEngine::new()
+            .halt_on_error_mode(false)
+            .initex_mode(false)
+            .process(&mut io, &mut NoopIoEventBackend::new(),
+                      &mut NoopStatusBackend::new(), "etrip.fmt.gz", "etrip").unwrap();
     }
 
     // Check that outputs match expectations.