change: medium struct with more infos

diff --git a/discspan.c b/discspan.c
index b4fe792b1b28926965ccd13bc38aadd9b27bae6d..e90063666a3dba915904a0a84327ba6c4d4b6756 100644 (file)
--- a/discspan.c
+++ b/discspan.c
@@ -8,13 +8,10 @@
 #include "filehandler.h"
 #include "help.h"
 
-extern void (*printEvent)(const char *output, unsigned long long splitgroesse);
 extern void useage();
-extern void read_input_file(const char *input, const unsigned long long split,
-               file_size_handler_t *handler);
-extern void write_output_file(const char *output, file_size_handler_t disc);
-extern file_size_handler_t splitter(file_size_handler_t *handler,
-               const char *output, unsigned long long splitgroesse);
+extern void read_input_file(const char *input, medium_t *srcdata);
+extern void write_output_file(const char *output, medium_t disc);
+extern medium_t splitter(medium_t *srcdata);
 
 int cmpfunc(const void *filea, const void *fileb)
 {
@@ -68,13 +65,13 @@ const unsigned long long readArgument(int argc, char *argv[])
        return split;
 }
 
-void printHumanReadSize(const char *output, unsigned long long splitgroesse)
+void print_human_read_size(const char *output, medium_t medium)
 {
        unsigned long long humanread;
        char einheit[6] = {'B', 'K', 'M', 'G', 'T', 'P'};
        int i = 0;
 
-       humanread = splitgroesse;
+       humanread = medium.freespace;
        while (humanread >= 1024) {
                humanread /= 1024;
                i++;
@@ -84,7 +81,7 @@ void printHumanReadSize(const char *output, unsigned long long splitgroesse)
                i = 0;
 
        printf("Restlicher Platz in Bytes(%s): %lld (%lld %c)\n", output,
-                       splitgroesse, humanread, einheit[i]);
+                       medium.freespace, humanread, einheit[i]);
 }
 
 int main(int argc, char *argv[])
@@ -94,29 +91,26 @@ int main(int argc, char *argv[])
                return 1;
        }
 
-       printEvent = printHumanReadSize;
-
        const char *input = argv[1];
        const char *output = argv[2];
-
-       file_size_handler_t arrayhandler = { NULL, 0 };
-
        const unsigned long long split = readArgument(argc, argv);
-       read_input_file(input, split, &arrayhandler);
 
-       qsort(arrayhandler.filearray, arrayhandler.length, sizeof(file_size_t),
-                       cmpfunc);
+       medium_t srcdata = { 0, split, 0, NULL };
+       read_input_file(input, &srcdata);
+
+       qsort(srcdata.filearray, srcdata.length, sizeof(file_size_t), cmpfunc);
 
        char outname[strlen(output) + 3];
-       int num = 1;
-       file_size_handler_t disc;
-       while (arrayhandler.length > 0) {
-               sprintf(outname, "%s%03d", output, num++);
-               disc = splitter(&arrayhandler, outname, split);
+       medium_t disc;
+       while (srcdata.length > 0) {
+               srcdata.nr++;
+               sprintf(outname, "%s%03d", output, srcdata.nr);
+               disc = splitter(&srcdata);
+               print_human_read_size(outname, disc);
                write_output_file(outname, disc);
                free(disc.filearray);
        }
 
-       free(arrayhandler.filearray);
+       free(srcdata.filearray);
        return 0;
 }

diff --git a/discspan.h b/discspan.h
index 6b0534533b2c0122d42a9033665c99ca47f9c6cc..4e3a537fe032018eeb0b8b8e0c31ecc5eb2d45c7 100644 (file)
--- a/discspan.h
+++ b/discspan.h
@@ -3,12 +3,14 @@
 
 typedef struct {
        char name[255];
-       long long unsigned fsize;
+       unsigned long long fsize;
 } file_size_t;
 
 typedef struct {
-       file_size_t *filearray;
+       int nr;
+       unsigned long long freespace;
        int length;
-} file_size_handler_t;
+       file_size_t *filearray;
+} medium_t;
 
 #endif

diff --git a/filehandler.c b/filehandler.c
index fa7b0b64bbd641e5ed480bcc5b9bb0346379bbff..c2647e70e388ba8b40ae179169b901de23b13e40 100644 (file)
--- a/filehandler.c
+++ b/filehandler.c
@@ -6,7 +6,7 @@
 #include "discspan.h"
 #include "filehandler.h"
 
-void malloc_array_length(FILE *in, file_size_handler_t *handler)
+void malloc_array_length(FILE *in, medium_t *handler)
 {
        int lines = 0;
        char pfad[255];
@@ -21,8 +21,7 @@ void malloc_array_length(FILE *in, file_size_handler_t *handler)
                malloc(handler->length * sizeof(file_size_t));
 }
 
