BIBLIOTHÈQUE DE GESTION DE FILES DYNAMIQUES

file.h :

#ifndef _file_h_
#define _file_h_

#include <stdlib.h>

typedef int variant; /* remplacer int par le type de donnees a enfiler */

/*---------------- STRUCTURE DE FILE.C ---------------------------------------------*/

/*
  Structure :
  Nom	:	section
  Fct	:	structure definisssant une section d'elements de type "variant"
*/

typedef struct section
{
  variant * tab;     /* tableau representant la section proprement dite */
  struct section * suiv;  /* pointeur sur la section suivante */
  struct section * prec;  /* pointeur sur la section precedente */
} section_t;

/*
  Structure :
  Nom	:	file
  Fct	:	structure definissant une file d'elements de type "variant"
*/

typedef struct file
{
  int a;            /* indice de debut de la file : premier element a sortir */
  int b;            /* indice de fin de la file : dernier element a sortir */
  int pas;          /* nombre d'elements dans une section de file */
  section_t * tete; /* pointeur de tete de la file */
  section_t * sect;  /* pointeur sur la dernière section de la file */
} file_t;


/*---------------- FONCTIONS DE FILE.C ---------------------------------------------*/

/*
  Nom	:	vide
  Fct	:	retourne un booleen indiquant si la file est vide
  Entree	:	(f) adresse de la file
  Sortie	:	booleen indiquant que la file est vide
*/

unsigned short int vide(file_t * f);

/*
  Nom	:	init
  Fct	:	cree une nouvelle file et retourne son adresse
  Entree	:	(maxi) nombre maximal d'elements de la file
  Sortie	:	adresse de la nouvelle file
*/

file_t * init(int maxi);

/*
  Nom	:	enfile
  Fct	:	enfile un nouvel element sur la file
  Entree	:	(f) adresse de la file
			(x) element a rajouter
  Sortie	:	booleen indiquant que tout s'est bien passe
*/

void enfile(file_t * f, variant x);

/*
  Nom	:	defile
  Fct	:	defile un element de la file et renvoie un booleen indiquant que tout s'est bien passe
  Entree	:	(f) adresse de la file
			(x) adresse de stockage de l'element defile
  Sortie	:	booleen indiquant que tout s'est bien passe
*/

unsigned short int defile(file_t * f, variant * x);

/*
Nom	:	supprime
Fct	:	libere toute la mémoire occupee par une file
Entree	:	(f) adresse de la file
*/

void supprime(file_t * f);

#endif



file.c :

#include "file.h"

/*
  Nom	:	vide
  Fct	:	retourne un booleen indiquant si la file est vide
  Entree	:	(f) adresse de la file
  Sortie	:	booleen indiquant que la file est vide
*/

unsigned short int vide(file_t * f)
{
  return ((f->a) == -1); /* la pile est vide si a=-1 */
}

/*
  Nom	:	init
  Fct	:	cree une nouvelle file et retourne son adresse
  Entree	:	(maxi) nombre maximal d'elements de la file
  Sortie	:	adresse de la nouvelle file
*/

file_t * init(int pas)
{
  file_t * adr_file=NULL; /* l'adresse de la file est NULL si l'allocation echoue */
  
  adr_file = (file_t *)malloc(sizeof(file_t)); /* adresse de la pile cree */
  if ( adr_file )
  {
    adr_file->a = -1;      /* aucun element dans la file */
    adr_file->b = -1;
    adr_file->pas = pas;  /* nombre maximal d'elements */
    adr_file->tete = NULL; /* la file est vide */
    adr_file->sect = NULL; /* la file est vide */
  }
  
  return adr_file;
}

/*
  Nom	:	enfile
  Fct	:	enfile un nouvel element sur la file
  Entree	:	(f) adresse de la file
			(x) element a rajouter
  Sortie	:	booleen indiquant que tout s'est bien passe
*/

void enfile(file_t * f, variant x)
{
  unsigned short int succes = 0;

  if ( vide(f) ) /* si la file est vide */
  {
    f->tete = (section_t *)malloc(sizeof(section_t));             /* creation d'une premiere section */
    f->sect = f->tete;
    f->sect->tab = (variant *)malloc((f->pas) * sizeof(variant)); /* allocation de la premiere section */
    f->sect->suiv = NULL;                                         /* pas de section suivante */
    f->sect->prec = NULL;                                         /* pas de section precedente */
    f->a = 0;  /* le premier element est mis au debut du tableau */
    f->b = 0;  /* le dernier element est aussi le premier */
  }
  else
  {
    if( f->b == f->pas - 1 ) /* si la section est pleine */
    {
      f->sect->suiv = (section_t *)malloc(sizeof(section_t));       /* creation d'une nouvelle section */
      f->sect->suiv->prec = f->sect;                                /* maj section precedente */
      f->sect = f->sect->suiv;                                      /* maj derniere section */
      f->sect->tab = (variant *)malloc((f->pas) * sizeof(variant)); /* allocation de la derniere section */
      f->sect->suiv = NULL;                                         /* pas de section suivante */
      f->b = 0;                                                     /* indice de fin a zero */
    }
    else
    {
      f->b = f->b + 1; /* incrementation de l'indice de fin */
    }
  }
  *(f->sect->tab + f->b) = x; /* rajout du nouvel element sur la file */
}

/*
  Nom	:	defile
  Fct	:	defile un element de la file et renvoie un booleen indiquant que tout s'est bien passe
  Entree	:	(f) adresse de la file
			(x) adresse de stockage de l'element defile
  Sortie	:	booleen indiquant que tout s'est bien passe
*/

unsigned short int defile(file_t * f, variant * x)
{
  unsigned short int succes = 0;
  
  if ( !vide(f) ) /* si la file n'est pas vide */
    {
      *x = *(f->tete->tab + f->a); /* sortie du premier element rajoute */
      if ( f->sect->prec != NULL ) /* s'il y a au moins deux sections */
      {
        if ( f->a != f->pas - 1 ) /* si la section ne doit pas disparaitre */
        {
          f->a = f->a + 1; /*incrementation de l'indice de debut*/
        }
        else
        {
          f->tete = f->tete->suiv; /* changement de la section de tete */
          free(f->tete->prec);     /* suppression de la section */
          f->tete->prec = NULL;    /* pas de section precedente */
          f->a = 0;                /* mise a zero de l'indice de debut */
        }
      }
      else
      {
        if ( f->a != f->b ) /* si la file comporte au moins deux elements */
        {
          f->a = f->a + 1; /* incrementation de l'indice de debut */
        }
        else
        {
          free(f->tete);  /* liberation de la section */
          f->sect = NULL; /* raz du pointeur de derniere section */
          f->a = -1;      /* maintenant la file est vide */
          f->b = -1;
        }
      }
      succes = 1; /* marquage de la reussite */
    }
  
  return succes;
}

/*
Nom	:	supprime
Fct	:	libere toute la memoire occupee par une file
Entree	:	(f) adresse de la file
*/

void supprime(file_t * f)
{
  section_t * cour = f->tete, * suiv;
  if ( cour != NULL )  /* s'il existe au moins une section */
  {
    suiv = f->tete->suiv;
    while ( cour != NULL )  /* tant qu'il reste des sections non supprimees */
    {
       suiv = cour->suiv;  /* progression du pointeur suivant */
       free(cour->tab);    /* liberation du contenu de la section courante */
       free(cour);         /* liberation de la section courante */
       cour = suiv;        /* progression du pointeur courant */
    }
  }
  free(f);  /* liberation de la structure pile */
}