[BACK]Return to instructions_r1.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/instructions_r1.c between versions 1.5 and 1.75

version 1.5, 2010/03/09 10:18:48 version 1.75, 2025/04/15 10:17:55
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.13    RPL/2 (R) version 4.1.36
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2025 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 89  instruction_roll(struct_processus *s_eta Line 89  instruction_roll(struct_processus *s_eta
   
     struct_objet                            *s_objet;      struct_objet                            *s_objet;
   
     unsigned long                           i;      integer8                                i;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 110  instruction_roll(struct_processus *s_eta Line 110  instruction_roll(struct_processus *s_eta
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
         printf("    ...\n");          printf("    ...\n");
         printf("    2: %s, %s, %s, %s, %s, %s,\n"          printf("    2: %s, %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
         printf("    1: %s\n", d_INT);          printf("    1: %s\n", d_INT);
         printf("->  n: %s, %s, %s, %s, %s, %s,\n"          printf("->  n: %s, %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
         printf("    ...\n");          printf("    ...\n");
         printf("    1: %s, %s, %s, %s, %s, %s,\n"          printf("    1: %s, %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
   
         return;          return;
     }      }
Line 199  instruction_roll(struct_processus *s_eta Line 199  instruction_roll(struct_processus *s_eta
     {      {
         l_liste1 = (*s_etat_processus).l_base_pile;          l_liste1 = (*s_etat_processus).l_base_pile;
   
         for(i = 2; i < (unsigned long) (*((integer8 *) (*s_objet).objet)); i++)          for(i = 2; i < (*((integer8 *) (*s_objet).objet)); i++)
         {          {
             l_liste1 = (*l_liste1).suivant;              l_liste1 = (*l_liste1).suivant;
         }          }
Line 236  instruction_rolld(struct_processus *s_et Line 236  instruction_rolld(struct_processus *s_et
   
     struct_objet                                *s_objet;      struct_objet                                *s_objet;
   
     unsigned long                               i;      integer8                                    i;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 257  instruction_rolld(struct_processus *s_et Line 257  instruction_rolld(struct_processus *s_et
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
         printf("    ...\n");          printf("    ...\n");
         printf("    2: %s, %s, %s, %s, %s, %s,\n"          printf("    2: %s, %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
         printf("    1: %s\n", d_INT);          printf("    1: %s\n", d_INT);
         printf("->  n: %s, %s, %s, %s, %s, %s,\n"          printf("->  n: %s, %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
         printf("    ...\n");          printf("    ...\n");
         printf("    1: %s, %s, %s, %s, %s, %s,\n"          printf("    1: %s, %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
   
         return;          return;
     }      }
Line 346  instruction_rolld(struct_processus *s_et Line 346  instruction_rolld(struct_processus *s_et
     {      {
         l_liste1 = (*s_etat_processus).l_base_pile;          l_liste1 = (*s_etat_processus).l_base_pile;
   
         for(i = 1; i < (unsigned long) (*((integer8 *) (*s_objet).objet)); i++)          for(i = 1; i < (*((integer8 *) (*s_objet).objet)); i++)
         {          {
             l_liste1 = (*l_liste1).suivant;              l_liste1 = (*l_liste1).suivant;
         }          }
Line 401  instruction_rot(struct_processus *s_etat Line 401  instruction_rot(struct_processus *s_etat
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
         printf("    2: %s, %s, %s, %s, %s, %s,\n"          printf("    2: %s, %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
         printf("    1: %s, %s, %s, %s, %s, %s,\n"          printf("    1: %s, %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
         printf("->  3: %s, %s, %s, %s, %s, %s,\n"          printf("->  3: %s, %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
         printf("    2: %s, %s, %s, %s, %s, %s,\n"          printf("    2: %s, %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
         printf("    1: %s, %s, %s, %s, %s, %s,\n"          printf("    1: %s, %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
   
         return;          return;
     }      }
Line 504  instruction_repeat(struct_processus *s_e Line 504  instruction_repeat(struct_processus *s_e
     unsigned char                   *instruction_majuscule;      unsigned char                   *instruction_majuscule;
     unsigned char                   *tampon;      unsigned char                   *tampon;
   
     unsigned long                   niveau;      integer8                        niveau;
   
     void                            (*fonction)();      void                            (*fonction)();
   
Line 596  instruction_repeat(struct_processus *s_e Line 596  instruction_repeat(struct_processus *s_e
                     }                      }
   
                     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)
                     {                      {
                         liberation(s_etat_processus, s_objet);                          liberation(s_etat_processus, s_objet);
Line 615  instruction_repeat(struct_processus *s_e Line 616  instruction_repeat(struct_processus *s_e
                                 || (strcmp(instruction_majuscule, "ELSEIF")                                  || (strcmp(instruction_majuscule, "ELSEIF")
                                 == 0))                                  == 0))
                         {                          {
                             (*s_etat_processus).position_courante -= (strlen(                              (*s_etat_processus).position_courante -=
                                       (integer8) (strlen(
                                     instruction_majuscule) + 1);                                      instruction_majuscule) + 1);
                             drapeau_fin = d_vrai;                              drapeau_fin = d_vrai;
                         }                          }
Line 868  instruction_rclf(struct_processus *s_eta Line 870  instruction_rclf(struct_processus *s_eta
   
     for(i = 1; i <= 64; i++)      for(i = 1; i <= 64; i++)
     {      {
         indice_drapeau = i - 1;          indice_drapeau = (unsigned char) (i - 1);
         indice_bloc = indice_drapeau / taille_bloc;          indice_bloc = indice_drapeau / taille_bloc;
         indice_bit = indice_drapeau % taille_bloc;          indice_bit = indice_drapeau % taille_bloc;
         masque = ((t_8_bits) 1) << (taille_bloc - indice_bit - 1);          masque = (t_8_bits) (((t_8_bits) 1) << (taille_bloc - indice_bit - 1));
   
         if (((*s_etat_processus).drapeaux_etat[indice_bloc] & masque) != 0)          if (((*s_etat_processus).drapeaux_etat[indice_bloc] & masque) != 0)
         {          {
Line 905  instruction_rclf(struct_processus *s_eta Line 907  instruction_rclf(struct_processus *s_eta
 void  void
 instruction_rcl(struct_processus *s_etat_processus)  instruction_rcl(struct_processus *s_etat_processus)
 {  {
     logical1                            presence_variable;  
   
     long                                i;  
   
     struct_objet                        *s_objet;      struct_objet                        *s_objet;
     struct_objet                        *s_objet_variable;      struct_objet                        *s_objet_variable;
   
Line 932  instruction_rcl(struct_processus *s_etat Line 930  instruction_rcl(struct_processus *s_etat
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
   
         return;          return;
     }      }
Line 968  instruction_rcl(struct_processus *s_etat Line 966  instruction_rcl(struct_processus *s_etat
         return;          return;
     }      }
   
     if (recherche_variable(s_etat_processus, (*((struct_nom *)      if (recherche_variable_globale(s_etat_processus, (*((struct_nom *)
             (*s_objet).objet)).nom) == d_faux)              (*s_objet).objet)).nom) == d_faux)
     {      {
         liberation(s_etat_processus, s_objet);          liberation(s_etat_processus, s_objet);
   
         (*s_etat_processus).erreur_systeme = d_es;          (*s_etat_processus).erreur_systeme = d_es;
         (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;  
         return;  
     }  
   
     i = (*s_etat_processus).position_variable_courante;  
     presence_variable = d_faux;  
   
     while(i >= 0)          if ((*s_etat_processus).erreur_execution == d_ex)
     {  
         if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,  
                 (*((struct_nom *) (*s_objet).objet)).nom) == 0) &&  
                 ((*s_etat_processus).s_liste_variables[i].niveau == 1))  
         {          {
             presence_variable = d_vrai;              (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
             break;  
         }          }
   
         i--;  
     }  
   
     (*s_etat_processus).position_variable_courante = i;  
   
     if (presence_variable == d_faux)  
     {  
         liberation(s_etat_processus, s_objet);  
   
         (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;  
         return;  
     }  
   
     if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)  
             .position_variable_courante].objet == NULL)  
     {  
         liberation(s_etat_processus, s_objet);  
   
         (*s_etat_processus).erreur_systeme = d_es;  
         (*s_etat_processus).erreur_execution = d_ex_variable_partagee;  
         return;          return;
     }      }
   
     if ((s_objet_variable = copie_objet(s_etat_processus,      if ((s_objet_variable = copie_objet(s_etat_processus,
             ((*s_etat_processus).s_liste_variables)              (*(*s_etat_processus).pointeur_variable_courante).objet, 'P'))
             [(*s_etat_processus).position_variable_courante].objet, 'P'))  
             == NULL)              == NULL)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1168  instruction_rdz(struct_processus *s_etat Line 1134  instruction_rdz(struct_processus *s_etat
     if ((*s_objet).type == INT)      if ((*s_objet).type == INT)
     {      {
         initialisation_generateur_aleatoire(s_etat_processus, d_faux,          initialisation_generateur_aleatoire(s_etat_processus, d_faux,
                 (unsigned long int) (*((integer8 *) (*s_objet).objet)));                  (*((integer8 *) (*s_objet).objet)));
     }      }
     else      else
     {      {
Line 1266  instruction_rnd(struct_processus *s_etat Line 1232  instruction_rnd(struct_processus *s_etat
             return;              return;
         }          }
   
           (*s_etat_processus).type_en_cours = NON;
         recherche_type(s_etat_processus);          recherche_type(s_etat_processus);
   
         free((*s_etat_processus).instruction_courante);          free((*s_etat_processus).instruction_courante);
Line 1315  instruction_r_vers_c(struct_processus *s Line 1282  instruction_r_vers_c(struct_processus *s
     struct_objet                    *s_objet_argument_2;      struct_objet                    *s_objet_argument_2;
     struct_objet                    *s_objet_resultat;      struct_objet                    *s_objet_resultat;
   
     unsigned long                   i;      integer8                        i;
     unsigned long                   j;      integer8                        j;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 1397  instruction_r_vers_c(struct_processus *s Line 1364  instruction_r_vers_c(struct_processus *s
         if ((*s_objet_argument_1).type == INT)          if ((*s_objet_argument_1).type == INT)
         {          {
             (*((struct_complexe16 *) (*s_objet_resultat).objet))              (*((struct_complexe16 *) (*s_objet_resultat).objet))
                     .partie_imaginaire =                      .partie_imaginaire = (real8)
                     (*((integer8 *) (*s_objet_argument_1).objet));                      (*((integer8 *) (*s_objet_argument_1).objet));
         }          }
         else          else
Line 1410  instruction_r_vers_c(struct_processus *s Line 1377  instruction_r_vers_c(struct_processus *s
         if ((*s_objet_argument_2).type == INT)          if ((*s_objet_argument_2).type == INT)
         {          {
             (*((struct_complexe16 *) (*s_objet_resultat).objet))              (*((struct_complexe16 *) (*s_objet_resultat).objet))
                     .partie_reelle =                      .partie_reelle = (real8)
                     (*((integer8 *) (*s_objet_argument_2).objet));                      (*((integer8 *) (*s_objet_argument_2).objet));
         }          }
         else          else
Line 1452  instruction_r_vers_c(struct_processus *s Line 1419  instruction_r_vers_c(struct_processus *s
                 (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;                  (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
   
         if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
                 malloc((*(((struct_vecteur *) (*s_objet_resultat)                  malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat)
                 .objet))).taille * sizeof(struct_complexe16))) == NULL)                  .objet))).taille) * sizeof(struct_complexe16))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 1466  instruction_r_vers_c(struct_processus *s Line 1433  instruction_r_vers_c(struct_processus *s
             {              {
                 ((struct_complexe16 *) (*((struct_vecteur *)                  ((struct_complexe16 *) (*((struct_vecteur *)
                         (*s_objet_resultat).objet)).tableau)[i]                          (*s_objet_resultat).objet)).tableau)[i]
                         .partie_imaginaire = ((integer8 *)                          .partie_imaginaire = (real8) ((integer8 *)
                         (*((struct_vecteur *) (*s_objet_argument_1).objet))                          (*((struct_vecteur *) (*s_objet_argument_1).objet))
                         .tableau)[i];                          .tableau)[i];
             }              }
Line 1483  instruction_r_vers_c(struct_processus *s Line 1450  instruction_r_vers_c(struct_processus *s
             {              {
                 ((struct_complexe16 *) (*((struct_vecteur *)                  ((struct_complexe16 *) (*((struct_vecteur *)
                         (*s_objet_resultat).objet)).tableau)[i]                          (*s_objet_resultat).objet)).tableau)[i]
                         .partie_reelle = ((integer8 *)                          .partie_reelle = (real8) ((integer8 *)
                         (*((struct_vecteur *) (*s_objet_argument_2).objet))                          (*((struct_vecteur *) (*s_objet_argument_2).objet))
                         .tableau)[i];                          .tableau)[i];
             }              }
Line 1537  instruction_r_vers_c(struct_processus *s Line 1504  instruction_r_vers_c(struct_processus *s
                 .nombre_colonnes;                  .nombre_colonnes;
   
         if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
                 malloc((*(((struct_matrice *) (*s_objet_resultat)                  malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat)
                 .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)                  .objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
                   == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 1549  instruction_r_vers_c(struct_processus *s Line 1517  instruction_r_vers_c(struct_processus *s
         {          {
             if ((((struct_complexe16 **) (*((struct_matrice *)              if ((((struct_complexe16 **) (*((struct_matrice *)
                     (*s_objet_resultat).objet)).tableau)[i] =                      (*s_objet_resultat).objet)).tableau)[i] =
                     malloc((*((struct_matrice *)                      malloc(((size_t) (*((struct_matrice *)
                     (*s_objet_resultat).objet)).nombre_colonnes *                      (*s_objet_resultat).objet)).nombre_colonnes) *
                     sizeof(struct_complexe16))) == NULL)                      sizeof(struct_complexe16))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1564  instruction_r_vers_c(struct_processus *s Line 1532  instruction_r_vers_c(struct_processus *s
                 {                  {
                     ((struct_complexe16 **) (*((struct_matrice *)                      ((struct_complexe16 **) (*((struct_matrice *)
                             (*s_objet_resultat).objet)).tableau)[i][j]                              (*s_objet_resultat).objet)).tableau)[i][j]
                             .partie_imaginaire = ((integer8 **)                              .partie_imaginaire = (real8) ((integer8 **)
                             (*((struct_matrice *) (*s_objet_argument_1).objet))                              (*((struct_matrice *) (*s_objet_argument_1).objet))
                             .tableau)[i][j];                              .tableau)[i][j];
                 }                  }
Line 1581  instruction_r_vers_c(struct_processus *s Line 1549  instruction_r_vers_c(struct_processus *s
                 {                  {
                     ((struct_complexe16 **) (*((struct_matrice *)                      ((struct_complexe16 **) (*((struct_matrice *)
                             (*s_objet_resultat).objet)).tableau)[i][j]                              (*s_objet_resultat).objet)).tableau)[i][j]
                             .partie_reelle = ((integer8 **)                              .partie_reelle = (real8) ((integer8 **)
                             (*((struct_matrice *) (*s_objet_argument_2).objet))                              (*((struct_matrice *) (*s_objet_argument_2).objet))
                             .tableau)[i][j];                              .tableau)[i][j];
                 }                  }
Line 1647  instruction_re(struct_processus *s_etat_ Line 1615  instruction_re(struct_processus *s_etat_
     struct_objet                    *s_objet_argument;      struct_objet                    *s_objet_argument;
     struct_objet                    *s_objet_resultat;      struct_objet                    *s_objet_resultat;
   
     unsigned long                   i;      integer8                        i;
     unsigned long                   j;      integer8                        j;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 1765  instruction_re(struct_processus *s_etat_ Line 1733  instruction_re(struct_processus *s_etat_
         }          }
   
         if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
                 malloc((*(((struct_vecteur *) (*s_objet_argument)                  malloc(((size_t) (*(((struct_vecteur *) (*s_objet_argument)
                 .objet))).taille * sizeof(real8))) == NULL)                  .objet))).taille) * sizeof(real8))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 1805  instruction_re(struct_processus *s_etat_ Line 1773  instruction_re(struct_processus *s_etat_
         }          }
   
         if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
                 malloc((*(((struct_matrice *) (*s_objet_argument)                  malloc(((size_t) (*(((struct_matrice *) (*s_objet_argument)
                 .objet))).nombre_lignes * sizeof(real8 *))) == NULL)                  .objet))).nombre_lignes) * sizeof(real8 *))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 1822  instruction_re(struct_processus *s_etat_ Line 1790  instruction_re(struct_processus *s_etat_
                 .nombre_lignes; i++)                  .nombre_lignes; i++)
         {          {
             if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)              if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
                     .objet)).tableau)[i] = malloc(                      .objet)).tableau)[i] = malloc(((size_t) 
                     (*(((struct_matrice *) (*s_objet_argument).objet)))                      (*(((struct_matrice *) (*s_objet_argument).objet)))
                     .nombre_colonnes * sizeof(real8))) == NULL)                      .nombre_colonnes) * sizeof(real8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 2137  instruction_r_vers_p(struct_processus *s Line 2105  instruction_r_vers_p(struct_processus *s
         if ((*s_objet_argument).type == INT)          if ((*s_objet_argument).type == INT)
         {          {
             (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle              (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle
                     = (*((integer8 *) (*s_objet_argument).objet));                      = (real8) (*((integer8 *) (*s_objet_argument).objet));
         }          }
         else          else
         {          {
Removed from v.1.5  
changed lines
  Added in v.1.75

CVSweb interface <joel.bertrand@systella.fr>