New Memory management + Fixed bugs

Author: thisRedH

main.c

@@ -4,6 +4,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <errno.h>
 
 #include "utils.h"
 
@@ -13,38 +14,40 @@
  * \param _file The file to open
  * \param _prog Return value for the Brainfuck code string
  * \param _len Return value for length of the Brainfuck code string
- * \return Error 1, Success 0
+ * \return 0 = Success, 1 = Err
  */
 int loadProgr(const char* _file, char** _prog, size_t* _len);
 
 Command cmds[] = {
-    // Informatical args like help or version come before all other to quit the program before making anything else
     {"yacbfi",  0,      COMMAND_NO_ARG,  "[options]",                       0},
     {"help",    'h',    COMMAND_NO_ARG,  "Shows this message",              'h'},
     {"version", 'v',    COMMAND_NO_ARG,  "Show the current version number", 'v'},
     {"file",    'f',    COMMAND_HAS_ARG, "Brainf*ck File to use",           'f'},
     {NULL, 0, 0, NULL, 0}
 };
 
-#define ALLOC_MEM               (size_t)5
+#define ALLOC_MEM               (size_t)512
 #define REALLOC_MEM             (size_t)1024
 
 int main(int argc, char const *argv[]) {
     const char* filename;
     char* program;
     size_t program_len;
 
-    size_t memory_size = ALLOC_MEM;
-    unsigned char* memory = (char*) calloc(sizeof(unsigned char), memory_size); ERR_ALLOC(memory)
+    size_t memory_length = ALLOC_MEM;
+    unsigned char* memory = (char*) calloc(memory_length, sizeof(unsigned char));
+    if (memory == NULL) { ERR_ALLOC(); }
+
     size_t mem_ptr = 0;
-    unsigned char current_instr;
 
     int err = handleArgs(argc, argv, cmds, &filename);
-    if (err == 1) { ERR("Failed to Initialize!\n") }
+    if (err == 1) { ERR("Failed to Initialize!"); }
     if (err == 2) { return 0; }
     else if (filename == NULL) {
         printf("Input your programm (max. 1000 chars): ");
-        program = (char*) malloc(sizeof(char) * 1024); ERR_ALLOC(program)
+        program = (char*) malloc(sizeof(char) * 1024);
+        if (program == NULL) { ERR_ALLOC(); }
+
         fgets(program, 1024, stdin);
         program_len = strlen(program);
     } else {
@@ -54,16 +57,16 @@ int main(int argc, char const *argv[]) {
 
     for (int i = 0; i < program_len; i++) {
         // Dynamicly alloc if the Memory gets too small
-        if (mem_ptr >= memory_size) {
-            unsigned char* new_memory = (unsigned char*) calloc(sizeof(unsigned char), (memory_size) + REALLOC_MEM); ERR_ALLOC(new_memory)
-            memcpy(new_memory, memory, memory_size);
-            memory_size += REALLOC_MEM;
-            free(memory);
-            memory = new_memory;
+        if (mem_ptr >= memory_length) {
+            int reerr = recallocMem((void**)&memory, memory_length,
+                        sizeof(unsigned char), (memory_length + REALLOC_MEM));
+            if (reerr != 0) { ERR_ALLOC(); }
+
+            memory_length += REALLOC_MEM;
         }
 
-        current_instr = program[i];
-        switch(current_instr) {
+        // Process the current instruction
+        switch(program[i]) {
             case '+':
                 memory[mem_ptr] += 1;
                 break;
@@ -122,16 +125,18 @@ int main(int argc, char const *argv[]) {
 
 int loadProgr(const char* _file_name, char** _prog, size_t* _len) {
     FILE* _fp = fopen(_file_name, "rb");
-    ERR_FOPEN(_fp, _file_name)
+    if (_fp == NULL) { ERR_FOPEN(_file_name); return 1; }
 
     fseek(_fp, 0, SEEK_END);
     long _flen = ftell(_fp);
     rewind(_fp);
     *_len = _flen + 1;
 
-    *_prog = (char*) malloc(sizeof(char) * (_flen + 1)); ERR_ALLOC(*_prog)
+    *_prog = (char*) malloc(sizeof(char) * (_flen + 1));
+    if (*_prog == NULL) { ERR_ALLOC(); return 1; }
 
     fread(*_prog, sizeof(char), _flen, _fp);
+    // Set 0 Terminator
     (*_prog)[_flen] = '\0';
 
     fclose(_fp);

utils.c

@@ -4,7 +4,7 @@
 #include "utils.h"
 
 #ifndef YACBFI_VERSION
-#define YACBFI_VERSION  "1.0.2"
+#define YACBFI_VERSION  "1.0.5"
 #endif
 
 int getargs(int _argc, char const *_argv[], Command _cmds[], int* _index) {
@@ -45,7 +45,7 @@ int getargs(int _argc, char const *_argv[], Command _cmds[], int* _index) {
 
 void printhelp(Command _cmds[]) {
     // Print the Usage (Usage: Name [help])
-    printf("Usage: %s %s\n", _cmds[0].name, _cmds[0].help);
+    printf("\nUsage: %s %s\n", _cmds[0].name, _cmds[0].help);
 
     // Print all helps (   -a, --name {spaces} help)
     for (int i = 1; _cmds[i].name != NULL; i++) {
@@ -82,8 +82,8 @@ int handleArgs(int _argc, char const *_argv[], Command _cmds[], const char** _fi
             _index++;
             break;
         case 'v':
-            printf("\nYACBFI - Made by RedH - %s\n", YACBFI_VERSION);
-            printf("This software is published under the MIT license.\nSee the LICENSE file for more information.\n\n");
+            printf("\nYACBFI - Made by RedH - %s\n\n", YACBFI_VERSION);
+            printf("This software is published under the MIT license.\nSee the LICENSE file for more information.\n");
             return 2;
             break;
         case '?':
@@ -93,5 +93,22 @@ int handleArgs(int _argc, char const *_argv[], Command _cmds[], const char** _fi
             break;
         }
     }
+    return 0;
+}
+
+int recallocMem(void** _mem, size_t _oldNitems, size_t _size, size_t _newNitems) {
+    if (_newNitems <= _oldNitems) {
+        return 0;
+    }
+
+    void* _new_memory = calloc(_newNitems, _size);
+    if (_new_memory == NULL) {
+        return 1;
+    }
+
+    memcpy(_new_memory, *_mem, _oldNitems);
+    free(*_mem);
+    *_mem = _new_memory;
+
     return 0;
 }

utils.h

@@ -8,9 +8,9 @@
 #include <stdio.h>
 #include <string.h>
 
-#define ERR(msg)                fprintf(stderr, msg); return 1;
-#define ERR_ALLOC(ptr)          if (ptr == NULL) { fprintf(stderr, "Error allocating memory\n"); return 1; }
-#define ERR_FOPEN(fptr, fn)     if (fptr == NULL) { fprintf(stderr, "Could not open the file \"%s\"\n", fn); return 1; }
+#define ERR(msg)                fprintf(stderr, "\n\n%s\n\n", msg)
+#define ERR_ALLOC()             fprintf(stderr, "\n\nError reallocating new Memory: %s\n\n", strerror(errno))
+#define ERR_FOPEN(fn)           fprintf(stderr, "\n\nCould not open the file \"%s\": %s\n\n", fn, strerror(errno))
 
 #define COMMAND_HAS_ARG         1
 #define COMMAND_NO_ARG          0
@@ -25,9 +25,9 @@ typedef struct {
 
 
 /**
- * @param _cmds A list of all possible args. The last has to be NULL (ptr) and 0 (char) termiantet
- * @param _filename Return value
- * @return 0 = Success, 1 = Err, 2 = End programm no Err
+ * \param _cmds A list of all possible args. First has to be Program Name. The last has to be NULL (ptr) and 0 (char) termiantet
+ * \param _filename Return value
+ * \return 0 = Success, 1 = Err, 2 = End programm no Err
  */
 int handleArgs(int _argc, char const *_argv[], Command _cmds[], const char** _filename);
 
@@ -45,4 +45,15 @@ int getargs(int _argc, char const *_argv[], Command _cmds[], int* _index);
  */
 void printhelp(Command _cmds[]);
 
+/**
+ * \brief Reallocate a block of memory to make it bigger (smaller not supportet). New space Iitialiced to 0 (using calloc)
+ * 
+ * \param _mem Memory that needs to be reallocatet
+ * \param _oldNitems The length of the old "array"
+ * \param _size Size of the type that u allocate (sizeof())
+ * \param _newNitems The length of the new "array"
+ * \return 0 = Success, 1 = Err
+ */
+int recallocMem(void** _mem, size_t _oldNitems, size_t _size, size_t _newNitems);
+
 #endif