Ticket #9027: svmp.patch

extract_agos.cpp

@@ -24 +24 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "util.h"
+
 typedef unsigned int ULONG;
 typedef unsigned char UBYTE;
 
@@ -142 +144 @@
  * - call free() on ptr to free memory
  * - size of loaded file is available in global var 'filelen'
  */
-void *loadfile(char *name) {
+void *loadfile(const char *name) {
         void *mem = NULL;
         FILE *fd;
 
@@ -166 +168 @@
  *   the file named by [filename]
  * - returns zero if failed, or non-zero if successful
  */
-int savefile(char *name, void *mem, size_t length) {
+int savefile(const char *name, void *mem, size_t length) {
         unsigned int bytesWritten;
 
         FILE *fd = fopen(name, "wb");
@@ -184 +186 @@
         return 1;
 }
 
-char filename[1024];
-
 int main(int argc, char *argv[]) {
-        int i;
+        int first_arg = 1;
+        int last_arg = argc;
 
-        if (argc < 2) {
-                printf("\nUsage: %s <file 1> ... <file n>\n", argv[0]);
-                exit(2);
-        }
+        Filename inpath, outpath;
 
-        for (i = 1; i < argc; i++) {
-                UBYTE *x = (UBYTE *) loadfile(argv[i]);
-                strcpy(filename, argv[i]);
+        // Check if we should display some heplful text
+        parseHelpArguments(argv, argc);
+        
+        // Continuing with finding out output directory
+        // also make sure we skip those arguments
+        if ( parseOutputArguments(&outpath, argv, argc, first_arg))
+                first_arg += 2;
+        else if (parseOutputArguments(&outpath, argv, argc, last_arg - 2))
+                last_arg -= 2;
+        else
+                // Standard output dir
+                outpath.setFullPath("out/");
 
+        // Loop through all input files
+        for (int parsed_args = first_arg; parsed_args <= last_arg; ++parsed_args) {
+                const char *filename = argv[parsed_args];
+                UBYTE *x = (UBYTE *) loadfile(filename);
+
+                inpath.setFullPath(filename);
+                outpath.setFullName(inpath.getFullName());
+
                 if (x) {
                         ULONG decrlen = simon_decr_length(x, (ULONG) filelen);
                         UBYTE *out = (UBYTE *) malloc(decrlen);
 
                         if (out) {
                                 if (simon_decr(x, out, filelen)) {
-                                        strcat(filename, ".out");
-                                        savefile(filename, out, decrlen);
+                                        savefile(outpath.getFullPath(), out, decrlen);
                                 }
                                 else {
-                                        printf("%s: decrunch error\n", filename);
+                                        notice("%s: decrunch error\n", filename);
                                 }
 
                                 free((void *) x);
                         }
                 }
+                else {
+                        notice("Could not load file %s\n", filename);
+                }
         }
 
         return 0;

util.cpp

@@ -146 +146 @@
         return sz;
 }
 
-void getPath(const char *fullpath, char *path) {
-        const char *p;
+Filename::Filename(const char *path) {
+        strcpy(_path, path);
+}
 
-        /* Find the last occurence of '/' or '\'
-         * Everything before this point is the path
-         * Everything after this point is the filename
-         */
-        p = strrchr(fullpath, '/');
-        if (!p) {
-                p = strrchr(fullpath, '\\');
+void Filename::setFullPath(const char *path) {
+        strcpy(_path, path);
+}
 
-                if (!p) {
-                        p = fullpath - 1;
-                }
+Filename *Filename::setFullName(const char *newname) {
+        char p[1024];
+        if (getPath(p)) {
+                strcat(p, newname);
+                strcpy(_path, p);
+                return this;
         }
+        return NULL;
+}
 
-        /* The path is everything before p, unless the file is in the current
-         * directory, in which case the path is '.'
-         */
-        if (p < fullpath) {
-                strcpy(path, ".");
-        } else {
-                strncpy(path, fullpath, p - fullpath);
-                path[strlen(fullpath) - strlen(p)] = '\0';
+void Filename::addExtension(const char *ext) {
+        strcat(_path, ext);
+}
+
+bool Filename::empty() const {
+        return *_path == 0;
+}
+
+const char *Filename::getFullPath() const {
+        return _path;
+}
+
+const char *Filename::getFullName(char *out) const {
+        const char *slash;
+        if ((slash = strrchr(_path, '/')) || (slash = strrchr(_path, '\\'))) {
+                strcpy(out, slash + 1);
+                return out;
         }
+        return NULL;
 }
 
-void getFilename(const char *fullpath, char *filename) {
-        const char *p;
+const char *Filename::getFullName() const {
+        const char *slash;
+        if ((slash = strrchr(_path, '/')) || (slash = strrchr(_path, '\\'))) {
+                return slash + 1;
+        }
+        return NULL;
+}
 
-        /* Find the last occurence of '/' or '\'
-         * Everything before this point is the path
-         * Everything after this point is the filename
-         */
-        p = strrchr(fullpath, '/');
-        if (!p) {
-                p = strrchr(fullpath, '\\');
+const char *Filename::getPath(char *out) const {
+        const char *slash;
+        if ((slash = strrchr(_path, '/')) || (slash = strrchr(_path, '\\'))) {
+                int end = strlen(_path) - strlen(slash) + 1;
+                strncpy(out, _path, end);
+                out[end] = 0;
+                return out;
+        }
+        // If there was no '/', this was a relative path
+        strcpy(out, _path);
+        return out;
+}
 
-                if (!p) {
-                        p = fullpath - 1;
+void parseHelpArguments(const char * const argv[], int argc, const char *msg) {
+        if (argc < 2 || strcmp(argv[1], "--help") == 0 || stricmp(argv[1], "-h") == 0) {
+                if (!msg) {
+                        printf("\nUsage: %s [-o <output dir> = out/] <file 1> ... <file n>\n", argv[0]);
                 }
+                else {
+                        printf(msg, argv[0]);
+                }
+                exit(2);
         }
+}
 
-        strcpy(filename, p + 1);
+bool parseOutputArguments(Filename *outputname, const char * const argv[], int argc, int start_arg) {
+        char lastchr;
+
+        if (start_arg >= 0 && (strcmp(argv[start_arg], "-o") == 0 || strcmp(argv[start_arg], "--output") == 0)) {
+                /* It's a -o argument, can we check next arg? */
+
+                if (start_arg + 1 < argc) {
+                        outputname->setFullPath(argv[start_arg + 1]);
+
+                        /* Ensure last character is a /, this way we force directory output */
+                        lastchr = outputname->getFullPath()[strlen(outputname->getFullPath()) - 1];
+                        if (lastchr != '/' && lastchr != '\\') {
+                                strcat(outputname->_path, "/");
+                        }
+                        return true;
+                } else {
+                        error("Expected directory path after '-o' or '--output'.");
+                }
+        }
+        return false;
 }

util.h

@@ -158 +158 @@
         return (b[0] << 8) + b[1];
 }
 FORCEINLINE uint32 READ_BE_UINT32(const void *ptr) {
-        const byte *b = (const byte*)ptr;
+        const byte *b = (const byte *)ptr;
         return (b[0] << 24) + (b[1] << 16) + (b[2] << 8) + (b[3]);
 }
 FORCEINLINE void WRITE_BE_UINT16(void *ptr, uint16 value) {
@@ -204 +204 @@
 void warning(const char *s, ...);
 void debug(int level, const char *s, ...);
 void notice(const char *s, ...);
-void getPath(const char *fullpath, char *path);
-void getFilename(const char *fullpath, char *filename);
 
+struct Filename {
+        char _path[1024];
+
+        Filename(const char *path = "");
+
+        void setFullPath(const char *path);
+        Filename *setFullName(const char *name);
+        void addExtension(const char *ext);
+
+        bool empty() const;
+
+        const char *getFullPath() const;
+        const char *getFullName() const;
+        const char *getFullName(char *out) const;
+        const char *getPath(char *out) const;
+};
+
+void parseHelpArguments(const char * const argv[], int argc, const char *msg = NULL);
+bool parseOutputArguments(Filename *outputname, const char * const argv[], int argc, int start_arg);
+
+
 #endif