Diff for /rpl/src/analyse.c between versions 1.8 and 1.107

version 1.8, 2010/04/07 13:45:00 version 1.107, 2017/07/30 22:00:02
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.14    RPL/2 (R) version 4.1.27
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2017 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 35 Line 35
 ================================================================================  ================================================================================
 */  */
   
   
 static void  static void
 creation_instruction(struct_processus *s_etat_processus,  creation_instruction(struct_processus *s_etat_processus,
         unsigned char *instruction, void (*routine)())          unsigned char *instruction, void (*routine)())
Line 46  creation_instruction(struct_processus *s Line 45  creation_instruction(struct_processus *s
   
     unsigned char           *ptr;      unsigned char           *ptr;
   
       BUG(strlen(instruction) >= d_longueur_maximale_instruction,
               printf("%s -> %d >= %d\n", instruction, (int) strlen(instruction),
               d_longueur_maximale_instruction));
   
     if ((*s_etat_processus).arbre_instructions == NULL)      if ((*s_etat_processus).arbre_instructions == NULL)
     {      {
         if (((*s_etat_processus).arbre_instructions =          if (((*s_etat_processus).arbre_instructions =
Line 57  creation_instruction(struct_processus *s Line 60  creation_instruction(struct_processus *s
   
         (*(*s_etat_processus).arbre_instructions).feuille = NULL;          (*(*s_etat_processus).arbre_instructions).feuille = NULL;
   
         if (((*(*s_etat_processus).arbre_instructions).noeud =          if (((*(*s_etat_processus).arbre_instructions).noeuds =
                 malloc((*s_etat_processus).nombre_caracteres                  malloc(((size_t) (*s_etat_processus).nombre_caracteres)
                 * sizeof(struct_instruction))) == NULL)                  * sizeof(struct_instruction))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 67  creation_instruction(struct_processus *s Line 70  creation_instruction(struct_processus *s
   
         for(i = 0; i < (*s_etat_processus).nombre_caracteres; i++)          for(i = 0; i < (*s_etat_processus).nombre_caracteres; i++)
         {          {
             (*(*s_etat_processus).arbre_instructions).noeud[i] = NULL;              (*(*s_etat_processus).arbre_instructions).noeuds[i] = NULL;
         }          }
     }      }
   
Line 80  creation_instruction(struct_processus *s Line 83  creation_instruction(struct_processus *s
                 printf("Instruction=\"%s\", (*ptr)='%c'\n",                  printf("Instruction=\"%s\", (*ptr)='%c'\n",
                 instruction, *ptr));                  instruction, *ptr));
   
         if ((*l_instruction_courante).noeud[(*s_etat_processus)          if ((*l_instruction_courante).noeuds[(*s_etat_processus)
                 .pointeurs_caracteres[*ptr]] == NULL)                  .pointeurs_caracteres[*ptr]] == NULL)
         {          {
             // Le noeud suivant n'existe pas, on le crée.              // Le noeud suivant n'existe pas, on le crée.
   
             if (((*l_instruction_courante).noeud[(*s_etat_processus)              if (((*l_instruction_courante).noeuds[(*s_etat_processus)
                     .pointeurs_caracteres[*ptr]] =                      .pointeurs_caracteres[*ptr]] =
                     malloc(sizeof(struct_instruction))) == NULL)                      malloc(sizeof(struct_instruction))) == NULL)
             {              {
Line 93  creation_instruction(struct_processus *s Line 96  creation_instruction(struct_processus *s
                 return;                  return;
             }              }
   
             (*(*l_instruction_courante).noeud[(*s_etat_processus)              (*(*l_instruction_courante).noeuds[(*s_etat_processus)
                     .pointeurs_caracteres[*ptr]]).feuille = NULL;                      .pointeurs_caracteres[*ptr]]).feuille = NULL;
   
             if (((*(*l_instruction_courante).noeud[(*s_etat_processus)              if (((*(*l_instruction_courante).noeuds[(*s_etat_processus)
                     .pointeurs_caracteres[*ptr]]).noeud =                      .pointeurs_caracteres[*ptr]]).noeuds =
                     malloc((*s_etat_processus).nombre_caracteres                      malloc(((size_t) (*s_etat_processus).nombre_caracteres)
                     * sizeof(struct_instruction))) == NULL)                      * sizeof(struct_instruction))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 107  creation_instruction(struct_processus *s Line 110  creation_instruction(struct_processus *s
   
             for(i = 0; i < (*s_etat_processus).nombre_caracteres; i++)              for(i = 0; i < (*s_etat_processus).nombre_caracteres; i++)
             {              {
                 (*(*l_instruction_courante).noeud[(*s_etat_processus)                  (*(*l_instruction_courante).noeuds[(*s_etat_processus)
                         .pointeurs_caracteres[*ptr]]).noeud[i] = NULL;                          .pointeurs_caracteres[*ptr]]).noeuds[i] = NULL;
             }              }
         }          }
   
         l_instruction_courante = (*l_instruction_courante).noeud          l_instruction_courante = (*l_instruction_courante).noeuds
                 [(*s_etat_processus).pointeurs_caracteres[*ptr]];                  [(*s_etat_processus).pointeurs_caracteres[*ptr]];
         ptr++;          ptr++;
     }      }
Line 134  liberation_arbre_instructions(struct_pro Line 137  liberation_arbre_instructions(struct_pro
   
     for(i = 0; i < (*s_etat_processus).nombre_caracteres; i++)      for(i = 0; i < (*s_etat_processus).nombre_caracteres; i++)
     {      {
         if ((*arbre).noeud[i] != NULL)          if ((*arbre).noeuds[i] != NULL)
         {          {
             liberation_arbre_instructions(s_etat_processus, (*arbre).noeud[i]);              liberation_arbre_instructions(s_etat_processus, (*arbre).noeuds[i]);
         }          }
     }      }
   
     free((*arbre).noeud);      free((*arbre).noeuds);
     free(arbre);      free(arbre);
   
     return;      return;
Line 177  initialisation_instructions(struct_proce Line 180  initialisation_instructions(struct_proce
     }      }
   
     if (((*s_etat_processus).pointeurs_caracteres =      if (((*s_etat_processus).pointeurs_caracteres =
             malloc(longueur_tableau * sizeof(int))) == NULL)              malloc(((size_t) longueur_tableau * sizeof(int)))) == NULL)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         return;          return;
Line 320  initialisation_instructions(struct_proce Line 323  initialisation_instructions(struct_proce
     INSTRUCTION("EGV", instruction_egv);      INSTRUCTION("EGV", instruction_egv);
     INSTRUCTION("END", instruction_end);      INSTRUCTION("END", instruction_end);
     INSTRUCTION("ENG", instruction_eng);      INSTRUCTION("ENG", instruction_eng);
       INSTRUCTION("EQV", instruction_eqv);
     INSTRUCTION("EXP", instruction_exp);      INSTRUCTION("EXP", instruction_exp);
     INSTRUCTION("FC?", instruction_fc_test);      INSTRUCTION("FC?", instruction_fc_test);
     INSTRUCTION("FFT", instruction_fft);      INSTRUCTION("FFT", instruction_fft);
Line 462  initialisation_instructions(struct_proce Line 466  initialisation_instructions(struct_proce
     INSTRUCTION("LINE", instruction_line);      INSTRUCTION("LINE", instruction_line);
     INSTRUCTION("LNP1", instruction_lnp1);      INSTRUCTION("LNP1", instruction_lnp1);
     INSTRUCTION("LOCK", instruction_lock);      INSTRUCTION("LOCK", instruction_lock);
       INSTRUCTION("L->T", instruction_l_vers_t);
     INSTRUCTION("MANT", instruction_mant);      INSTRUCTION("MANT", instruction_mant);
     INSTRUCTION("MARK", instruction_mark);      INSTRUCTION("MARK", instruction_mark);
     //INSTRUCTION("MAXR")      //INSTRUCTION("MAXR")
Line 483  initialisation_instructions(struct_proce Line 488  initialisation_instructions(struct_proce
     INSTRUCTION("PMAX", instruction_pmax);      INSTRUCTION("PMAX", instruction_pmax);
     INSTRUCTION("PMIN", instruction_pmin);      INSTRUCTION("PMIN", instruction_pmin);
     INSTRUCTION("POKE", instruction_poke);      INSTRUCTION("POKE", instruction_poke);
       INSTRUCTION("POLL", instruction_poll);
     INSTRUCTION("PPAR", instruction_ppar);      INSTRUCTION("PPAR", instruction_ppar);
     INSTRUCTION("PRMD", instruction_prmd);      INSTRUCTION("PRMD", instruction_prmd);
     INSTRUCTION("PRST", instruction_prst);      INSTRUCTION("PRST", instruction_prst);
Line 508  initialisation_instructions(struct_proce Line 514  initialisation_instructions(struct_proce
     INSTRUCTION("RECV", instruction_recv);      INSTRUCTION("RECV", instruction_recv);
     INSTRUCTION("REGV", instruction_regv);      INSTRUCTION("REGV", instruction_regv);
     INSTRUCTION("REPL", instruction_repl);      INSTRUCTION("REPL", instruction_repl);
       INSTRUCTION("RGDL", instruction_rgdl);
       INSTRUCTION("RGDR", instruction_rgdr);
     INSTRUCTION("RNRM", instruction_rnrm);      INSTRUCTION("RNRM", instruction_rnrm);
     INSTRUCTION("ROLL", instruction_roll);      INSTRUCTION("ROLL", instruction_roll);
     //INSTRUCTION("ROOT")      //INSTRUCTION("ROOT")
Line 536  initialisation_instructions(struct_proce Line 544  initialisation_instructions(struct_proce
     INSTRUCTION("SPAR", instruction_spar);      INSTRUCTION("SPAR", instruction_spar);
     INSTRUCTION("SQRT", instruction_sqrt);      INSTRUCTION("SQRT", instruction_sqrt);
     //INSTRUCTION("SRAD");      //INSTRUCTION("SRAD");
       INSTRUCTION("SREV", instruction_srev);
     //INSTRUCTION("SRNM")      //INSTRUCTION("SRNM")
     //Instruction HP48 (renvoie la norme spectrale d'un tableau. Pour une      //Instruction HP48 (renvoie la norme spectrale d'un tableau. Pour une
     //matrice,      //matrice,
Line 561  initialisation_instructions(struct_proce Line 570  initialisation_instructions(struct_proce
     INSTRUCTION("TRNC", instruction_trnc);      INSTRUCTION("TRNC", instruction_trnc);
     INSTRUCTION("TRUE", instruction_true);      INSTRUCTION("TRUE", instruction_true);
     INSTRUCTION("TYPE", instruction_type);      INSTRUCTION("TYPE", instruction_type);
       INSTRUCTION("T->L", instruction_t_vers_l);
     INSTRUCTION("UTPC", instruction_utpc);      INSTRUCTION("UTPC", instruction_utpc);
     INSTRUCTION("UTPF", instruction_utpf);      INSTRUCTION("UTPF", instruction_utpf);
     INSTRUCTION("UTPN", instruction_utpn);      INSTRUCTION("UTPN", instruction_utpn);
Line 641  initialisation_instructions(struct_proce Line 651  initialisation_instructions(struct_proce
     INSTRUCTION("LCASE", instruction_lcase);      INSTRUCTION("LCASE", instruction_lcase);
     INSTRUCTION("LCHOL", instruction_lchol);      INSTRUCTION("LCHOL", instruction_lchol);
     INSTRUCTION("LCD->", instruction_lcd_fleche);      INSTRUCTION("LCD->", instruction_lcd_fleche);
       INSTRUCTION("LIMIT", instruction_limit);
     //INSTRUCTION("NDIST")      //INSTRUCTION("NDIST")
     //Instruction HP48 (distribution normale, prend la moyenne au niveau 3,      //Instruction HP48 (distribution normale, prend la moyenne au niveau 3,
     //la variance au niveau 2, un réel x au niveau 1 et renvoie la probabilité      //la variance au niveau 2, un réel x au niveau 1 et renvoie la probabilité
Line 669  initialisation_instructions(struct_proce Line 680  initialisation_instructions(struct_proce
     INSTRUCTION("PSDEV", instruction_psdev);      INSTRUCTION("PSDEV", instruction_psdev);
     INSTRUCTION("PURGE", instruction_purge);      INSTRUCTION("PURGE", instruction_purge);
     INSTRUCTION("RDATE", instruction_rdate);      INSTRUCTION("RDATE", instruction_rdate);
       INSTRUCTION("REGEX", instruction_regex);
     INSTRUCTION("RELAX", instruction_relax);      INSTRUCTION("RELAX", instruction_relax);
     INSTRUCTION("RFUSE", instruction_rfuse);      INSTRUCTION("RFUSE", instruction_rfuse);
     INSTRUCTION("RSTOP", instruction_rstop);      INSTRUCTION("RSTOP", instruction_rstop);
Line 710  initialisation_instructions(struct_proce Line 722  initialisation_instructions(struct_proce
   
     INSTRUCTION("APPEND", instruction_append);      INSTRUCTION("APPEND", instruction_append);
     INSTRUCTION("ARRY->", instruction_array_fleche);      INSTRUCTION("ARRY->", instruction_array_fleche);
       INSTRUCTION("ATEXIT", instruction_atexit);
       INSTRUCTION("ATPOKE", instruction_atpoke);
     INSTRUCTION("BESSEL", instruction_bessel);      INSTRUCTION("BESSEL", instruction_bessel);
       INSTRUCTION("CIPHER", instruction_cipher);
     INSTRUCTION("CLRERR", instruction_clrerr);      INSTRUCTION("CLRERR", instruction_clrerr);
     INSTRUCTION("CLRMTX", instruction_clrmtx);      INSTRUCTION("CLRMTX", instruction_clrmtx);
     INSTRUCTION("CLRSWI", instruction_clrswi);      INSTRUCTION("CLRSWI", instruction_clrswi);
     INSTRUCTION("CREATE", instruction_create);      INSTRUCTION("CREATE", instruction_create);
     INSTRUCTION("DELETE", instruction_delete);      INSTRUCTION("DELETE", instruction_delete);
     INSTRUCTION("DETACH", instruction_detach);  #   ifdef SHARED_MEMORY
           INSTRUCTION("DETACH", instruction_detach);
   #   else
           if ((*s_etat_processus).langue == 'F')
           {
               printf("+++Attention : DETACH est émulé par SPAWN car le système"
                       " hôte ne supporte\n"
                       "               pas de mémoire partagée !\n");
           }
           else
           {
               printf("+++Warning : DETACH is replaced by SPAWN as host system"
                       " does not support\n"
                       "             shared memory !\n");
           }
   
           INSTRUCTION("DETACH", instruction_spawn);
   #   endif
     INSTRUCTION("DIAG->", instruction_diag_fleche);      INSTRUCTION("DIAG->", instruction_diag_fleche);
       INSTRUCTION("DIGEST", instruction_digest);
     //INSTRUCTION("DOLIST")      //INSTRUCTION("DOLIST")
     //Instruction HP48 (application d'une fonction à une liste)      //Instruction HP48 (application d'une fonction à une liste)
     //liste(s) nombre_de_listes_a_traiter fonction DOLIST      //liste(s) nombre_de_listes_a_traiter fonction DOLIST
Line 729  initialisation_instructions(struct_proce Line 762  initialisation_instructions(struct_proce
     //DOLIST      //DOLIST
     //=> { 29 42 57 }      //=> { 29 42 57 }
     INSTRUCTION("ELSEIF", instruction_elseif);      INSTRUCTION("ELSEIF", instruction_elseif);
       INSTRUCTION("FORALL", instruction_forall);
     INSTRUCTION("FORMAT", instruction_format);      INSTRUCTION("FORMAT", instruction_format);
     //INSTRUCTION("HEIGHT")      //INSTRUCTION("HEIGHT")
     INSTRUCTION("ITRACE", instruction_itrace);      INSTRUCTION("ITRACE", instruction_itrace);
Line 736  initialisation_instructions(struct_proce Line 770  initialisation_instructions(struct_proce
     INSTRUCTION("LOGGER", instruction_logger);      INSTRUCTION("LOGGER", instruction_logger);
     INSTRUCTION("MCLRIN", instruction_mclrin);      INSTRUCTION("MCLRIN", instruction_mclrin);
     INSTRUCTION("NRPROC", instruction_nrproc);      INSTRUCTION("NRPROC", instruction_nrproc);
       INSTRUCTION("PROCID", instruction_procid);
     INSTRUCTION("PROMPT", instruction_prompt);      INSTRUCTION("PROMPT", instruction_prompt);
     INSTRUCTION("RCLSWI", instruction_rclswi);      INSTRUCTION("RCLSWI", instruction_rclswi);
     INSTRUCTION("RECALL", instruction_recall);      INSTRUCTION("RECALL", instruction_recall);
Line 788  initialisation_instructions(struct_proce Line 823  initialisation_instructions(struct_proce
     //f(x,y)=fnct complexe évaluée sur la grille (x,y) et affichée comme une      //f(x,y)=fnct complexe évaluée sur la grille (x,y) et affichée comme une
     //fonction paramétrique.      //fonction paramétrique.
     INSTRUCTION("INQUIRE", instruction_inquire);      INSTRUCTION("INQUIRE", instruction_inquire);
       INSTRUCTION("MEMLOCK", instruction_memlock);
     INSTRUCTION("MTXLOCK", instruction_mtxlock);      INSTRUCTION("MTXLOCK", instruction_mtxlock);
     INSTRUCTION("PERSIST", instruction_persist);      INSTRUCTION("PERSIST", instruction_persist);
     INSTRUCTION("PLOTTER", instruction_plotter);      INSTRUCTION("PLOTTER", instruction_plotter);
Line 795  initialisation_instructions(struct_proce Line 831  initialisation_instructions(struct_proce
     INSTRUCTION("PROTECT", instruction_protect);      INSTRUCTION("PROTECT", instruction_protect);
     INSTRUCTION("PSHPRFL", instruction_pshprfl);      INSTRUCTION("PSHPRFL", instruction_pshprfl);
     INSTRUCTION("PULPRFL", instruction_pulprfl);      INSTRUCTION("PULPRFL", instruction_pulprfl);
       INSTRUCTION("RESTART", instruction_restart);
     INSTRUCTION("REVLIST", instruction_revlist);      INSTRUCTION("REVLIST", instruction_revlist);
     INSTRUCTION("SCATTER", instruction_scatter);      INSTRUCTION("SCATTER", instruction_scatter);
     INSTRUCTION("SUSPEND", instruction_suspend);      INSTRUCTION("SUSPEND", instruction_suspend);
Line 808  initialisation_instructions(struct_proce Line 845  initialisation_instructions(struct_proce
   
     INSTRUCTION("CLRCNTXT", instruction_clrcntxt);      INSTRUCTION("CLRCNTXT", instruction_clrcntxt);
     INSTRUCTION("CLRSMPHR", instruction_clrsmphr);      INSTRUCTION("CLRSMPHR", instruction_clrsmphr);
       INSTRUCTION("COMPRESS", instruction_compress);
     INSTRUCTION("CONTINUE", instruction_continue);      INSTRUCTION("CONTINUE", instruction_continue);
       INSTRUCTION("CRITICAL", instruction_critical);
     INSTRUCTION("DUPCNTXT", instruction_dupcntxt);      INSTRUCTION("DUPCNTXT", instruction_dupcntxt);
     INSTRUCTION("FUNCTION", instruction_function);      INSTRUCTION("FUNCTION", instruction_function);
     INSTRUCTION("IMPLICIT", instruction_implicit);      INSTRUCTION("IMPLICIT", instruction_implicit);
       INSTRUCTION("INFINITY", instruction_sensible_infinity);
     INSTRUCTION("KEYLABEL", instruction_keylabel);      INSTRUCTION("KEYLABEL", instruction_keylabel);
     INSTRUCTION("KEYTITLE", instruction_keytitle);      INSTRUCTION("KEYTITLE", instruction_keytitle);
     INSTRUCTION("LOGSCALE", instruction_logscale);      INSTRUCTION("LOGSCALE", instruction_logscale);
Line 827  initialisation_instructions(struct_proce Line 867  initialisation_instructions(struct_proce
   
     INSTRUCTION("AUTOSCALE", instruction_autoscale);      INSTRUCTION("AUTOSCALE", instruction_autoscale);
     INSTRUCTION("BACKSPACE", instruction_backspace);      INSTRUCTION("BACKSPACE", instruction_backspace);
       INSTRUCTION("BACKTRACE", instruction_backtrace);
       INSTRUCTION("CLRATEXIT", instruction_clratexit);
       INSTRUCTION("CLRATPOKE", instruction_clratpoke);
     INSTRUCTION("COPYRIGHT", instruction_copyright);      INSTRUCTION("COPYRIGHT", instruction_copyright);
     //INSTRUCTION("CYLINDRIC");      //INSTRUCTION("CYLINDRIC");
     INSTRUCTION("DAEMONIZE", instruction_daemonize);      INSTRUCTION("DAEMONIZE", instruction_daemonize);
     INSTRUCTION("DROPCNTXT", instruction_dropcntxt);      INSTRUCTION("DROPCNTXT", instruction_dropcntxt);
     INSTRUCTION("EXTERNALS", instruction_externals);      INSTRUCTION("EXTERNALS", instruction_externals);
     INSTRUCTION("HISTOGRAM", instruction_histogram);      INSTRUCTION("HISTOGRAM", instruction_histogram);
       INSTRUCTION("MEMUNLOCK", instruction_memunlock);
     INSTRUCTION("MTXSTATUS", instruction_mtxstatus);      INSTRUCTION("MTXSTATUS", instruction_mtxstatus);
     INSTRUCTION("MTXUNLOCK", instruction_mtxunlock);      INSTRUCTION("MTXUNLOCK", instruction_mtxunlock);
     INSTRUCTION("PARAMETER", instruction_parameter);      INSTRUCTION("PARAMETER", instruction_parameter);
Line 861  initialisation_instructions(struct_proce Line 905  initialisation_instructions(struct_proce
     //pentes      //pentes
     //représentent la valeur de la fonction (x,y) en leur milieu.      //représentent la valeur de la fonction (x,y) en leur milieu.
     //=> utile pour y'=F(x,y)      //=> utile pour y'=F(x,y)
       INSTRUCTION("UNCOMPRESS", instruction_uncompress);
   
     INSTRUCTION("LOCALIZATION", instruction_localization);      INSTRUCTION("LOCALIZATION", instruction_localization);
     INSTRUCTION("SMPHRTRYDECR", instruction_smphrtrydecr);      INSTRUCTION("SMPHRTRYDECR", instruction_smphrtrydecr);
Line 872  initialisation_instructions(struct_proce Line 917  initialisation_instructions(struct_proce
 }  }
   
   
 inline void *  void *
 analyse_instruction(struct_processus *s_etat_processus, unsigned char *ptr)  analyse_instruction(struct_processus *s_etat_processus, unsigned char *ptr)
 {  {
     int                             pointeur;      int                             pointeur;
Line 892  analyse_instruction(struct_processus *s_ Line 937  analyse_instruction(struct_processus *s_
             return(NULL);              return(NULL);
         }          }
   
         if ((*l_instruction_courante).noeud[pointeur] == NULL)          if ((*l_instruction_courante).noeuds[pointeur] == NULL)
         {          {
             // Le chemin de l'instruction candidate n'existe pas.              // Le chemin de l'instruction candidate n'existe pas.
   
             return(NULL);              return(NULL);
         }          }
   
         l_instruction_courante = (*l_instruction_courante).noeud[pointeur];          l_instruction_courante = (*l_instruction_courante).noeuds[pointeur];
         ptr++;          ptr++;
   
         if ((l_instruction_courante == NULL) && ((*ptr) != d_code_fin_chaine))          if ((l_instruction_courante == NULL) && ((*ptr) != d_code_fin_chaine))
Line 922  analyse_instruction(struct_processus *s_ Line 967  analyse_instruction(struct_processus *s_
 void  void
 analyse(struct_processus *s_etat_processus, void (*fonction)())  analyse(struct_processus *s_etat_processus, void (*fonction)())
 {  {
     static logical1                 initialisation = d_faux;  
   
     real8                           attente;      real8                           attente;
     real8                           pourcentage;      real8                           pourcentage;
     real8                           temps_cpu;      real8                           temps_cpu;
Line 932  analyse(struct_processus *s_etat_process Line 975  analyse(struct_processus *s_etat_process
     static struct timeval           horodatage_initial;      static struct timeval           horodatage_initial;
     struct timeval                  horodatage_final;      struct timeval                  horodatage_final;
   
   #   ifndef OS2
     static struct rusage            usage_initial;      static struct rusage            usage_initial;
     struct rusage                   usage_final;      struct rusage                   usage_final;
   #   else
       static clock_t                  usage_initial;
       clock_t                         usage_final;
   #   endif
   
     struct timespec                 temporisation;      struct timespec                 temporisation;
   
     unsigned char                   *position;      unsigned char                   *position;
     unsigned char                   *bibliotheque_candidate;      unsigned char                   *bibliotheque_candidate;
     unsigned char                   *instruction_majuscule;      unsigned char                   instruction_majuscule
                                               [d_longueur_maximale_instruction];
     unsigned char                   registre_instruction_valide;      unsigned char                   registre_instruction_valide;
   
     void                            (*instruction)();      void                            (*instruction)();
Line 956  analyse(struct_processus *s_etat_process Line 1005  analyse(struct_processus *s_etat_process
      * On autorise l'exécution d'un fork() dans un thread concurrent.       * On autorise l'exécution d'un fork() dans un thread concurrent.
      */       */
   
     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  #   ifndef SEMAPHORES_NOMMES
           if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #   else
           if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #   endif
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
   
     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  #   ifndef SEMAPHORES_NOMMES
           while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
   #   else
           while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #   endif
     {      {
         if (errno != EINTR)          if (errno != EINTR)
         {          {
Line 971  analyse(struct_processus *s_etat_process Line 1028  analyse(struct_processus *s_etat_process
         }          }
     }      }
   
       /*
        * Verrou pour les sections_critiques
        */
   
       if (pthread_mutex_lock(&mutex_sections_critiques) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
       if (pthread_mutex_unlock(&mutex_sections_critiques) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
     scrutation_injection(s_etat_processus);      scrutation_injection(s_etat_processus);
   
     if (fonction == NULL)      if (fonction == NULL)
     {      {
         if ((instruction_majuscule = conversion_majuscule(          conversion_majuscule_limitee((*s_etat_processus).instruction_courante,
                 (*s_etat_processus).instruction_courante)) == NULL)                  instruction_majuscule, d_longueur_maximale_instruction);
         {  
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
             return;  
         }  
   
         instruction = analyse_instruction(s_etat_processus,          instruction = analyse_instruction(s_etat_processus,
                 instruction_majuscule);                  instruction_majuscule);
   
Line 1010  analyse(struct_processus *s_etat_process Line 1078  analyse(struct_processus *s_etat_process
                 profilage(s_etat_processus, NULL);                  profilage(s_etat_processus, NULL);
             }              }
         }          }
   
         free(instruction_majuscule);  
     }      }
     else      else
     {      {
Line 1040  analyse(struct_processus *s_etat_process Line 1106  analyse(struct_processus *s_etat_process
         if ((position = index((*s_etat_processus).instruction_courante, '$'))          if ((position = index((*s_etat_processus).instruction_courante, '$'))
                 != NULL)                  != NULL)
         {          {
             if ((bibliotheque_candidate = malloc((position + 1              if ((bibliotheque_candidate = malloc(((size_t) (position + 1
                     - (*s_etat_processus).instruction_courante)                      - (*s_etat_processus).instruction_courante))
                     * sizeof(unsigned char))) == NULL)                      * sizeof(unsigned char))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1050  analyse(struct_processus *s_etat_process Line 1116  analyse(struct_processus *s_etat_process
   
             (*bibliotheque_candidate) = d_code_fin_chaine;              (*bibliotheque_candidate) = d_code_fin_chaine;
             strncat(bibliotheque_candidate,              strncat(bibliotheque_candidate,
                     (*s_etat_processus).instruction_courante,                      (*s_etat_processus).instruction_courante, ((size_t)
                     position - (*s_etat_processus).instruction_courante);                      (position - (*s_etat_processus).instruction_courante)));
   
             position++;              position++;
   
Line 1096  analyse(struct_processus *s_etat_process Line 1162  analyse(struct_processus *s_etat_process
     {      {
         if ((*s_etat_processus).test_instruction == 'N')          if ((*s_etat_processus).test_instruction == 'N')
         {          {
             if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)              if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions)
                       != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
               }
               else
             {              {
                 affectation_interruptions_logicielles(s_etat_processus);                  if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
                   {
                       affectation_interruptions_logicielles(s_etat_processus);
                   }
   
                   if (pthread_mutex_unlock(&(*s_etat_processus)
                           .mutex_interruptions) != 0)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                   }
             }              }
   
             if (((*s_etat_processus).nombre_interruptions_en_queue != 0) &&              if (((*s_etat_processus).nombre_interruptions_en_queue != 0) &&
Line 1123  analyse(struct_processus *s_etat_process Line 1203  analyse(struct_processus *s_etat_process
   
     if ((*s_etat_processus).pourcentage_maximal_cpu < 100)      if ((*s_etat_processus).pourcentage_maximal_cpu < 100)
     {      {
   #       ifndef OS2
         getrusage(RUSAGE_SELF, &usage_final);          getrusage(RUSAGE_SELF, &usage_final);
   #       else
           usage_final = clock();
   #       endif
   
         gettimeofday(&horodatage_final, NULL);          gettimeofday(&horodatage_final, NULL);
   
         if (initialisation == d_vrai)          if ((*s_etat_processus).initialisation_scheduler == d_vrai)
         {          {
             temps_reel = ((real8) (horodatage_final.tv_sec -              temps_reel = ((real8) (horodatage_final.tv_sec -
                     horodatage_initial.tv_sec)) +                      horodatage_initial.tv_sec)) +
                     (((real8) (horodatage_final.tv_usec -                      (((real8) (horodatage_final.tv_usec -
                     horodatage_initial.tv_usec)) / ((real8) 1E6));                      horodatage_initial.tv_usec)) / ((real8) 1E6));
   
               // Le temps depuis la dernière limitation est de plus de un
               // dixième de seconde.
   
             if (temps_reel >= 0.1)              if (temps_reel >= 0.1)
             {              {
   #               ifndef OS2
                 temps_cpu = ((real8) ((usage_final.ru_utime.tv_sec +                  temps_cpu = ((real8) ((usage_final.ru_utime.tv_sec +
                         usage_final.ru_stime.tv_sec) -                          usage_final.ru_stime.tv_sec) -
                         (usage_initial.ru_utime.tv_sec +                          (usage_initial.ru_utime.tv_sec +
Line 1143  analyse(struct_processus *s_etat_process Line 1232  analyse(struct_processus *s_etat_process
                         usage_final.ru_stime.tv_usec) -                          usage_final.ru_stime.tv_usec) -
                         (usage_initial.ru_utime.tv_usec +                          (usage_initial.ru_utime.tv_usec +
                         usage_initial.ru_stime.tv_usec))) / ((real8) 1E6));                          usage_initial.ru_stime.tv_usec))) / ((real8) 1E6));
   #               else
                   temps_cpu = (usage_final - usage_initial) / CLOCKS_PER_SEC;
   #               endif
   
                 pourcentage = 100 * temps_cpu / temps_reel;                  pourcentage = 100 * temps_cpu / temps_reel;
   
Line 1157  analyse(struct_processus *s_etat_process Line 1249  analyse(struct_processus *s_etat_process
                             (*s_etat_processus).pourcentage_maximal_cpu)                              (*s_etat_processus).pourcentage_maximal_cpu)
                             - (pourcentage * temps_cpu / 100);                              - (pourcentage * temps_cpu / 100);
   
                     temporisation.tv_sec = floor(attente);                      temporisation.tv_sec = (time_t) floor(attente);
                     temporisation.tv_nsec = (attente - temporisation.tv_sec) *                      temporisation.tv_nsec = (suseconds_t) ((attente
                             1E9;                              - ((real8) temporisation.tv_sec)) * 1E9);
   
                     nanosleep(&temporisation, NULL);                      while(nanosleep(&temporisation, &temporisation) == -1)
                       {
                           if (errno != EINTR)
                           {
                               break;
                           }
                       }
                 }                  }
   
                 horodatage_initial = horodatage_final;                  horodatage_initial = horodatage_final;
Line 1170  analyse(struct_processus *s_etat_process Line 1268  analyse(struct_processus *s_etat_process
         }          }
         else          else
         {          {
             initialisation = d_vrai;              (*s_etat_processus).initialisation_scheduler = d_vrai;
   
             horodatage_initial = horodatage_final;              horodatage_initial = horodatage_final;
             usage_initial = usage_final;              usage_initial = usage_final;
         }          }
     }      }
       else
       {
           (*s_etat_processus).initialisation_scheduler = d_faux;
       }
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 1212  analyse(struct_processus *s_etat_process Line 1314  analyse(struct_processus *s_etat_process
                 ((*s_etat_processus).erreur_systeme != d_es) ||                  ((*s_etat_processus).erreur_systeme != d_es) ||
                 ((*s_etat_processus).exception != d_ep))                  ((*s_etat_processus).exception != d_ep))
         {          {
             if ((*s_etat_processus).instruction_derniere_erreur != NULL)  
             {  
                 free((*s_etat_processus).instruction_derniere_erreur);  
                 (*s_etat_processus).instruction_derniere_erreur = NULL;  
             }  
   
             (*s_etat_processus).niveau_derniere_erreur =              (*s_etat_processus).niveau_derniere_erreur =
                     (*s_etat_processus).niveau_courant;                      (*s_etat_processus).niveau_courant;
   
             if ((*s_etat_processus).mode_execution_programme == 'Y')              if ((*s_etat_processus).mode_execution_programme == 'Y')
             {              {
                   if ((*s_etat_processus).instruction_derniere_erreur != NULL)
                   {
                       free((*s_etat_processus).instruction_derniere_erreur);
                       (*s_etat_processus).instruction_derniere_erreur = NULL;
                   }
   
                 if ((*s_etat_processus).instruction_courante == NULL)                  if ((*s_etat_processus).instruction_courante == NULL)
                 {                  {
                     if (((*s_etat_processus).instruction_derniere_erreur =                      if (((*s_etat_processus).instruction_derniere_erreur =
Line 1254  analyse(struct_processus *s_etat_process Line 1356  analyse(struct_processus *s_etat_process
             }              }
             else              else
             {              {
                 if (((*s_etat_processus).instruction_derniere_erreur =                  if ((*s_etat_processus).objet_courant != NULL)
                         formateur(s_etat_processus, 0,  
                         (*s_etat_processus).objet_courant)) == NULL)  
                 {                  {
                     return;                      if ((*s_etat_processus).instruction_derniere_erreur != NULL)
                       {
                           free((*s_etat_processus).instruction_derniere_erreur);
                           (*s_etat_processus).instruction_derniere_erreur = NULL;
                       }
   
                       if (((*s_etat_processus).instruction_derniere_erreur =
                               formateur(s_etat_processus, 0,
                               (*s_etat_processus).objet_courant)) == NULL)
                       {
                           return;
                       }
   
                       (*s_etat_processus).objet_courant = NULL;
                 }                  }
             }              }
         }          }

Removed from v.1.8  
changed lines
  Added in v.1.107


CVSweb interface <joel.bertrand@systella.fr>