Diff for /rpl/src/instructions_l5.c between versions 1.22 and 1.45

version 1.22, 2011/06/21 15:26:32 version 1.45, 2013/04/01 15:29:36
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.2    RPL/2 (R) version 4.1.14
   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 265  instruction_label(struct_processus *s_et Line 265  instruction_label(struct_processus *s_et
   
     struct_objet                *s_objet_argument;      struct_objet                *s_objet_argument;
   
     unsigned long               nombre_labels;      integer8                    nombre_labels;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 772  instruction_lq(struct_processus *s_etat_ Line 772  instruction_lq(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;
     unsigned long               k;      integer8                    k;
     unsigned long               nombre_reflecteurs_elementaires;      integer8                    nombre_reflecteurs_elementaires;
   
     void                        *tau;      void                        *tau;
   
Line 986  instruction_lq(struct_processus *s_etat_ Line 986  instruction_lq(struct_processus *s_etat_
                     (*((struct_matrice *) (*s_copie_argument).objet))                      (*((struct_matrice *) (*s_copie_argument).objet))
                     .nombre_colonnes;                      .nombre_colonnes;
   
             if ((vecteur_reel = malloc((*((struct_matrice *) (*s_objet).objet))              if ((vecteur_reel = malloc(((size_t) (*((struct_matrice *)
                     .nombre_lignes * sizeof(real8))) == NULL)                      (*s_objet).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 1012  instruction_lq(struct_processus *s_etat_ Line 1012  instruction_lq(struct_processus *s_etat_
             }              }
   
             if (((*((struct_matrice *) (*s_objet).objet)).tableau =              if (((*((struct_matrice *) (*s_objet).objet)).tableau =
                     malloc((*((struct_matrice *) (*s_objet).objet))                      malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
                     .nombre_lignes * sizeof(real8 *))) == NULL)                      .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 1023  instruction_lq(struct_processus *s_etat_ Line 1023  instruction_lq(struct_processus *s_etat_
                     .nombre_lignes; j++)                      .nombre_lignes; j++)
             {              {
                 if ((((real8 **) (*((struct_matrice *) (*s_objet).objet))                  if ((((real8 **) (*((struct_matrice *) (*s_objet).objet))
                         .tableau)[j] = malloc((*((struct_matrice *) (*s_objet)                          .tableau)[j] = malloc(((size_t) (*((struct_matrice *)
                         .objet)).nombre_lignes * sizeof(real8))) == NULL)                          (*s_objet).objet)).nombre_lignes) * sizeof(real8)))
                           == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 1304  instruction_lq(struct_processus *s_etat_ Line 1305  instruction_lq(struct_processus *s_etat_
                     (*((struct_matrice *) (*s_copie_argument).objet))                      (*((struct_matrice *) (*s_copie_argument).objet))
                     .nombre_colonnes;                      .nombre_colonnes;
   
             if ((vecteur_complexe = malloc((*((struct_matrice *)              if ((vecteur_complexe = malloc(((size_t) (*((struct_matrice *)
                     (*s_objet).objet)).nombre_lignes * sizeof(complex16)))                      (*s_objet).objet)).nombre_lignes) * sizeof(complex16)))
                     == NULL)                      == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1339  instruction_lq(struct_processus *s_etat_ Line 1340  instruction_lq(struct_processus *s_etat_
             }              }
   
             if (((*((struct_matrice *) (*s_objet).objet)).tableau =              if (((*((struct_matrice *) (*s_objet).objet)).tableau =
                     malloc((*((struct_matrice *) (*s_objet).objet))                      malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
                     .nombre_lignes * sizeof(complex16 *))) == NULL)                      .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 1350  instruction_lq(struct_processus *s_etat_ Line 1351  instruction_lq(struct_processus *s_etat_
                     .nombre_lignes; j++)                      .nombre_lignes; j++)
             {              {
                 if ((((complex16 **) (*((struct_matrice *) (*s_objet).objet))                  if ((((complex16 **) (*((struct_matrice *) (*s_objet).objet))
                         .tableau)[j] = malloc((*((struct_matrice *) (*s_objet)                          .tableau)[j] = malloc(((size_t) (*((struct_matrice *)
                         .objet)).nombre_lignes * sizeof(complex16))) == NULL)                          (*s_objet).objet)).nombre_lignes) * sizeof(complex16)))
                           == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 1609  instruction_lcase(struct_processus *s_et Line 1611  instruction_lcase(struct_processus *s_et
     struct_objet            *s_objet_argument;      struct_objet            *s_objet_argument;
     struct_objet            *s_objet_resultat;      struct_objet            *s_objet_resultat;
   
     unsigned char           *ptr;  
     unsigned char           registre;  
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
     if ((*s_etat_processus).affichage_arguments == 'Y')      if ((*s_etat_processus).affichage_arguments == 'Y')
Line 1620  instruction_lcase(struct_processus *s_et Line 1619  instruction_lcase(struct_processus *s_et
                   
         if ((*s_etat_processus).langue == 'F')          if ((*s_etat_processus).langue == 'F')
         {          {
             printf("(converison d'une chaîne de caractères en minuscules)\n\n");              printf("(conversion d'une chaîne de caractères en minuscules)\n\n");
         }          }
         else          else
         {          {
Line 1662  instruction_lcase(struct_processus *s_et Line 1661  instruction_lcase(struct_processus *s_et
         }          }
   
         liberation(s_etat_processus, s_objet_argument);          liberation(s_etat_processus, s_objet_argument);
         ptr = (unsigned char *) (*s_objet_resultat).objet;          conversion_chaine(s_etat_processus, (unsigned char *)
                   (*s_objet_resultat).objet, 'm');
         while((*ptr) != d_code_fin_chaine)  
         {  
             registre = tolower((*ptr));  
   
             if (toupper(registre) == (*ptr))  
             {  
                 (*ptr) = registre;  
             }  
   
             ptr++;  
         }  
   
         if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),          if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                 s_objet_resultat) == d_erreur)                  s_objet_resultat) == d_erreur)

Removed from v.1.22  
changed lines
  Added in v.1.45


CVSweb interface <joel.bertrand@systella.fr>