Return to instructions_a5.c CVS log

Up to [local] / rpl / src

Correction d'une réinitialisation sauvage de la pile des variables par niveau
dans la copie de la structure de description du processus. Cela corrige
la fonction SPAWN qui échouait sur un segmentation fault car la pile des
variables par niveau était vide alors même que l'arbre des variables contenait
bien les variables. Passage à la prerelease 2.

    1: /*
    2: ================================================================================
    3:   RPL/2 (R) version 4.1.0.prerelease.2
    4:   Copyright (C) 1989-2011 Dr. BERTRAND Joël
    5: 
    6:   This file is part of RPL/2.
    7: 
    8:   RPL/2 is free software; you can redistribute it and/or modify it
    9:   under the terms of the CeCILL V2 License as published by the french
   10:   CEA, CNRS and INRIA.
   11:  
   12:   RPL/2 is distributed in the hope that it will be useful, but WITHOUT
   13:   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   14:   FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
   15:   for more details.
   16:  
   17:   You should have received a copy of the CeCILL License
   18:   along with RPL/2. If not, write to info@cecill.info.
   19: ================================================================================
   20: */
   21: 
   22: 
   23: #include "rpl-conv.h"
   24: 
   25: 
   26: /*
   27: ================================================================================
   28:   Fonction 'alarm'
   29: ================================================================================
   30:   Entrées : pointeur sur une structure struct_processus
   31: --------------------------------------------------------------------------------
   32:   Sorties :
   33: --------------------------------------------------------------------------------
   34:   Effets de bord : néant
   35: ================================================================================
   36: */
   37: 
   38: void
   39: instruction_alarm(struct_processus *s_etat_processus)
   40: {
   41:     double                      duree;
   42: 
   43:     int                         code_retour;
   44:     int                         erreur;
   45: 
   46:     logical1                    specification_date;
   47: 
   48:     struct_liste_chainee        *l_element_courant;
   49: 
   50:     struct_objet                *s_objet_argument;
   51: 
   52:     struct timeb                st;
   53: 
   54:     struct timespec             attente;
   55: 
   56:     struct timeval              debut_interruption;
   57:     struct timeval              duree_interruption;
   58:     struct timeval              fin_interruption;
   59: 
   60:     struct tm                   *s_time_actuel;
   61:     struct tm                   s_time_alarme;
   62:     struct tm                   s_time_registre;
   63: 
   64:     time_t                      alarme;
   65: 
   66:     unsigned long               nombre_elements;
   67: 
   68:     (*s_etat_processus).erreur_execution = d_ex;
   69: 
   70:     if ((*s_etat_processus).affichage_arguments == 'Y')
   71:     {
   72:         printf("\n  ALARM ");
   73: 
   74:         if ((*s_etat_processus).langue == 'F')
   75:         {
   76:             printf("(suspension du processus jusqu'à un instant spécifié)\n\n");
   77:         }
   78:         else
   79:         {
   80:             printf("(wait until timestamp)\n\n");
   81:         }
   82: 
   83:         printf("    1: %s\n\n", d_LST);
   84: 
   85:         if ((*s_etat_processus).langue == 'F')
   86:         {
   87:             printf("  Utilisation :\n\n");
   88:         }
   89:         else
   90:         {
   91:             printf("  Usage:\n\n");
   92:         }
   93: 
   94:         printf("    { hours minutes } ALARM\n");
   95:         printf("    { hours minutes seconds } ALARM\n");
   96:         printf("    { hours minutes seconds day } ALARM\n");
   97:         printf("    { hours minutes seconds day month } ALARM\n");
   98:         printf("    { hours minutes seconds day month year } ALARM\n");
   99: 
  100:         return;
  101:     }
  102:     else if ((*s_etat_processus).test_instruction == 'Y')
  103:     {
  104:         (*s_etat_processus).nombre_arguments = 1;
  105:         return;
  106:     }
  107: 
  108:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  109:     {
  110:         if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
  111:         {
  112:             return;
  113:         }
  114:     }
  115: 
  116:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  117:             &s_objet_argument) == d_erreur)
  118:     {
  119:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
  120:         return;
  121:     }
  122: 
  123:     if ((*s_objet_argument).type == LST)
  124:     {
  125:         l_element_courant = (*s_objet_argument).objet;
  126:         nombre_elements = 0;
  127: 
  128:         while(l_element_courant != NULL)
  129:         {
  130:             if ((*(*l_element_courant).donnee).type != INT)
  131:             {
  132:                 (*s_etat_processus).erreur_execution =
  133:                         d_ex_erreur_type_argument;
  134: 
  135:                 liberation(s_etat_processus, s_objet_argument);
  136:                 return;
  137:             }
  138: 
  139:             l_element_courant = (*l_element_courant).suivant;
  140:             nombre_elements++;
  141:         }
  142: 
  143:         if ((nombre_elements < 2) || (nombre_elements > 6))
  144:         {
  145:             (*s_etat_processus).erreur_execution =
  146:                     d_ex_argument_invalide;
  147: 
  148:             liberation(s_etat_processus, s_objet_argument);
  149:             return;
  150:         }
  151: 
  152:         st.time = time(NULL);
  153:         s_time_actuel = localtime(&(st.time));
  154: 
  155:         l_element_courant = (*s_objet_argument).objet;
  156:         s_time_alarme.tm_hour = (*((integer8 *) (*(*l_element_courant)
  157:                 .donnee).objet));
  158:         l_element_courant = (*l_element_courant).suivant;
  159:         s_time_alarme.tm_min = (*((integer8 *) (*(*l_element_courant)
  160:                 .donnee).objet));
  161:         l_element_courant = (*l_element_courant).suivant;
  162: 
  163:         specification_date = d_faux;
  164: 
  165:         if (l_element_courant != NULL)
  166:         {
  167:             s_time_alarme.tm_sec = (*((integer8 *) (*(*l_element_courant)
  168:                     .donnee).objet));
  169:             l_element_courant = (*l_element_courant).suivant;
  170: 
  171:             if (l_element_courant != NULL)
  172:             {
  173:                 specification_date = d_vrai;
  174: 
  175:                 s_time_alarme.tm_mday = (*((integer8 *) (*(*l_element_courant)
  176:                         .donnee).objet));
  177:                 l_element_courant = (*l_element_courant).suivant;
  178: 
  179:                 if (l_element_courant != NULL)
  180:                 {
  181:                     s_time_alarme.tm_mon = (*((integer8 *)
  182:                             (*(*l_element_courant).donnee).objet)) - 1;
  183:                     l_element_courant = (*l_element_courant).suivant;
  184: 
  185:                     if (l_element_courant != NULL)
  186:                     {
  187:                         s_time_alarme.tm_year = (*((integer8 *)
  188:                                 (*(*l_element_courant).donnee).objet))
  189:                                 - 1900;
  190:                         l_element_courant = (*l_element_courant).suivant;
  191:                     }
  192:                     else
  193:                     {
  194:                         s_time_alarme.tm_year = (*s_time_actuel).tm_year;
  195:                     }
  196:                 }
  197:                 else
  198:                 {
  199:                     s_time_alarme.tm_mon = (*s_time_actuel).tm_mon;
  200:                     s_time_alarme.tm_year = (*s_time_actuel).tm_year;
  201:                 }
  202:             }
  203:             else
  204:             {
  205:                 s_time_alarme.tm_mday = (*s_time_actuel).tm_mday;
  206:                 s_time_alarme.tm_mon = (*s_time_actuel).tm_mon;
  207:                 s_time_alarme.tm_year = (*s_time_actuel).tm_year;
  208:             }
  209:         }
  210:         else
  211:         {
  212:             s_time_alarme.tm_sec = 0;
  213:             s_time_alarme.tm_mday = (*s_time_actuel).tm_mday;
  214:             s_time_alarme.tm_mon = (*s_time_actuel).tm_mon;
  215:             s_time_alarme.tm_year = (*s_time_actuel).tm_year;
  216:         }
  217: 
  218:         s_time_alarme.tm_isdst = 0;
  219:         s_time_registre = s_time_alarme;
  220:         alarme = mktime(&s_time_alarme);
  221: 
  222:         if ((s_time_alarme.tm_sec != s_time_registre.tm_sec) ||
  223:                 (s_time_alarme.tm_min != s_time_registre.tm_min) ||
  224:                 (s_time_alarme.tm_hour != s_time_registre.tm_hour) ||
  225:                 (s_time_alarme.tm_mday != s_time_registre.tm_mday) ||
  226:                 (s_time_alarme.tm_mon != s_time_registre.tm_mon) ||
  227:                 (s_time_alarme.tm_year != s_time_registre.tm_year))
  228:         {
  229:             (*s_etat_processus).erreur_execution =
  230:                     d_ex_argument_invalide;
  231: 
  232:             liberation(s_etat_processus, s_objet_argument);
  233:             return;
  234:         }
  235: 
  236:         while((duree = difftime(alarme, st.time)) < 0)
  237:         {
  238:             if (specification_date == d_vrai)
  239:             {
  240:                 (*s_etat_processus).erreur_execution =
  241:                         d_ex_argument_invalide;
  242: 
  243:                 liberation(s_etat_processus, s_objet_argument);
  244:                 return;
  245:             }
  246: 
  247:             s_time_alarme.tm_mday++;
  248:             alarme = mktime(&s_time_alarme);
  249:         }
  250: 
  251:         attente.tv_nsec = (long) ((duree - (attente.tv_sec =
  252:                 (long) floor(duree))) * 1000000000);
  253: 
  254:         if ((*s_etat_processus).profilage == d_vrai)
  255:         {
  256:             profilage(s_etat_processus, "Sleep function (ALARM)");
  257: 
  258:             if ((*s_etat_processus).erreur_systeme != d_es)
  259:             {
  260:                 return;
  261:             }
  262:         }
  263: 
  264:         do
  265:         {
  266:             code_retour = nanosleep(&attente, &attente);
  267:             erreur = errno;
  268: 
  269:             if (code_retour == -1)
  270:             {
  271:                 gettimeofday(&debut_interruption, NULL);
  272: 
  273:                 scrutation_injection(s_etat_processus);
  274: 
  275:                 if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
  276:                 {
  277:                     affectation_interruptions_logicielles(s_etat_processus);
  278:                 }
  279: 
  280:                 if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
  281:                 {
  282:                     traitement_interruptions_logicielles(s_etat_processus);
  283:                 }
  284: 
  285:                 gettimeofday(&fin_interruption, NULL);
  286: 
  287:                 if (fin_interruption.tv_usec < debut_interruption.tv_usec)
  288:                 {
  289:                     duree_interruption.tv_usec = (1000000
  290:                             + fin_interruption.tv_usec)
  291:                             - debut_interruption.tv_usec;
  292:                     duree_interruption.tv_sec = fin_interruption.tv_sec
  293:                             - (debut_interruption.tv_sec + 1);
  294:                 }
  295:                 else
  296:                 {
  297:                     duree_interruption.tv_usec = fin_interruption.tv_usec
  298:                             - debut_interruption.tv_usec;
  299:                     duree_interruption.tv_sec = fin_interruption.tv_sec
  300:                             - debut_interruption.tv_sec;
  301:                 }
  302: 
  303:                 if (attente.tv_nsec < (1000 * duree_interruption.tv_usec))
  304:                 {
  305:                     attente.tv_nsec = (1000000000 + attente.tv_nsec)
  306:                             - (1000 * duree_interruption.tv_usec);
  307:                     attente.tv_sec = attente.tv_sec
  308:                             - (duree_interruption.tv_sec + 1);
  309:                 }
  310:                 else
  311:                 {
  312:                     attente.tv_nsec = attente.tv_nsec
  313:                             - (1000 * duree_interruption.tv_usec);
  314:                     attente.tv_sec = attente.tv_sec
  315:                             - duree_interruption.tv_sec;
  316:                 }
  317: 
  318:                 if (attente.tv_sec < 0)
  319:                 {
  320:                     code_retour = 0;
  321:                 }
  322:             }
  323:         } while(((code_retour == -1) && (erreur == EINTR))
  324:                 && ((*s_etat_processus).var_volatile_requete_arret == 0));
  325: 
  326:         if ((*s_etat_processus).profilage == d_vrai)
  327:         {
  328:             profilage(s_etat_processus, NULL);
  329:         }
  330:     }
  331:     else
  332:     {
  333:         liberation(s_etat_processus, s_objet_argument);
  334: 
  335:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  336:         return;
  337:     }
  338: 
  339:     liberation(s_etat_processus, s_objet_argument);
  340:     return;
  341: }
  342: 
  343: 
  344: /*
  345: ================================================================================
  346:   Fonction 'atexit'
  347: ================================================================================
  348:   Entrées :
  349: --------------------------------------------------------------------------------
  350:   Sorties :
  351: --------------------------------------------------------------------------------
  352:   Effets de bord : néant
  353: ================================================================================
  354: */
  355: 
  356: void
  357: instruction_atexit(struct_processus *s_etat_processus)
  358: {
  359:     struct_objet        *s_objet_argument;
  360: 
  361:     (*s_etat_processus).erreur_execution = d_ex;
  362: 
  363:     if ((*s_etat_processus).affichage_arguments == 'Y')
  364:     {
  365:         printf("\n  ATEXIT ");
  366: 
  367:         if ((*s_etat_processus).langue == 'F')
  368:         {
  369:             printf("(exécution d'une fonction à la sortie d'une tâche)\n\n");
  370:         }
  371:         else
  372:         {
  373:             printf("(register a function to be called on task exit)\n\n");
  374:         }
  375: 
  376:         printf("    1: %s, %s\n", d_NOM, d_RPN);
  377: 
  378:         return;
  379:     }
  380:     else if ((*s_etat_processus).test_instruction == 'Y')
  381:     {
  382:         (*s_etat_processus).nombre_arguments = 1;
  383:         return;
  384:     }
  385: 
  386:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  387:     {
  388:         if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
  389:         {
  390:             return;
  391:         }
  392:     }
  393: 
  394:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  395:             &s_objet_argument) == d_erreur)
  396:     {
  397:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
  398:         return;
  399:     }
  400: 
  401:     if ((*s_objet_argument).type == NOM)
  402:     {
  403:         liberation(s_etat_processus, (*s_etat_processus).at_exit);
  404:         (*s_etat_processus).at_exit = s_objet_argument;
  405:     }
  406:     else if ((*s_objet_argument).type == RPN)
  407:     {
  408:         liberation(s_etat_processus, (*s_etat_processus).at_exit);
  409:         (*s_etat_processus).at_exit = s_objet_argument;
  410:     }
  411:     else
  412:     {
  413:         liberation(s_etat_processus, s_objet_argument);
  414: 
  415:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  416:         return;
  417:     }
  418: 
  419:     return;
  420: }
  421: 
  422: 
  423: /*
  424: ================================================================================
  425:   Fonction 'atpoke'
  426: ================================================================================
  427:   Entrées :
  428: --------------------------------------------------------------------------------
  429:   Sorties :
  430: --------------------------------------------------------------------------------
  431:   Effets de bord : néant
  432: ================================================================================
  433: */
  434: 
  435: void
  436: instruction_atpoke(struct_processus *s_etat_processus)
  437: {
  438:     struct_objet        *s_objet_argument;
  439: 
  440:     (*s_etat_processus).erreur_execution = d_ex;
  441: 
  442:     if ((*s_etat_processus).affichage_arguments == 'Y')
  443:     {
  444:         printf("\n  ATPOKE ");
  445: 
  446:         if ((*s_etat_processus).langue == 'F')
  447:         {
  448:             printf("(exécution d'une fonction lors de l'injection "
  449:                     "d'une donnée)\n\n");
  450:         }
  451:         else
  452:         {
  453:             printf("(register a function to be called on data injection)\n\n");
  454:         }
  455: 
  456:         printf("    1: %s, %s\n", d_NOM, d_RPN);
  457: 
  458:         return;
  459:     }
  460:     else if ((*s_etat_processus).test_instruction == 'Y')
  461:     {
  462:         (*s_etat_processus).nombre_arguments = 1;
  463:         return;
  464:     }
  465: 
  466:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  467:     {
  468:         if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
  469:         {
  470:             return;
  471:         }
  472:     }
  473: 
  474:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  475:             &s_objet_argument) == d_erreur)
  476:     {
  477:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
  478:         return;
  479:     }
  480: 
  481:     if ((*s_objet_argument).type == NOM)
  482:     {
  483:         liberation(s_etat_processus, (*s_etat_processus).at_poke);
  484:         (*s_etat_processus).at_poke = s_objet_argument;
  485:     }
  486:     else if ((*s_objet_argument).type == RPN)
  487:     {
  488:         liberation(s_etat_processus, (*s_etat_processus).at_poke);
  489:         (*s_etat_processus).at_poke = s_objet_argument;
  490:     }
  491:     else
  492:     {
  493:         liberation(s_etat_processus, s_objet_argument);
  494: 
  495:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  496:         return;
  497:     }
  498: 
  499:     return;
  500: }
  501: 
  502: // vim: ts=4