Exercice 1
==========

Q1.

typedef struct {unsigned int racine ; unsigned int exposant ; } Puissance ;

Q2. 

Puissance produitPuiss (Puissance n1 ; Puissance n2) {
  // pre-condition : n1 et n2 ont meme racine
  Puissance resultat ;
  resultat.racine = n1.racine ;
  resultat.exposant = n1.exposant + n2.exposant ;
  return resultat ;
}

Puissance expPuiss (Puissance n1 ; int p2) {
  Puissance resultat ;
  resultat.racine = n1.racine ;
  resultat.exposant = n1.exposant * p2 ;
  return resultat ;
}

Q3.

int valeurpuiss (Puissance n) {
  int resultat = 1 ;
  unsigned int i ;
  for (i=0; i<n.exposant ; i++) {
  	resultat = resultat x n.racine ;
  } ;
  return resultat ;
}

Q4. L'interet du type Puissance est de pouvoir representer certains entiers de
grandes tailles. Le type unsigned int est limite a la valeur 2^32 -1, alors
qu'avec le type Puissance on peut representer (2^32 -1)^(2^32 -1). 


Exercice 2
==========

Q1. Un Makefile possible

main: main.o saisie.o calcul.o 
	gcc -o main main.o saisie.o calcul.o 

main.o: types.h saisie.h calcul.h main.c 
	gcc -c main.c 

saisie.o: types.h saisie.c
	gcc -c saisie.c 

calcul.o: types.h calcul.c
	gcc -c calcul.c 

Q2. Si on modifie saisie.c apres une premiere compilation, le prochain appel a
make produira les deux commandes suivantes :

	gcc -c saisie.c 
	gcc -o main main.o saisie.o calcul.o 


Exercice 3
==========

Q1.

void makeBlock (Block b) {
  int i ;			// indice de boucle

  i=-1 ;
  do {
    i=i+1 ;
  	scanf ("%c", &(b[i])) ;  // lecture d'un caractere et stockage dans b[i]
  } while (b[i] != '\0') ;

  b[255] = checksum (b) ;   // on memorise le checksum de la chaine lue
}

Q2.

int checkBlock(Block b) {
	return (cheksum(b) == b[255]) ;
}

Q3.

unsigned char checksum (unsigned char *m) {
	int i=0 ; // indice de boucle
	unsigned char cs=0 ; // checksum

	while (b[i] != '\0') {
		cs = cs + b[i] ;
        i = i+1 ;
    } ;
	return cs % 255 ;  
} 

Rqs : 
     on pourrait terminer par "returm cs" au lieu de "return (cs % 255)",  car 
     les additions sur le type unsigned char se font toujours modulo 255

Q4. Cette fonction checksum ne tient pas compte de l'ordre des caracteres.
    Ainsi, "CCI" et "ICI" auront meme checksum ...
    Plus generalement il est possible que 2 messages differents aient meme
    checksum, ce qui fait que le recepteur peut accepeter un message incorrect.

Q5.

   typedef struct message {
		Block b ;
        struct message suiv ;
   } cellule ;					// un element de la liste chainee

   typedef cellule *Message ;   // Message est un pointeur de cellule

Q6. 

On choisit ici de perserver l'ordre des caracateres, on va donc inserer les 
nouveaux blocs en fin de liste (on pourrait aussi faire une insertion en tete,
ce qui serait plus facile ...)

Message makeMsg() {
  int i ;			// indice de boucle
  unsigned char c ; // caractere courant 
  Message mfictif, mqueue, mpred ; // message fictif, message de queue et predecesseur

  mfictif = (Message) malloc (sizeof cellule) ; // allocation d'un fictif
  mfictif->suiv = NULL ;
  mqueue = mtete ;

  i=0 ;
  do {
  	fscanf("%c", &c) ;  // lecture du caractere courant
	if (i==0) {
		// allocation d'un nouveau bloc et mise a jour de mpred et mqueue
  		mqueue->suiv = (Message) malloc (sizeof cellule) ; 
		mpred = mqueue ;
		mqueue = mqueue -> suiv ;
		mqueue->suiv = NULL ;
		mqueue->(b[i]) = c ; // stockage du caractere lu
		i=i+1 ;
 		if (i == 255) {
			// on termine le bloc courant en lui ajoutant son checksum 
			mqueue->(b[255]) = checksum(mqueue->b) ; // checksum
			i=0 ; // on remet i a 0 pour le prochain bloc ...
        } ;
    } while (c != '\0') ; 

	// on renvoie la liste sans le fictif
	returm mfictif->suiv ;
}

Q7. 

int checkMsg (Message m) {
   Message mcour ; // acces au bloc courant

   mcour = m ;
   while ((mcour != NULL) &&  checkBlock(mcour)) { 
		mcour = mcour->suiv ;
   } ;
   return (mcour == NULL) ;
		 
} 

Q8.

void suppIncBlock (Message *m) {
  Message mcour, mfictif,  mpred ;

  mfictif = (Message) malloc (sizeof cellule) ; // allocation d'un fictif
  mfictif->suiv = *m ;
  mcour = *m ;
  mpred = mfictif ;

  while (mcour != NULL) {
     	if (checksum(mcour->b) != mcour->(b[255])) {
				// mcour est un bloc incorrect, il faut le supprimer
				mpred->suiv = mcour->suiv ;
				free(mcour) ;
				mcour=mpred->suiv ;
		} else {
				mpred = mcour ;
				mcour = mcour->suiv ;
		} 
  }

  // on affecte a m la liste privee de son fictif
  *m = mfictif->suiv ; 
  
}