![]() ![]() | ![]() |
Passage de la branche 4.1 en branche stable.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.0 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