File:
[local] /
rpl /
src /
date.c
Revision
1.21:
download - view:
text,
annotated -
select for diffs -
revision graph
Tue Jun 21 15:26:28 2011 UTC (12 years, 11 months ago) by
bertrand
Branches:
MAIN
CVS tags:
HEAD
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
CVSweb interface <joel.bertrand@systella.fr>