xor_compress refactoring

- C: Use consistent error-reporting for read_files and write_compressed
- Rust: Combine both into compress_files for a single error eprintln

2 files changed, 21 insertions, 26 deletions

diff --git a/tools/xor_compress.c b/tools/xor_compress.c
index 0e1c5e2..555274a 100644
--- a/tools/xor_compress.c
+++ b/tools/xor_compress.c
@@ -55,11 +55,12 @@ failure:
     return buffer;
 }
 
-int write_compressed(const char *filename, unsigned char *data, size_t n, bool verbose) {
+int write_compressed(const char *filename, unsigned char *data, size_t n, int *err) {
     FILE *f = fopen(filename, "wb");
     if (!f) {
         fprintf(stderr, PROGRAM_NAME ": %s: %s\n", filename, strerror(errno));
-        return errno;
+        *err = errno;
+        return 0;
     }
 
     int runs = 0;
@@ -90,11 +91,10 @@ int write_compressed(const char *filename, unsigned char *data, size_t n, bool v
         }
     }
 
-    if (verbose) printf(PROGRAM_NAME ": %s: ld bc, $%x\n", filename, runs);
-
     fflush(f);
     fclose(f);
-    return 0;
+    *err = 0;
+    return runs;
 }
 
 int main(int argc, char *argv[]) {
@@ -111,10 +111,17 @@ int main(int argc, char *argv[]) {
     argv++;
     argc -= 2;
 
+    const char *out_filename = argv[argc];
+
     int err = 0;
     size_t data_size = 0;
     unsigned char *data = read_files(argv, argc, &data_size, &err);
-    if (!err) err = write_compressed(argv[argc], data, data_size, verbose);
+    if (!err) {
+        int runs = write_compressed(out_filename, data, data_size, &err);
+        if (!err && verbose) {
+            printf(PROGRAM_NAME ": %s: ld bc, $%x\n", out_filename, runs);
+        }
+    }
     free(data);
     return err;
 }
diff --git a/tools/xor_compress.rs b/tools/xor_compress.rs
index 3a41b16..c9c47e7 100644
--- a/tools/xor_compress.rs
+++ b/tools/xor_compress.rs
@@ -5,17 +5,14 @@ use std::io::{Read, Error};
 
 const PROGRAM_NAME: &str = "xor-compress";
 
-fn read_files(filenames: &[String]) -> Result<Vec<u8>, (&String, Error)> {
+fn compress_files<'a>(in_filenames: &'a [String], out_filename: &'a String) -> Result<u32, (&'a String, Error)> {
     let mut data = Vec::new();
-    for filename in filenames {
+    for filename in in_filenames {
         (|| {
             Ok(File::open(filename)?.read_to_end(&mut data)?)
         })().map_err(|err| (filename, err))?;
     }
-    Ok(data)
-}
 
-fn write_compressed(filename: &str, data: &[u8]) -> Result<u32, Error> {
     let n = data.len();
 
     let mut output = Vec::new();
@@ -59,9 +56,9 @@ fn write_compressed(filename: &str, data: &[u8]) -> Result<u32, Error> {
         }
     }
 
-    match write(filename, &output[..]) {
+    match write(out_filename, &output[..]) {
         Ok(()) => Ok(runs),
-        Err(err) => Err(err),
+        Err(err) => Err((out_filename, err)),
     }
 }
 
@@ -79,22 +76,13 @@ fn main() {
     }
 
     let out_filename = argv.pop().unwrap();
-    let data = match read_files(&argv[..]) {
-        Ok(data) => data,
+    match compress_files(&argv[..], &out_filename) {
+        Ok(runs) => if verbose {
+            println!("{}: {}: ld bc, ${:x}", PROGRAM_NAME, out_filename, runs);
+        },
         Err((filename, err)) => {
             eprintln!("{}: {}: {}", PROGRAM_NAME, filename, err);
             exit(err.raw_os_error().unwrap_or(1));
         }
-    };
-    if !data.is_empty() {
-        match write_compressed(&out_filename, &data[..]) {
-            Ok(runs) => if verbose {
-                println!("{}: {}: ld bc, ${:x}", PROGRAM_NAME, out_filename, runs);
-            },
-            Err(err) => {
-                eprintln!("{}: {}: {}", PROGRAM_NAME, out_filename, err);
-                exit(err.raw_os_error().unwrap_or(1));
-            },
-        }
     }
 }