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

Diff for /rpl/src/instructions_s1.c between versions 1.47 and 1.59

version 1.47, 2012/04/13 14:12:59 version 1.59, 2012/12/17 21:22:44
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.8    RPL/2 (R) version 4.1.11
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2012 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
Line 2572  instruction_start(struct_processus *s_et Line 2572  instruction_start(struct_processus *s_et
         }          }
     }      }
   
     empilement_pile_systeme(s_etat_processus);  
   
     if ((*s_etat_processus).erreur_systeme != d_es)  
     {  
         return;  
     }  
   
     (*(*s_etat_processus).l_base_pile_systeme).type_cloture = 'S';  
   
     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),      if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
             &s_objet_1) == d_erreur)              &s_objet_1) == d_erreur)
     {      {
Line 2614  instruction_start(struct_processus *s_et Line 2605  instruction_start(struct_processus *s_et
         return;          return;
     }      }
   
       empilement_pile_systeme(s_etat_processus);
   
       if ((*s_etat_processus).erreur_systeme != d_es)
       {
           return;
       }
   
       (*(*s_etat_processus).l_base_pile_systeme).type_cloture = 'S';
   
     (*(*s_etat_processus).l_base_pile_systeme).indice_boucle = s_objet_2;      (*(*s_etat_processus).l_base_pile_systeme).indice_boucle = s_objet_2;
     (*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle = s_objet_1;      (*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle = s_objet_1;
   
Line 2916  instruction_step(struct_processus *s_eta Line 2916  instruction_step(struct_processus *s_eta
         {          {
             (*s_etat_processus).niveau_courant--;              (*s_etat_processus).niveau_courant--;
   
             if (retrait_variable_par_niveau(s_etat_processus) == d_erreur)              if (retrait_variables_par_niveau(s_etat_processus) == d_erreur)
             {              {
                 return;                  return;
             }              }
Line 3219  instruction_sto(struct_processus *s_etat Line 3219  instruction_sto(struct_processus *s_etat
   
         if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)          if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
         {          {
             if (pthread_mutex_lock(&((*(*s_etat_processus)  
                     .s_liste_variables_partagees).mutex)) != 0)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
   
             if (recherche_variable_partagee(s_etat_processus,              if (recherche_variable_partagee(s_etat_processus,
                     (*(*s_etat_processus).pointeur_variable_courante).nom,                      (*(*s_etat_processus).pointeur_variable_courante).nom,
                     (*(*s_etat_processus).pointeur_variable_courante)                      (*(*s_etat_processus).pointeur_variable_courante)
                     .variable_partagee, (*(*s_etat_processus)                      .variable_partagee, (*(*s_etat_processus)
                     .pointeur_variable_courante).origine) == d_faux)                      .pointeur_variable_courante).origine) == NULL)
             {              {
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                  if (((*s_etat_processus).autorisation_nom_implicite == 'N') &&
                         .s_liste_variables_partagees).mutex)) != 0)                          ((*((struct_nom *) (*s_objet_1).objet)).symbole
                 {                          == d_faux))
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
   
                 if ((*s_etat_processus).autorisation_nom_implicite == 'N')  
                 {                  {
                     liberation(s_etat_processus, s_objet_1);                      liberation(s_etat_processus, s_objet_1);
                     liberation(s_etat_processus, s_objet_2);                      liberation(s_etat_processus, s_objet_2);
Line 3282  instruction_sto(struct_processus *s_etat Line 3270  instruction_sto(struct_processus *s_etat
             else              else
             {              {
                 liberation(s_etat_processus, (*(*s_etat_processus)                  liberation(s_etat_processus, (*(*s_etat_processus)
                         .s_liste_variables_partagees).table                          .pointeur_variable_partagee_courante).objet);
                         [(*(*s_etat_processus).s_liste_variables_partagees)                  (*(*s_etat_processus).pointeur_variable_partagee_courante)
                         .position_variable].objet);                          .objet = s_objet_2;
   
                 (*(*s_etat_processus).s_liste_variables_partagees).table  
                         [(*(*s_etat_processus).s_liste_variables_partagees)  
                         .position_variable].objet = s_objet_2;  
   
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                         .s_liste_variables_partagees).mutex)) != 0)                          .pointeur_variable_partagee_courante).mutex)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
Line 3300  instruction_sto(struct_processus *s_etat Line 3284  instruction_sto(struct_processus *s_etat
         }          }
         else          else
         {          {
             if ((*s_etat_processus).autorisation_nom_implicite == 'N')              if (((*s_etat_processus).autorisation_nom_implicite == 'N') &&
                       ((*((struct_nom *) (*s_objet_1).objet)).symbole == d_faux))
             {              {
                 if ((*(*s_etat_processus).pointeur_variable_courante)                  if ((*(*s_etat_processus).pointeur_variable_courante)
                         .niveau == 1)                          .niveau == 1)
Line 3327  instruction_sto(struct_processus *s_etat Line 3312  instruction_sto(struct_processus *s_etat
          * une variable globale.           * une variable globale.
          */           */
   
         if ((*s_etat_processus).autorisation_nom_implicite == 'N')          if (((*s_etat_processus).autorisation_nom_implicite == 'N') &&
                   ((*((struct_nom *) (*s_objet_1).objet)).symbole == d_faux))
         {          {
             liberation(s_etat_processus, s_objet_1);              liberation(s_etat_processus, s_objet_1);
             liberation(s_etat_processus, s_objet_2);              liberation(s_etat_processus, s_objet_2);
Line 3399  instruction_syseval(struct_processus *s_ Line 3385  instruction_syseval(struct_processus *s_
     logical1                    presence_stdin;      logical1                    presence_stdin;
   
     long                        i;      long                        i;
       long                        longueur_ecriture;
       long                        longueur_traitee;
     long                        nombre_arguments;      long                        nombre_arguments;
   
     pid_t                       pid;      pid_t                       pid;
   
     ssize_t                     longueur_ecriture;  
   
     struct_liste_chainee        *l_element_courant;      struct_liste_chainee        *l_element_courant;
     struct_liste_chainee        *l_element_precedent;      struct_liste_chainee        *l_element_precedent;
     struct_liste_chainee        *l_element_stdin;      struct_liste_chainee        *l_element_stdin;
Line 3417  instruction_syseval(struct_processus *s_ Line 3403  instruction_syseval(struct_processus *s_
     struct sigaction            action_courante;      struct sigaction            action_courante;
     struct sigaction            action_passee;      struct sigaction            action_passee;
   
       unsigned char               *ligne;
     unsigned char               *ptr;      unsigned char               *ptr;
     unsigned char               *ptr2;      unsigned char               *ptr2;
     unsigned char               registre_autorisation_empilement_programme;      unsigned char               registre_autorisation_empilement_programme;
Line 3523  instruction_syseval(struct_processus *s_ Line 3510  instruction_syseval(struct_processus *s_
         registre_programme = (*s_etat_processus).definitions_chainees;          registre_programme = (*s_etat_processus).definitions_chainees;
         registre_position_courante = (*s_etat_processus).position_courante;          registre_position_courante = (*s_etat_processus).position_courante;
   
         (*s_etat_processus).definitions_chainees =  
                 (unsigned char *) (*s_objet).objet;  
         (*s_etat_processus).position_courante = 0;          (*s_etat_processus).position_courante = 0;
         (*s_etat_processus).autorisation_empilement_programme = 'N';          (*s_etat_processus).autorisation_empilement_programme = 'N';
   
Line 3532  instruction_syseval(struct_processus *s_ Line 3517  instruction_syseval(struct_processus *s_
          * Échappement des guillemets           * Échappement des guillemets
          */           */
   
         ptr = (*s_etat_processus).definitions_chainees;          if (((*s_etat_processus).definitions_chainees =
         ptr2 = ptr;                  formateur_flux(s_etat_processus, (unsigned char *)
         i = 0;                  (*s_objet).objet, &longueur_traitee)) == NULL)
   
         while((*ptr) != d_code_fin_chaine)  
         {          {
             if ((*ptr) == '\\')              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             {              return;
                 switch (*(ptr + 1))  
                 {  
                     case '"':  
                     case '\\':  
                     {  
                         ptr++;  
                         break;  
                     }  
                 }  
             }  
   
             *ptr2++ = *ptr++;  
         }          }
   
         *ptr2 = d_code_fin_chaine;  
   
         /*          /*
          * Scission de la chaîne en différents arguments           * Scission de la chaîne en différents arguments
          */           */
Line 3567  instruction_syseval(struct_processus *s_ Line 3536  instruction_syseval(struct_processus *s_
         {          {
             if (recherche_instruction_suivante(s_etat_processus) == d_erreur)              if (recherche_instruction_suivante(s_etat_processus) == d_erreur)
             {              {
                   free((*s_etat_processus).definitions_chainees);
   
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         registre_autorisation_empilement_programme;                          registre_autorisation_empilement_programme;
                 (*s_etat_processus).instruction_courante =                  (*s_etat_processus).instruction_courante =
Line 3584  instruction_syseval(struct_processus *s_ Line 3555  instruction_syseval(struct_processus *s_
                 if ((s_objet_temporaire = allocation(s_etat_processus, CHN))                  if ((s_objet_temporaire = allocation(s_etat_processus, CHN))
                         == NULL)                          == NULL)
                 {                  {
                       free((*s_etat_processus).definitions_chainees);
   
                     (*s_etat_processus).autorisation_empilement_programme =                      (*s_etat_processus).autorisation_empilement_programme =
                             registre_autorisation_empilement_programme;                              registre_autorisation_empilement_programme;
                     (*s_etat_processus).instruction_courante =                      (*s_etat_processus).instruction_courante =
Line 3628  instruction_syseval(struct_processus *s_ Line 3601  instruction_syseval(struct_processus *s_
                         &((*s_etat_processus).l_base_pile),                          &((*s_etat_processus).l_base_pile),
                         s_objet_temporaire) == d_erreur)                          s_objet_temporaire) == d_erreur)
                 {                  {
                       free((*s_etat_processus).definitions_chainees);
   
                       (*s_etat_processus).autorisation_empilement_programme =
                               registre_autorisation_empilement_programme;
                       (*s_etat_processus).instruction_courante =
                               registre_instruction_courante;
                       (*s_etat_processus).definitions_chainees =
                               registre_programme;
                       (*s_etat_processus).position_courante =
                               registre_position_courante;
                     return;                      return;
                 }                  }
             }              }
Line 3640  instruction_syseval(struct_processus *s_ Line 3623  instruction_syseval(struct_processus *s_
             nombre_arguments++;              nombre_arguments++;
         } while(drapeau_fin == d_faux);          } while(drapeau_fin == d_faux);
   
           free((*s_etat_processus).definitions_chainees);
   
         (*s_etat_processus).autorisation_empilement_programme =          (*s_etat_processus).autorisation_empilement_programme =
                 registre_autorisation_empilement_programme;                  registre_autorisation_empilement_programme;
         (*s_etat_processus).instruction_courante =          (*s_etat_processus).instruction_courante =
Line 3855  instruction_syseval(struct_processus *s_ Line 3840  instruction_syseval(struct_processus *s_
   
                 while(l_element_courant != NULL)                  while(l_element_courant != NULL)
                 {                  {
                     longueur_ecriture = strlen((unsigned char *)                      if ((ligne = formateur_flux(s_etat_processus,
                             (*(*l_element_courant).donnee).objet);                              (unsigned char *) (*(*l_element_courant).donnee)
                               .objet, &longueur_ecriture)) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                         if (sem_post(&((*s_etat_processus).semaphore_fork))                          if (sem_post(&((*s_etat_processus).semaphore_fork))
Line 3870  instruction_syseval(struct_processus *s_ Line 3861  instruction_syseval(struct_processus *s_
                     }                      }
   
                     while(write_atomic(s_etat_processus,                      while(write_atomic(s_etat_processus,
                             pipes_entree[1], (unsigned char *)                              pipes_entree[1], ligne,
                             (*(*l_element_courant).donnee).objet,  
                             longueur_ecriture) != longueur_ecriture)                              longueur_ecriture) != longueur_ecriture)
                     {                      {
 #                       ifndef SEMAPHORES_NOMMES  #                       ifndef SEMAPHORES_NOMMES
Line 3906  instruction_syseval(struct_processus *s_ Line 3896  instruction_syseval(struct_processus *s_
                         }                          }
                     }                      }
   
                       free(ligne);
   
                     while(write_atomic(s_etat_processus,                      while(write_atomic(s_etat_processus,
                             pipes_entree[1], "\n", 1) != 1)                              pipes_entree[1], "\n", 1) != 1)
                     {                      {
Line 4031  instruction_syseval(struct_processus *s_ Line 4023  instruction_syseval(struct_processus *s_
                 return;                  return;
             }              }
   
               tampon[0] = d_code_fin_chaine;
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
Line 4092  instruction_syseval(struct_processus *s_ Line 4086  instruction_syseval(struct_processus *s_
                 }                  }
             }              }
   
             if ((tampon = realloc(tampon, (strlen(tampon) + 1) *  
                     sizeof(unsigned char))) == NULL)  
             {  
                 (*s_etat_processus).erreur_systeme =  
                         d_es_allocation_memoire;  
                 return;  
             }  
   
             if (ios == -1)              if (ios == -1)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
Line 4164  instruction_syseval(struct_processus *s_ Line 4150  instruction_syseval(struct_processus *s_
                     }                      }
   
                     if (((*(*l_element_courant).donnee).objet =                      if (((*(*l_element_courant).donnee).objet =
                             malloc((strlen(ptr) + 1) * sizeof(unsigned char)))                              analyse_flux(s_etat_processus, ptr,
                             == NULL)                              strlen(ptr))) == NULL)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
                                 d_es_allocation_memoire;                                  d_es_allocation_memoire;
                         return;                          return;
                     }                      }
   
                     strcpy((*(*l_element_courant).donnee).objet, ptr);  
                   
                     while((*ptr) != d_code_fin_chaine)                      while((*ptr) != d_code_fin_chaine)
                     {                      {
                         ptr++;                          ptr++;
Removed from v.1.47  
changed lines
  Added in v.1.59

CVSweb interface <joel.bertrand@systella.fr>