File:  [local] / rpl / src / date.c
Revision 1.66: download - view: text, annotated - select for diffs - revision graph
Fri Jan 10 11:15:41 2020 UTC (4 years, 2 months ago) by bertrand
Branches: MAIN
CVS tags: rpl-4_1_32, HEAD
Modification du copyright.

    1: /*
    2: ================================================================================
    3:   RPL/2 (R) version 4.1.32
    4:   Copyright (C) 1989-2020 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((const time_t *) &((*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) * ((real8) 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 += (integer8) 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

CVSweb interface <joel.bertrand@systella.fr>