Return to date.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 de calcul d'une date
   29: ================================================================================
   30:   Entrées : pointeur sur un time_t
   31: --------------------------------------------------------------------------------
   32:   Sorties : pointeur sur un object
   33: --------------------------------------------------------------------------------
   34:   Effets de bord : néant
   35: ================================================================================
   36: */
   37: 
   38: struct_objet *
   39: formateur_date(struct_processus *s_etat_processus, struct timeval *horodatage)
   40: {
   41:     char                    tableau[64 + 1];
   42: 
   43:     integer8                jour_julien;
   44: 
   45:     long                    d;
   46:     long                    heures;
   47:     long                    m;
   48:     long                    minutes;
   49:     long                    secondes;
   50:     long                    y;
   51: 
   52:     real8                   heure_julienne;
   53:     real8                   offset_julien;
   54: 
   55:     size_t                  taille;
   56: 
   57:     struct_liste_chainee    *l_element_courant;
   58: 
   59:     struct_objet            *s_objet;
   60: 
   61:     struct tm               *stm;
   62: 
   63:     /*
   64:      * Récupération de la structure tm
   65:      */
   66: 
   67:     stm = localtime(&((*horodatage).tv_sec));
   68: 
   69:     if ((s_objet = allocation(s_etat_processus, LST)) == NULL)
   70:     {
   71:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
   72:         return(NULL);
   73:     }
   74: 
   75:     /*
   76:      * Jour de la semaine
   77:      */
   78: 
   79:     if ((l_element_courant = malloc(sizeof(struct_liste_chainee))) == NULL)
   80:     {
   81:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
   82:         return(NULL);
   83:     }
   84: 
   85:     (*s_objet).objet = l_element_courant;
   86: 
   87:     if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
   88:             == NULL)
   89:     {
   90:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
   91:         return(NULL);
   92:     }
   93: 
   94:     taille = strftime(tableau, 64, "%A", stm);
   95: 
   96:     if (((*(*l_element_courant).donnee).objet = malloc((taille + 1) *
   97:             sizeof(unsigned char))) == NULL)
   98:     {
   99:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  100:         return(NULL);
  101:     }
  102: 
  103:     strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, tableau);
  104: 
  105:     /*
  106:      * Quantième du mois
  107:      */
  108: 
  109:     if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
  110:             == NULL)
  111:     {
  112:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  113:         return(NULL);
  114:     }
  115: 
  116:     l_element_courant = (*l_element_courant).suivant;
  117: 
  118:     if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
  119:             == NULL)
  120:     {
  121:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  122:         return(NULL);
  123:     }
  124: 
  125:     taille = strftime(tableau, 64, "%d", stm);
  126:     sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);
  127:     d = (long) (*((integer8 *) (*(*l_element_courant).donnee).objet));
  128: 
  129:     /*
  130:      * Mois
  131:      */
  132: 
  133:     if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
  134:             == NULL)
  135:     {
  136:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  137:         return(NULL);
  138:     }
  139: 
  140:     l_element_courant = (*l_element_courant).suivant;
  141: 
  142:     if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
  143:             == NULL)
  144:     {
  145:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  146:         return(NULL);
  147:     }
  148: 
  149:     taille = strftime(tableau, 64, "%B", stm);
  150: 
  151:     if (((*(*l_element_courant).donnee).objet = malloc((taille + 1) *
  152:             sizeof(unsigned char))) == NULL)
  153:     {
  154:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  155:         return(NULL);
  156:     }
  157: 
  158:     strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, tableau);
  159: 
  160:     /*
  161:      * Année
  162:      */
  163: 
  164:     if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
  165:             == NULL)
  166:     {
  167:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  168:         return(NULL);
  169:     }
  170: 
  171:     l_element_courant = (*l_element_courant).suivant;
  172: 
  173:     if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
  174:             == NULL)
  175:     {
  176:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  177:         return(NULL);
  178:     }
  179: 
  180:     taille = strftime(tableau, 64, "%Y", stm);
  181:     sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);
  182:     y = (long) (*((integer8 *) (*(*l_element_courant).donnee).objet));
  183: 
  184:     /*
  185:      * Heure
  186:      */
  187: 
  188:     if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
  189:             == NULL)
  190:     {
  191:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  192:         return(NULL);
  193:     }
  194: 
  195:     l_element_courant = (*l_element_courant).suivant;
  196: 
  197:     if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
  198:             == NULL)
  199:     {
  200:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  201:         return(NULL);
  202:     }
  203: 
  204:     taille = strftime(tableau, 64, "%H", stm);
  205:     sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);
  206:     heures = (long) (*((integer8 *) (*(*l_element_courant).donnee).objet));
  207: 
  208:     /*
  209:      * Minutes
  210:      */
  211: 
  212:     if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
  213:             == NULL)
  214:     {
  215:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  216:         return(NULL);
  217:     }
  218: 
  219:     l_element_courant = (*l_element_courant).suivant;
  220: 
  221:     if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
  222:             == NULL)
  223:     {
  224:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  225:         return(NULL);
  226:     }
  227: 
  228:     taille = strftime(tableau, 64, "%M", stm);
  229:     sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);
  230:     minutes = (long) (*((integer8 *) (*(*l_element_courant).donnee).objet));
  231: 
  232:     /*
  233:      * Secondes
  234:      */
  235: 
  236:     if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
  237:             == NULL)
  238:     {
  239:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  240:         return(NULL);
  241:     }
  242: 
  243:     l_element_courant = (*l_element_courant).suivant;
  244: 
  245:     if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
  246:             == NULL)
  247:     {
  248:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  249:         return(NULL);
  250:     }
  251: 
  252:     taille = strftime(tableau, 64, "%S", stm);
  253:     sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);
  254:     secondes = (long) (*((integer8 *) (*(*l_element_courant).donnee).objet));
  255: 
  256:     /*
  257:      * Microsecondes
  258:      */
  259: 
  260:     if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
  261:             == NULL)
  262:     {
  263:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  264:         return(NULL);
  265:     }
  266: 
  267:     l_element_courant = (*l_element_courant).suivant;
  268: 
  269:     if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
  270:             == NULL)
  271:     {
  272:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  273:         return(NULL);
  274:     }
  275: 
  276:     (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
  277:             (integer8) (*horodatage).tv_usec;
  278: 
  279:     /*
  280:      * Fuseau horaire
  281:      */
  282: 
  283:     if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
  284:             == NULL)
  285:     {
  286:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  287:         return(NULL);
  288:     }
  289: 
  290:     l_element_courant = (*l_element_courant).suivant;
  291: 
  292:     if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
  293:             == NULL)
  294:     {
  295:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  296:         return(NULL);
  297:     }
  298: 
  299:     taille = strftime(tableau, 64, "%Z", stm);
  300: 
  301:     if (((*(*l_element_courant).donnee).objet = malloc((taille + 1) *
  302:             sizeof(unsigned char))) == NULL)
  303:     {
  304:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  305:         return(NULL);
  306:     }
  307: 
  308:     strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, tableau);
  309: 
  310:     /*
  311:      * Jour de la semaine en numérique
  312:      */
  313: 
  314:     if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
  315:             == NULL)
  316:     {
  317:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  318:         return(NULL);
  319:     }
  320: 
  321:     l_element_courant = (*l_element_courant).suivant;
  322: 
  323:     if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
  324:             == NULL)
  325:     {
  326:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  327:         return(NULL);
  328:     }
  329: 
  330:     taille = strftime(tableau, 64, "%u", stm);
  331:     sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);
  332: 
  333:     /*
  334:      * Numéro de la semaine
  335:      */
  336: 
  337:     if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
  338:             == NULL)
  339:     {
  340:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  341:         return(NULL);
  342:     }
  343: 
  344:     l_element_courant = (*l_element_courant).suivant;
  345: 
  346:     if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
  347:             == NULL)
  348:     {
  349:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  350:         return(NULL);
  351:     }
  352: 
  353:     taille = strftime(tableau, 64, "%W", stm);
  354:     sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);
  355: 
  356:     /*
  357:      * Numéro du mois
  358:      */
  359: 
  360:     if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
  361:             == NULL)
  362:     {
  363:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  364:         return(NULL);
  365:     }
  366: 
  367:     l_element_courant = (*l_element_courant).suivant;
  368: 
  369:     if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
  370:             == NULL)
  371:     {
  372:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  373:         return(NULL);
  374:     }
  375: 
  376:     taille = strftime(tableau, 64, "%m", stm);
  377:     sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);
  378:     m = (long) (*((integer8 *) (*(*l_element_courant).donnee).objet));
  379: 
  380:     /*
  381:      * Numéro du jour dans l'année
  382:      */
  383: 
  384:     if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
  385:             == NULL)
  386:     {
  387:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  388:         return(NULL);
  389:     }
  390: 
  391:     l_element_courant = (*l_element_courant).suivant;
  392: 
  393:     if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
  394:             == NULL)
  395:     {
  396:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  397:         return(NULL);
  398:     }
  399: 
  400:     taille = strftime(tableau, 64, "%j", stm);
  401:     sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);
  402: 
  403:     /*
  404:      * Jours juliens (référence 0 le 24 novembre -4713 dans le calendrier
  405:      * grégorien proleptique). Le résultat est séparé en deux, tout
  406:      * d'abord la partie entière, puis la partie fractionnaire.
  407:      * Cette valeur apparaît dans la liste en deux parties, tout d'abord la
  408:      * partie entière, puis la partie fractionnaire.
  409:      */
  410: 
  411:     if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
  412:             == NULL)
  413:     {
  414:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  415:         return(NULL);
  416:     }
  417: 
  418:     l_element_courant = (*l_element_courant).suivant;
  419: 
  420:     if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
  421:             == NULL)
  422:     {
  423:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  424:         return(NULL);
  425:     }
  426: 
  427:     if (m < 3)
  428:     {
  429:         y--;
  430:         m += 12;
  431:     }
  432: 
  433:     /*
  434:      * À noter : la date de base est toujours dans le calendrier
  435:      * grégorien à moins d'avoir un sérieux problème de date
  436:      * sur le calculateur.
  437:      */
  438: 
  439:     jour_julien = 1721024 + (365 * y) + (30 * m) + d + ((integer8) (y / 4))
  440:             + 2 + ((integer8) (y / 400)) - ((integer8) (y / 100));
  441:     heure_julienne = floor(((real8) 0.6001) * (m + 1)) +
  442:             (((real8 ) heures) / 24) + (((real8) minutes) / 1440) +
  443:             (((real8) secondes + (((real8) (*horodatage).tv_usec) / 1000000))
  444:             / 86400) + ((real8) 0.5);
  445: 
  446:     offset_julien = floor(heure_julienne);
  447: 
  448:     jour_julien += offset_julien;
  449:     heure_julienne -= offset_julien;
  450: 
  451:     (*((integer8 *) (*(*l_element_courant).donnee).objet)) = jour_julien;
  452: 
  453:     if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
  454:             == NULL)
  455:     {
  456:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  457:         return(NULL);
  458:     }
  459: 
  460:     l_element_courant = (*l_element_courant).suivant;
  461: 
  462:     if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
  463:             == NULL)
  464:     {
  465:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  466:         return(NULL);
  467:     }
  468: 
  469:     (*((real8 *) (*(*l_element_courant).donnee).objet)) = heure_julienne;
  470: 
  471:     /*
  472:      * Temps Unix
  473:      */
  474: 
  475:     if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
  476:             == NULL)
  477:     {
  478:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  479:         return(NULL);
  480:     }
  481: 
  482:     l_element_courant = (*l_element_courant).suivant;
  483: 
  484:     if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
  485:             == NULL)
  486:     {
  487:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  488:         return(NULL);
  489:     }
  490: 
  491:     (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
  492:             (*horodatage).tv_sec;
  493: 
  494:     /*
  495:      * Fermeture de la liste
  496:      */
  497: 
  498:     (*l_element_courant).suivant = NULL;
  499: 
  500:     return(s_objet);
  501: }
  502: 
  503: // vim: ts=4