Update parser & algorithm

Update parser to work around line breaks as file ending, update algorithm to print errors when target could not be reached in the defined map

Author: Julessh05

germany_map_false.csv

@@ -1,31 +1,19 @@
-Stuttgart, Karlsruhe, 75
-Karlsruhe, Stuttgart, 75
-Stuttgart, Nürnberg, 210
-Nürnberg, Stuttgart, 210
 Stuttgart, München, 220
 München, Stuttgart, 220
-München, Nürnberg, 170
-Nürnberg, München, 170
 München, Linz, 370
 Linz, München, 370
-Nürnberg, Hamburg, 620
-Hamburg, Nürnberg, 620
 Bonn, Düsseldorf, 70
 Düsseldorf, Bonn, 70
 Karlsruhe, Düsseldorf, 350
 Düsseldorf, Karlsruhe, 350
 Hamburg, Karlsruhe, 620
 Karlsruhe, Hamburg, 620
-Karlsruhe, Nürnberg, 250
-Nürnberg, Karlsruhe, 250
 Nürnberg, Dresden, 310
 Dresden, Nürnberg, 310
 Stuttgart, Freiburg, 200
 Freiburg, Stuttgart, 200
 München, Augsburg, 70
 Augsburg, München, 70
-Nürnberg, Regensburg, 120
-Regensburg, Nürnberg, 120
 Berlin, Potsdam, 40
 Potsdam, Berlin, 40
 Hamburg, Bremen, 120

src/logic/algo.c

