#include <stdio.h>
#include <string.h>

#include "verif.h"
#include "utils.h"

#define ERR_DECLARATION_TYPE_LABYRINTHE \
  "Ligne : %lu.\n" \
  "Erreur de déclaration du type de labyrinthe : " \
  "type de labyrinthe inconnu : %s.\n", \
  no_ligne, u

#define ERR_DECLARATION_TYPE_LABYRINTHE_2_FOIS \
  "Ligne : %lu.\n" \
  "Erreur de déclaration du type de labyrinthe : " \
  "déclaration faite une seconde fois.\n", no_ligne

#define ERR_DECLARATION_MANQUE_TYPE_LABYRINTHE \
  "Ligne : %lu.\n" \
  "Erreur de déclaration de paramètres : " \
  "il faut d'abord déclarer le type de labyrinthe.\n", \
  no_ligne

#define ERR_DECLARATION_PARAMS_BUFFER_TROP_PETIT \
  "Ligne : %lu.\n" \
  "Erreur de déclaration de paramètres : " \
  "il n'y a plus de place dans le buffer " \
  "destination des paramètres.\n", no_ligne

#define ERR_DECLARATION_TOTAL_CELLULES_NEGATIF \
  "Ligne : %lu.\n" \
  "Le nombre total de cellules " \
  "doit être obligatoirement positif " \
  "et ce n'est pas le cas.\n", no_ligne

#define ERR_DECLARATION_TOTAL_CELLULES_DECLARE_2_FOIS \
  "Ligne : %lu.\n" \
  "Une seule déclaration du nombre total " \
  "de cellules est autorisée " \
  "et ce n'est pas le cas.\n", no_ligne

#define ERR_DECLARATION_TOTAL_LIENS_NEGATIF \
  "Ligne : %lu.\n" \
  "Le nombre total de liens " \
  "doit être obligatoirement positif " \
  "et ce n'est pas le cas.\n", no_ligne

#define ERR_DECLARATION_TOTAL_LIENS_DECLARE_2_FOIS \
  "Ligne : %lu.\n" \
  "Une seule déclaration du nombre total " \
  "de liens est autorisée " \
  "et ce n'est pas le cas.\n", no_ligne

#define ERR_DECLARATION_BEGIN_CELL_MIN_NEGATIF \
  "Ligne : %lu.\n" \
  "Le nombre begin_nb_cells_min " \
  "doit être obligatoirement positif " \
  "et ce n'est pas le cas.\n", no_ligne

#define ERR_DECLARATION_BEGIN_CELL_MIN_DECLARE_2_FOIS \
  "Ligne : %lu.\n" \
  "Une seule déclaration du nombre " \
  "begin_nb_cells_min est autorisée " \
  "et ce n'est pas le cas.\n", no_ligne

#define ERR_DECLARATION_BEGIN_CELL_MAX_NEGATIF \
  "Ligne : %lu.\n" \
  "Le nombre begin_nb_cells_max " \
  "doit être obligatoirement positif " \
  "et ce n'est pas le cas.\n", no_ligne

#define ERR_DECLARATION_BEGIN_CELL_MAX_DECLARE_2_FOIS \
  "Ligne : %lu.\n" \
  "Une seule déclaration du nombre " \
  "begin_nb_cells_max cellules est autorisée " \
  "et ce n'est pas le cas.\n", no_ligne

#define ERR_DECLARATION_END_CELL_MIN_NEGATIF \
  "Ligne : %lu.\n" \
  "Le nombre end_nb_cells_min " \
  "doit être obligatoirement positif " \
  "et ce n'est pas le cas.\n", no_ligne

#define ERR_DECLARATION_END_CELL_MIN_DECLARE_2_FOIS \
  "Ligne : %lu.\n" \
  "Une seule déclaration du nombre " \
  "end_nb_cells_min est autorisée " \
  "et ce n'est pas le cas.\n", no_ligne

#define ERR_DECLARATION_END_CELL_MAX_NEGATIF \
  "Ligne : %lu.\n" \
  "Le nombre end_nb_cells_max " \
  "doit être obligatoirement positif " \
  "et ce n'est pas le cas.\n", no_ligne

#define ERR_DECLARATION_END_CELL_MAX_DECLARE_2_FOIS \
  "Ligne : %lu.\n" \
  "Une seule déclaration du nombre " \
  "end_nb_cells_max est autorisée " \
  "et ce n'est pas le cas.\n", no_ligne

