char param2[15];};

// Définition d'un tableau dynamique qui contiendra les lignes.
ligne_inst *code;
code = (ligne_inst *) calloc (1, sizeof(ligne_inst));

// On parcours le code et on le range dans le tableau.
int i=0; // pointeur vers le caractère du buffer d'instructions.
int no_ligne=0; // numéro de la ligne lue.
int position=0; // Position dans la ligne
int nb_lignes = 1; // nombre de lignes d'instruction.
int j=0; // Un pointeur qui servira à se déplacer dans les tableaux etiquette, instruction, param1 et param2.
#define car buffer_inst[i] // Simplification de l'écriture

while (i<size_inst-1)
    {

    if (commentaire(car)) // Du commentaire. On avance jusqu'à la ligne suivante.
        while (!retchar(car))
        i++;
    i++;

    if (minuscule(car)) // On a affaire à une étiquette. On la note dans le tableau prévu à cet effet.
        {               // On parcourt ensuite toute la ligne d'instruction.
            j=0;
            while (caractere(car))
                {
                    cout<<car;
                    if (j==50) // On évite de dépasser le tableau si un fou a utilisé plus de 50 caractères sur une étiquette.
                    j=49;      // L'étiquette est alors différenciée par ses 49 premiers caractères + par le dernier.
                    code[no_ligne].etiquette[j]=car;
                    i++;
                    j++;
                }
            // On est à la fin de l'étiquette. On attend maintenant l'instruction.
                while (espace(car))
                    i++;

            // On attend une majuscule pour le début d'une instruction. S'il n'y a pas de majuscule, on crie.
            if (!majuscule(car))
                    {
                        cout<<"Instruction manquante a la ligne "<<no_ligne;
                        return 1;
                    }
            else   // On a une majuscule. Copie de l'instruction dans le tableau prévu à cet effet.
                    {
                        j=0;
                        while (majuscule(car)) // Une instruction ne contient que des majuscules. Sinon y'a problème.
                            {
                                if (j==6) // Si une instruction dépasse 6 caractères, ce n'est pas une instruction.
                                    {
                                        cout<<"Instruction non valide a la ligne "<<no_ligne;
                                        return 1;
                                    }
                                code[no_ligne].instruction[j]=car;
                                i++;
                                j++;
                            }
                        // On n'a plus de majuscules. Est-ce une erreur dans le nom de l'instruction, ou la fin de celle-ci?
                        if (!espace(car))
                            {
                                cout<<"Erreur dans le nom de l'instruction a la ligne "<<no_ligne;
                                return 1;
                            }
                    }
                    i++;
                // On est à la fin de l'instruction. On attend de lire 0, 1 ou deux paramètres.
            while (espace(car))
                    i++;

            if (commentaire(car)) //du commentaire tout de suite. Donc pas de paramètres.
                {
                    code[no_ligne].param1[1]=0; // Le premier caractère d'un paramètre non utilisé est mis à 0.
                    code[no_ligne].param1[2]=0; // Cela servira plus tard lors de la traduction.
                }
            else  //la syntaxe des paramètres sera testée à la traduction, car potentiellement complexe et variable selon l'instruction.
                {
                    while (caractere(car))
                        {
                            if (j==15) // Si un paramètre dépasse 15 caractères, ce n'est pas un paramètre.
                                {
                                    cout<<"Premier parametre non valide a la ligne "<<no_ligne;
                                    return 1;
                                }
                                code[no_ligne].param1[j]=car;
                                i++;
                                j++;
                        }
                    // Fin du premier paramètre. Soit il y a une virgule et un deuxième paramètre, soit du commentaire, soit une erreur.
            while (espace(car))
                    i++;