Diff for /rpl/src/analyse.c between versions 1.75 and 1.115

version 1.75, 2012/10/01 11:04:57 version 1.115, 2019/10/31 15:40:00
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.11    RPL/2 (R) version 4.1.32
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2019 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 61  creation_instruction(struct_processus *s Line 61  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).noeuds =          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 101  creation_instruction(struct_processus *s Line 101  creation_instruction(struct_processus *s
   
             if (((*(*l_instruction_courante).noeuds[(*s_etat_processus)              if (((*(*l_instruction_courante).noeuds[(*s_etat_processus)
                     .pointeurs_caracteres[*ptr]]).noeuds =                      .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 180  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 323  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 513  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 722  initialisation_instructions(struct_proce Line 725  initialisation_instructions(struct_proce
     INSTRUCTION("ATEXIT", instruction_atexit);      INSTRUCTION("ATEXIT", instruction_atexit);
     INSTRUCTION("ATPOKE", instruction_atpoke);      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);
Line 746  initialisation_instructions(struct_proce Line 750  initialisation_instructions(struct_proce
         INSTRUCTION("DETACH", instruction_spawn);          INSTRUCTION("DETACH", instruction_spawn);
 #   endif  #   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 770  initialisation_instructions(struct_proce Line 775  initialisation_instructions(struct_proce
     INSTRUCTION("RCLSWI", instruction_rclswi);      INSTRUCTION("RCLSWI", instruction_rclswi);
     INSTRUCTION("RECALL", instruction_recall);      INSTRUCTION("RECALL", instruction_recall);
     INSTRUCTION("RECODE", instruction_recode);      INSTRUCTION("RECODE", instruction_recode);
       INSTRUCTION("RECORD", instruction_record);
     INSTRUCTION("REDRAW", instruction_redraw);      INSTRUCTION("REDRAW", instruction_redraw);
     INSTRUCTION("REMOVE", instruction_remove);      INSTRUCTION("REMOVE", instruction_remove);
     INSTRUCTION("REPEAT", instruction_repeat);      INSTRUCTION("REPEAT", instruction_repeat);
Line 820  initialisation_instructions(struct_proce Line 826  initialisation_instructions(struct_proce
     INSTRUCTION("INQUIRE", instruction_inquire);      INSTRUCTION("INQUIRE", instruction_inquire);
     INSTRUCTION("MEMLOCK", instruction_memlock);      INSTRUCTION("MEMLOCK", instruction_memlock);
     INSTRUCTION("MTXLOCK", instruction_mtxlock);      INSTRUCTION("MTXLOCK", instruction_mtxlock);
       INSTRUCTION("NBRCPUS", instruction_nbrcpus);
     INSTRUCTION("PERSIST", instruction_persist);      INSTRUCTION("PERSIST", instruction_persist);
     INSTRUCTION("PLOTTER", instruction_plotter);      INSTRUCTION("PLOTTER", instruction_plotter);
     INSTRUCTION("PRIVATE", instruction_private);      INSTRUCTION("PRIVATE", instruction_private);
Line 840  initialisation_instructions(struct_proce Line 847  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("CRITICAL", instruction_critical);
     INSTRUCTION("DUPCNTXT", instruction_dupcntxt);      INSTRUCTION("DUPCNTXT", instruction_dupcntxt);
Line 899  initialisation_instructions(struct_proce Line 907  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 960  analyse_instruction(struct_processus *s_ Line 969  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 1101  analyse(struct_processus *s_etat_process Line 1108  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 1111  analyse(struct_processus *s_etat_process Line 1118  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 1157  analyse(struct_processus *s_etat_process Line 1164  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)
             {              {
                 affectation_interruptions_logicielles(s_etat_processus);                  (*s_etat_processus).erreur_systeme = d_es_processus;
               }
               else
               {
                   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 1192  analyse(struct_processus *s_etat_process Line 1213  analyse(struct_processus *s_etat_process
   
         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)) +
Line 1230  analyse(struct_processus *s_etat_process Line 1251  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);
   
                     while(nanosleep(&temporisation, &temporisation) == -1)                      while(nanosleep(&temporisation, &temporisation) == -1)
                     {                      {
Line 1249  analyse(struct_processus *s_etat_process Line 1270  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;
Line 1257  analyse(struct_processus *s_etat_process Line 1278  analyse(struct_processus *s_etat_process
     }      }
     else      else
     {      {
         initialisation = d_faux;          (*s_etat_processus).initialisation_scheduler = d_faux;
     }      }
   
 /*  /*

Removed from v.1.75  
changed lines
  Added in v.1.115


CVSweb interface <joel.bertrand@systella.fr>