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

Diff for /rpl/src/instructions_f4.c between versions 1.16.2.3 and 1.49

version 1.16.2.3, 2011/05/09 13:52:16 version 1.49, 2013/12/03 09:36:13
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.24    RPL/2 (R) version 4.1.17
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2013 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 40  instruction_fleche_table(struct_processu Line 40  instruction_fleche_table(struct_processu
 {  {
     struct_objet                    *s_objet;      struct_objet                    *s_objet;
   
     signed long                     i;      integer8                        i;
     signed long                     nombre_elements;      integer8                        nombre_elements;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 116  instruction_fleche_table(struct_processu Line 116  instruction_fleche_table(struct_processu
         return;          return;
     }      }
   
     if ((unsigned long) nombre_elements >=      if (nombre_elements >= (*s_etat_processus).hauteur_pile_operationnelle)
             (*s_etat_processus).hauteur_pile_operationnelle)  
     {      {
         (*s_etat_processus).erreur_execution = d_ex_manque_argument;          (*s_etat_processus).erreur_execution = d_ex_manque_argument;
         return;          return;
Line 149  instruction_fleche_table(struct_processu Line 148  instruction_fleche_table(struct_processu
     (*((struct_tableau *) (*s_objet).objet)).nombre_elements =      (*((struct_tableau *) (*s_objet).objet)).nombre_elements =
             nombre_elements;              nombre_elements;
   
     if (((*((struct_tableau *) (*s_objet).objet)).elements = malloc(      if (((*((struct_tableau *) (*s_objet).objet)).elements = malloc(((size_t)
             nombre_elements * sizeof(struct_objet *))) == NULL)              nombre_elements) * sizeof(struct_objet *))) == NULL)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         return;          return;
Line 194  instruction_fleche_diag(struct_processus Line 193  instruction_fleche_diag(struct_processus
     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 256  instruction_fleche_diag(struct_processus Line 255  instruction_fleche_diag(struct_processus
                 (*((struct_vecteur *) (*s_objet_argument).objet)).taille;                  (*((struct_vecteur *) (*s_objet_argument).objet)).taille;
   
         if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
                 malloc((*((struct_matrice *) (*s_objet_resultat).objet))                  malloc(((size_t) (*((struct_matrice *)
                 .nombre_lignes * sizeof(integer8 *))) == NULL)                  (*s_objet_resultat).objet)).nombre_lignes)
                   * sizeof(integer8 *))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 268  instruction_fleche_diag(struct_processus Line 268  instruction_fleche_diag(struct_processus
         {          {
             if ((((integer8 **) (*((struct_matrice *)              if ((((integer8 **) (*((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(integer8))) == NULL)                      sizeof(integer8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 308  instruction_fleche_diag(struct_processus Line 308  instruction_fleche_diag(struct_processus
                 (*((struct_vecteur *) (*s_objet_argument).objet)).taille;                  (*((struct_vecteur *) (*s_objet_argument).objet)).taille;
   
         if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
                 malloc((*((struct_matrice *) (*s_objet_resultat).objet))                  malloc(((size_t) (*((struct_matrice *) (*s_objet_resultat)
                 .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 320  instruction_fleche_diag(struct_processus Line 320  instruction_fleche_diag(struct_processus
         {          {
             if ((((real8 **) (*((struct_matrice *)              if ((((real8 **) (*((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(real8))) == NULL)                      sizeof(real8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 360  instruction_fleche_diag(struct_processus Line 360  instruction_fleche_diag(struct_processus
                 (*((struct_vecteur *) (*s_objet_argument).objet)).taille;                  (*((struct_vecteur *) (*s_objet_argument).objet)).taille;
   
         if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
                 malloc((*((struct_matrice *) (*s_objet_resultat).objet))                  malloc(((size_t) (*((struct_matrice *) (*s_objet_resultat)
                 .nombre_lignes * sizeof(complex16 *))) == NULL)                  .objet)).nombre_lignes) * sizeof(complex16 *))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 372  instruction_fleche_diag(struct_processus Line 372  instruction_fleche_diag(struct_processus
         {          {
             if ((((complex16 **) (*((struct_matrice *)              if ((((complex16 **) (*((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(complex16))) == NULL)                      sizeof(complex16))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 423  instruction_fleche_diag(struct_processus Line 423  instruction_fleche_diag(struct_processus
   
     return;      return;
 }  }
   
   
   /*
   ================================================================================
     Fonction 'forall'
   ================================================================================
     Entrées : structure processus
   --------------------------------------------------------------------------------
     Sorties :
   --------------------------------------------------------------------------------
     Effets de bord : néant
   ================================================================================
   */
   
   void
   instruction_forall(struct_processus *s_etat_processus)
   {
       struct_objet                        *s_objet_1;
       struct_objet                        *s_objet_2;
   
       struct_variable                     s_variable;
   
       unsigned char                       instruction_valide;
       unsigned char                       *tampon;
       unsigned char                       test_instruction;
   
       (*s_etat_processus).erreur_execution = d_ex;
   
       if ((*s_etat_processus).affichage_arguments == 'Y')
       {
           printf("\n  FORALL ");
   
           if ((*s_etat_processus).langue == 'F')
           {
               printf("(boucle définie sur un objet)\n\n");
           }
           else
           {
               printf("(define a object-based loop)\n\n");
           }
   
           if ((*s_etat_processus).langue == 'F')
           {
               printf("  Utilisation :\n\n");
           }
           else
           {
               printf("  Usage:\n\n");
           }
   
           printf("    %s FORALL (variable)\n", d_LST);
           printf("        (expression)\n");
           printf("        [EXIT]/[CYCLE]\n");
           printf("        ...\n");
           printf("    NEXT\n\n");
   
           printf("    %s FORALL (variable)\n", d_TAB);
           printf("        (expression)\n");
           printf("        [EXIT]/[CYCLE]\n");
           printf("        ...\n");
           printf("    NEXT\n");
           return;
       }
       else if ((*s_etat_processus).test_instruction == 'Y')
       {
           (*s_etat_processus).nombre_arguments = -1;
           return;
       }
   
       if ((*s_etat_processus).erreur_systeme != d_es)
       {
           return;
       }
   
       if (test_cfsf(s_etat_processus, 31) == d_vrai)
       {
           if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
           {
               return;
           }
       }
   
       if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
               &s_objet_1) == d_erreur)
       {
           (*s_etat_processus).erreur_execution = d_ex_manque_argument;
           return;
       }
   
       if (((*s_objet_1).type != LST) && ((*s_objet_1).type != TBL))
       {
           liberation(s_etat_processus, s_objet_1);
   
           (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle;
           return;
       }
   
       tampon = (*s_etat_processus).instruction_courante;
       test_instruction = (*s_etat_processus).test_instruction;
       instruction_valide = (*s_etat_processus).instruction_valide;
       (*s_etat_processus).test_instruction = 'Y';
   
       empilement_pile_systeme(s_etat_processus);
   
       if ((*s_etat_processus).erreur_systeme != d_es)
       {
           return;
       }
   
       if ((*s_etat_processus).mode_execution_programme == 'Y')
       {
           if (recherche_instruction_suivante(s_etat_processus) == d_erreur)
           {
               return;
           }
   
           analyse(s_etat_processus, NULL);
   
           if ((*s_etat_processus).instruction_valide == 'Y')
           {
               liberation(s_etat_processus, s_objet_1);
               free((*s_etat_processus).instruction_courante);
               (*s_etat_processus).instruction_courante = tampon;
   
               depilement_pile_systeme(s_etat_processus);
   
               (*s_etat_processus).erreur_execution = d_ex_nom_reserve;
               return;
           }
   
           recherche_type(s_etat_processus);
   
           free((*s_etat_processus).instruction_courante);
           (*s_etat_processus).instruction_courante = tampon;
   
           if ((*s_etat_processus).erreur_execution != d_ex)
           {
               depilement_pile_systeme(s_etat_processus);
               liberation(s_etat_processus, s_objet_1);
               return;
           }
   
           if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                   &s_objet_2) == d_erreur)
           {
               liberation(s_etat_processus, s_objet_1);
   
               depilement_pile_systeme(s_etat_processus);
               (*s_etat_processus).erreur_execution = d_ex_manque_argument;
               return;
           }
   
           (*(*s_etat_processus).l_base_pile_systeme)
                   .origine_routine_evaluation = 'N';
       }
       else
       {
           if ((*s_etat_processus).expression_courante == NULL)
           {
               depilement_pile_systeme(s_etat_processus);
   
               (*s_etat_processus).erreur_execution = d_ex_manque_argument;
               return;
           }
   
           (*s_etat_processus).expression_courante = (*(*s_etat_processus)
                   .expression_courante).suivant;
   
           if ((s_objet_2 = copie_objet(s_etat_processus,
                   (*(*s_etat_processus).expression_courante)
                   .donnee, 'P')) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           (*(*s_etat_processus).l_base_pile_systeme)
                   .origine_routine_evaluation = 'Y';
       }
   
       if ((*s_objet_2).type != NOM)
       {
           liberation(s_etat_processus, s_objet_1);
           depilement_pile_systeme(s_etat_processus);
   
           (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle;
           return;
       }
       else if ((*((struct_nom *) (*s_objet_2).objet)).symbole == d_vrai)
       {
           liberation(s_etat_processus, s_objet_1);
           depilement_pile_systeme(s_etat_processus);
   
           (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle;
           return;
       }
   
       (*s_etat_processus).niveau_courant++;
       (*(*s_etat_processus).l_base_pile_systeme).type_cloture = 'A';
   
       if ((s_variable.nom = malloc((strlen(
               (*((struct_nom *) (*s_objet_2).objet)).nom) + 1) *
               sizeof(unsigned char))) == NULL)
       {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
       strcpy(s_variable.nom, (*((struct_nom *) (*s_objet_2).objet)).nom);
       s_variable.niveau = (*s_etat_processus).niveau_courant;
   
       if ((*s_objet_1).type == LST)
       {
           if ((*s_objet_1).objet == NULL)
           {
               // La liste est vide. On doit sauter au NEXT correspondant.
               liberation(s_etat_processus, s_objet_1);
               liberation(s_etat_processus, s_objet_2);
               free(s_variable.nom);
   
               if (((*(*s_etat_processus).l_base_pile_systeme)
                       .limite_indice_boucle = allocation(s_etat_processus, NON))
                       == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               (*s_etat_processus).test_instruction = test_instruction;
               (*s_etat_processus).instruction_valide = instruction_valide;
   
               instruction_cycle(s_etat_processus);
               return;
           }
   
           if ((s_variable.objet = copie_objet(s_etat_processus,
                   (*((struct_liste_chainee *) (*s_objet_1).objet)).donnee, 'P'))
                   == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           // Mémorisation de la position courante dans la liste
   
           if (((*(*s_etat_processus).l_base_pile_systeme).indice_boucle =
                   allocation(s_etat_processus, NON)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           (*(*(*s_etat_processus).l_base_pile_systeme).indice_boucle).objet =
                   (struct_objet *) (*s_objet_1).objet;
       }
       else
       {
           if ((*((struct_tableau *) (*s_objet_1).objet)).nombre_elements == 0)
           {
               // La table est vide, il convient de sauter au NEXT correspondant.
               liberation(s_etat_processus, s_objet_1);
               liberation(s_etat_processus, s_objet_2);
               free(s_variable.nom);
   
               if (((*(*s_etat_processus).l_base_pile_systeme)
                       .limite_indice_boucle = allocation(s_etat_processus, NON))
                       == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               (*s_etat_processus).test_instruction = test_instruction;
               (*s_etat_processus).instruction_valide = instruction_valide;
   
               instruction_cycle(s_etat_processus);
               return;
           }
   
           if ((s_variable.objet = copie_objet(s_etat_processus,
                   (*((struct_tableau *) (*s_objet_1).objet)).elements[0], 'P'))
                   == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           // Création d'un objet de type entier contenant la position
           // de l'élément courant dans la table.
   
           if (((*(*s_etat_processus).l_base_pile_systeme).indice_boucle =
                   allocation(s_etat_processus, INT)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           (*((integer8 *) (*(*(*s_etat_processus).l_base_pile_systeme)
                   .indice_boucle).objet)) = 0;
       }
   
       if (creation_variable(s_etat_processus, &s_variable, 'V', 'P') == d_erreur)
       {
           return;
       }
   
       liberation(s_etat_processus, s_objet_2);
   
       (*s_etat_processus).test_instruction = test_instruction;
       (*s_etat_processus).instruction_valide = instruction_valide;
   
       (*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle = s_objet_1;
   
       if ((*s_etat_processus).mode_execution_programme == 'Y')
       {
           (*(*s_etat_processus).l_base_pile_systeme).adresse_retour =
                   (*s_etat_processus).position_courante;
       }
       else
       {
           (*(*s_etat_processus).l_base_pile_systeme).pointeur_objet_retour =
                   (*s_etat_processus).expression_courante;
       }
   
       if (((*(*s_etat_processus).l_base_pile_systeme).nom_variable =
               malloc((strlen(s_variable.nom) + 1) *
               sizeof(unsigned char))) == NULL)
       {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
       strcpy((*(*s_etat_processus).l_base_pile_systeme).nom_variable,
               s_variable.nom);
   
       return;
   }
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.16.2.3  
changed lines
  Added in v.1.49

CVSweb interface <joel.bertrand@systella.fr>