Diff for /rpl/src/instructions_d1.c between versions 1.31 and 1.53

version 1.31, 2011/11/26 10:01:28 version 1.53, 2015/01/05 15:32:17
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.5    RPL/2 (R) version 4.1.20
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2015 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 525  instruction_dropn(struct_processus *s_et Line 525  instruction_dropn(struct_processus *s_et
 {  {
     struct_objet                    *s_objet;      struct_objet                    *s_objet;
   
     signed long                     nombre_suppressions;      integer8                        nombre_suppressions;
   
     unsigned long                   i;      integer8                        i;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 624  instruction_dropn(struct_processus *s_et Line 624  instruction_dropn(struct_processus *s_et
         return;          return;
     }      }
   
     if ((unsigned long) nombre_suppressions >      if (nombre_suppressions > (*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;
     }      }
   
     for(i = 0; i < (unsigned long) nombre_suppressions; i++)      for(i = 0; i < nombre_suppressions; i++)
     {      {
         if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),          if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                 &s_objet) == d_erreur)                  &s_objet) == d_erreur)
Line 762  instruction_dup2(struct_processus *s_eta Line 761  instruction_dup2(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 879  instruction_dupn(struct_processus *s_eta Line 878  instruction_dupn(struct_processus *s_eta
     struct_objet                        *s_objet;      struct_objet                        *s_objet;
     struct_objet                        *s_nouvel_objet;      struct_objet                        *s_nouvel_objet;
   
     signed long                         nombre_duplications;      integer8                            nombre_duplications;
     unsigned long                       i;      integer8                            i;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 979  instruction_dupn(struct_processus *s_eta Line 978  instruction_dupn(struct_processus *s_eta
   
     l_element_courant = (*s_etat_processus).l_base_pile;      l_element_courant = (*s_etat_processus).l_base_pile;
   
     for(i = 0; i < (unsigned long) nombre_duplications; i++)      for(i = 0; i < nombre_duplications; i++)
     {      {
         if (l_element_courant == NULL)          if (l_element_courant == NULL)
         {          {
Line 1005  instruction_dupn(struct_processus *s_eta Line 1004  instruction_dupn(struct_processus *s_eta
         l_element_courant = (*l_element_courant).suivant;          l_element_courant = (*l_element_courant).suivant;
     }      }
   
     for(i = 0; i < (unsigned long) nombre_duplications; i++)      for(i = 0; i < nombre_duplications; i++)
     {      {
         if (depilement(s_etat_processus, &l_base_pile, &s_objet) == d_erreur)          if (depilement(s_etat_processus, &l_base_pile, &s_objet) == d_erreur)
         {          {
Line 1057  instruction_division(struct_processus *s Line 1056  instruction_division(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;
     unsigned long                   k;      integer8                        k;
     unsigned long                   nombre_elements;      integer8                        nombre_elements;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 2054  instruction_division(struct_processus *s Line 2053  instruction_division(struct_processus *s
                     (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;                      (*((struct_vecteur *) (*s_objet_argument_2).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(integer8))) == NULL)                      .objet))).taille) * sizeof(integer8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 2084  instruction_division(struct_processus *s Line 2083  instruction_division(struct_processus *s
                     (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;                      (*((struct_vecteur *) (*s_objet_argument_2).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(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 2151  instruction_division(struct_processus *s Line 2150  instruction_division(struct_processus *s
                 (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;                  (*((struct_vecteur *) (*s_objet_argument_2).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 2212  instruction_division(struct_processus *s Line 2211  instruction_division(struct_processus *s
                 (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;                  (*((struct_vecteur *) (*s_objet_argument_2).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 2280  instruction_division(struct_processus *s Line 2279  instruction_division(struct_processus *s
                 (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;                  (*((struct_vecteur *) (*s_objet_argument_2).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 2373  instruction_division(struct_processus *s Line 2372  instruction_division(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(integer8 *))) == NULL)                      .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 2384  instruction_division(struct_processus *s Line 2383  instruction_division(struct_processus *s
                     .objet))).nombre_lignes; i++)                      .objet))).nombre_lignes; i++)
             {              {
                 if ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat)                  if ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
                         .objet)).tableau)[i] = malloc((*(((struct_matrice *)                          .objet)).tableau)[i] = malloc(((size_t)
                         (*s_objet_resultat).objet))).nombre_colonnes *                          (*(((struct_matrice *)
                           (*s_objet_resultat).objet))).nombre_colonnes) *
                         sizeof(integer8))) == NULL)                          sizeof(integer8))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 2421  instruction_division(struct_processus *s Line 2421  instruction_division(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(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 2453  instruction_division(struct_processus *s Line 2453  instruction_division(struct_processus *s
                     .objet))).nombre_lignes; i++)                      .objet))).nombre_lignes; i++)
             {              {
                 if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)                  if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
                         .objet)).tableau)[i] = malloc((*(((struct_matrice *)                          .objet)).tableau)[i] = malloc(((size_t)
                         (*s_objet_resultat).objet))).nombre_colonnes *                          (*(((struct_matrice *)
                           (*s_objet_resultat).objet))).nombre_colonnes) *
                         sizeof(real8))) == NULL)                          sizeof(real8))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 2506  instruction_division(struct_processus *s Line 2507  instruction_division(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 2530  instruction_division(struct_processus *s Line 2532  instruction_division(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 2585  instruction_division(struct_processus *s Line 2587  instruction_division(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 2617  instruction_division(struct_processus *s Line 2620  instruction_division(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 2671  instruction_division(struct_processus *s Line 2674  instruction_division(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 2695  instruction_division(struct_processus *s Line 2699  instruction_division(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 2757  instruction_division(struct_processus *s Line 2761  instruction_division(struct_processus *s
                 .objet))).taille;                  .objet))).taille;
   
         if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
                 malloc((*((struct_vecteur *)                  malloc(((size_t) (*((struct_vecteur *)
                 (*s_objet_resultat).objet)).taille * sizeof(real8))) == NULL)                  (*s_objet_resultat).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 2808  instruction_division(struct_processus *s Line 2812  instruction_division(struct_processus *s
                             (*s_objet_resultat).objet))                              (*s_objet_resultat).objet))
                             .tableau)[i] += ((real8 **) (*((struct_matrice *)                              .tableau)[i] += ((real8 **) (*((struct_matrice *)
                             (*s_objet_argument_1).objet)).tableau)[i][j] *                              (*s_objet_argument_1).objet)).tableau)[i][j] *
                             ((integer8 *) (*((struct_vecteur *)                              (real8) ((integer8 *) (*((struct_vecteur *)
                             (*s_objet_argument_2).objet)).tableau)[j];                              (*s_objet_argument_2).objet)).tableau)[j];
                 }                  }
                 else                  else
Line 2855  instruction_division(struct_processus *s Line 2859  instruction_division(struct_processus *s
                 .objet))).taille;                  .objet))).taille;
   
         if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
                 malloc((*((struct_vecteur *)                  malloc(((size_t) (*((struct_vecteur *)
                 (*s_objet_resultat).objet)).taille * sizeof(struct_complexe16)))                  (*s_objet_resultat).objet)).taille) *
                 == NULL)                  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 2968  instruction_division(struct_processus *s Line 2972  instruction_division(struct_processus *s
                 .objet))).taille;                  .objet))).taille;
   
         if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
                 malloc((*((struct_vecteur *)                  malloc(((size_t) (*((struct_vecteur *)
                 (*s_objet_resultat).objet)).taille * sizeof(struct_complexe16)))                  (*s_objet_resultat).objet)).taille) *
                 == NULL)                  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 3068  instruction_division(struct_processus *s Line 3072  instruction_division(struct_processus *s
                 .objet))).taille;                  .objet))).taille;
   
         if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
                 malloc((*((struct_vecteur *)                  malloc(((size_t) (*((struct_vecteur *)
                 (*s_objet_resultat).objet)).taille * sizeof(struct_complexe16)))                  (*s_objet_resultat).objet)).taille) *
                 == NULL)                  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 3172  instruction_division(struct_processus *s Line 3176  instruction_division(struct_processus *s
                 .objet))).nombre_colonnes;                  .objet))).nombre_colonnes;
   
         if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
                 malloc((*((struct_matrice *)                  malloc(((size_t) (*((struct_matrice *)
                 (*s_objet_resultat).objet)).nombre_lignes * sizeof(real8 *)))                  (*s_objet_resultat).objet)).nombre_lignes) * sizeof(real8 *)))
                 == NULL)                  == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3214  instruction_division(struct_processus *s Line 3218  instruction_division(struct_processus *s
                 (*s_objet_resultat).objet)).nombre_lignes; i++)                  (*s_objet_resultat).objet)).nombre_lignes; i++)
         {          {
             if ((((*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i]              if ((((*((struct_matrice *) (*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 3238  instruction_division(struct_processus *s Line 3242  instruction_division(struct_processus *s
                                 .tableau)[i][j] += ((real8 **)                                  .tableau)[i][j] += ((real8 **)
                                 (*((struct_matrice *)                                  (*((struct_matrice *)
                                 (*s_objet_argument_1).objet)).tableau)[i][k] *                                  (*s_objet_argument_1).objet)).tableau)[i][k] *
                                 ((integer8 **) (*((struct_matrice *)                                  (real8) ((integer8 **) (*((struct_matrice *)
                                 (*s_objet_argument_2).objet)).tableau)[k][j];                                  (*s_objet_argument_2).objet)).tableau)[k][j];
                     }                      }
                     else                      else
Line 3289  instruction_division(struct_processus *s Line 3293  instruction_division(struct_processus *s
                 .objet))).nombre_colonnes;                  .objet))).nombre_colonnes;
   
         if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
                 malloc((*((struct_matrice *)                  malloc(((size_t) (*((struct_matrice *)
                 (*s_objet_resultat).objet)).nombre_lignes *                  (*s_objet_resultat).objet)).nombre_lignes) *
                 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 3330  instruction_division(struct_processus *s Line 3334  instruction_division(struct_processus *s
                 (*s_objet_resultat).objet)).nombre_lignes; i++)                  (*s_objet_resultat).objet)).nombre_lignes; i++)
         {          {
             if ((((*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i]              if ((((*((struct_matrice *) (*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 3416  instruction_division(struct_processus *s Line 3420  instruction_division(struct_processus *s
                 .objet))).nombre_colonnes;                  .objet))).nombre_colonnes;
   
         if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
                 malloc((*((struct_matrice *)                  malloc(((size_t) (*((struct_matrice *)
                 (*s_objet_resultat).objet)).nombre_lignes *                  (*s_objet_resultat).objet)).nombre_lignes) *
                 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 3457  instruction_division(struct_processus *s Line 3461  instruction_division(struct_processus *s
                 (*s_objet_resultat).objet)).nombre_lignes; i++)                  (*s_objet_resultat).objet)).nombre_lignes; i++)
         {          {
             if ((((*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i]              if ((((*((struct_matrice *) (*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 3533  instruction_division(struct_processus *s Line 3537  instruction_division(struct_processus *s
                 .objet))).nombre_colonnes;                  .objet))).nombre_colonnes;
   
         if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
                 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 3574  instruction_division(struct_processus *s Line 3578  instruction_division(struct_processus *s
                 (*s_objet_resultat).objet)).nombre_lignes; i++)                  (*s_objet_resultat).objet)).nombre_lignes; i++)
         {          {
             if ((((*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i]              if ((((*((struct_matrice *) (*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 3670  instruction_division(struct_processus *s Line 3674  instruction_division(struct_processus *s
   
         if ((*s_objet_argument_1).type == BIN)          if ((*s_objet_argument_1).type == BIN)
         {          {
             (*((logical8 *) (*s_objet_resultat).objet)) =              (*((logical8 *) (*s_objet_resultat).objet)) = (logical8)
                     (*((integer8 *) (*s_objet_argument_2).objet))                      ((*((integer8 *) (*s_objet_argument_2).objet))
                     / (*((logical8 *) (*s_objet_argument_1).objet));                      / ((integer8) (*((logical8 *)
                       (*s_objet_argument_1).objet))));
         }          }
         else          else
         {          {
             (*((logical8 *) (*s_objet_resultat).objet)) =              (*((logical8 *) (*s_objet_resultat).objet)) = (logical8)
                     (*((logical8 *) (*s_objet_argument_2).objet))                      (((integer8) (*((logical8 *) (*s_objet_argument_2).objet)))
                     / (*((integer8 *) (*s_objet_argument_1).objet));                      / (*((integer8 *) (*s_objet_argument_1).objet)));
         }          }
     }      }
   
Line 3817  instruction_default(struct_processus *s_ Line 3822  instruction_default(struct_processus *s_
     unsigned char                   *instruction_majuscule;      unsigned char                   *instruction_majuscule;
     unsigned char                   *tampon;      unsigned char                   *tampon;
   
     unsigned long                   niveau;      integer8                        niveau;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 3942  instruction_default(struct_processus *s_ Line 3947  instruction_default(struct_processus *s_
                     {                      {
                         if ((*s_etat_processus).mode_execution_programme == 'Y')                          if ((*s_etat_processus).mode_execution_programme == 'Y')
                         {                          {
                             (*s_etat_processus).position_courante -= (strlen(                              (*s_etat_processus).position_courante -=
                                       (integer8) (strlen(
                                     instruction_majuscule) + 1);                                      instruction_majuscule) + 1);
                         }                          }
                         else                          else

Removed from v.1.31  
changed lines
  Added in v.1.53


CVSweb interface <joel.bertrand@systella.fr>