terça-feira apos lab

Author: RicardoQS23

9.sol1

@@ -1,2 +1,4 @@
 0
 
+6
+

Makefile

@@ -3,7 +3,7 @@
 CC = gcc #compiler
 
 # flags para compilar
-CFLAGS= -Wall -std=c99 -O3
+CFLAGS= -Wall -std=c99 -O3 -g
 TARGET= RoaP_Int
 # gerar variáveis com listas ficheiros de cada tipo para usar nas várias regras
 SRCS=$(wildcard *.c)

Processor.c

@@ -95,50 +95,11 @@ int mode_A5(int a, int b, int **labyrinth, int L, int C)
     return 0;
 }
 
-/*
-int traversed(int x, int y, int **traversed_path, int L, int C, int *size_traversed)
+int mode_A6(int a, int b, int c, int d)
 {
-    int i;
-    for (i = 0; i < (*size_traversed); i++)
-    {
-        if (x == traversed_path[i][0] && y == traversed_path[i][1]) return 1;
-    }
-    return 1;
-}
-
-int try(int x,int y, int **labyrinth, int **traversed_path, int x_finish, int y_finish, int *size_traversed, int L, int C)
-{
-    if (x < 0 || y < 0 || x > L-1 || y > C-1) return 0;
-    if (traversed(x, y, traversed_path, L, C, size_traversed) || labyrinth[x][y] > 0) return 0;
-    //colocar no traversed_path
-    labyrinth[x][y] = -3;
-    (*size_traversed)++;
-    if (x == x_finish && y == y_finish)
-    {
-        //tirar do traversed_path
-        return 1;
-    }
-    else
-    {
-        try(x - 1, y, labyrinth, traversed_path, x_finish, y_finish, size_traversed, L, C);
-        try(x + 1, y, labyrinth, traversed_path, x_finish, y_finish, size_traversed, L, C);
-        try(x, y + 1, labyrinth, traversed_path, x_finish, y_finish, size_traversed, L, C);
-        try(x, y - 1, labyrinth, traversed_path, x_finish, y_finish, size_traversed, L, C);
-    }
-    //tirar dos traversed_path
     return 0;
-    
-
 }
 
-
-int mode_A6(int a, int b, int l, int c, int **labyrinth, int **traversed_path, int *size_traversed, int L, int C)
-{
-
-    return try(a, b, labyrinth, traversed_path, l, c, size_traversed, L, C);
-    return 0;
-}
-*/
 int **allocate_table(int **labyrinth, int C, int L)
 {
     int i;
@@ -148,7 +109,7 @@ int **allocate_table(int **labyrinth, int C, int L)
     return labyrinth;
 }
 
-int choose_test(char *test_mode, int **labyrinth, int L, int C, int a, int b)
+int choose_test(char *test_mode, int **labyrinth, int L, int C, int a, int b, int c, int d)
 {
     if (strcmp(test_mode, "A1") == 0)
         return mode_A1(a, b, labyrinth, L, C);
@@ -161,6 +122,6 @@ int choose_test(char *test_mode, int **labyrinth, int L, int C, int a, int b)
     if (strcmp(test_mode, "A5") == 0)
         return mode_A5(a, b, labyrinth, L, C);
     if (strcmp(test_mode, "A6") == 0)
-        return mode_A6(a, b, l, c, labyrinth, traversed_path, &size_traversed, L, C);
+        return mode_A6(a, b, c, d);
     return 0;
 }

Proj_Int.h

@@ -13,16 +13,16 @@ int mode_A2(int a, int b, int **labyrinth, int L, int C);
 int mode_A3(int a, int b, int **labyrinth, int L, int C);
 int mode_A4(int a, int b, int **labyrinth, int L, int C);
 int mode_A5(int a, int b, int **labyrinth, int L, int C);
-//int mode_A6(int a, int b);
-int choose_test(char *test_mode, int **labyrinth, int L, int C, int a, int b);
+int mode_A6(int a, int b, int c, int d);
+int choose_test(char *test_mode, int **labyrinth, int L, int C, int a, int b, int c, int d);
 void print_table(int **labyrinth, int L, int C);
 void free_labyrinth(int **labyrinth, int C);
-void write_output(FILE *fp_out, int result);
+void write_output(FILE *fp, int result);
 void str_paste(char *name, char *filename, int num_chars);
 int find_last_period(char *filename);
-int **allocate_table(int **labyrinth, int C, int L);
 char *allocate_outputname(char *out_name, char *in_name);
-void error(FILE *fp);
-FILE *open_outputfile(FILE *fp_out, char *filename);
+int **allocate_table(int **labyrinth, int C, int L);
 FILE *open_inputfile(FILE *fp_in, char *filename);
