Doppelt verkettete Listen & Rd -> Read umbenannt

loesung.c

@@ -8,6 +8,7 @@ typedef struct Tile {
     uint32_t x;
     uint32_t y;
     struct Tile *p_next;
+    struct Tile *p_prev;
 } Tile;
 
 
@@ -34,24 +35,29 @@ Tile* list_push(List *s) {
     p_tile->x = 0;
     p_tile->y = 0;
     p_tile->p_next = s->p_top;
+    p_tile->p_prev = 0;
     s->p_top = p_tile;
     s->size++;
+    if(p_tile->p_next != 0) {
+        p_tile->p_next->p_prev = p_tile;
+    }
     return p_tile;
 }
 
 /** Entfernen des obersten Elementes von der Liste und zurueckgeben des Tiles
  *
- * Der List muss mindestens ein Element besitzen
+ * Der List muss mindestens ein Element besitzen TODO: Notwendig?
  */
 Tile* list_pop(List *s) {
     Tile *p_tile = s->p_top;
     s->p_top->p_next = p_tile->p_next;
+    s->p_top->p_prev = 0;
     return p_tile;
 }
 
 /** Freigeben des reservierten Speichers von der Liste
  *
- * Alle Tiles werden mit free vom speicher deallocaiert
+ * Alle Tiles weReaden mit free vom speicher deallocaiert
  */
 void list_free(List *s) {
     Tile *p_cur = s->p_top;
@@ -64,12 +70,12 @@ void list_free(List *s) {
 }
 
 typedef enum ReadResult {
-    RdOk,
-    RdEof,
-    RdErrIntegerOverflow,
-    RdErrNonDigitCharacter,
-    RdErrTooFewNumbers,
-    RdErrTooManyNumbers,
+    ReadOk,
+    ReadEof,
+    ReadErrIntegerOverflow,
+    ReadErrNonDigitCharacter,
+    ReadErrTooFewNumbers,
+    ReadErrTooManyNumbers,
 } ReadResult;
 
 typedef struct Field {
@@ -80,7 +86,7 @@ typedef struct Field {
 
 /** Parsen einer Kachel(Tile) aus einer Zeile von StdIn
  *
- * Die Zahlen werden in das uebergebene Struct pTile geschrieben, sind aber
+ * Die Zahlen weReaden in das uebergebene Struct pTile geschrieben, sind aber
  * nur gueltig, wenn der Rueckgabewert `Ok` ist.
  *
  * Voraussetzung: p_tile muss initialisiert sein
@@ -88,7 +94,7 @@ typedef struct Field {
 ReadResult read_line(Tile* p_tile){
     int c = getchar();
     if (c == EOF) {
-        return RdEof;
+        return ReadEof;
     }
     int cur_number = 0;
     bool cur_whitespace = true;
@@ -97,23 +103,23 @@ ReadResult read_line(Tile* p_tile){
         if ('0' <= c && c <= '9') {
             if (cur_whitespace) {
                 if(cur_number == 2) {
-                    return RdErrTooManyNumbers;
+                    return ReadErrTooManyNumbers;
                 }
                 p_cur = (&p_tile->x)+cur_number;
                 cur_whitespace = false;
                 cur_number++;
             }
-            // 429496730 = 2^32 / 10, daher wenn `p_cur` groesser ist, wird ein
+            // 429496730 = 2^32 / 10, daher wenn `p_cur` groesser ist, wiRead ein
             // overflow erzeugt
             if (*p_cur > 429496729) {
                 printf("Multiplizieren ueberlauf %u\n", *p_cur);
-                return RdErrIntegerOverflow;
+                return ReadErrIntegerOverflow;
             }
             (*p_cur) *= 10;
             int digit = c - '0';
             if (*p_cur > UINT32_MAX - digit) {
                 printf("Addieren ueberlauf %u\n", *p_cur);
-                return RdErrIntegerOverflow;
+                return ReadErrIntegerOverflow;
             }
             (*p_cur) += digit;
         } else if (c == ' ') {
@@ -122,17 +128,16 @@ ReadResult read_line(Tile* p_tile){
             }
         } else if (c == '\n') {
             if (cur_number == 2) {
-                return RdOk;
+                return ReadOk;
             } else {
-                return RdErrTooFewNumbers;
+                return ReadErrTooFewNumbers;
             }
         } else {
-            return RdErrNonDigitCharacter;
+            return ReadErrNonDigitCharacter;
         }
         c = getchar(); // get next character
-
     }
-    return RdOk;
+    return ReadOk;
 }
 
 /**
@@ -155,8 +160,8 @@ inline uint32_t max(uint32_t a, uint32_t b) {
  *
  * Return:
  *  - ReadResult:
- *     RdOk, falls das lesen erfolgreich war
- *     RdErr..., falls die eingabe ungueltig ist. f ist dann nicht vollstaendig
+ *     ReadOk, falls das lesen erfolgreich war
+ *     ReadErr..., falls die eingabe ungueltig ist. f ist dann nicht vollstaendig
  *               initialisiert
  */
 ReadResult parse_input(Field *f) {
@@ -171,19 +176,19 @@ ReadResult parse_input(Field *f) {
         Tile *t = list_push(&f->tiles); // neues Element in die Liste einfuegen
         ReadResult result = read_line(t);
         switch (result) {
-        case RdOk:
+        case ReadOk:
             // Reichweite des Feldes ermitteln
             f->t_min.x = min(f->t_min.x, t->x);
             f->t_min.y = min(f->t_min.y, t->y);
             f->t_max.x = max(f->t_max.x, t->x);
             f->t_max.y = max(f->t_max.x, t->y);
             break;
-        case RdEof:
+        case ReadEof:
             list_pop(&f->tiles);
             if (f->tiles.size == 1) {
-                return RdEof;
+                return ReadEof;
             } else {
-                return RdOk;
+                return ReadOk;
             }
         default: // error
             return result;
@@ -197,7 +202,7 @@ int main (int argc,
     Field f;
     ReadResult result = parse_input(&f);
     switch (result) {
-    case RdOk:
+    case ReadOk:
         printf("Valider Input\n");
         printf("Anzahl: %d\n", f.tiles.size);
         printf("Range(%d, %d), (%d, %d)\n",
@@ -207,23 +212,23 @@ int main (int argc,
                f.t_max.x - f.t_min.x,
                f.t_max.y - f.t_min.y);
         break;
-    case RdEof:
+    case ReadEof:
         // bei leerer Eingabe nichts ausgeben
         return EXIT_SUCCESS;
-    case RdErrIntegerOverflow:
+    case ReadErrIntegerOverflow:
         fprintf(stderr, "Error in line %d: too big integer\n", f.tiles.size);
         list_free(&f.tiles);
         return EXIT_FAILURE;
-    case RdErrNonDigitCharacter:
+    case ReadErrNonDigitCharacter:
         fprintf(stderr, "Error in line %d: invalid character\n", f.tiles.size);
         list_free(&f.tiles);
         return EXIT_FAILURE;
-    case RdErrTooFewNumbers:
+    case ReadErrTooFewNumbers:
         fprintf(stderr, "Error in line %d: Too few numbers, expected exactly 2\n",
                f.tiles.size);
         list_free(&f.tiles);
         return EXIT_FAILURE;
-    case RdErrTooManyNumbers:
+    case ReadErrTooManyNumbers:
         fprintf(stderr, "Error in line %d: Too much numbers, expected exactly 2\n",
                f.tiles.size);
         list_free(&f.tiles);