#define ERR_DECLARATION_BEGIN_CELL_MANQUE_DECLARATIONS \
  "Ligne : %lu.\n" \
  "Toutes les déclarations nécessaires " \
  "avant de déclararer une cellule de début " \
  "n'ont pas été faites :\n" \
  "parmi ces chiffes, " \
  "ceux qui sont négatifs posent problème :\n" \
  "- begin_nb_cells_min = %lu\n" \
  "- begin_nb_cells_max = %lu.\n", \
  no_ligne, \
  *begin_nb_cells_min, *begin_nb_cells_max

#define ERR_DECLARATION_BEGIN_CELL_NEGATIF \
  "Ligne : %lu.\n" \
  "L'ordre b:XX (qui précise une cellule début XX), " \
  "XX doit être obligatoirement positif " \
  "doit être obligatoirement positif " \
  "et ce n'est pas le cas.\n", no_ligne

#define ERR_DECLARATION_END_CELL_MANQUE_DECLARATIONS \
  "Ligne : %lu.\n" \
  "Toutes les déclarations nécessaires " \
  "avant de déclararer une cellule de début " \
  "n'ont pas été faites :\n" \
  "parmi ces chiffes, " \
  "ceux qui sont négatifs posent problème :\n" \
  "- end_nb_cells_min = %lu\n" \
  "- end_nb_cells_max = %lu.\n", \
  no_ligne, \
  *begin_nb_cells_min, *begin_nb_cells_max

#define ERR_DECLARATION_FORCE_WALL_OU_PATH_MANQUE_DECLARATIONS \
  "Ligne : %lu.\n" \
  "Avant de déclararer une option :\n" \
  "- force_walls, ou\n" \
  "- force_paths,\n" \
  "il faut au moins déclarer le nombre total\n" \
  "de cellules présentes.\n", \
  no_ligne

#define ERR_DECLARATION_FORCE_WALL_OU_PATH_NO_CELL_PAS_VALIDE \
  "Ligne : %lu.\n" \
  "Le numéro d'index de la cellule n'est pas valide.\n" \
  "Il doit être compris entre 1 et %lu.\n" \
  "Or, il vaut %lu.\n", \
  no_ligne, *total_cellules, i

#define ERR_DECLARATION_END_CELL_NEGATIF \
  "Ligne : %lu.\n" \
  "L'ordre e:XX (qui précise une cellule fin XX), " \
  "XX doit être obligatoirement positif " \
  "doit être obligatoirement positif " \
  "et ce n'est pas le cas.\n", no_ligne

#define ERR_DECLARATION_CELLULE \
  "Ligne : %lu.\n" \
  "Sur la cellule no %lu, les liens sont mal déclarés.\n" \
  "Pour chaque cellule la déclaration doit être ainsi :\n" \
  "no_cellule:tag=" \
  "(lien_Xx_cellule_destination,[...]) " \
  "(lien_Xx_tag,[...])\n", no_ligne, i

#define ERR_DECLARATION_CELLULE_LIENS \
  "Ligne : %lu.\n" \
  "Sur la cellule no %lu, les liens sont mal déclarés.\n" \
  "Pour chaque cellule la déclaration doit être ainsi :\n" \
  "no_cellule:tag=" \
  "(lien_Xx_cellule_destination,[...]) " \
  "(lien_Xx_tag,[...])\n", no_ligne, i

#define ERR_DECLARATION_CELLULE_LIENS_MAX_DEPASSE \
  "Ligne : %lu.\n" \
  "Sur la cellule no %lu, il y a trop de liens.\n" \
  "Le nombre maximum autorisé de liens est %d.\n", \
  no_ligne, i, sizeof(tab_liens)

#define ERR_DECLARATION_CELLULE_LIENS_TAGS \
  "Ligne : %lu.\n" \
  "Sur la cellule no %lu, les liens sont mal déclarés.\n" \
  "Pour chaque cellule la déclaration doit être ainsi :\n" \
  "no_cellule:tag=" \
  "(lien_Xx_cellule_destination,[...]) " \
  "(lien_Xx_tag,[...])\n", no_ligne, i

#define ERR_DECLARATION_CELLULE_LIENS_TAGS_MAX_DEPASSE \
  "Ligne : %lu.\n" \
  "Sur la cellule no %lu, il y a trop de liens.\n" \
  "Le nombre maximum autorisé de liens est %d.\n", \
  no_ligne, i, sizeof(tab_liens)