+FILE *open_outputfile(FILE *fp_out, char *filename);
+void error(FILE *fp_in, FILE *fp_out, char *filename_out, char *filename_in);
 #endif

Read.c

@@ -10,8 +10,6 @@
 
 void Read_input_file(char *filename)
 {
-    // int **traversed_path = NULL;
-    //int *size_traversed = NULL;
     int x = 0, y = 0, v = 0, count = 0, P = 0, result = 0; //P= number of grey/black cells, (x,y) = grey/black cells coordinates, v=value of respective cell
     int C = 0, L = 0, a = 0, b = 0, c = 0, d = 0;          // C=columns, L=lines, (a,b)=coordinates of the cell we want to analyse, P= number of grey/black cells
     int **labyrinth = NULL;
@@ -21,40 +19,37 @@ void Read_input_file(char *filename)
     FILE *fp_in = NULL, *fp_out = NULL;
 
     fp_in = open_inputfile(fp_in, filename);
-
     out_name = allocate_outputname(out_name, filename);
     fp_out = open_outputfile(fp_out, out_name);
-    while (fp_in != NULL)
+
+    while ((fscanf(fp_in, "%d %d", &L, &C)) == 2)
     {
-        if ((fscanf(fp_in, "%d %d", &L, &C)) != 2)
-            error(fp_in);
         if ((fscanf(fp_in, "%d %d %s", &a, &b, test_mode)) != 3)
-            error(fp_in);
+            error(fp_in, fp_out, out_name, filename);
 
         if (strcmp(test_mode, "A6") == 0)
             if ((fscanf(fp_in, "%d %d", &c, &d)) != 2)
-                error(fp_in);
+                error(fp_in, fp_out, out_name, filename);
+
+        if ((fscanf(fp_in, "%d", &P)) != 1)
+            error(fp_in, fp_out, out_name, filename);
 
         labyrinth = allocate_table(labyrinth, C, L); // Dynamic allocation of the main labyrinth
 
-        if ((fscanf(fp_in, "%d", &P)) != 1)
-        {
-            free_labyrinth(labyrinth, C);
-            error(fp_in);
-        }
-        while ((fscanf(fp_in, "%d %d %d", &x, &y, &v) == 3) && (count < P))
+        while (count < P)
         {
+            if ((fscanf(fp_in, "%d %d %d", &x, &y, &v) != 3))
+            {
+                free_labyrinth(labyrinth, C);
+                error(fp_in, fp_out, out_name, filename);
+            }
             labyrinth[x - 1][y - 1] = v; //remember that the coordinate (0,0) represents the (1,1) cell
             count++;
         }
-        //print_table(labyrinth, L, C);
-        /* result = choose_test(test_mode, labyrinth, L, C, a, b, c, d, traversed_path, size_traversed);
-        write_output_file(name, result, filename);
-        free_labyrinth(labyrinth, L, C);*/
-        result = choose_test(test_mode, labyrinth, L, C, a, b);
+        result = choose_test(test_mode, labyrinth, L, C, a, b, c, d);
         write_output(fp_out, result);
         free_labyrinth(labyrinth, C);
-        count = 0;
+     count = 0;
     }
     free(out_name);
     fclose(fp_in);
@@ -89,10 +84,13 @@ char *allocate_outputname(char *out_name, char *in_name)
     return out_name;
 }
 
-void error(FILE *fp)
+void error(FILE *fp_in, FILE *fp_out, char *filename_in, char *filename_out)
 {
-    printf("Error when reading the input file.\n");
-    fclose(fp);
+    printf("Error when reading data.\n");
+    fclose(fp_in);
+    fclose(fp_out);
+    free(filename_out);
+    free(filename_in);
     exit(0);
 }
 

RoaP_Int

@@ -30,12 +30,32 @@ no âmbito da Licenciatura Bolonha em Engenharia Eletrotécnica e de Computadore
 
 int main(int argc, char *argv[])
 {
+    char *filename = NULL;
     if (argc != 3)
     {
         help();
         exit(0);
     }
-    Read_input_file(argv[2]);
+    if (strcmp(argv[1], "-s") == 0)
+    {
+        if ((filename = (char *)malloc((strlen(argv[2]) + 1) * sizeof(char))) == NULL)
+        {
+            printf("Error when trying to get memory to allocate input file name!\n");
+            exit(0);
+        }
+        strcpy(filename, argv[2]);
+    }
+    else
+    {
+        if ((filename = (char *)malloc((strlen(argv[1]) + 1) * sizeof(char))) == NULL)
+        {
+            printf("Error when trying to get memory to allocate input file name!\n");
+            exit(0);
+        }
+        strcpy(filename, argv[1]);
+    }
+    Read_input_file(filename);
+    free(filename);
     return 0;
 }