Merge pull request #91 from rekka/fix-63

pkgw · web-flow · commit 7f3326e0e35d · 2018-09-10T05:33:19.000-07:00
Fix #63: do not panic into C
diff --git a/src/engines/mod.rs b/src/engines/mod.rs
@@ -383,15 +383,9 @@ impl<'a, I: 'a + IoProvider> ExecutionState<'a, I> {
         }
     }
 
-    fn input_seek(&mut self, handle: *mut InputHandle, pos: SeekFrom) -> u64 {
+    fn input_seek(&mut self, handle: *mut InputHandle, pos: SeekFrom) -> Result<u64> {
         let rhandle: &mut InputHandle = unsafe { &mut *handle };
-        match rhandle.try_seek(pos) {
-            Ok(pos) => pos,
-            Err(e) => {
-                tt_warning!(self.status, "input seek failed"; e);
-                0
-            }
-        }
+        rhandle.try_seek(pos)
     }
 
     fn input_read(&mut self, handle: *mut InputHandle, buf: &mut [u8]) -> Result<()> {
@@ -422,8 +416,10 @@ impl<'a, I: 'a + IoProvider> ExecutionState<'a, I> {
                 return false;
             }
         }
+        // TODO: Handle the error better. This indicates a bug in the engine.
+        tt_error!(self.status, "serious internal bug: unexpected handle in input close: {:?}", handle);
 
-        panic!("unexpected handle {:?}", handle);
+        true
     }
 }
 
@@ -472,21 +468,21 @@ extern {
 
 // Entry points for the C/C++ API functions.
 
-fn issue_warning<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, text: *const libc::c_char) {
+extern fn issue_warning<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, text: *const libc::c_char) {
     let es = unsafe { &mut *es };
     let rtext = unsafe { CStr::from_ptr(text) };
 
     tt_warning!(es.status, "{}", rtext.to_string_lossy());
 }
 
-fn issue_error<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, text: *const libc::c_char) {
+extern fn issue_error<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, text: *const libc::c_char) {
     let es = unsafe { &mut *es };
     let rtext = unsafe { CStr::from_ptr(text) };
 
     tt_error!(es.status, "{}", rtext.to_string_lossy());
 }
 
-fn get_file_md5<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, path: *const libc::c_char, digest: *mut u8) -> libc::c_int {
+extern 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_cstr(unsafe { CStr::from_ptr(path) });
     let rdest = unsafe { slice::from_raw_parts_mut(digest, 16) };
@@ -498,7 +494,7 @@ fn get_file_md5<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, path: *c
     }
 }
 
-fn get_data_md5<'a, I: 'a + IoProvider>(_es: *mut ExecutionState<'a, I>, data: *const u8, len: libc::size_t, digest: *mut u8) -> libc::c_int {
+extern fn get_data_md5<'a, I: 'a + IoProvider>(_es: *mut ExecutionState<'a, I>, data: *const u8, len: libc::size_t, digest: *mut u8) -> libc::c_int {
     //let es = unsafe { &mut *es };
     let rdata = unsafe { slice::from_raw_parts(data, len) };
     let rdest = unsafe { slice::from_raw_parts_mut(digest, 16) };
@@ -511,21 +507,21 @@ fn get_data_md5<'a, I: 'a + IoProvider>(_es: *mut ExecutionState<'a, I>, data: *
     0
 }
 
-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 {
+extern 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_cstr(&unsafe { CStr::from_ptr(name) });
     let ris_gz = is_gz != 0;
 
     es.output_open(&rname, ris_gz) as *const _
 }
 
-fn output_open_stdout<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, ) -> *const libc::c_void {
+extern fn output_open_stdout<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, ) -> *const libc::c_void {
     let es = unsafe { &mut *es };
 
     es.output_open_stdout() as *const _
 }
 
-fn output_putc<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void, c: libc::c_int) -> libc::c_int {
+extern fn output_putc<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void, c: libc::c_int) -> libc::c_int {
     let es = unsafe { &mut *es };
     let rhandle = handle as *mut OutputHandle;
     let rc = c as u8;
@@ -537,7 +533,7 @@ fn output_putc<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *
     }
 }
 
