1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.14
4: Copyright (C) 1989-2013 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 'alarm'
29: ================================================================================
30: Entrées : pointeur sur une structure struct_processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_alarm(struct_processus *s_etat_processus)
40: {
41: double duree;
42:
43: int code_retour;
44: int erreur;
45:
46: integer8 nombre_elements;
47:
48: logical1 specification_date;
49:
50: struct_liste_chainee *l_element_courant;
51:
52: struct_objet *s_objet_argument;
53:
54: struct timeb st;
55:
56: struct timespec attente;
57:
58: struct timeval debut_interruption;
59: struct timeval duree_interruption;
60: struct timeval fin_interruption;
61:
62: struct tm *s_time_actuel;
63: struct tm s_time_alarme;
64: struct tm s_time_registre;
65:
66: time_t alarme;
67:
68: (*s_etat_processus).erreur_execution = d_ex;
69:
70: if ((*s_etat_processus).affichage_arguments == 'Y')
71: {
72: printf("\n ALARM ");
73:
74: if ((*s_etat_processus).langue == 'F')
75: {
76: printf("(suspension du processus jusqu'à un instant spécifié)\n\n");
77: }
78: else
79: {
80: printf("(wait until timestamp)\n\n");
81: }
82:
83: printf(" 1: %s\n\n", d_LST);
84:
85: if ((*s_etat_processus).langue == 'F')
86: {
87: printf(" Utilisation :\n\n");
88: }
89: else
90: {
91: printf(" Usage:\n\n");
92: }
93:
94: printf(" { hours minutes } ALARM\n");
95: printf(" { hours minutes seconds } ALARM\n");
96: printf(" { hours minutes seconds day } ALARM\n");
97: printf(" { hours minutes seconds day month } ALARM\n");
98: printf(" { hours minutes seconds day month year } ALARM\n");
99:
100: return;
101: }
102: else if ((*s_etat_processus).test_instruction == 'Y')
103: {
104: (*s_etat_processus).nombre_arguments = 1;
105: return;
106: }
107:
108: if (test_cfsf(s_etat_processus, 31) == d_vrai)
109: {
110: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
111: {
112: return;
113: }
114: }
115:
116: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
117: &s_objet_argument) == d_erreur)
118: {
119: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
120: return;
121: }
122:
123: if ((*s_objet_argument).type == LST)
124: {
125: l_element_courant = (*s_objet_argument).objet;
126: nombre_elements = 0;
127:
128: while(l_element_courant != NULL)
129: {
130: if ((*(*l_element_courant).donnee).type != INT)
131: {
132: (*s_etat_processus).erreur_execution =
133: d_ex_erreur_type_argument;
134:
135: liberation(s_etat_processus, s_objet_argument);
136: return;
137: }
138:
139: l_element_courant = (*l_element_courant).suivant;
140: nombre_elements++;
141: }
142:
143: if ((nombre_elements < 2) || (nombre_elements > 6))
144: {
145: (*s_etat_processus).erreur_execution =
146: d_ex_argument_invalide;
147:
148: liberation(s_etat_processus, s_objet_argument);
149: return;
150: }
151:
152: st.time = time(NULL);
153: s_time_actuel = localtime(&(st.time));
154:
155: l_element_courant = (*s_objet_argument).objet;
156: s_time_alarme.tm_hour = (int) (*((integer8 *) (*(*l_element_courant)
157: .donnee).objet));
158: l_element_courant = (*l_element_courant).suivant;
159: s_time_alarme.tm_min = (int) (*((integer8 *) (*(*l_element_courant)
160: .donnee).objet));
161: l_element_courant = (*l_element_courant).suivant;
162:
163: specification_date = d_faux;
164:
165: if (l_element_courant != NULL)
166: {
167: s_time_alarme.tm_sec = (int) (*((integer8 *) (*(*l_element_courant)
168: .donnee).objet));
169: l_element_courant = (*l_element_courant).suivant;
170:
171: if (l_element_courant != NULL)
172: {
173: specification_date = d_vrai;
174:
175: s_time_alarme.tm_mday = (int) (*((integer8 *)
176: (*(*l_element_courant).donnee).objet));
177: l_element_courant = (*l_element_courant).suivant;
178:
179: if (l_element_courant != NULL)
180: {
181: s_time_alarme.tm_mon = (int) ((*((integer8 *)
182: (*(*l_element_courant).donnee).objet)) - 1);
183: l_element_courant = (*l_element_courant).suivant;
184:
185: if (l_element_courant != NULL)
186: {
187: s_time_alarme.tm_year = (int) ((*((integer8 *)
188: (*(*l_element_courant).donnee).objet))
189: - 1900);
190: l_element_courant = (*l_element_courant).suivant;
191: }
192: else
193: {
194: s_time_alarme.tm_year = (*s_time_actuel).tm_year;
195: }
196: }
197: else
198: {
199: s_time_alarme.tm_mon = (*s_time_actuel).tm_mon;
200: s_time_alarme.tm_year = (*s_time_actuel).tm_year;
201: }
202: }
203: else
204: {
205: s_time_alarme.tm_mday = (*s_time_actuel).tm_mday;
206: s_time_alarme.tm_mon = (*s_time_actuel).tm_mon;
207: s_time_alarme.tm_year = (*s_time_actuel).tm_year;
208: }
209: }
210: else
211: {
212: s_time_alarme.tm_sec = 0;
213: s_time_alarme.tm_mday = (*s_time_actuel).tm_mday;
214: s_time_alarme.tm_mon = (*s_time_actuel).tm_mon;
215: s_time_alarme.tm_year = (*s_time_actuel).tm_year;
216: }
217:
218: s_time_alarme.tm_isdst = -1;
219: s_time_registre = s_time_alarme;
220: alarme = mktime(&s_time_alarme);
221:
222: if ((s_time_alarme.tm_sec != s_time_registre.tm_sec) ||
223: (s_time_alarme.tm_min != s_time_registre.tm_min) ||
224: (s_time_alarme.tm_hour != s_time_registre.tm_hour) ||
225: (s_time_alarme.tm_mday != s_time_registre.tm_mday) ||
226: (s_time_alarme.tm_mon != s_time_registre.tm_mon) ||
227: (s_time_alarme.tm_year != s_time_registre.tm_year))
228: {
229: (*s_etat_processus).erreur_execution =
230: d_ex_argument_invalide;
231:
232: liberation(s_etat_processus, s_objet_argument);
233: return;
234: }
235:
236: while((duree = difftime(alarme, st.time)) < 0)
237: {
238: if (specification_date == d_vrai)
239: {
240: (*s_etat_processus).erreur_execution =
241: d_ex_argument_invalide;
242:
243: liberation(s_etat_processus, s_objet_argument);
244: return;
245: }
246:
247: s_time_alarme.tm_mday++;
248: alarme = mktime(&s_time_alarme);
249: }
250:
251: attente.tv_nsec = (long) ((duree - (double) (attente.tv_sec =
252: (time_t) floor(duree))) * 1000000000);
253:
254: if ((*s_etat_processus).profilage == d_vrai)
255: {
256: profilage(s_etat_processus, "Sleep function (ALARM)");
257:
258: if ((*s_etat_processus).erreur_systeme != d_es)
259: {
260: return;
261: }
262: }
263:
264: do
265: {
266: code_retour = nanosleep(&attente, &attente);
267: erreur = errno;
268:
269: if (code_retour == -1)
270: {
271: gettimeofday(&debut_interruption, NULL);
272:
273: scrutation_injection(s_etat_processus);
274:
275: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
276: {
277: (*s_etat_processus).erreur_systeme = d_es_processus;
278: return;
279: }
280:
281: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
282: {
283: affectation_interruptions_logicielles(s_etat_processus);
284: }
285:
286: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
287: {
288: traitement_interruptions_logicielles(s_etat_processus);
289: }
290:
291: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
292: {
293: (*s_etat_processus).erreur_systeme = d_es_processus;
294: return;
295: }
296:
297: gettimeofday(&fin_interruption, NULL);
298:
299: if (fin_interruption.tv_usec < debut_interruption.tv_usec)
300: {
301: duree_interruption.tv_usec = (1000000
302: + fin_interruption.tv_usec)
303: - debut_interruption.tv_usec;
304: duree_interruption.tv_sec = fin_interruption.tv_sec
305: - (debut_interruption.tv_sec + 1);
306: }
307: else
308: {
309: duree_interruption.tv_usec = fin_interruption.tv_usec
310: - debut_interruption.tv_usec;
311: duree_interruption.tv_sec = fin_interruption.tv_sec
312: - debut_interruption.tv_sec;
313: }
314:
315: if (attente.tv_nsec < (1000 * duree_interruption.tv_usec))
316: {
317: attente.tv_nsec = (1000000000 + attente.tv_nsec)
318: - (1000 * duree_interruption.tv_usec);
319: attente.tv_sec = attente.tv_sec
320: - (duree_interruption.tv_sec + 1);
321: }
322: else
323: {
324: attente.tv_nsec = attente.tv_nsec
325: - (1000 * duree_interruption.tv_usec);
326: attente.tv_sec = attente.tv_sec
327: - duree_interruption.tv_sec;
328: }
329:
330: if (attente.tv_sec < 0)
331: {
332: code_retour = 0;
333: }
334: }
335: } while(((code_retour == -1) && (erreur == EINTR))
336: && ((*s_etat_processus).var_volatile_requete_arret == 0));
337:
338: if ((*s_etat_processus).profilage == d_vrai)
339: {
340: profilage(s_etat_processus, NULL);
341: }
342: }
343: else
344: {
345: liberation(s_etat_processus, s_objet_argument);
346:
347: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
348: return;
349: }
350:
351: liberation(s_etat_processus, s_objet_argument);
352: return;
353: }
354:
355:
356: /*
357: ================================================================================
358: Fonction 'atexit'
359: ================================================================================
360: Entrées :
361: --------------------------------------------------------------------------------
362: Sorties :
363: --------------------------------------------------------------------------------
364: Effets de bord : néant
365: ================================================================================
366: */
367:
368: void
369: instruction_atexit(struct_processus *s_etat_processus)
370: {
371: struct_objet *s_objet_argument;
372:
373: (*s_etat_processus).erreur_execution = d_ex;
374:
375: if ((*s_etat_processus).affichage_arguments == 'Y')
376: {
377: printf("\n ATEXIT ");
378:
379: if ((*s_etat_processus).langue == 'F')
380: {
381: printf("(exécution d'une fonction à la sortie d'une tâche)\n\n");
382: }
383: else
384: {
385: printf("(register a function to be called on task exit)\n\n");
386: }
387:
388: printf(" 1: %s, %s\n", d_NOM, d_RPN);
389:
390: return;
391: }
392: else if ((*s_etat_processus).test_instruction == 'Y')
393: {
394: (*s_etat_processus).nombre_arguments = 1;
395: return;
396: }
397:
398: if (test_cfsf(s_etat_processus, 31) == d_vrai)
399: {
400: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
401: {
402: return;
403: }
404: }
405:
406: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
407: &s_objet_argument) == d_erreur)
408: {
409: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
410: return;
411: }
412:
413: if ((*s_objet_argument).type == NOM)
414: {
415: liberation(s_etat_processus, (*s_etat_processus).at_exit);
416: (*s_etat_processus).at_exit = s_objet_argument;
417: }
418: else if ((*s_objet_argument).type == RPN)
419: {
420: liberation(s_etat_processus, (*s_etat_processus).at_exit);
421: (*s_etat_processus).at_exit = s_objet_argument;
422: }
423: else
424: {
425: liberation(s_etat_processus, s_objet_argument);
426:
427: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
428: return;
429: }
430:
431: return;
432: }
433:
434:
435: /*
436: ================================================================================
437: Fonction 'atpoke'
438: ================================================================================
439: Entrées :
440: --------------------------------------------------------------------------------
441: Sorties :
442: --------------------------------------------------------------------------------
443: Effets de bord : néant
444: ================================================================================
445: */
446:
447: void
448: instruction_atpoke(struct_processus *s_etat_processus)
449: {
450: struct_objet *s_objet_argument;
451:
452: (*s_etat_processus).erreur_execution = d_ex;
453:
454: if ((*s_etat_processus).affichage_arguments == 'Y')
455: {
456: printf("\n ATPOKE ");
457:
458: if ((*s_etat_processus).langue == 'F')
459: {
460: printf("(exécution d'une fonction lors de l'injection "
461: "d'une donnée)\n\n");
462: }
463: else
464: {
465: printf("(register a function to be called on data injection)\n\n");
466: }
467:
468: printf(" 1: %s, %s\n", d_NOM, d_RPN);
469:
470: return;
471: }
472: else if ((*s_etat_processus).test_instruction == 'Y')
473: {
474: (*s_etat_processus).nombre_arguments = 1;
475: return;
476: }
477:
478: if (test_cfsf(s_etat_processus, 31) == d_vrai)
479: {
480: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
481: {
482: return;
483: }
484: }
485:
486: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
487: &s_objet_argument) == d_erreur)
488: {
489: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
490: return;
491: }
492:
493: if ((*s_objet_argument).type == NOM)
494: {
495: liberation(s_etat_processus, (*s_etat_processus).at_poke);
496: (*s_etat_processus).at_poke = s_objet_argument;
497: }
498: else if ((*s_objet_argument).type == RPN)
499: {
500: liberation(s_etat_processus, (*s_etat_processus).at_poke);
501: (*s_etat_processus).at_poke = s_objet_argument;
502: }
503: else
504: {
505: liberation(s_etat_processus, s_objet_argument);
506:
507: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
508: return;
509: }
510:
511: return;
512: }
513:
514: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_a5.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src