#define ERR_DECLARATION_LIENS_DEBUT_ET_LIENS_TROUVES \
  "Ligne : %lu.\n" \
  "Au début du fichier il est déclaré : nombre total de liens = %lu.\n" \
  "Lors de la lecture des cellules, %lu lien(s) ont été trouvé(s).\n" \
  "Les deux chiffres devraient être identiques.\n", \
  no_ligne, *total_liens, nb_liens_lus

#define ERR_DECLARATION_NUMERO_CELLULE \
  "Ligne : %lu.\n" \
  "Le numéro de cellule attendu est : %lu.\n" \
  "Le numéro lu est : %lu.\n" \
  "Ce n'est pas normal.\n", \
  no_ligne, cell_attendue, i

int verif_coherence_fichier(char *nom_fichier,
                            unsigned char *id_algo,
                            unsigned long *total_cellules,
                            unsigned long *total_liens,
                            char *params,
                            unsigned long max_len_params,
                            unsigned long *begin_total_cells,
                            unsigned long *begin_nb_cells_min,
                            unsigned long *begin_nb_cells_max,
                            unsigned long *end_total_cells,
                            unsigned long *end_nb_cells_min,
                            unsigned long *end_nb_cells_max,
                            unsigned long *nb_options_forcer_link,
                            char *buffer_erreur, int maxlen_erreur)
{
    FILE *hinput;
    char s[250];
    char *t;


    /* variables temporaires utilisées pour la lecture du fichier */
    char u[251];
    char v[251];
    unsigned long no_ligne = 0;
    unsigned long len;
    unsigned long i, j, k, ok;
    unsigned long cell_attendue = 1;
    unsigned long nb_liens_lus = 0;

    unsigned long tab_liens[50];
    unsigned long nb_tab_liens;

    unsigned long tab_liens_tag[50];
    unsigned long nb_tab_liens_tag;

    /* gestion des paramètres à passer à la dll */
    unsigned long curr_maxlen_param;
    char *pparams;

    /* variable de retour, par défaut = ok */
    int ret = 0;

    /* variables en paramètre */
    curr_maxlen_param = max_len_params;
    pparams = params;
    *id_algo = 0;
    *total_cellules = 0;
    *total_liens = 0;
    *begin_total_cells = 0;
    *begin_nb_cells_min = 0;
    *begin_nb_cells_max = 0;
    *end_total_cells = 0;
    *end_nb_cells_min = 0;
    *end_nb_cells_max = 0;
    *nb_options_forcer_link = 0;

    /* analyse du fichier */
    hinput = fopen(nom_fichier, "rb");
    if (hinput == NULL) {
        snprintf(buffer_erreur, maxlen_erreur,
                 "Erreur d'ouverture du fichier <%s>.\n", nom_fichier);
        return -1;
    }

    while (fgets(s, sizeof(s), hinput) != NULL) {
        no_ligne++;
        len = strlen(s);
        /* supprimer derniers chars = retour chariot : */
        while (len) {
            if (s[len - 1] >= ' ')
                break;
            s[len - 1] = 0;
            len--;
        }

        if (len == 0)
            continue;

        /* ignorer les espaces et tabulations du début */
        t = s;
        while (t[0]) {
            if ((t[0] != ' ') && (t[0] != 9))
                break;
            t++;
        }
        if (strlen(t) == 0)
            continue;
        if (t[0] == ';')
            continue;

        /* arrivé ici, chaine valide => analyse */

        /* déclaration du type de labyrinthe */
        ok = sscanf(t, "maze_type:%20s", u);
        if (ok == 1) {
            if (*id_algo == 0) {
                /* accepter uniquement certains types de labyrinthe */
                if (strcmp(u, "carre_classique") == 0) {
                    *id_algo = 1;
                } else {
                    snprintf(buffer_erreur, maxlen_erreur,
                             ERR_DECLARATION_TYPE_LABYRINTHE);
                    ret = -1;
                    break;
                }
            } else {
                snprintf(buffer_erreur, maxlen_erreur,
                         ERR_DECLARATION_TYPE_LABYRINTHE_2_FOIS);
                ret = -1;
                break;
            }
            /* chaine correctement analysée => passer à la ligne suivante */
            continue;
        }

        /* déclaration de paramètres à passer à la dll */
        if (strstr(t, "params:") == t) {
            strncpy(u, (t + strlen("params:")), sizeof(u));
            len = strlen(u);
            if (*id_algo == 0) {
                snprintf(buffer_erreur, maxlen_erreur,
                         ERR_DECLARATION_MANQUE_TYPE_LABYRINTHE);
                ret = -1;
                break;
            }

            if (pparams == params) {
                ok = ((len + 1) < curr_maxlen_param);
            } else {
                /* (!) espace à ajouter pour séparer les paramètres */
                ok = ((len + 2) < curr_maxlen_param);
            }
            if (!ok) {
                snprintf(buffer_erreur, maxlen_erreur,
                         ERR_DECLARATION_PARAMS_BUFFER_TROP_PETIT);
                ret = -1;
                break;
            }
            /* ok, on peut concaténer : */
            if (pparams != params) {
                /* déjà des params avant => mettre un espace */
                pparams[0] = ' ';
                pparams++;
            }
            strncat(pparams, u, curr_maxlen_param - 1);
            /* on décale le buffer où il faudra faire les copies : */
            pparams += len;
            /* on réduit la taille max de copie pour les prochains params : */
            curr_maxlen_param -= len;
            /* chaine correctement analysée => passer à la ligne suivante */
            continue;
        }
        /* déclaration du nombre de cellules composant le labyrinthe */
        ok = sscanf(t, "total_cells:%lu", &i);
        if (ok == 1) {
            if (*total_cellules == 0) {
                if (i > 0) {
                    /* nombre total de cellules ok */
                    *total_cellules = i;
                } else {
                    snprintf(buffer_erreur, maxlen_erreur,
                             ERR_DECLARATION_TOTAL_CELLULES_NEGATIF);
                    ret = -1;
                    break;
                }
            } else {
                snprintf(buffer_erreur, maxlen_erreur,
                         ERR_DECLARATION_TOTAL_CELLULES_DECLARE_2_FOIS);
                ret = -1;
                break;
            }
            /* chaine correctement analysée => passer à la ligne suivante */
            continue;
        }

        /* déclaration du nombre total de liens (toutes cellules confondues) */
        ok = sscanf(t, "total_links:%lu", &i);
        if (ok == 1) {
            if (*total_liens == 0) {
                if (i > 0) {
                    /* nombre total de cellules ok */
                    *total_liens = i;
                } else {
                    snprintf(buffer_erreur, maxlen_erreur,
                             ERR_DECLARATION_TOTAL_LIENS_NEGATIF);
                    ret = -1;
                    break;
                }
            } else {
                snprintf(buffer_erreur, maxlen_erreur,
                         ERR_DECLARATION_TOTAL_LIENS_DECLARE_2_FOIS);
                ret = -1;
                break;
            }
            /* chaine correctement analysée => passer à la ligne suivante */
            continue;
        }

        /* nombre min de cellules à choisir pour les départs
           (il peut y avoir plusieurs cellules départ) */
        ok = sscanf(t, "begin_nb_cells_min:%lu", &i);
        if (ok == 1) {
            if (*begin_nb_cells_min == 0) {
                if (i > 0) {
                    /* chiffre positif => ok */
                    *begin_nb_cells_min = i;
                } else {
                    snprintf(buffer_erreur, maxlen_erreur,
                             ERR_DECLARATION_BEGIN_CELL_MIN_NEGATIF);
                    ret = -1;
                    break;
                }
            } else {
                snprintf(buffer_erreur, maxlen_erreur,
                         ERR_DECLARATION_BEGIN_CELL_MIN_DECLARE_2_FOIS);
                ret = -1;
                break;
            }
            /* chaine correctement analysée => passer à la ligne suivante */
            continue;
        }

        /* nombre max de cellules à choisir pour les départs
           (il peut y avoir plusieurs cellules départ) */
        ok = sscanf(t, "begin_nb_cells_max:%lu", &i);
        if (ok == 1) {
            if (*begin_nb_cells_max == 0) {
                if (i > 0) {
                    /* chiffre positif => ok */
                    *begin_nb_cells_max = i;
                } else {
                    snprintf(buffer_erreur, maxlen_erreur,
                             ERR_DECLARATION_BEGIN_CELL_MAX_NEGATIF);
                    ret = -1;
                    break;
                }
            } else {
                snprintf(buffer_erreur, maxlen_erreur,
                         ERR_DECLARATION_BEGIN_CELL_MAX_DECLARE_2_FOIS);
                ret = -1;
                break;
            }
            /* chaine correctement analysée => passer à la ligne suivante */
            continue;
        }

        /* nombre min de cellules à choisir pour les fins
           (il peut y avoir plusieurs cellules fin) */
        ok = sscanf(t, "end_nb_cells_min:%lu", &i);
        if (ok == 1) {
            if (*end_nb_cells_min == 0) {
                if (i > 0) {
                    /* chiffre positif => ok */
                    *end_nb_cells_min = i;
                } else {
                    snprintf(buffer_erreur, maxlen_erreur,
                             ERR_DECLARATION_END_CELL_MIN_NEGATIF);
                    ret = -1;
                    break;
                }
            } else {
                snprintf(buffer_erreur, maxlen_erreur,
                         ERR_DECLARATION_END_CELL_MIN_DECLARE_2_FOIS);
                ret = -1;
                break;
            }
            /* chaine correctement analysée => passer à la ligne suivante */
            continue;
        }

        /* nombre max de cellules à choisir pour les fins
           (il peut y avoir plusieurs cellules fin) */
        ok = sscanf(t, "end_nb_cells_max:%lu", &i);
        if (ok == 1) {
            if (*end_nb_cells_max == 0) {
                if (i > 0) {
                    /* chiffre positif => ok */
                    *end_nb_cells_max = i;
                } else {
                    snprintf(buffer_erreur, maxlen_erreur,
                             ERR_DECLARATION_END_CELL_MAX_NEGATIF);
                    ret = -1;
                    break;
                }
            } else {
                snprintf(buffer_erreur, maxlen_erreur,
                         ERR_DECLARATION_END_CELL_MAX_DECLARE_2_FOIS);
                ret = -1;
                break;
            }
            /* chaine correctement analysée => passer à la ligne suivante */
            continue;
        }

        /* déclaration d'une cellule possible de départ
           (il peut y avoir plusieurs cellules début) */
        ok = sscanf(t, "b:%lu", &i);
        if (ok == 1) {
            if (*begin_total_cells == 0) {
                if ((*begin_nb_cells_min == 0) ||
                    (*begin_nb_cells_max == 0)) {
                    snprintf(buffer_erreur, maxlen_erreur,
                             ERR_DECLARATION_BEGIN_CELL_MANQUE_DECLARATIONS);
                    ret = -1;
                    break;
                }
                if (i > 0) {
                    /* ok, on peut commencer à compter
                       le nombre total de cellules de départ : */
                    *begin_total_cells = 1;
                } else {
                    snprintf(buffer_erreur, maxlen_erreur,
                             ERR_DECLARATION_BEGIN_CELL_NEGATIF);
                    ret = -1;
                    break;
                }
            } else {
                /* RAF : vérifier que la cellule à
                   ajouter n'est pas déjà dans la liste */
                (*begin_total_cells)++;
            }
            /* chaine correctement analysée => passer à la ligne suivante */
            continue;
        }

        /* déclaration d'une cellule possible de fin
           (il peut y avoir plusieurs cellules fin) */
        ok = sscanf(t, "e:%lu", &i);
        if (ok == 1) {
            if (*end_total_cells == 0) {
                if ((*end_nb_cells_min == 0) || (*end_nb_cells_max == 0)) {
                    snprintf(buffer_erreur, maxlen_erreur,
                             ERR_DECLARATION_END_CELL_MANQUE_DECLARATIONS);
                    ret = -1;
                    break;
                }
                if (i > 0) {
                    /* ok, on peut commencer à compter
                       le nombre total de cellules de départ : */
                    *end_total_cells = 1;
                } else {
                    snprintf(buffer_erreur, maxlen_erreur,
                             ERR_DECLARATION_END_CELL_NEGATIF);
                    ret = -1;
                    break;
                }
            } else {
                /* RAF : vérifier que la cellule à
                   ajouter n'est pas déjà dans la liste */
                (*end_total_cells)++;
            }
            /* chaine correctement analysée => passer à la ligne suivante */
            continue;
        }

        /* vérifier deux options à la fois "force_walls" et "force_paths" :
           (!) vérif *que* sur le no cellule, pas sur index lien (2ème param)
         */
        ok = sscanf(t, "force_walls:%lu=%lu", &i, &j);
        if (ok != 2) {
            ok = sscanf(t, "force_paths:%lu=%lu", &i, &j);
        }
        if (ok == 2) {
            if (*total_cellules == 0) {
                snprintf(buffer_erreur, maxlen_erreur,
                         ERR_DECLARATION_FORCE_WALL_OU_PATH_MANQUE_DECLARATIONS);
                ret = -1;
                break;
            }
            if ((i < 1) || (i > (*total_cellules))) {
                snprintf(buffer_erreur, maxlen_erreur,
                         ERR_DECLARATION_FORCE_WALL_OU_PATH_NO_CELL_PAS_VALIDE);
                ret = -1;
                break;
            }
            (*nb_options_forcer_link)++;
            continue;
        }
        /* pour chaque cellule
           - no_cellule:tag=(lien_Xx_cellule_destination,[...]) (lien_Xx_tag,[...])
         */
        ok = sscanf(t, "%lu:%lu=(%250s (%250s", &i, &j, u, v);
        if (ok == 4) {
            /* le sscanf() prend la fin de parenthèse à l'intérieur de la chaine
               donc u et v sont du genre : '[plein d'espaces]4,5,8,7,9)' 
               => si dernier char != ')' alors erreur :
             */
            if (cell_attendue != i) {
                snprintf(buffer_erreur, maxlen_erreur,
                         ERR_DECLARATION_NUMERO_CELLULE);
                ret = -1;
                break;
            }
            /* vérif que dernier char == ')' */
            k = strlen(u) - 1;
            if (k < 1) {
                ok = 0;
            } else if (u[k] != ')') {
                ok = 0;
            } else if ((u[0] < '0') || (u[0] > '9')) {
                ok = 0;
            }
            /* vérif que dernier char == ')' */
            k = strlen(v) - 1;
            if (k < 1) {
                ok = 0;
            } else if (v[k] != ')') {
                ok = 0;
            } else if ((v[0] < '0') || (v[0] > '9')) {
                ok = 0;
            }
            /* si ok a été mis à 0 c'est que erreur */
            if (!ok) {
                snprintf(buffer_erreur, maxlen_erreur,
                         ERR_DECLARATION_CELLULE);
                ret = -1;
                break;
            }
            /* analyse du buffer u qui doit être ainsi :
               lien_Xx_cellule_destination,[...])
             */
            /* remplacer la parenthèse de fin par ','
               pour simplifier l'analyse */
            u[strlen(u) - 1] = ',';
            v[strlen(v) - 1] = ',';
            /* ok => u et v du type 'nombre,nombre,...'
             */
            t = u;
            nb_tab_liens = 0;
            do {
                if (recup_ul(&t, &tab_liens[nb_tab_liens])) {
                    /* = pas sous la forme 'nombre,' */
                    snprintf(buffer_erreur, maxlen_erreur,
                             ERR_DECLARATION_CELLULE_LIENS);
                    ret = -1;
                    break;
                }
                nb_tab_liens++;
                if (!*t) {
                    break;
                }
                if (nb_tab_liens > sizeof(tab_liens)) {
                    snprintf(buffer_erreur, maxlen_erreur,
                             ERR_DECLARATION_CELLULE_LIENS_MAX_DEPASSE);
                    ret = -1;
                    break;
                }
            } while (1);

            t = v;
            nb_tab_liens_tag = 0;
            do {
                if (recup_ul(&t, &tab_liens_tag[nb_tab_liens_tag])) {
                    /* = pas sous la forme 'nombre,' */
                    snprintf(buffer_erreur, maxlen_erreur,
                             ERR_DECLARATION_CELLULE_LIENS_TAGS);
                    ret = -1;
                    break;
                }
                nb_tab_liens_tag++;
                if (!*t) {
                    break;
                }
                if (nb_tab_liens_tag > sizeof(tab_liens_tag)) {
                    snprintf(buffer_erreur, maxlen_erreur,
                             ERR_DECLARATION_CELLULE_LIENS_TAGS_MAX_DEPASSE);
                    ret = -1;
                    break;
                }
            } while (1);

            /* ok, arrivé ici :
               - le tableau des liens est rempli
               - le tableau des tags est rempli */

            /* arrivé ici, c'est que la déclaration de la cellule est ok */
            cell_attendue++;
            nb_liens_lus += nb_tab_liens;
            /* chaine correctement analysée => passer à la ligne suivante */
            continue;
        }

    }
    fclose(hinput);
    if (ret == 0) {
        if (nb_liens_lus != *total_liens) {
            snprintf(buffer_erreur, maxlen_erreur,
                     ERR_DECLARATION_LIENS_DEBUT_ET_LIENS_TROUVES);
            ret = -1;
        }
    }
    return ret;
}
