Annotation of rpl/src/date.c, revision 1.1
1.1 ! bertrand 1: /*
! 2: ================================================================================
! 3: RPL/2 (R) version 4.0.9
! 4: Copyright (C) 1989-2010 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
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to date.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src