-fn output_write<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void, data: *const u8, len: libc::size_t) -> libc::size_t {
+extern fn output_write<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void, data: *const u8, len: libc::size_t) -> libc::size_t {
     let es = unsafe { &mut *es };
     let rhandle = handle as *mut OutputHandle;
     let rdata = unsafe { slice::from_raw_parts(data, len) };
@@ -551,7 +547,7 @@ fn output_write<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle:
     }
 }
 
-fn output_flush<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void) -> libc::c_int {
+extern fn output_flush<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void) -> libc::c_int {
     let es = unsafe { &mut *es };
     let rhandle = handle as *mut OutputHandle;
 
@@ -562,7 +558,7 @@ fn output_flush<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle:
     }
 }
 
-fn output_close<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void) -> libc::c_int {
+extern fn output_close<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void) -> libc::c_int {
     let es = unsafe { &mut *es };
 
     if handle == 0 as *mut _ {
@@ -579,7 +575,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 {
+extern 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_cstr(unsafe { CStr::from_ptr(name) });
     let rformat = c_format_to_rust(format);
@@ -593,34 +589,48 @@ fn input_open<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, name: *con
     }
 }
 
-fn input_open_primary<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>) -> *const libc::c_void {
+extern fn input_open_primary<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>) -> *const libc::c_void {
     let es = unsafe { &mut *es };
 
     es.input_open_primary() as *const _
 }
 
-fn input_get_size<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void) -> libc::size_t {
+extern fn input_get_size<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void) -> libc::size_t {
     let es = unsafe { &mut *es };
     let rhandle = handle as *mut InputHandle;
 
     es.input_get_size(rhandle)
 }
 
-fn input_seek<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void, offset: libc::ssize_t, whence: libc::c_int) -> libc::size_t {
+extern fn input_seek<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void, offset: libc::ssize_t, whence: libc::c_int, internal_error: *mut libc::c_int) -> libc::size_t {
     let es = unsafe { &mut *es };
     let rhandle = handle as *mut InputHandle;
 
     let rwhence = match whence {
         libc::SEEK_SET => SeekFrom::Start(offset as u64),
         libc::SEEK_CUR => SeekFrom::Current(offset as i64),
         libc::SEEK_END => SeekFrom::End(offset as i64),
-        _ => panic!("Unexpected \"whence\" parameter to fseek() wrapper: {}", whence),
+        _ => {
+                tt_error!(es.status, "serious internal bug: unexpected \"whence\" parameter to fseek() wrapper: {}",
+                            whence);
+                unsafe {
+                    *internal_error = 1;
+                }
+                return 0;
+        }
     };
 
-    es.input_seek(rhandle, rwhence) as libc::size_t
+    match es.input_seek(rhandle, rwhence) {
+        Ok(pos) => pos as libc::size_t,
+        Err(e) => {
+            // TODO: Handle the error better. Report the error properly to the caller?
+            tt_error!(es.status, "input seek failed"; e);
+            0
+        }
+    }
 }
 
-fn input_getc<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void) -> libc::c_int {
+extern fn input_getc<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void) -> libc::c_int {
     let es = unsafe { &mut *es };
     let rhandle = handle as *mut InputHandle;
 
@@ -637,7 +647,7 @@ fn input_getc<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *m
     }
 }
 
-fn input_ungetc<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void, ch: libc::c_int) -> libc::c_int {
+extern fn input_ungetc<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void, ch: libc::c_int) -> libc::c_int {
     let es = unsafe { &mut *es };
     let rhandle = handle as *mut InputHandle;
 
@@ -650,7 +660,7 @@ fn input_ungetc<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle:
     }
 }
 
-fn input_read<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void, data: *mut u8, len: libc::size_t) -> libc::ssize_t {
+extern fn input_read<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void, data: *mut u8, len: libc::size_t) -> libc::ssize_t {
     let es = unsafe { &mut *es };
     let rhandle = handle as *mut InputHandle;
     let rdata = unsafe { slice::from_raw_parts_mut(data, len) };
@@ -664,7 +674,7 @@ fn input_read<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *m
     }
 }
 