@@ -55,13 +55,16 @@ ROUTE* get_route_min_dist(ROUTE* routes, const int size,
   int min_distance = -1;
   ROUTE* route = nullptr;
   for (int i = 0; i < size; i++) {
-    if (min_distance < 0 && !city_visited(routes[i].destination.name,
-                                          applicable_cities,
-                                          cities_size) ||
-        routes[i].distance > 0 && routes[i].distance < min_distance &&
+    if (routes[i].distance == 0 && !city_visited(routes[i].destination.name,
+                                                 applicable_cities,
+                                                 cities_size) ||
+        routes[i].distance > 0 && (
+          min_distance < 0 || routes[i].distance < min_distance) &&
         !city_visited(routes[i].destination.name, applicable_cities,
                       cities_size)) {
-      min_distance = routes[i].distance;
+      if (routes[i].distance != 0) {
+        min_distance = routes[i].distance;
+      }
       route = &routes[i];
     }
   }
@@ -136,8 +139,8 @@ int dijkstra(
         routes, DICT_SIZE, all_cities,
         DICT_SIZE);
     if (shortest_route == nullptr) {
-      printf("No path could be found\n");
-      exit(1);
+      // No further path can be found here
+      break;
     }
     const CITY sr_destination = shortest_route->destination;
     const VALUE* value = get_value(dict, sr_destination.name);
@@ -172,9 +175,14 @@ int dijkstra(
 
   // Print route to target
   const ROUTE* target_route = get_route_for_city(routes, DICT_SIZE, target);
-  printf("Destination %s reached:\n", target);
-  print_route(target_route, start, complete_route, debug);
-  const int distance = target_route->distance;
+  int distance = 0;
+  if (target_route->distance != -1) {
+    printf("Destination %s reached:\n", target);
+    print_route(target_route, start, complete_route, debug);
+    distance = target_route->distance;
+  } else {
+    printf("No path could be found\n");
+  }
 
   // Free mem
   for (int i = 0; i < DICT_SIZE; i++) {

src/main.c

@@ -202,16 +202,18 @@ void calculate_distances(
       *complete_route = tmp_complete_route;
       strcat(*complete_route, " -> ");
     }
-    if (!reallife) {
-      printf(
-          "Estimated price and fuel consumption based on average data (7.7l/km - 1.85€/l):\n"
-          );
+    if (distance != 0) {
+      if (!reallife) {
+        printf(
+            "Estimated price and fuel consumption based on average data (7.7l/km - 1.85€/l):\n"
+            );
+      }
+      const double liter =
+          calculate_fuel_consumption(distance, fuel_efficiency);
+      calculate_liter_price(liter, price_per_liter);
+      *complete_distance += distance;
+      printf("\n");
     }
-    const double liter =
-        calculate_fuel_consumption(distance, fuel_efficiency);
-    calculate_liter_price(liter, price_per_liter);
-    *complete_distance += distance;
-    printf("\n");
   }
 }
 
@@ -311,7 +313,8 @@ int main(const int argc, char* argv[]) {
   // calculate distances
   calculate_distances(waypoints, waypoints_size, dictionary, reallife, debug,
                       &complete_route, &complete_distance);
-  if (strlen(complete_route) > 0 && waypoints_size > 2) {
+  if (complete_route != nullptr && strlen(complete_route) > 0 && waypoints_size
+      > 2) {
     printf("%s\n", complete_route);
     const double liter =
         calculate_fuel_consumption(complete_distance, fuel_efficiency);

src/parsing/parser.c

@@ -15,10 +15,10 @@
 
 int csv_column;
 int char_column_index;
-CITY *start_city;
-CITY *dest_city;
-FILE *map_file;
-DICTIONARY *dictionary;
+CITY* start_city;
+CITY* dest_city;
+FILE* map_file;
+DICTIONARY* dictionary;
 
 /**
  * Initializes the global variables for parsing a new csv row.
@@ -45,13 +45,13 @@ void next_column() {
  * @param dest_city destination city
  * @param dist distance between start and destination city
  */
-bool add_connection_to_dict(DICTIONARY *dictionary, const CITY *start_city,
-                    const CITY *dest_city, const int dist) {
+bool add_connection_to_dict(DICTIONARY* dictionary, const CITY* start_city,
+                            const CITY* dest_city, const int dist) {
   if (start_city == nullptr || dest_city == nullptr) {
     return false;
   }
 
-  VALUE *val = get_value(dictionary, start_city->name);
+  VALUE* val = get_value(dictionary, start_city->name);
   if (val == nullptr) {
     val = malloc(sizeof(VALUE));
     if (val == nullptr) {
@@ -66,7 +66,7 @@ bool add_connection_to_dict(DICTIONARY *dictionary, const CITY *start_city,
   }
 
   const CONNECTION connection = (CONNECTION){
-    .city = *start_city, .destination = *dest_city, .distance = dist};
+      .city = *start_city, .destination = *dest_city, .distance = dist};
 
   if (connection_in_values(val, &connection)) {
     return true;
@@ -79,7 +79,7 @@ bool add_connection_to_dict(DICTIONARY *dictionary, const CITY *start_city,
 /**
  * Frees given parameters and closes file stream.
  */
-void free_mem(FILE *file, char *val) {
+void free_mem(FILE* file, char* val) {
   free(val);
   fclose(file);
 }
@@ -111,7 +111,7 @@ bool malloc_start_dest_city() {
  * @param city city to set the name
  * @return a bool if the name was set successfully
  */
-bool set_city_name(const char *name, CITY *city) {
+bool set_city_name(const char* name, CITY* city) {
   city->name = malloc(strlen(name) + 1);
   if (city->name == nullptr) {
     print_error_general("Name of city is NULL");
@@ -127,11 +127,11 @@ bool set_city_name(const char *name, CITY *city) {
  * @param val string to convert
  * @return the converted integer
  */
-int get_distance_from_str(const char *val) {
+int get_distance_from_str(const char* val) {
   char tmp[char_column_index + 1];
   strncpy(tmp, val + '\0', char_column_index);
   tmp[char_column_index] = '\0';
-  return (int) strtoumax(tmp, nullptr, 10);
+  return (int)strtoumax(tmp, nullptr, 10);
 }
 
 /**
@@ -140,7 +140,7 @@ int get_distance_from_str(const char *val) {
  * @param current_word
  * @return
  */
-bool handle_csv_column(const char *current_word) {
+bool handle_csv_column(const char* current_word) {
   switch (csv_column) {
     case 0: {
       set_city_name(current_word, start_city);
@@ -189,13 +189,14 @@ bool init_parser(const char path[]) {
  * @param current_word string to resize.
  * @return true if reallocation succeeded, false otherwise.
  */
-bool resize_buffer(int *buf_size, char **current_word) {
-  if (current_word == nullptr || *current_word == nullptr || buf_size == nullptr) {
+bool resize_buffer(int* buf_size, char** current_word) {
+  if (current_word == nullptr || *current_word == nullptr || buf_size ==
+      nullptr) {
     return false;
   }
 
   *buf_size += BUFFER_SIZE;
-  char *tmp = realloc(*current_word, *buf_size);
+  char* tmp = realloc(*current_word, *buf_size);
   if (tmp == NULL) {
     return false;
   }
@@ -227,7 +228,7 @@ DICTIONARY* parse(const char path[]) {
     return nullptr;
   }
 
-  char *current_word = malloc(32 * sizeof(char));
+  char* current_word = malloc(32 * sizeof(char));
   if (current_word == NULL || !malloc_start_dest_city()) {
     fclose(map_file);
     free(dictionary);
@@ -251,6 +252,14 @@ DICTIONARY* parse(const char path[]) {
     if (current_char == '\n' || current_char == EOF) {
       line_number++;
       first_column_printable_char = false;
+      // if char_column_index is 0 at this point, we have two consecutive line breaks, either skip or abort if not allowed
+      if (char_column_index == 0) {
+        if (current_char == EOF) {
+          break;
+        } else {
+          continue;
+        }
+      }
       const int dist_str = get_distance_from_str(current_word);
       if (dist_str == 0) {
         print_error_general("Distance has to be 1 or greater");
@@ -259,7 +268,8 @@ DICTIONARY* parse(const char path[]) {
 
       add_connection_to_dict(dictionary, start_city, dest_city, dist_str);
 
-      if (start_city == NULL || dest_city == NULL || !malloc_start_dest_city()) {
+      if (start_city == NULL || dest_city == NULL || !
+          malloc_start_dest_city()) {
         free_mem(map_file, current_word);
         return nullptr;
       }
@@ -291,7 +301,7 @@ DICTIONARY* parse(const char path[]) {
     }
 
     if (is_printable_char(current_char) || first_column_printable_char) {
-      current_word[char_column_index++] = (char) current_char;
+      current_word[char_column_index++] = (char)current_char;
       first_column_printable_char = true;
     }
     increment_char_index();