Diff for /rpl/src/types.c between versions 1.52 and 1.80

version 1.52, 2012/10/01 11:05:10 version 1.80, 2016/03/01 22:12:37
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.11    RPL/2 (R) version 4.1.25
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2016 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 38 Line 38
 void  void
 recherche_type(struct_processus *s_etat_processus)  recherche_type(struct_processus *s_etat_processus)
 {  {
     int                         nombre_elements_convertis;      integer8                    i;
       integer8                    j;
       integer8                    niveau;
       integer8                    niveau_maximal;
       integer8                    nombre_colonnes;
       integer8                    nombre_egalites;
       integer8                    nombre_elements;
       integer8                    nombre_elements_convertis;
       integer8                    nombre_exposants;
       integer8                    nombre_lignes;
       integer8                    nombre_lignes_a_supprimer;
       integer8                    nombre_points;
       integer8                    nombre_virgules;
       integer8                    position_courante;
       integer8                    profondeur_finale;
       integer8                    profondeur_initiale;
       integer8                    sauvegarde_niveau_courant;
       integer8                    sauvegarde_longueur_definitions_chainees;
   
     struct_liste_chainee        *l_base_liste_fonctions;      struct_liste_chainee        *l_base_liste_fonctions;
     struct_liste_chainee        *l_base_liste_decomposition;      struct_liste_chainee        *l_base_liste_decomposition;
Line 82  recherche_type(struct_processus *s_etat_ Line 99  recherche_type(struct_processus *s_etat_
     unsigned char               *tampon;      unsigned char               *tampon;
     unsigned char               variable_implicite;      unsigned char               variable_implicite;
   
     unsigned long               i;  
     unsigned long               j;  
     unsigned long               niveau;  
     unsigned long               niveau_maximal;  
     unsigned long               nombre_colonnes;  
     unsigned long               nombre_egalites;  
     unsigned long               nombre_elements;  
     unsigned long               nombre_exposants;  
     unsigned long               nombre_lignes;  
     unsigned long               nombre_lignes_a_supprimer;  
     unsigned long               nombre_points;  
     unsigned long               nombre_virgules;  
     unsigned long               position_courante;  
     unsigned long               profondeur_finale;  
     unsigned long               profondeur_initiale;  
     unsigned long               sauvegarde_niveau_courant;  
     unsigned long               sauvegarde_longueur_definitions_chainees;  
   
     void                        *element;      void                        *element;
   
     if ((s_objet = allocation(s_etat_processus, NON)) == NULL)      if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
Line 144  recherche_type(struct_processus *s_etat_ Line 143  recherche_type(struct_processus *s_etat_
                  */                   */
   
                 if (((*((struct_fonction *) element)).nom_fonction =                  if (((*((struct_fonction *) element)).nom_fonction =
                         conversion_majuscule((*s_etat_processus)                          conversion_majuscule(s_etat_processus,
                         .instruction_courante)) == NULL)                          (*s_etat_processus).instruction_courante)) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 192  recherche_type(struct_processus *s_etat_ Line 191  recherche_type(struct_processus *s_etat_
         }          }
         else          else
         {          {
             if ((instruction_majuscule = conversion_majuscule(              if ((instruction_majuscule = conversion_majuscule(s_etat_processus,
                     (*s_etat_processus).instruction_courante)) == NULL)                      (*s_etat_processus).instruction_courante)) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 289  recherche_type(struct_processus *s_etat_ Line 288  recherche_type(struct_processus *s_etat_
             sauvegarde_longueur_definitions_chainees =              sauvegarde_longueur_definitions_chainees =
                     (*s_etat_processus).longueur_definitions_chainees;                      (*s_etat_processus).longueur_definitions_chainees;
   
             tampon = (unsigned char *) malloc(              tampon = (unsigned char *) malloc(((size_t)
                     (((*s_etat_processus).longueur_definitions_chainees                      (((*s_etat_processus).longueur_definitions_chainees
                     = strlen((*s_etat_processus).instruction_courante)                      = (integer8) strlen((*s_etat_processus)
                     + 4) + 1) * sizeof(unsigned char));                      .instruction_courante) + 4) + 1)) * sizeof(unsigned char));
   
             if (tampon == NULL)              if (tampon == NULL)
             {              {
Line 432  recherche_type(struct_processus *s_etat_ Line 431  recherche_type(struct_processus *s_etat_
                 liberation(s_etat_processus, s_objet);                  liberation(s_etat_processus, s_objet);
                 free(element);                  free(element);
   
                 for(i = 0; i < (unsigned long) nombre_elements_convertis; i++)                  for(i = 0; i < nombre_elements_convertis; i++)
                 {                  {
                     if (depilement(s_etat_processus, &((*s_etat_processus)                      if (depilement(s_etat_processus, &((*s_etat_processus)
                             .l_base_pile), &s_sous_objet) == d_erreur)                              .l_base_pile), &s_sous_objet) == d_erreur)
Line 458  recherche_type(struct_processus *s_etat_ Line 457  recherche_type(struct_processus *s_etat_
                     if ((*s_sous_objet).type == INT)                      if ((*s_sous_objet).type == INT)
                     {                      {
                         (*((struct_complexe16 *) element)).partie_imaginaire =                          (*((struct_complexe16 *) element)).partie_imaginaire =
                                 (*((integer8 *) (*s_sous_objet).objet));                                  (real8) (*((integer8 *) (*s_sous_objet).objet));
                     }                      }
                     else if ((*s_sous_objet).type == REL)                      else if ((*s_sous_objet).type == REL)
                     {                      {
Line 488  recherche_type(struct_processus *s_etat_ Line 487  recherche_type(struct_processus *s_etat_
                         if ((*s_sous_objet).type == INT)                          if ((*s_sous_objet).type == INT)
                         {                          {
                             (*((struct_complexe16 *) element)).partie_reelle =                              (*((struct_complexe16 *) element)).partie_reelle =
                                     (*((integer8 *) (*s_sous_objet).objet));                                      (real8) (*((integer8 *)
                                       (*s_sous_objet).objet));
                         }                          }
                         else if ((*s_sous_objet).type == REL)                          else if ((*s_sous_objet).type == REL)
                         {                          {
Line 544  recherche_type(struct_processus *s_etat_ Line 544  recherche_type(struct_processus *s_etat_
             {              {
                 case 'b' :                  case 'b' :
                 {                  {
                     i = strlen((*s_etat_processus).instruction_courante) - 2;                      i = ((integer8) strlen((*s_etat_processus)
                               .instruction_courante)) - 2;
                     valeur_base = 1;                      valeur_base = 1;
                                           
                     (*((logical8 *) element)) = 0;                      (*((logical8 *) element)) = 0;
Line 618  recherche_type(struct_processus *s_etat_ Line 619  recherche_type(struct_processus *s_etat_
   
                 case 'o' :                  case 'o' :
                 {                  {
                     i = strlen((*s_etat_processus).instruction_courante) - 2;                      i = ((integer8) strlen((*s_etat_processus)
                               .instruction_courante)) - 2;
                     valeur_base = 1;                      valeur_base = 1;
                                           
                     (*((logical8 *) element)) = 0;                      (*((logical8 *) element)) = 0;
Line 722  recherche_type(struct_processus *s_etat_ Line 724  recherche_type(struct_processus *s_etat_
   
                 case 'd' :                  case 'd' :
                 {                  {
                     i = strlen((*s_etat_processus).instruction_courante) - 2;                      i = ((integer8) strlen((*s_etat_processus)
                               .instruction_courante)) - 2;
                     valeur_base = 1;                      valeur_base = 1;
                                           
                     (*((logical8 *) element)) = 0;                      (*((logical8 *) element)) = 0;
Line 836  recherche_type(struct_processus *s_etat_ Line 839  recherche_type(struct_processus *s_etat_
   
                 case 'h' :                  case 'h' :
                 {                  {
                     i = strlen((*s_etat_processus).instruction_courante) - 2;                      i = ((integer8) strlen((*s_etat_processus)
                               .instruction_courante)) - 2;
                     valeur_base = 1;                      valeur_base = 1;
                                           
                     (*((logical8 *) element)) = 0;                      (*((logical8 *) element)) = 0;
Line 1089  recherche_type(struct_processus *s_etat_ Line 1093  recherche_type(struct_processus *s_etat_
                     sauvegarde_longueur_definitions_chainees =                      sauvegarde_longueur_definitions_chainees =
                             (*s_etat_processus).longueur_definitions_chainees;                              (*s_etat_processus).longueur_definitions_chainees;
   
                     tampon = (unsigned char *) malloc(                      tampon = (unsigned char *) malloc(((size_t)
                             (((*s_etat_processus).longueur_definitions_chainees                              (((*s_etat_processus).longueur_definitions_chainees
                             = strlen((*s_etat_processus).instruction_courante)                              = (integer8) strlen((*s_etat_processus)
                             + 4) + 1) * sizeof(unsigned char));                              .instruction_courante) + 4) + 1)) *
                               sizeof(unsigned char));
   
                     if (tampon == NULL)                      if (tampon == NULL)
                     {                      {
Line 1313  recherche_type(struct_processus *s_etat_ Line 1318  recherche_type(struct_processus *s_etat_
                     if (drapeau_complexe == d_vrai)                      if (drapeau_complexe == d_vrai)
                     {                      {
                         (*((struct_vecteur *) element)).tableau = (void *)                          (*((struct_vecteur *) element)).tableau = (void *)
                                 ((struct_complexe16 *) malloc(nombre_colonnes *                                  ((struct_complexe16 *) malloc(((size_t)
                                   nombre_colonnes) *
                                 sizeof(struct_complexe16)));                                  sizeof(struct_complexe16)));
                         (*((struct_vecteur *) element)).type = 'C';                          (*((struct_vecteur *) element)).type = 'C';
                     }                      }
                     else if (drapeau_reel == d_vrai)                      else if (drapeau_reel == d_vrai)
                     {                      {
                         (*((struct_vecteur *) element)).tableau = (void *)                          (*((struct_vecteur *) element)).tableau = (void *)
                                 ((real8 *) malloc(nombre_colonnes *                                  ((real8 *) malloc(((size_t) nombre_colonnes) *
                                 sizeof(real8)));                                  sizeof(real8)));
                         (*((struct_vecteur *) element)).type = 'R';                          (*((struct_vecteur *) element)).type = 'R';
                     }                      }
                     else                      else
                     {                      {
                         (*((struct_vecteur *) element)).tableau = (void *)                          (*((struct_vecteur *) element)).tableau = (void *)
                                 ((integer8 *) malloc(nombre_colonnes *                                  ((integer8 *) malloc(((size_t) nombre_colonnes)
                                 sizeof(integer8)));                                  * sizeof(integer8)));
                         (*((struct_vecteur *) element)).type = 'I';                          (*((struct_vecteur *) element)).type = 'I';
                     }                      }
   
Line 1501  recherche_type(struct_processus *s_etat_ Line 1507  recherche_type(struct_processus *s_etat_
                     sauvegarde_longueur_definitions_chainees =                      sauvegarde_longueur_definitions_chainees =
                             (*s_etat_processus).longueur_definitions_chainees;                              (*s_etat_processus).longueur_definitions_chainees;
   
                     tampon = (unsigned char *) malloc(                      tampon = (unsigned char *) malloc(((size_t)
                             (((*s_etat_processus).longueur_definitions_chainees                              (((*s_etat_processus).longueur_definitions_chainees
                             = strlen((*s_etat_processus).instruction_courante)                              = (integer8) strlen((*s_etat_processus)
                             + 4) + 1) * sizeof(unsigned char));                              .instruction_courante) + 4) + 1)) *
                               sizeof(unsigned char));
   
                     if (tampon == NULL)                      if (tampon == NULL)
                     {                      {
Line 1791  recherche_type(struct_processus *s_etat_ Line 1798  recherche_type(struct_processus *s_etat_
                         {                          {
                             if (((*((struct_matrice *) element)).tableau =                              if (((*((struct_matrice *) element)).tableau =
                                     (void **) ((struct_complexe16 **)                                      (void **) ((struct_complexe16 **)
                                     malloc(nombre_lignes * sizeof(                                      malloc(((size_t) nombre_lignes) * sizeof(
                                     struct_complexe16 *)))) == NULL)                                      struct_complexe16 *)))) == NULL)
                             {                              {
                                 liberation(s_etat_processus, s_objet_registre);                                  liberation(s_etat_processus, s_objet_registre);
Line 1810  recherche_type(struct_processus *s_etat_ Line 1817  recherche_type(struct_processus *s_etat_
                                 if ((((*((struct_matrice *)                                  if ((((*((struct_matrice *)
                                         element)).tableau)[i] = (void *)                                          element)).tableau)[i] = (void *)
                                         ((struct_complexe16 *)                                          ((struct_complexe16 *)
                                         malloc(nombre_colonnes * sizeof(                                          malloc(((size_t) nombre_colonnes) *
                                         struct_complexe16)))) == NULL)                                          sizeof(struct_complexe16)))) == NULL)
                                 {                                  {
                                     liberation(s_etat_processus,                                      liberation(s_etat_processus,
                                             s_objet_registre);                                              s_objet_registre);
Line 1828  recherche_type(struct_processus *s_etat_ Line 1835  recherche_type(struct_processus *s_etat_
                         else if (drapeau_reel == d_vrai)                          else if (drapeau_reel == d_vrai)
                         {                          {
                             if (((*((struct_matrice *) element)).tableau =                              if (((*((struct_matrice *) element)).tableau =
                                     (void **) ((real8 **)                                      (void **) ((real8 **) malloc(((size_t)
                                     malloc(nombre_lignes * sizeof(real8 *))))                                      nombre_lignes) * sizeof(real8 *))))
                                     == NULL)                                      == NULL)
                             {                              {
                                 liberation(s_etat_processus, s_objet_registre);                                  liberation(s_etat_processus, s_objet_registre);
Line 1847  recherche_type(struct_processus *s_etat_ Line 1854  recherche_type(struct_processus *s_etat_
                             {                              {
                                 if ((((*((struct_matrice *)element)).tableau)[i]                                  if ((((*((struct_matrice *)element)).tableau)[i]
                                         = (void *) ((real8 *)                                          = (void *) ((real8 *)
                                         malloc(nombre_colonnes *                                          malloc(((size_t) nombre_colonnes) *
                                         sizeof(real8)))) == NULL)                                          sizeof(real8)))) == NULL)
                                 {                                  {
                                     liberation(s_etat_processus,                                      liberation(s_etat_processus,
Line 1866  recherche_type(struct_processus *s_etat_ Line 1873  recherche_type(struct_processus *s_etat_
                         {                          {
                             if (((*((struct_matrice *) element)).tableau =                              if (((*((struct_matrice *) element)).tableau =
                                     (void **) ((integer8 **)                                      (void **) ((integer8 **)
                                     malloc(nombre_lignes *                                      malloc(((size_t) nombre_lignes) *
                                     sizeof(integer8 *)))) == NULL)                                      sizeof(integer8 *)))) == NULL)
                             {                              {
                                 liberation(s_etat_processus, s_objet_registre);                                  liberation(s_etat_processus, s_objet_registre);
Line 1885  recherche_type(struct_processus *s_etat_ Line 1892  recherche_type(struct_processus *s_etat_
                                 if ((((*((struct_matrice *)                                  if ((((*((struct_matrice *)
                                         element)).tableau)[i] = (void *)                                          element)).tableau)[i] = (void *)
                                         ((integer8 *)                                          ((integer8 *)
                                         malloc(nombre_colonnes *                                          malloc(((size_t) nombre_colonnes) *
                                         sizeof(integer8)))) == NULL)                                          sizeof(integer8)))) == NULL)
                                 {                                  {
                                     liberation(s_etat_processus,                                      liberation(s_etat_processus,
Line 2132  recherche_type(struct_processus *s_etat_ Line 2139  recherche_type(struct_processus *s_etat_
             sauvegarde_longueur_definitions_chainees =              sauvegarde_longueur_definitions_chainees =
                     (*s_etat_processus).longueur_definitions_chainees;                      (*s_etat_processus).longueur_definitions_chainees;
   
             tampon = (unsigned char *) malloc(              tampon = (unsigned char *) malloc(((size_t)
                     (((*s_etat_processus).longueur_definitions_chainees =                      (((*s_etat_processus).longueur_definitions_chainees =
                     strlen((*s_etat_processus).instruction_courante) + 4) + 1)                      (integer8) strlen((*s_etat_processus)
                     * sizeof(unsigned char));                      .instruction_courante) + 4) + 1)) * sizeof(unsigned char));
   
             if (tampon == NULL)              if (tampon == NULL)
             {              {
Line 2222  recherche_type(struct_processus *s_etat_ Line 2229  recherche_type(struct_processus *s_etat_
                 if ((*s_etat_processus).definitions_chainees                  if ((*s_etat_processus).definitions_chainees
                         [(*s_etat_processus).position_courante] == '"')                          [(*s_etat_processus).position_courante] == '"')
                 {                  {
                     if (drapeau_chaine == d_faux)                      if ((*s_etat_processus).position_courante > 0)
                     {                      {
                         drapeau_chaine = d_vrai;                          if ((*s_etat_processus).definitions_chainees
                                   [(*s_etat_processus).position_courante - 1]
                                   != '\\')
                           {
                               if (drapeau_chaine == d_faux)
                               {
                                   drapeau_chaine = d_vrai;
                               }
                               else
                               {
                                   drapeau_chaine = d_faux;
                               }
                           }
                     }                      }
                     else                      else 
                     {                      {
                         drapeau_chaine = d_faux;                          if (drapeau_chaine == d_faux)
                           {
                               drapeau_chaine = d_vrai;
                           }
                           else
                           {
                               drapeau_chaine = d_faux;
                           }
                     }                      }
                 }                  }
                 else if (drapeau_chaine == d_faux)                  else if (drapeau_chaine == d_faux)
Line 2640  recherche_type(struct_processus *s_etat_ Line 2666  recherche_type(struct_processus *s_etat_
                          * elle est convertie en majuscules.                           * elle est convertie en majuscules.
                          */                           */
   
                         tampon = conversion_majuscule((*((struct_fonction *)                          tampon = conversion_majuscule(s_etat_processus,
                                   (*((struct_fonction *)
                                 (*(*l_element_courant).donnee).objet))                                  (*(*l_element_courant).donnee).objet))
                                 .nom_fonction);                                  .nom_fonction);
   
Line 2678  recherche_type(struct_processus *s_etat_ Line 2705  recherche_type(struct_processus *s_etat_
                                 {                                  {
                                     if ((fonction_majuscule =                                      if ((fonction_majuscule =
                                             conversion_majuscule(                                              conversion_majuscule(
                                               s_etat_processus,
                                             (*((struct_fonction *)                                              (*((struct_fonction *)
                                             ((*l_element_courant_fonctions)                                              ((*l_element_courant_fonctions)
                                             .donnee))).nom_fonction)) == NULL)                                              .donnee))).nom_fonction)) == NULL)
Line 2829  recherche_type(struct_processus *s_etat_ Line 2857  recherche_type(struct_processus *s_etat_
                 free(l_element_courant_fonctions);                  free(l_element_courant_fonctions);
             }              }
   
               (*s_etat_processus).autorisation_empilement_programme = 'Y';
             break;              break;
         }          }
   
Line 2889  recherche_type(struct_processus *s_etat_ Line 2918  recherche_type(struct_processus *s_etat_
             {              {
                 // Tableau                  // Tableau
   
                   (*s_etat_processus).type_en_cours = TBL;
                 sauvegarde_longueur_definitions_chainees =                  sauvegarde_longueur_definitions_chainees =
                         (*s_etat_processus).longueur_definitions_chainees;                          (*s_etat_processus).longueur_definitions_chainees;
   
                 tampon = (unsigned char *) malloc(                  tampon = (unsigned char *) malloc(((size_t)
                         (((*s_etat_processus).longueur_definitions_chainees                          (((*s_etat_processus).longueur_definitions_chainees
                         = strlen((*s_etat_processus).instruction_courante)                          = (integer8) strlen((*s_etat_processus)
                         + 2) + 1) * sizeof(unsigned char));                          .instruction_courante) + 2) + 1)) *
                           sizeof(unsigned char));
   
                 if (tampon == NULL)                  if (tampon == NULL)
                 {                  {
Line 2949  recherche_type(struct_processus *s_etat_ Line 2980  recherche_type(struct_processus *s_etat_
   
                 (*(*s_etat_processus).l_base_pile_systeme)                  (*(*s_etat_processus).l_base_pile_systeme)
                         .retour_definition = 'Y';                          .retour_definition = 'Y';
                   (*(*s_etat_processus).l_base_pile_systeme)
                           .origine_routine_evaluation = 'N';
                 (*s_etat_processus).niveau_courant = 0;                  (*s_etat_processus).niveau_courant = 0;
                 (*s_etat_processus).autorisation_empilement_programme = 'N';                  (*s_etat_processus).autorisation_empilement_programme = 'N';
   
                   tampon = (*s_etat_processus).instruction_courante;
                   autorisation_evaluation_nom = (*s_etat_processus)
                           .autorisation_evaluation_nom;
                   (*s_etat_processus).autorisation_evaluation_nom = 'N';
   
                 registre_mode_execution_programme =                  registre_mode_execution_programme =
                         (*s_etat_processus).mode_execution_programme;                          (*s_etat_processus).mode_execution_programme;
                 (*s_etat_processus).mode_execution_programme = 'Y';                  (*s_etat_processus).mode_execution_programme = 'Y';
                 (*s_etat_processus).erreur_scrutation = d_faux;                  (*s_etat_processus).erreur_scrutation = d_faux;
   
                 tampon = (*s_etat_processus).instruction_courante;  
                 nombre_lignes_a_supprimer =                  nombre_lignes_a_supprimer =
                         (*s_etat_processus).hauteur_pile_operationnelle;                          (*s_etat_processus).hauteur_pile_operationnelle;
   
Line 3005  recherche_type(struct_processus *s_etat_ Line 3043  recherche_type(struct_processus *s_etat_
                     }                      }
   
                     (*s_etat_processus).instruction_courante = tampon;                      (*s_etat_processus).instruction_courante = tampon;
                       (*s_etat_processus).autorisation_evaluation_nom =
                               autorisation_evaluation_nom;
   
                     effacement_pile_systeme(s_etat_processus);                      effacement_pile_systeme(s_etat_processus);
                     (*s_etat_processus).l_base_pile_systeme =                      (*s_etat_processus).l_base_pile_systeme =
Line 3058  recherche_type(struct_processus *s_etat_ Line 3098  recherche_type(struct_processus *s_etat_
                     }                      }
   
                     (*s_etat_processus).instruction_courante = tampon;                      (*s_etat_processus).instruction_courante = tampon;
                       (*s_etat_processus).autorisation_evaluation_nom =
                               autorisation_evaluation_nom;
   
                     effacement_pile_systeme(s_etat_processus);                      effacement_pile_systeme(s_etat_processus);
                     (*s_etat_processus).l_base_pile_systeme =                      (*s_etat_processus).l_base_pile_systeme =
Line 3085  recherche_type(struct_processus *s_etat_ Line 3127  recherche_type(struct_processus *s_etat_
                 }                  }
   
                 (*s_etat_processus).instruction_courante = tampon;                  (*s_etat_processus).instruction_courante = tampon;
                   (*s_etat_processus).autorisation_evaluation_nom =
                           autorisation_evaluation_nom;
   
                 (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;                  (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
                 (*s_etat_processus).niveau_courant =                  (*s_etat_processus).niveau_courant =
Line 3122  recherche_type(struct_processus *s_etat_ Line 3166  recherche_type(struct_processus *s_etat_
                 (*((struct_tableau *) element)).nombre_elements = nombre_lignes;                  (*((struct_tableau *) element)).nombre_elements = nombre_lignes;
   
                 if (((*((struct_tableau *) element)).elements =                  if (((*((struct_tableau *) element)).elements =
                         malloc(nombre_lignes * sizeof(struct_objet *))) == NULL)                          malloc(((size_t) nombre_lignes) *
                           sizeof(struct_objet *))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 3155  recherche_type(struct_processus *s_etat_ Line 3200  recherche_type(struct_processus *s_etat_
             {              {
                 // Définition                  // Définition
   
                   (*s_etat_processus).type_en_cours = RPN;
   
                 if (strlen((*s_etat_processus).instruction_courante) < 5)                  if (strlen((*s_etat_processus).instruction_courante) < 5)
                 {                  {
                     liberation(s_etat_processus, s_objet);                      liberation(s_etat_processus, s_objet);
Line 3528  recherche_type(struct_processus *s_etat_ Line 3575  recherche_type(struct_processus *s_etat_
                     integer8                    conversion_entiere;                      integer8                    conversion_entiere;
                     real8                       conversion_reelle;                      real8                       conversion_reelle;
   
                     if (sscanf((*s_etat_processus).instruction_courante, "%lg",  
                             &conversion_reelle) != 1)  
                     {  
                         (*s_etat_processus).erreur_execution = d_ex_syntaxe;  
                     }  
   
                     if (sscanf((*s_etat_processus).instruction_courante, "%lld",                      if (sscanf((*s_etat_processus).instruction_courante, "%lld",
                             &conversion_entiere) != 1)                              &conversion_entiere) != 1)
                     {                      {
                         (*s_etat_processus).erreur_execution = d_ex_syntaxe;                          (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                     }                      }
   
                     if (abs(nextafter(conversion_reelle, conversion_entiere)                      if (errno != ERANGE)
                             - conversion_reelle) >= abs(conversion_reelle  
                             - conversion_entiere))  
                     {                      {
                         (*s_objet).type = INT;                          (*s_objet).type = INT;
   
Line 3561  recherche_type(struct_processus *s_etat_ Line 3600  recherche_type(struct_processus *s_etat_
                     }                      }
                     else                      else
                     {                      {
                           if (sscanf((*s_etat_processus).instruction_courante,
                                   "%lg", &conversion_reelle) != 1)
                           {
                               (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                           }
   
                         (*s_objet).type = REL;                          (*s_objet).type = REL;
   
                         element = malloc(sizeof(real8));                          element = malloc(sizeof(real8));

Removed from v.1.52  
changed lines
  Added in v.1.80


CVSweb interface <joel.bertrand@systella.fr>