coding style

src/darray.c

@@ -7,9 +7,6 @@
 #include <stdio.h>
 #include <string.h>
 
-/// Constante pour les erreurs liées à \ref darray_t
-#define PTR_ERROR 2
-
 /**
  * `darrayNew` permet de créer un nouvel objet de type \ref darray_t ne
  * contenant aucun élément. Le seul paramètre, `element_size`, est utilisé afin
@@ -19,12 +16,12 @@
  * \param element_size Taille des objets stockés
  * \return Pointeur sur le nouvel objet \ref darray_t
  */
-darray_t *darrayNew(size_t element_size) {
+darray_t darrayNew(size_t t_element_size) {
-  darray_t *ret;
+  darray_t ret;
-  ret = (darray_t *)malloc(sizeof(darray_t));
+  ret = (darray_t)malloc(sizeof(darray_t));
   ret->begin = NULL;
   ret->end = ret->begin;
-  ret->element_size = element_size;
+  ret->element_size = t_element_size;
   ret->capacity = 0;
   return ret;
 }
@@ -39,17 +36,18 @@ darray_t *darrayNew(size_t element_size) {
  * \param pos Position à laquelle on souhaite insérer un nouvel élément
  * \param elem Élément que l’on souhaite insérer
  */
-void darrayInsert(darray_t *self, void *pos, void *elem) {
+void darrayInsert(darray_t t_self, void *t_pos, void *t_elem) {
   char *itr;
   long pos_aux;
-  pos_aux = (char *)pos - (char *)self->begin;
+  pos_aux = (char *)t_pos - (char *)t_self->begin;
-  if (darraySize(self) >= self->capacity) {
+  if (darraySize(t_self) >= t_self->capacity) {
-    darrayExtend(self);
+    darrayExtend(t_self);
   }
-  itr = (char *)self->begin + pos_aux;
+  itr = (char *)t_self->begin + pos_aux;
-  memmove(itr + self->element_size, itr, (unsigned long)((char *)self->end - itr));
+  memmove(itr + t_self->element_size, itr,
-  memcpy(itr, elem, self->element_size);
+          (unsigned long)((char *)t_self->end - itr));
-  self->end = (char *)self->end + self->element_size;
+  memcpy(itr, t_elem, t_self->element_size);
+  (*t_self).end = (char *)t_self->end + t_self->element_size;
 }
 
 /**
@@ -59,20 +57,20 @@ void darrayInsert(darray_t *self, void *pos, void *elem) {
  *
  *  \param self L'objet darray_t à étendre
  */
-void darrayExtend(darray_t *self) {
+void darrayExtend(darray_t t_self) {
   void *new_array;
   size_t size;
-  size = darraySize(self);
+  size = darraySize(t_self);
   new_array =
-    realloc(self->begin, (darraySize(self) + 1) * self->element_size);
+      realloc(t_self->begin, (darraySize(t_self) + 1) * t_self->element_size);
   if (!new_array) {
     fprintf(stderr, "Failed memory reallocation at %s:%d\nAborting...",
             __FILE__, __LINE__ - 2);
     exit(PTR_ERROR);
   }
-  self->begin = new_array;
+  (*t_self).begin = new_array;
-  ++self->capacity;
+  ++(*t_self).capacity;
-  self->end = (char *)self->begin + size * self->element_size;
+  (*t_self).end = (char *)t_self->begin + size * t_self->element_size;
 }
 
 /**
@@ -84,10 +82,11 @@ void darrayExtend(darray_t *self) {
  * \param self Objet \ref `darray_t` dont on souhaite supprimer un élément
  * \param pos Élément de `self` que l’on souhaite supprimer
  */
-void darrayErase(darray_t *self, void *pos) {
+void darrayErase(darray_t t_self, void *t_pos) {
-  memmove(pos, (char *)pos + self->element_size,
+  memmove(t_pos, (char *)t_pos + t_self->element_size,
-          (unsigned long)(((char *)self->end - self->element_size) - (char *)pos));
+          (unsigned long)(((char *)t_self->end - t_self->element_size) -
-  self->end = (char *)self->end - self->element_size;
+                          (char *)t_pos));
+  (*t_self).end = (char *)t_self->end - t_self->element_size;
 }
 
 /**
@@ -96,8 +95,8 @@ void darrayErase(darray_t *self, void *pos) {
  * \param self Objet \ref darray_t à la fin duquel on souhaite ajouter un nouvel élément
  * \param elem Élément que l’on souhaite ajouter à la fin de `self`
  */
-void darrayPushBack(darray_t *self, void *elem) {
+void darrayPushBack(darray_t t_self, void *t_elem) {
-  darrayInsert(self, self->end, elem);
+  darrayInsert(t_self, t_self->end, t_elem);
 }
 
 /**
@@ -106,8 +105,8 @@ void darrayPushBack(darray_t *self, void *elem) {
  * dernier objet.
  * \param self Objet dont on souhaite supprimer le dernier élément
  */
-void darrayPopBack(darray_t *self) {
+void darrayPopBack(darray_t t_self) {
-  darrayErase(self, (char *)self->end - self->element_size);
+  darrayErase(t_self, (char *)t_self->end - t_self->element_size);
 }
 
 /**
@@ -117,9 +116,9 @@ void darrayPopBack(darray_t *self) {
  * fonction.
  * \param self Objet \ref darray_t à supprimer
  */
-void darrayDelete(darray_t *self) {
+void darrayDelete(darray_t t_self) {
-  free(self->begin);
+  free(t_self->begin);
-  free(self);
+  free(t_self);
 }
 
 /**
@@ -129,8 +128,9 @@ void darrayDelete(darray_t *self) {
  * \param self Objet \ref darray_t dont on souhaite connaître le nombre d’éléments
  * \return Nombre d’éléments contenus dans `self`
  */
-size_t darraySize(darray_t *self) {
+size_t darraySize(darray_t t_self) {
-  return (size_t)((char *)self->end - (char *)self->begin) / self->element_size;
+  return (size_t)((char *)t_self->end - (char *)t_self->begin) /
+         t_self->element_size;
 }
 
 /**
@@ -143,8 +143,8 @@ size_t darraySize(darray_t *self) {
  * \param idx Index de l’élément que l’on souhaite récupérer
  * \return Pointeur de type `void*` pointant sur l’élément si l’index est valide, sur NULL sinon.
  */
-void *darrayGet(darray_t *self, size_t idx) {
+void *darrayGet(darray_t t_self, size_t t_idx) {
   void *itr;
-  itr = (char *)self->begin + idx * self->element_size;
+  itr = (char *)t_self->begin + t_idx * t_self->element_size;
   return itr;
 }

src/darray.h

@@ -20,35 +20,28 @@ typedef struct darray_s {
   void *end; /*!< Pointeur sur l’élément situé immédiatement après le dernier élément du tableau */
   size_t element_size; /*!< Taille des éléments stockés dans le tableau */
   size_t capacity; /*!< Capacité maximale du tableau actuel (non destinée à l’utilisateur) */
-} darray_t;
+} darray;
+typedef darray *darray_t;
 
-/// \brief Créé un nouvel objet \ref darray_t vide
+/// \brief Créé un nouvel objet \ref darray vide
-darray_t *darrayNew(size_t element_size);
+darray *darrayNew(size_t element_size);
-
+/// \brief Augmente la capacité d'un \ref darray
-/// \brief Augmente la capacité d'un \ref darray_t
+void darrayExtend(darray *self);
-void darrayExtend(darray_t *self);
+/// \brief Insère un élément à l’endroit pointé dans un \ref darray
-
+void  darrayInsert(darray *self, void *pos, void *elem);
-/// \brief Insère un élément à l’endroit pointé dans un \ref darray_t
+/// \brief Supprime l’élément pointé dans l’objet \ref darray
-void  darrayInsert(darray_t *self, void *pos, void *elem);
+void  darrayErase(darray *self, void *pos);
-
+/// \brief Retourne l’élément du \ref darray au idx-ème index
-/// \brief Supprime l’élément pointé dans l’objet \ref darray_t
+void *darrayGet(darray *self, size_t idx);
-void  darrayErase(darray_t *self, void *pos);
+/// \brief Insère un élément à la fin de l’élément \ref darray
-
+void  darrayPushBack(darray *self, void *elem);
-/// \brief Retourne l’élément du \ref darray_t au idx-ème index
+/// \brief Supprime le dernier élément de l’élément \ref darray
-void *darrayGet(darray_t *self, size_t idx);
+void  darrayPopBack(darray *self);
-
+/// \brief Détruit l’élément \ref darray
-/// \brief Insère un élément à la fin de l’élément \ref darray_t
+void  darrayDelete(darray *self);
-void  darrayPushBack(darray_t *self, void *elem);
+/// \brief Renvoie la taille de l’élément \ref darray
-
+size_t darraySize(darray *self);
-/// \brief Supprime le dernier élément de l’élément \ref darray_t
+/// \brief Renvoie la taille de l’élément \ref darray
-void  darrayPopBack(darray_t *self);
+size_t darrayElemSize(darray *self);
-
-/// \brief Détruit l’élément \ref darray_t
-void  darrayDelete(darray_t *self);
-
-size_t darraySize(darray_t *self);
-
-/// \brief Renvoie la taille de l’élément \ref darray_t
-size_t darrayElemSize(darray_t *self);
 
 #endif /* DARRAY_H */

src/ppm.c

@@ -9,7 +9,7 @@
 #include <assert.h>
 
 #define RGB_COMPONENT_COLOR 255
-#define CREATOR "Cartier"
+#define CREATOR "CL"
 
 /**
  *  \brief function description
@@ -23,11 +23,11 @@
  *  \param[in] mode Mode du fichier à ouvrir
  *  \return Pointeur de fichier
  */
-FILE* get_file(char *filename, const char* mode) {
+FILE* get_file(char *t_filename, const char* t_mode) {
-  FILE* fp = fopen(filename, mode);
+  FILE* fp = fopen(t_filename, t_mode);
   if (!fp) {
-    fprintf(stderr, "Unable to open file '%s'\n", filename);
+    fprintf(stderr, "Unable to open file '%s'\n", t_filename);
-    exit(1);
+    exit(FILE_IO_ERROR);
   }
   return fp;
 }
@@ -39,16 +39,16 @@ FILE* get_file(char *filename, const char* mode) {
  *  \param[in] fb Fichier ppm où lire les données
  *  \param[in] filename Nom du fichier ouvert
  */
-void read_file_format(FILE* fp, char* filename) {
+void read_file_format(FILE* t_fp, char* t_filename) {
   char buff[16];
-  if (!fgets(buff, sizeof(buff), fp)) {
+  if (!fgets(buff, sizeof(buff), t_fp)) {
-    perror(filename);
+    perror(t_filename);
-    exit(1);
+    exit(FILE_IO_ERROR);
   }
   /* check file format */
   if (buff[0] != 'P' || buff[1] != '6') {
     fprintf(stderr, "Invalid image format (must be 'P6')\n");
-    exit(1);
+    exit(FILE_FORMAT_ERROR);
   }
 }
 
@@ -57,15 +57,15 @@ void read_file_format(FILE* fp, char* filename) {
  *
  *  \param[in] fp Fichier ppm où lire les données
  */
-void check_for_comments(FILE* fp) {
+void check_for_comments(FILE* t_fp) {
   char c;
-  c = (char)getc(fp);
+  c = (char)getc(t_fp);
   while (c == '#') {
-    while (getc(fp) != '\n')
+    while (getc(t_fp) != '\n')
       ;
-    c = (char)getc(fp);
+    c = (char)getc(t_fp);
   }
-  ungetc(c, fp);
+  ungetc(c, t_fp);
 }
 
 /**
@@ -76,10 +76,10 @@ void check_for_comments(FILE* fp) {
  *  \param[out] img Conteneur d’image où écrire les résultats
  *  \param[in] filename Nom du fichier ouvert
  */
-void read_file_size(FILE* fp, Image* img, char* filename) {
+void read_file_size(FILE* t_fp, Image* t_img, char* t_filename) {
-  if (fscanf(fp, "%lu %lu", &img->x, &img->y) != 2) {
+  if (fscanf(t_fp, "%lu %lu", &t_img->x, &t_img->y) != 2) {
-    fprintf(stderr, "Invalid image size (error loading '%s')\n", filename);
+    fprintf(stderr, "Invalid image size (error loading '%s')\n", t_filename);
-    exit(1);
+    exit(FILE_FORMAT_ERROR);
   }
 }
 
@@ -90,35 +90,36 @@ void read_file_size(FILE* fp, Image* img, char* filename) {
  *  \param[in] fp Fichier ppm où lire les données
  *  \param[in] filename Nom du fichier ouvert
  */
-void read_rgb(FILE* fp, char* filename) {
+void read_rgb(FILE* t_fp, char* t_filename) {
   char d;
   int rgb_comp_color;
   /* read rgb component */
-  if (fscanf(fp, "%d", &rgb_comp_color) != 1) {
+  if (fscanf(t_fp, "%d", &rgb_comp_color) != 1) {
-    fprintf(stderr, "Invalid rgb component (error loading '%s')\n", filename);
+    fprintf(stderr, "Invalid rgb component (error loading '%s')\n", t_filename);
-    exit(1);
+    exit(FILE_FORMAT_ERROR);
   }
-  fscanf(fp, "%c ", &d);
+  fscanf(t_fp, "%c ", &d);
   /* check rgb component depth */
   if (rgb_comp_color != RGB_COMPONENT_COLOR) {
-    fprintf(stderr, "'%s' does not have 8-bits components\n", filename);
+    fprintf(stderr, "'%s' does not have 8-bits components\n", t_filename);
-    exit(1);
+    exit(FILE_FORMAT_ERROR);
   }
 }
 
-unsigned long read_data(FILE *fp, Image *img, GLubyte *data, char *filename) {
+unsigned long read_data(FILE *t_fp, Image *t_img, GLubyte *t_data,
+                        char *t_filename) {
   unsigned long size;
   /* allocation memoire */
-  size = img->x * img->y * 3;
+  size = t_img->x * t_img->y * 3;
-  printf("Size image %lu %lu => %lu\n", img->x, img->y, size);
+  printf("Size image %lu %lu => %lu\n", t_img->x, t_img->y, size);
-  data = (GLubyte *)malloc((size_t)size * sizeof(GLubyte));
+  t_data = (GLubyte *)malloc((size_t)size * sizeof(GLubyte));
-  assert(data);
+  assert(t_data);
   /* read pixel data from file */
-  if (!fread(data, (size_t)1, (size_t)size, fp)) {
+  if (!fread(t_data, (size_t)1, (size_t)size, t_fp)) {
-    fprintf(stderr, "Error loading image '%s'\n", filename);
+    fprintf(stderr, "Error loading image '%s'\n", t_filename);
-    exit(1);
+    exit(FILE_IO_ERROR);
   }
-  free(data);
+  free(t_data);
   return size;
 }
 
@@ -133,12 +134,14 @@ unsigned long read_data(FILE *fp, Image *img, GLubyte *data, char *filename) {
  *  \param[in] size Taille du tableau de `GLubyte`
  *  \return return type
  */
-void dataToImage(Image *img, GLubyte *data, unsigned long size) {
+void dataToImage(Image *t_img, GLubyte *t_data, unsigned long t_size) {
   unsigned long i;
-  img->pixels = darrayNew(sizeof(Pixel));
+  t_img->pixels = darrayNew(sizeof(Pixel));
-  for (i = 0; i < size; i += 3) {
+  for (i = 0; i < t_size; i += 3) {
-    darrayPushBack(img->pixels, newPixel(data[i], data[i+1], data[i+2]));
+    darrayPushBack(t_img->pixels,
-    darrayPushBack(img->pixels, newPixel(data[i], data[i+1], data[i+2]));
+                   newPixel(t_data[i], t_data[i + 1], t_data[i + 2]));
+    darrayPushBack(t_img->pixels,
+                   newPixel(t_data[i], t_data[i + 1], t_data[i + 2]));
   }
 }
 
@@ -150,14 +153,14 @@ void dataToImage(Image *img, GLubyte *data, unsigned long size) {
  *  \param[in] img Conteneur d’image contenant les pixels à convertir
  *  \return Tableau de pointeurs de `GLuint`
  */
-GLubyte *imageToData(Image_t img) {
+GLubyte *imageToData(Image_t t_img) {
   Pixel_t pixel;
   GLubyte *data, size;
   unsigned long i;
-  size = (GLubyte)darraySize(img->pixels);
+  size = (GLubyte)darraySize(t_img->pixels);
   data = (GLubyte *)malloc(3 * sizeof(GLubyte) * size);
   for(i = 0; i < size; i += 3) {
-    pixel = darrayGet(img->pixels, i / 3);
+    pixel = darrayGet(t_img->pixels, i / 3);
     data[i] = pixel->r;
     data[i + 1] = pixel->g;
     data[i + 2] = pixel->b;
@@ -175,17 +178,17 @@ GLubyte *imageToData(Image_t img) {
  *  \param[out] img Objet \ref Image manipulable
  *  \return Retourne 1 en cas de succès
  */
-int ImageLoadPPM(char *filename, Image *img) {
+int ImageLoadPPM(char *t_filename, Image *t_img) {
   FILE *fp;
   unsigned long size;
-  GLubyte* data = NULL;
+  GLubyte *data = NULL;
-  fp = get_file(filename, "rb"); /* open PPM file for reading */
+  fp = get_file(t_filename, "rb");       /* open PPM file for reading */
-  read_file_format(fp, filename); /* read image format */
+  read_file_format(fp, t_filename);      /* read image format */
   check_for_comments(fp);                /* check for comments */
-  read_file_size(fp, img, filename); /* read image size information */
+  read_file_size(fp, t_img, t_filename); /* read image size information */
-  read_rgb(fp, filename); /* read rgb component */
+  read_rgb(fp, t_filename);              /* read rgb component */
-  size = read_data(fp, img, data, filename); /* read data from file */
+  size = read_data(fp, t_img, data, t_filename); /* read data from file */
-  dataToImage(img, data, size);
+  dataToImage(t_img, data, size);
   fclose(fp);
   return 1;
 }
@@ -197,17 +200,17 @@ int ImageLoadPPM(char *filename, Image *img) {
  *  \param[in] filename Nom du fichier image à ouvrir
  *  \param[in] img Objet \ref Image à écrire
  */
-void imagesavePPM(char *filename, Image_t img) {
+void imagesavePPM(char *t_filename, Image_t t_img) {
   FILE *fp;
   GLubyte *data;
-  fp = get_file(filename, "wb"); /* open file for output */
+  fp = get_file(t_filename, "wb"); /* open file for output */
   /* write the header file */
   fprintf(fp, "P6\n");                          /* image format */
   fprintf(fp, "# Created by %s\n", CREATOR);    /* comments */
-  fprintf(fp, "%lu %lu\n", img->y, img->y);  /* image size */
+  fprintf(fp, "%lu %lu\n", t_img->y, t_img->y); /* image size */
   fprintf(fp, "%d\n", RGB_COMPONENT_COLOR);     /* rgb component depth */
-  data = imageToData(img); /* pixel data */
+  data = imageToData(t_img);                    /* pixel data */
-  fwrite(data, (size_t)1, (size_t)(3 * img->x * img->y), fp);
+  fwrite(data, (size_t)1, (size_t)(3 * t_img->x * t_img->y), fp);
   free(data);
   fclose(fp);
 }

src/utilities.c

@@ -18,12 +18,12 @@
  *  \param[in] b Valeur bleue du pixel
  *  \return Pointeur sur une structure de type \ref Pixel
  */
-Pixel_t newPixel(uint8_t r, uint8_t g, uint8_t b) {
+Pixel_t newPixel(uint8_t t_r, uint8_t t_g, uint8_t t_b) {
   Pixel_t res;
   res = (Pixel_t)malloc(sizeof(Pixel));
-  res->r = r;
+  res->r = t_r;
-  res->g = g;
+  res->g = t_g;
-  res->b = b;
+  res->b = t_b;
   res->visited = false;
   return res;
 }
@@ -36,8 +36,8 @@ Pixel_t newPixel(uint8_t r, uint8_t g, uint8_t b) {
  *
  *  \param[in] self Pointeur vers le pixel à détruire
  */
-void deletePixel(Pixel_t self) {
+void deletePixel(Pixel_t t_self) {
-  free(self);
+  free(t_self);
 }
 
 /**
@@ -64,13 +64,13 @@ Image_t newImage() {
  *
  *  \param[in] self Conteneur d’image à détruire
  */
-void deleteImage(Image_t self) {
+void deleteImage(Image_t t_self) {
   unsigned long i;
-  for(i = 0; i < darraySize(self->pixels); ++i) {
+  for(i = 0; i < darraySize(t_self->pixels); ++i) {
-    deletePixel(darrayGet(self->pixels, i));
+    deletePixel(darrayGet(t_self->pixels, i));
   }
-  darrayDelete(self->pixels);
+  darrayDelete(t_self->pixels);
-  free(self);
+  free(t_self);
 }
 
 /**
@@ -83,12 +83,12 @@ void deleteImage(Image_t self) {
  *  \param[in] xg Abscisse extrême gauche du segment
  *  \return Pointeur sur un conteneur de segment
  */
-Segment_t newSegment(uint16_t y, uint16_t xd, uint16_t xg) {
+Segment_t newSegment(uint16_t t_y, uint16_t t_xd, uint16_t t_xg) {
   Segment_t res;
   res = (Segment_t)malloc(sizeof(Segment));
-  res->y = y;
+  res->y = t_y;
-  res->xd = xd;
+  res->xd = t_xd;
-  res->xg = xg;
+  res->xg = t_xg;
   return res;
 }
 
@@ -99,8 +99,8 @@ Segment_t newSegment(uint16_t y, uint16_t xd, uint16_t xg) {
  *
  *  \param[in] self Conteneur de segment à détruire
  */
-void deleteSegment(Segment_t self) {
+void deleteSegment(Segment_t t_self) {
-  free(self);
+  free(t_self);
 }
 
 /**
@@ -115,12 +115,12 @@ void deleteSegment(Segment_t self) {
  *  \param[in] b Valeur bleue de la couleur de la zone
  *  \return Pointeur vers la structure créée
  */
-Zone_t newZone(uint8_t r, uint8_t g, uint8_t b) {
+Zone_t newZone(uint8_t t_r, uint8_t t_g, uint8_t t_b) {
   Zone_t res;
   res = (Zone_t)malloc(sizeof(Zone));
-  res->r = r;
+  res->r = t_r;
-  res->g = g;
+  res->g = t_g;
-  res->b = b;
+  res->b = t_b;
   res->segments = darrayNew(sizeof(Segment));
   return res;
 }
@@ -133,11 +133,11 @@ Zone_t newZone(uint8_t r, uint8_t g, uint8_t b) {
  *
  *  \param[in] self Conteneur de zone à détruire
  */
-void deleteZone(Zone_t self) {
+void deleteZone(Zone_t t_self) {
   unsigned long i;
-  for(i = 0; i < darraySize(self->segments); ++i) {
+  for(i = 0; i < darraySize(t_self->segments); ++i) {
-    deleteSegment(darrayGet(self->segments, i));
+    deleteSegment(darrayGet(t_self->segments, i));
   }
-  darrayDelete(self->segments);
+  darrayDelete(t_self->segments);
-  free(self);
+  free(t_self);
 }

src/utilities.h

@@ -32,6 +32,16 @@
   printf
 #endif
 
+/// Pas d’erreur
+#define NOERROR 0
+/// Constante pour les erreurs liées aux arguments
+#define ARGERROR 1
+/// Constante pour les erreurs liées à \ref darray_t
+#define PTR_ERROR 2
+/// Constante pour les erreurs liées à la lecture et écriture de fichiers
+#define FILE_IO_ERROR 3
+#define FILE_FORMAT_ERROR 4
+
 /*****************************************************************************/
 /*                             STRUCT DECLARATION                            */
 /*****************************************************************************/
@@ -64,7 +74,7 @@ typedef Segment *Segment_t;
 struct Image {
   uint64_t x;       /*!< Largeur de l’image */
   uint64_t y;       /*!< Hauteur de l’image */
-  darray_t *pixels; /*!< Vecteur de pixels */
+  darray_t pixels; /*!< Vecteur de pixels */
 };
 
 /**
@@ -91,7 +101,7 @@ struct Zone {
   uint8_t r;          /*!< Couleur rouge de la zone */
   uint8_t g;          /*!< Couleur verte de la zone */
   uint8_t b;          /*!< Couleur bleue de la zone */
-  darray_t *segments; /*!< Vecteur de segments */
+  darray_t segments; /*!< Vecteur de segments */
 };
 
 /**