-void fill_array_from_file(FILE *in, const unsigned long long split,
-               file_size_handler_t *handler)
+void fill_array_from_file(FILE *in, medium_t *srcdata)
 {
        FILE *ignore = NULL;
        char pfad[255];
@@ -33,9 +32,9 @@ void fill_array_from_file(FILE *in, const unsigned long long split,
                // Lese Dateieigenschaften in st struct
                stat(pfad, &st);
 
-               if (st.st_size <= split) {
-                       strcpy(handler->filearray[lines].name, pfad);
-                       handler->filearray[lines++].fsize = st.st_size;
+               if (st.st_size <= srcdata->freespace) {
+                       strcpy(srcdata->filearray[lines].name, pfad);
+                       srcdata->filearray[lines++].fsize = st.st_size;
                } else {
                        // irgnore List erstellen
                        if (ignore == NULL)
@@ -48,25 +47,23 @@ void fill_array_from_file(FILE *in, const unsigned long long split,
        if (ignore != NULL)
                fclose(ignore);
 
-       handler->length = lines;
-       handler->filearray = (file_size_t *)
-               realloc(handler->filearray,
-                               handler->length * sizeof(file_size_t));
+       srcdata->length = lines;
+       srcdata->filearray = (file_size_t *)
+               realloc(srcdata->filearray,
+                               srcdata->length * sizeof(file_size_t));
 }
 
-void read_input_file(const char *input,
-               const unsigned long long split,
-               file_size_handler_t *handler)
+void read_input_file(const char *input, medium_t *srcdata)
 {
        FILE *in = fopen(input, "r");
 
-       malloc_array_length(in, handler);
-       fill_array_from_file(in, split, handler);
+       malloc_array_length(in, srcdata);
+       fill_array_from_file(in, srcdata);
 
        fclose(in);
 }
 
-void write_output_file(const char *output, file_size_handler_t disc)
+void write_output_file(const char *output, medium_t disc)
 {
        FILE *out = fopen(output, "w");
 

diff --git a/filehandler.h b/filehandler.h
index a2c254f07d4172deb96aa992ef3c17d6dc60d16a..04bd2ee02b39708338c1538ff6a29f12f638a608 100644 (file)
--- a/filehandler.h
+++ b/filehandler.h
@@ -1,10 +1,8 @@
 #ifndef _FILEHANDLER_H
 #define _FILEHANDLER_H
 
-void read_input_file(const char *input,
-              const unsigned long long split,
-              file_size_handler_t *handler);
+void read_input_file(const char *input, medium_t *srcdata);
 
-void write_output_file(const char *output, file_size_handler_t disc); 
+void write_output_file(const char *output, medium_t disc);
 
 #endif

diff --git a/splitter.c b/splitter.c
index 10200a58788284901be653e4da27509c03e63ff9..a3817b95c639fa0eefea6643d3fb9062bfd00c88 100644 (file)
--- a/splitter.c
+++ b/splitter.c
@@ -6,22 +6,19 @@
 #include "discspan.h"
 #include "splitter.h"
 
-void onPrintEvent(const char *output, unsigned long long splitgroesse)
+medium_t splitter(medium_t *srcdata)
 {
-       if (printEvent != NULL)
-               printEvent(output, splitgroesse);
-}
-
-file_size_handler_t splitter(file_size_handler_t *handler, const char *output,
-               unsigned long long splitgroesse)
-{
-       file_size_handler_t rest;
-       rest.length = handler->length;
+       medium_t rest;
+       rest.nr = srcdata->nr;
+       rest.freespace = srcdata->freespace;
+       rest.length = srcdata->length;
        rest.filearray = (file_size_t *)
                malloc(rest.length * sizeof(file_size_t));
 
-       file_size_handler_t disc;
-       disc.length = handler->length;
+       medium_t disc;
+       disc.nr = srcdata->nr;
+       disc.freespace = srcdata->freespace;
+       disc.length = srcdata->length;
        disc.filearray = (file_size_t *)
                malloc(disc.length * sizeof(file_size_t));
 
@@ -29,15 +26,15 @@ file_size_handler_t splitter(file_size_handler_t *handler, const char *output,
        int restcount = 0;
        int disccount = 0;
 
-       for (int i = 0; i < handler->length; i++) {
+       for (int i = 0; i < srcdata->length; i++) {
                // ISO9660 filesystem overhead
-               filesize = ceil(handler->filearray[i].fsize / 2048.0) * 2048;
+               filesize = ceil(srcdata->filearray[i].fsize / 2048.0) * 2048;
 
-               if (splitgroesse >= filesize) {
-                       splitgroesse -= filesize;
-                       disc.filearray[disccount++] = handler->filearray[i];
+               if (disc.freespace >= filesize) {
+                       disc.freespace -= filesize;
+                       disc.filearray[disccount++] = srcdata->filearray[i];
                } else {
-                       rest.filearray[restcount++] = handler->filearray[i];
+                       rest.filearray[restcount++] = srcdata->filearray[i];
                }
        }
 
@@ -45,14 +42,12 @@ file_size_handler_t splitter(file_size_handler_t *handler, const char *output,
        disc.filearray = (file_size_t *)
                realloc(disc.filearray, disc.length * sizeof(file_size_t));
 
-       onPrintEvent(output, splitgroesse);
-
-       memcpy(handler->filearray, rest.filearray,
+       memcpy(srcdata->filearray, rest.filearray,
                        restcount * sizeof(file_size_t));
 
-       handler->length = restcount;
-       handler->filearray = (file_size_t *) realloc(handler->filearray,
-                                       handler->length * sizeof(file_size_t));
+       srcdata->length = restcount;
+       srcdata->filearray = (file_size_t *) realloc(srcdata->filearray,
+                                       srcdata->length * sizeof(file_size_t));
 
        free(rest.filearray);
        return disc;

diff --git a/splitter.h b/splitter.h
index da73a4431a3d1df98d04f44f6e7a0757b10aee77..a1d9dd8691f813103b48ed208d1aa951e0812a51 100644 (file)
--- a/splitter.h
+++ b/splitter.h
@@ -1,9 +1,6 @@
 #ifndef _SPLITTER_H
 #define _SPLITTER_H
 
-void (*printEvent)(const char *output, unsigned long long splitgroesse);
-
-file_size_handler_t splitter(file_size_handler_t *handler, const char *output,
-               unsigned long long splitgroesse);
+medium_t splitter(medium_t *srcdata);
 
 #endif