Annotation of rpl/src/date.c, revision 1.66
1.1 bertrand 1: /*
2: ================================================================================
1.65 bertrand 3: RPL/2 (R) version 4.1.32
1.66 ! bertrand 4: Copyright (C) 1989-2020 Dr. BERTRAND Joël
1.1 bertrand 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:
1.11 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 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:
1.35 bertrand 67: stm = localtime((const time_t *) &((*horodatage).tv_sec));
1.1 bertrand 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));
1.42 bertrand 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);
1.1 bertrand 445:
446: offset_julien = floor(heure_julienne);
447:
1.42 bertrand 448: jour_julien += (integer8) offset_julien;
1.1 bertrand 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