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

Diff for /rpl/src/sequenceur.c between versions 1.67 and 1.77

version 1.67, 2013/03/05 16:20:47 version 1.77, 2013/09/06 10:30:56
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.13    RPL/2 (R) version 4.1.16
   Copyright (C) 1989-2013 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 44  sequenceur(struct_processus *s_etat_proc Line 44  sequenceur(struct_processus *s_etat_proc
     struct_objet                *s_objet_evaluation;      struct_objet                *s_objet_evaluation;
     struct_objet                *s_sous_objet;      struct_objet                *s_sous_objet;
   
       integer8                    niveau;
       integer8                    position_courante;
   
     logical1                    drapeau_appel_definition;      logical1                    drapeau_appel_definition;
     logical1                    drapeau_fin;      logical1                    drapeau_fin;
     logical1                    drapeau_then;      logical1                    drapeau_then;
Line 61  sequenceur(struct_processus *s_etat_proc Line 64  sequenceur(struct_processus *s_etat_proc
     unsigned char               *message;      unsigned char               *message;
     unsigned char               *registre;      unsigned char               *registre;
     unsigned char               *tampon;      unsigned char               *tampon;
     unsigned char               tampon_retour;  
     unsigned char               *t_ligne;      unsigned char               *t_ligne;
   
     unsigned long               niveau;  
     unsigned long               position_courante;  
   
     Keymap                      ancien_keymap;      Keymap                      ancien_keymap;
     Keymap                      nouveau_keymap;      Keymap                      nouveau_keymap;
   
Line 80  sequenceur(struct_processus *s_etat_proc Line 79  sequenceur(struct_processus *s_etat_proc
         {          {
             if ((*s_etat_processus).langue == 'F')              if ((*s_etat_processus).langue == 'F')
             {              {
                 printf("[%d] Exécution récursive de niveau %lu\n",                  printf("[%d] Exécution récursive de niveau %lld\n",
                         (int) getpid(), (*s_etat_processus).niveau_recursivite);                          (int) getpid(), (*s_etat_processus).niveau_recursivite);
             }              }
             else              else
             {              {
                 printf("[%d] %lu level recursive execution\n",                  printf("[%d] %lld level recursive execution\n",
                         (int) getpid(), (*s_etat_processus).niveau_recursivite);                          (int) getpid(), (*s_etat_processus).niveau_recursivite);
             }              }
         }          }
Line 93  sequenceur(struct_processus *s_etat_proc Line 92  sequenceur(struct_processus *s_etat_proc
         {          {
             if ((*s_etat_processus).langue == 'F')              if ((*s_etat_processus).langue == 'F')
             {              {
                 printf("[%d] Exécution\n", (int) getpid());                  printf("[%d] Exécution\n", (int) getpid());
             }              }
             else              else
             {              {
Line 334  sequenceur(struct_processus *s_etat_proc Line 333  sequenceur(struct_processus *s_etat_proc
                     }                      }
                     else                      else
                     {                      {
                         tampon_retour = (*(*s_etat_processus)                          position_courante =
                                 .l_base_pile_systeme).retour_definition;                                  (*s_etat_processus).position_courante;
                           empilement_pile_systeme(s_etat_processus);
   
                           if ((*s_etat_processus).erreur_systeme != d_es)
                           {
                               return(d_erreur);
                           }
   
                         (*(*s_etat_processus).l_base_pile_systeme)                          (*(*s_etat_processus).l_base_pile_systeme)
                                 .retour_definition = 'Y';                                  .retour_definition = 'Y';
   
Line 349  sequenceur(struct_processus *s_etat_proc Line 355  sequenceur(struct_processus *s_etat_proc
   
                             if ((*s_etat_processus).langue == 'F')                              if ((*s_etat_processus).langue == 'F')
                             {                              {
                                 printf("+++Erreur : Défaut d'argument\n");                                  printf("+++Erreur : Défaut d'argument\n");
                             }                              }
                             else                              else
                             {                              {
                                 printf("+++Error : Too few arguments\n");                                  printf("+++Error : Too few arguments\n");
                             }                              }
   
                             (*(*s_etat_processus).l_base_pile_systeme)                              depilement_pile_systeme(s_etat_processus);
                                     .retour_definition = tampon_retour;  
                               if ((*s_etat_processus).erreur_systeme != d_es)
                               {
                                   return(d_erreur);
                               }
   
                             fflush(stdout);                              fflush(stdout);
                         }                          }
                         else if (evaluation(s_etat_processus, s_objet, 'I') ==                          else if (evaluation(s_etat_processus, s_objet, 'I') ==
                                 d_erreur)                                  d_erreur)
                         {                          {
                             (*(*s_etat_processus).l_base_pile_systeme)  
                                     .retour_definition = tampon_retour;  
   
                             if ((*s_etat_processus).erreur_systeme != d_es)                              if ((*s_etat_processus).erreur_systeme != d_es)
                             {                              {
                                 if (test_cfsf(s_etat_processus, 51) == d_faux)                                  if (test_cfsf(s_etat_processus, 51) == d_faux)
Line 452  sequenceur(struct_processus *s_etat_proc Line 459  sequenceur(struct_processus *s_etat_proc
                             liberation(s_etat_processus, s_objet);                              liberation(s_etat_processus, s_objet);
                         }                          }
   
                         (*(*s_etat_processus).l_base_pile_systeme)                          (*s_etat_processus).position_courante =
                                 .retour_definition = tampon_retour;                                  position_courante;
                     }                      }
                 }                  }
                 else if ((*s_etat_processus).invalidation_message_erreur                  else if ((*s_etat_processus).invalidation_message_erreur
Line 593  sequenceur(struct_processus *s_etat_proc Line 600  sequenceur(struct_processus *s_etat_proc
                             else                              else
                             {                              {
                                 printf("[%d] Pushing %s as %d type shared "                                  printf("[%d] Pushing %s as %d type shared "
                                         "variable \n", (int) getpid(),                                          "variable\n", (int) getpid(),
                                         (*s_etat_processus)                                          (*s_etat_processus)
                                         .instruction_courante,                                          .instruction_courante,
                                         (*(*(*s_etat_processus)                                          (*(*(*s_etat_processus)
Line 689  sequenceur(struct_processus *s_etat_proc Line 696  sequenceur(struct_processus *s_etat_proc
                         (*s_etat_processus).autorisation_empilement_programme =                          (*s_etat_processus).autorisation_empilement_programme =
                                 'N';                                  'N';
   
 uprintf("<A1>\n");  
                         empilement_pile_systeme(s_etat_processus);                          empilement_pile_systeme(s_etat_processus);
   
                         if ((*s_etat_processus).erreur_systeme != d_es)                          if ((*s_etat_processus).erreur_systeme != d_es)
Line 722  uprintf("<A1>\n"); Line 728  uprintf("<A1>\n");
                                     .niveau_courant;                                      .niveau_courant;
   
                             (*s_etat_processus).position_courante =                              (*s_etat_processus).position_courante =
                                     (*((unsigned long *)                                      (*((integer8 *)
                                     ((*(*(*s_etat_processus)                                      ((*(*(*s_etat_processus)
                                     .pointeur_variable_courante)                                      .pointeur_variable_courante)
                                     .objet).objet)));                                      .objet).objet)));
Line 952  uprintf("<A1>\n"); Line 958  uprintf("<A1>\n");
                 free(instruction_majuscule);                  free(instruction_majuscule);
             }              }
   
             erreur |= (((*s_etat_processus).erreur_execution != d_ex)              erreur = (logical1) (erreur | (((*s_etat_processus)
                     ? d_erreur : d_absence_erreur);                      .erreur_execution != d_ex) ? d_erreur : d_absence_erreur));
         }          }
         else          else
         {          {
Line 994  uprintf("<A1>\n"); Line 1000  uprintf("<A1>\n");
                 {                  {
                     if (strncmp(getenv("LANG"), "fr", 2) == 0)                      if (strncmp(getenv("LANG"), "fr", 2) == 0)
                     {                      {
                         printf("[%d] Arrêt\n", (int) getpid());                          printf("[%d] Arrêt\n", (int) getpid());
                     }                      }
                     else                      else
                     {                      {
Line 1066  uprintf("<A1>\n"); Line 1072  uprintf("<A1>\n");
             (*s_etat_processus).exception = d_ep;              (*s_etat_processus).exception = d_ep;
             erreur = d_absence_erreur;              erreur = d_absence_erreur;
   
             (*s_etat_processus).position_courante -=              (*s_etat_processus).position_courante -= (integer8)
                     strlen((*s_etat_processus).instruction_courante);                      strlen((*s_etat_processus).instruction_courante);
         }          }
   
Line 1156  uprintf("<A1>\n"); Line 1162  uprintf("<A1>\n");
                         else if ((*(*(*s_etat_processus)                          else if ((*(*(*s_etat_processus)
                                 .pointeur_variable_courante).objet).type == ADR)                                  .pointeur_variable_courante).objet).type == ADR)
                         {                          {
 uprintf("<A2>\n");  
                             empilement_pile_systeme(s_etat_processus);                              empilement_pile_systeme(s_etat_processus);
   
                             if ((*s_etat_processus).erreur_systeme != d_es)                              if ((*s_etat_processus).erreur_systeme != d_es)
Line 1177  uprintf("<A2>\n"); Line 1182  uprintf("<A2>\n");
                                     .niveau_courant;                                      .niveau_courant;
   
                             (*s_etat_processus).position_courante =                              (*s_etat_processus).position_courante =
                                     (*((unsigned long *)                                      (*((integer8 *)
                                     ((*(*(*s_etat_processus)                                      ((*(*(*s_etat_processus)
                                     .pointeur_variable_courante)                                      .pointeur_variable_courante)
                                     .objet).objet)));                                      .objet).objet)));
Line 1226  uprintf("<A2>\n"); Line 1231  uprintf("<A2>\n");
                                     == 0) || (strcmp(instruction_majuscule,                                      == 0) || (strcmp(instruction_majuscule,
                                     "START") == 0))                                      "START") == 0))
                             {                              {
 uprintf("<A3>\n");  
                                 empilement_pile_systeme(s_etat_processus);                                  empilement_pile_systeme(s_etat_processus);
   
                                 if ((*s_etat_processus).erreur_systeme != d_es)                                  if ((*s_etat_processus).erreur_systeme != d_es)
Line 1239  uprintf("<A3>\n"); Line 1243  uprintf("<A3>\n");
                             }                              }
                             else                              else
                             {                              {
 uprintf("<A4>\n");  
                                 empilement_pile_systeme(s_etat_processus);                                  empilement_pile_systeme(s_etat_processus);
   
                                 if ((*s_etat_processus).erreur_systeme != d_es)                                  if ((*s_etat_processus).erreur_systeme != d_es)
Removed from v.1.67  
changed lines
  Added in v.1.77

CVSweb interface <joel.bertrand@systella.fr>