-fn input_close<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void) -> libc::c_int {
+extern fn input_close<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle: *mut libc::c_void) -> libc::c_int {
     let es = unsafe { &mut *es };
 
     if handle == 0 as *mut _ {
diff --git a/tectonic/core-bridge.c b/tectonic/core-bridge.c
@@ -220,7 +220,13 @@ ttstub_input_get_size(rust_input_handle_t handle)
 size_t
 ttstub_input_seek(rust_input_handle_t handle, ssize_t offset, int whence)
 {
-    return TGB->input_seek(TGB->context, handle, offset, whence);
+    int internal_error = 0;
+    size_t rv = TGB->input_seek(TGB->context, handle, offset, whence, &internal_error);
+    if (internal_error) {
+        // Nonzero indicates a serious internal error.
+        longjmp(jump_buffer, 1);
+    }
+    return rv;
 }
 
 ssize_t
@@ -244,5 +250,9 @@ ttstub_input_ungetc(rust_input_handle_t handle, int ch)
 int
 ttstub_input_close(rust_input_handle_t handle)
 {
-    return TGB->input_close(TGB->context, handle);
+    if (TGB->input_close(TGB->context, handle)) {
+        // Nonzero return value indicates a serious internal error.
+        longjmp(jump_buffer, 1);
+    }
+    return 0;
 }
diff --git a/tectonic/core-bridge.h b/tectonic/core-bridge.h
@@ -68,7 +68,7 @@ typedef struct tt_bridge_api_t {
     rust_input_handle_t (*input_open)(void *context, char const *path, tt_input_format_type format, int is_gz);
     rust_input_handle_t (*input_open_primary)(void *context);
     size_t (*input_get_size)(void *context, rust_input_handle_t handle);
-    size_t (*input_seek)(void *context, rust_input_handle_t handle, ssize_t offset, int whence);
+    size_t (*input_seek)(void *context, rust_input_handle_t handle, ssize_t offset, int whence, int* internal_error);
     ssize_t (*input_read)(void *context, rust_input_handle_t handle, char *data, size_t len);
     int (*input_getc)(void *context, rust_input_handle_t handle);
     int (*input_ungetc)(void *context, rust_input_handle_t handle, int ch);

Original file line number	Diff line number	Diff line change
`@@ -383,15 +383,9 @@ impl<'a, I: 'a + IoProvider> ExecutionState<'a, I> {`
`383`	`383`	`}`
`384`	`384`	`}`
`385`	`385`
`386`		`- fn input_seek(&mut self, handle: *mut InputHandle, pos: SeekFrom) -> u64 {`
	`386`	`+ fn input_seek(&mut self, handle: *mut InputHandle, pos: SeekFrom) -> Result<u64> {`
`387`	`387`	`let rhandle: &mut InputHandle = unsafe { &mut *handle };`
`388`		`- match rhandle.try_seek(pos) {`
`389`		`- Ok(pos) => pos,`
`390`		`- Err(e) => {`
`391`		`- tt_warning!(self.status, "input seek failed"; e);`
`392`		`- 0`
`393`		`- }`
`394`		`- }`
	`388`	`+ rhandle.try_seek(pos)`
`395`	`389`	`}`
`396`	`390`
`397`	`391`	`fn input_read(&mut self, handle: *mut InputHandle, buf: &mut [u8]) -> Result<()> {`
`@@ -422,8 +416,10 @@ impl<'a, I: 'a + IoProvider> ExecutionState<'a, I> {`
`422`	`416`	`return false;`
`423`	`417`	`}`
`424`	`418`	`}`
	`419`	`+ // TODO: Handle the error better. This indicates a bug in the engine.`
	`420`	`+ tt_error!(self.status, "serious internal bug: unexpected handle in input close: {:?}", handle);`
`425`	`421`
`426`		`- panic!("unexpected handle {:?}", handle);`
	`422`	`+ true`
`427`	`423`	`}`
`428`	`424`	`}`
`429`	`425`
`@@ -472,21 +468,21 @@ extern {`
`472`	`468`
`473`	`469`	`// Entry points for the C/C++ API functions.`
`474`	`470`
`475`		`-fn issue_warning<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, text: const libc::c_char) {`
	`471`	`+extern fn issue_warning<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, text: const libc::c_char) {`
`476`	`472`	`let es = unsafe { &mut *es };`
`477`	`473`	`let rtext = unsafe { CStr::from_ptr(text) };`
`478`	`474`
`479`	`475`	`tt_warning!(es.status, "{}", rtext.to_string_lossy());`
`480`	`476`	`}`
`481`	`477`
`482`		`-fn issue_error<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, text: const libc::c_char) {`
	`478`	`+extern fn issue_error<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, text: const libc::c_char) {`
`483`	`479`	`let es = unsafe { &mut *es };`
`484`	`480`	`let rtext = unsafe { CStr::from_ptr(text) };`
`485`	`481`
`486`	`482`	`tt_error!(es.status, "{}", rtext.to_string_lossy());`
`487`	`483`	`}`
`488`	`484`
`489`		`-fn get_file_md5<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, path: const libc::c_char, digest: *mut u8) -> libc::c_int {`
	`485`	`+extern fn get_file_md5<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, path: const libc::c_char, digest: *mut u8) -> libc::c_int {`
`490`	`486`	`let es = unsafe { &mut *es };`
`491`	`487`	`let rpath = osstr_from_cstr(unsafe { CStr::from_ptr(path) });`
`492`	`488`	`let rdest = unsafe { slice::from_raw_parts_mut(digest, 16) };`
`@@ -498,7 +494,7 @@ fn get_file_md5<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, path: c`
`498`	`494`	`}`
`499`	`495`	`}`
`500`	`496`
`501`		`-fn get_data_md5<'a, I: 'a + IoProvider>(_es: mut ExecutionState<'a, I>, data: const u8, len: libc::size_t, digest: *mut u8) -> libc::c_int {`
	`497`	`+extern fn get_data_md5<'a, I: 'a + IoProvider>(_es: mut ExecutionState<'a, I>, data: const u8, len: libc::size_t, digest: *mut u8) -> libc::c_int {`
`502`	`498`	`//let es = unsafe { &mut *es };`
`503`	`499`	`let rdata = unsafe { slice::from_raw_parts(data, len) };`
`504`	`500`	`let rdest = unsafe { slice::from_raw_parts_mut(digest, 16) };`
`@@ -511,21 +507,21 @@ fn get_data_md5<'a, I: 'a + IoProvider>(_es: mut ExecutionState<'a, I>, data: `
`511`	`507`	`0`
`512`	`508`	`}`
`513`	`509`
`514`		`-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 {`
	`510`	`+extern 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 {`
`515`	`511`	`let es = unsafe { &mut *es };`
`516`	`512`	`let rname = osstr_from_cstr(&unsafe { CStr::from_ptr(name) });`
`517`	`513`	`let ris_gz = is_gz != 0;`
`518`	`514`
`519`	`515`	`es.output_open(&rname, ris_gz) as *const _`
`520`	`516`	`}`
`521`	`517`
`522`		`-fn output_open_stdout<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, ) -> const libc::c_void {`
	`518`	`+extern fn output_open_stdout<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, ) -> const libc::c_void {`
`523`	`519`	`let es = unsafe { &mut *es };`
`524`	`520`
`525`	`521`	`es.output_open_stdout() as *const _`
`526`	`522`	`}`
`527`	`523`
`528`		`-fn output_putc<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void, c: libc::c_int) -> libc::c_int {`
	`524`	`+extern fn output_putc<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void, c: libc::c_int) -> libc::c_int {`
`529`	`525`	`let es = unsafe { &mut *es };`
`530`	`526`	`let rhandle = handle as *mut OutputHandle;`
`531`	`527`	`let rc = c as u8;`
`@@ -537,7 +533,7 @@ fn output_putc<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: `
`537`	`533`	`}`
`538`	`534`	`}`
`539`	`535`
`540`		`-fn output_write<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void, data: *const u8, len: libc::size_t) -> libc::size_t {`
	`536`	`+extern fn output_write<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void, data: *const u8, len: libc::size_t) -> libc::size_t {`
`541`	`537`	`let es = unsafe { &mut *es };`
`542`	`538`	`let rhandle = handle as *mut OutputHandle;`
`543`	`539`	`let rdata = unsafe { slice::from_raw_parts(data, len) };`
`@@ -551,7 +547,7 @@ fn output_write<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle:`
`551`	`547`	`}`
`552`	`548`	`}`
`553`	`549`
`554`		`-fn output_flush<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void) -> libc::c_int {`
	`550`	`+extern fn output_flush<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void) -> libc::c_int {`
`555`	`551`	`let es = unsafe { &mut *es };`
`556`	`552`	`let rhandle = handle as *mut OutputHandle;`
`557`	`553`
`@@ -562,7 +558,7 @@ fn output_flush<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle:`
`562`	`558`	`}`
`563`	`559`	`}`
`564`	`560`
`565`		`-fn output_close<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void) -> libc::c_int {`
	`561`	`+extern fn output_close<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void) -> libc::c_int {`
`566`	`562`	`let es = unsafe { &mut *es };`
`567`	`563`
`568`	`564`	`if handle == 0 as *mut _ {`
`@@ -579,7 +575,7 @@ fn output_close<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle:`
`579`	`575`	`}`
`580`	`576`
`581`	`577`
`582`		`-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 {`
	`578`	`+extern 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 {`
`583`	`579`	`let es = unsafe { &mut *es };`
`584`	`580`	`let rname = osstr_from_cstr(unsafe { CStr::from_ptr(name) });`
`585`	`581`	`let rformat = c_format_to_rust(format);`
`@@ -593,34 +589,48 @@ fn input_open<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, name: con`
`593`	`589`	`}`
`594`	`590`	`}`
`595`	`591`
`596`		`-fn input_open_primary<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>) -> const libc::c_void {`
	`592`	`+extern fn input_open_primary<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>) -> const libc::c_void {`
`597`	`593`	`let es = unsafe { &mut *es };`
`598`	`594`
`599`	`595`	`es.input_open_primary() as *const _`
`600`	`596`	`}`
`601`	`597`
`602`		`-fn input_get_size<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void) -> libc::size_t {`
	`598`	`+extern fn input_get_size<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void) -> libc::size_t {`
`603`	`599`	`let es = unsafe { &mut *es };`
`604`	`600`	`let rhandle = handle as *mut InputHandle;`
`605`	`601`
`606`	`602`	`es.input_get_size(rhandle)`
`607`	`603`	`}`
`608`	`604`
`609`		`-fn input_seek<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void, offset: libc::ssize_t, whence: libc::c_int) -> libc::size_t {`
	`605`	`+extern fn input_seek<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void, offset: libc::ssize_t, whence: libc::c_int, internal_error: *mut libc::c_int) -> libc::size_t {`
`610`	`606`	`let es = unsafe { &mut *es };`
`611`	`607`	`let rhandle = handle as *mut InputHandle;`
`612`	`608`
`613`	`609`	`let rwhence = match whence {`
`614`	`610`	`libc::SEEK_SET => SeekFrom::Start(offset as u64),`
`615`	`611`	`libc::SEEK_CUR => SeekFrom::Current(offset as i64),`
`616`	`612`	`libc::SEEK_END => SeekFrom::End(offset as i64),`
`617`		`- _ => panic!("Unexpected \"whence\" parameter to fseek() wrapper: {}", whence),`
	`613`	`+ _ => {`
	`614`	`+ tt_error!(es.status, "serious internal bug: unexpected \"whence\" parameter to fseek() wrapper: {}",`
	`615`	`+ whence);`
	`616`	`+ unsafe {`
	`617`	`+ *internal_error = 1;`
	`618`	`+ }`
	`619`	`+ return 0;`
	`620`	`+ }`
`618`	`621`	`};`
`619`	`622`
`620`		`- es.input_seek(rhandle, rwhence) as libc::size_t`
	`623`	`+ match es.input_seek(rhandle, rwhence) {`
	`624`	`+ Ok(pos) => pos as libc::size_t,`
	`625`	`+ Err(e) => {`
	`626`	`+ // TODO: Handle the error better. Report the error properly to the caller?`
	`627`	`+ tt_error!(es.status, "input seek failed"; e);`
	`628`	`+ 0`
	`629`	`+ }`
	`630`	`+ }`
`621`	`631`	`}`
`622`	`632`
`623`		`-fn input_getc<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void) -> libc::c_int {`
	`633`	`+extern fn input_getc<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void) -> libc::c_int {`
`624`	`634`	`let es = unsafe { &mut *es };`
`625`	`635`	`let rhandle = handle as *mut InputHandle;`
`626`	`636`
`@@ -637,7 +647,7 @@ fn input_getc<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: m`
`637`	`647`	`}`
`638`	`648`	`}`
`639`	`649`
`640`		`-fn input_ungetc<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void, ch: libc::c_int) -> libc::c_int {`
	`650`	`+extern fn input_ungetc<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void, ch: libc::c_int) -> libc::c_int {`
`641`	`651`	`let es = unsafe { &mut *es };`
`642`	`652`	`let rhandle = handle as *mut InputHandle;`
`643`	`653`
`@@ -650,7 +660,7 @@ fn input_ungetc<'a, I: 'a + IoProvider>(es: *mut ExecutionState<'a, I>, handle:`
`650`	`660`	`}`
`651`	`661`	`}`
`652`	`662`
`653`		`-fn input_read<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void, data: *mut u8, len: libc::size_t) -> libc::ssize_t {`
	`663`	`+extern fn input_read<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void, data: *mut u8, len: libc::size_t) -> libc::ssize_t {`
`654`	`664`	`let es = unsafe { &mut *es };`
`655`	`665`	`let rhandle = handle as *mut InputHandle;`
`656`	`666`	`let rdata = unsafe { slice::from_raw_parts_mut(data, len) };`
`@@ -664,7 +674,7 @@ fn input_read<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: m`
`664`	`674`	`}`
`665`	`675`	`}`
`666`	`676`
`667`		`-fn input_close<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void) -> libc::c_int {`
	`677`	`+extern fn input_close<'a, I: 'a + IoProvider>(es: mut ExecutionState<'a, I>, handle: mut libc::c_void) -> libc::c_int {`
`668`	`678`	`let es = unsafe { &mut *es };`
`669`	`679`
`670`	`680`	`if handle == 0 as *mut _ {`
Original file line number	Diff line number	Diff line change
`@@ -220,7 +220,13 @@ ttstub_input_get_size(rust_input_handle_t handle)`
`220`	`220`	`size_t`
`221`	`221`	`ttstub_input_seek(rust_input_handle_t handle, ssize_t offset, int whence)`
`222`	`222`	`{`
`223`		`- return TGB->input_seek(TGB->context, handle, offset, whence);`
	`223`	`+ int internal_error = 0;`
	`224`	`+ size_t rv = TGB->input_seek(TGB->context, handle, offset, whence, &internal_error);`
	`225`	`+ if (internal_error) {`
	`226`	`+ // Nonzero indicates a serious internal error.`
	`227`	`+ longjmp(jump_buffer, 1);`
	`228`	`+ }`
	`229`	`+ return rv;`
`224`	`230`	`}`
`225`	`231`
`226`	`232`	`ssize_t`
`@@ -244,5 +250,9 @@ ttstub_input_ungetc(rust_input_handle_t handle, int ch)`
`244`	`250`	`int`
`245`	`251`	`ttstub_input_close(rust_input_handle_t handle)`
`246`	`252`	`{`
`247`		`- return TGB->input_close(TGB->context, handle);`
	`253`	`+ if (TGB->input_close(TGB->context, handle)) {`
	`254`	`+ // Nonzero return value indicates a serious internal error.`
	`255`	`+ longjmp(jump_buffer, 1);`
	`256`	`+ }`
	`257`	`+ return 0;`
`248`	`258`	`}`