/* interface */

#define NB_ELEM 20
struct matrice
{
   int tab[NB_ELEM][NB_ELEM];
   int nbl;
   int nbc;
};

typedef struct matrice matrice;

int puissance (int nb, int exposant);
char *mattoc (matrice * mat);
matrice *ctomat (char *final);

/* implementation */

#include <stdio.h>
#include <stdlib.h>

# define MAX 0

//fonction puissance//////////////////////////
int puissance (int nb, int exposant)
{
   int resu = nb;
   int k = 1;

   if (exposant > 0)
   {
      for (k = 1; k < exposant; k++)
      {
         resu = resu * nb;
      }

   }
   if (exposant == 0)
   {
      resu = 1;
   }
   return resu;
}

//fonction qui converti une matrice en chaine////////////////////////////////

char *mattoc (matrice * mat)
{
   char *resultat;
   char buf[1];
   char final[1024];
   resultat = "\0";
   int i, j;
   final[1024] = "\0";


   for (i = 0; i < (*mat).nbl; i++)
   {
      for (j = 0; j < (*mat).nbc; j++)
      {

         //printf("%d\n",j);
         sprintf (buf, "%d", (*mat).tab[i][j]);
         strcat (final, buf);
         if (j != 2)
         {
            strcat (final, ",");
         }
      }
      strcat (final, "/");
   }
   resultat = final;
   return resultat;
}

//fonction qui converti une chaine en matrice////////////////////////////////
matrice *ctomat (char *final)
{
   matrice *mat;
   char buffer;
   int nblu = 0;
   int compt = 0;
   int nbl = 0;
   int nbc = 0;
   int nb = 0;
   int n;
   int k = 0;
   int i = 0;
   int j = 0;
   char temp[500] = "\0";
   printf ("on rentre dans la fonction\n");
   strcpy (temp, final);
   printf (" le chaine a converir est %s\n", temp);
   printf ("on fait %d\n", strlen (temp));
   while (compt < strlen (temp))
   {
      printf ("on rentre dans while\n");
      if ((temp[compt] != ',') && (temp[compt] != '/'))
      {
         printf ("on rentre dans 1er if\n");
         nblu++;

      }

      if ((temp[compt] == ',') || (temp[compt] == '/'))
      {

         printf ("on rentre dans 2ème if\n");
         for (k = compt - nblu; k < compt; k++)
         {

            nblu--;
            buffer = temp[k];
            n = strtol (buffer, NULL, 10);
            printf ("on converti buffer vers n\n");
            printf (" n vaut %d\n", n);
            nb = nb + (n * puissance (10, nblu));
            printf (" nb vaut %d\n", nb);

         }
         printf ("valeur de nbl %d\n", nbl);
         printf ("valeur de nbc %d\n", nbc);
         mat->tab[nbl][nbc] = nb; //l erreur est ici
         //printf("%d\n",nb);
         nb = 0;
         nbc++;

      }
      if (temp[compt] == '/')
      {
         nbl++;
         (*mat).nbl = nbl;
         nbc = 0;
      }
      compt++;

   }
   return mat;
}


#ifdef TEST
main ()
{
   matrice m1;
   matrice *m2;
   char *m;
   init_mat (&m1);
   saisir_mat (&m1);
   m = mattoc (&m1);
   printf (" le tableau converti en chaine est %s\n", m);
   m2 = ctomat (m);
   affiche_mat (&m2);
}
#endif