![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_s8.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to instructions_s8.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.18 ! bertrand 3: RPL/2 (R) version 4.0.19
1.1 bertrand 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:
1.15 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'splash'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_splash(struct_processus *s_etat_processus)
40: {
41: real8 attente;
42:
43: struct_objet *s_objet;
44:
45: (*s_etat_processus).erreur_execution = d_ex;
46:
47: if ((*s_etat_processus).affichage_arguments == 'Y')
48: {
49: printf("\n SPLASH ");
50:
51: if ((*s_etat_processus).langue == 'F')
52: {
53: printf("(écran RPL/2)\n\n");
54: }
55: else
56: {
57: printf("(RPL/2 splash screen)\n\n");
58: }
59:
60: printf(" 1: %s, %s\n", d_INT, d_REL);
61:
62: return;
63: }
64: else if ((*s_etat_processus).test_instruction == 'Y')
65: {
66: (*s_etat_processus).nombre_arguments = -1;
67: return;
68: }
69:
70: if (test_cfsf(s_etat_processus, 31) == d_vrai)
71: {
72: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
73: {
74: return;
75: }
76: }
77:
78: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
79: &s_objet) == d_erreur)
80: {
81: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
82: return;
83: }
84:
85: if (((*s_objet).type == INT) ||
86: ((*s_objet).type == REL))
87: {
88: if ((*s_objet).type == INT)
89: {
90: attente = (real8) (*((integer8 *) (*s_objet).objet));
91: }
92: else
93: {
94: attente = (*((real8 *) (*s_objet).objet));
95: }
96:
97: if (attente < 0)
98: {
99: liberation(s_etat_processus, s_objet);
100:
101: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
102: return;
103: }
104:
105: encart(s_etat_processus, (unsigned long) (attente * 1E6));
106: }
107: else
108: {
109: liberation(s_etat_processus, s_objet);
110:
111: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
112: return;
113: }
114:
115: liberation(s_etat_processus, s_objet);
116:
117: return;
118: }
119:
120:
121: /*
122: ================================================================================
123: Fonction 'send'
124: ================================================================================
125: Entrées :
126: --------------------------------------------------------------------------------
127: Sorties :
128: --------------------------------------------------------------------------------
129: Effets de bord : néant
130: ================================================================================
131: */
132:
133: void
134: instruction_send(struct_processus *s_etat_processus)
135: {
136: pid_t pid;
137:
138: pthread_t tid;
139:
140: sig_atomic_t registre;
141:
142: ssize_t longueur_ecriture;
143:
144: struct_objet *s_objet;
145:
146: struct timespec attente;
147:
148: unsigned char tampon;
149:
150: (*s_etat_processus).erreur_execution = d_ex;
151:
152: if ((*s_etat_processus).affichage_arguments == 'Y')
153: {
154: printf("\n SEND ");
155:
156: if ((*s_etat_processus).langue == 'F')
157: {
158: printf("(envoi de données au processus père)\n\n");
159: }
160: else
161: {
162: printf("(send data to parent process)\n\n");
163: }
164:
165: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
166: " %s, %s, %s, %s, %s,\n"
167: " %s, %s, %s, %s, %s\n",
168: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
169: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_TAB);
170:
171: return;
172: }
173: else if ((*s_etat_processus).test_instruction == 'Y')
174: {
175: (*s_etat_processus).nombre_arguments = -1;
176: return;
177: }
178:
179: if (test_cfsf(s_etat_processus, 31) == d_vrai)
180: {
181: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
182: {
183: return;
184: }
185: }
186:
187: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
188: &s_objet) == d_erreur)
189: {
190: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
191: return;
192: }
193:
194: if ((*s_etat_processus).presence_pipes == d_faux)
195: {
196: liberation(s_etat_processus, s_objet);
197:
198: (*s_etat_processus).erreur_execution = d_ex_absence_processus_pere;
199: return;
200: }
201:
202: if (((*s_objet).type != INT) &&
203: ((*s_objet).type != REL) &&
204: ((*s_objet).type != CPL) &&
205: ((*s_objet).type != VIN) &&
206: ((*s_objet).type != VRL) &&
207: ((*s_objet).type != VCX) &&
208: ((*s_objet).type != MIN) &&
209: ((*s_objet).type != MRL) &&
210: ((*s_objet).type != MCX) &&
211: ((*s_objet).type != BIN) &&
212: ((*s_objet).type != NOM) &&
213: ((*s_objet).type != CHN) &&
214: ((*s_objet).type != LST) &&
215: ((*s_objet).type != ALG) &&
216: ((*s_objet).type != RPN) &&
217: ((*s_objet).type != TBL))
218: {
219: liberation(s_etat_processus, s_objet);
220:
221: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
222: return;
223: }
224:
225: /*
226: * On signale au processus père qu'il y a un objet de plus
227: * dans le pipe de données.
228: */
229:
230: registre = (*s_etat_processus).var_volatile_traitement_retarde_stop;
231: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
232:
233: if ((*s_etat_processus).processus_detache == d_vrai)
234: {
235: if ((*s_etat_processus).profilage == d_vrai)
236: {
237: profilage(s_etat_processus, "Interprocess communications (SEND)");
238:
239: if ((*s_etat_processus).erreur_systeme != d_es)
240: {
241: return;
242: }
243: }
244:
245: pid = -3;
246:
247: attente.tv_sec = 0;
248: attente.tv_nsec = GRANULARITE_us * 1000;
249:
1.7 bertrand 250: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 251: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
252: {
253: (*s_etat_processus).erreur_systeme = d_es_processus;
254: return;
255: }
1.7 bertrand 256: # else
257: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
258: {
259: (*s_etat_processus).erreur_systeme = d_es_processus;
260: return;
261: }
262: # endif
1.1 bertrand 263:
264: while((longueur_ecriture = write_atomic(s_etat_processus,
265: (*s_etat_processus).pipe_nombre_objets_attente,
266: &pid, sizeof(pid))) != sizeof(pid))
267: {
1.7 bertrand 268: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 269: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1.7 bertrand 270: # else
271: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
272: # endif
1.1 bertrand 273: {
274: if (errno != EINTR)
275: {
276: (*s_etat_processus).erreur_systeme = d_es_processus;
277: return;
278: }
279: }
280:
281: if (longueur_ecriture == -1)
282: {
283: if ((*s_etat_processus).profilage == d_vrai)
284: {
285: profilage(s_etat_processus, NULL);
286: }
287:
288: (*s_etat_processus).erreur_systeme = d_es_processus;
289: return;
290: }
291:
292: nanosleep(&attente, NULL);
293: INCR_GRANULARITE(attente.tv_nsec);
294:
1.7 bertrand 295: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 296: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
297: {
298: (*s_etat_processus).erreur_systeme = d_es_processus;
299: return;
300: }
1.7 bertrand 301: # else
302: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
303: {
304: (*s_etat_processus).erreur_systeme = d_es_processus;
305: return;
306: }
307: # endif
1.1 bertrand 308: }
309:
310: pid = getpid();
311:
312: attente.tv_sec = 0;
313: attente.tv_nsec = GRANULARITE_us * 1000;
314:
315: while((longueur_ecriture = write_atomic(s_etat_processus,
316: (*s_etat_processus).pipe_nombre_objets_attente,
317: &pid, sizeof(pid))) != sizeof(pid))
318: {
1.7 bertrand 319: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 320: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1.7 bertrand 321: # else
322: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
323: # endif
1.1 bertrand 324: {
325: if (errno != EINTR)
326: {
327: (*s_etat_processus).erreur_systeme = d_es_processus;
328: return;
329: }
330: }
331:
332: if (longueur_ecriture == -1)
333: {
334: if ((*s_etat_processus).profilage == d_vrai)
335: {
336: profilage(s_etat_processus, NULL);
337: }
338:
339: (*s_etat_processus).erreur_systeme = d_es_processus;
340: return;
341: }
342:
343: nanosleep(&attente, NULL);
344: INCR_GRANULARITE(attente.tv_nsec);
345:
1.7 bertrand 346: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 347: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.7 bertrand 348: # else
349: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
350: # endif
1.1 bertrand 351: {
352: (*s_etat_processus).erreur_systeme = d_es_processus;
353: return;
354: }
355: }
356:
1.7 bertrand 357: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 358: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1.7 bertrand 359: # else
360: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
361: # endif
1.1 bertrand 362: {
363: if (errno != EINTR)
364: {
365: (*s_etat_processus).erreur_systeme = d_es_processus;
366: return;
367: }
368: }
369: }
370: else
371: {
372: if ((*s_etat_processus).profilage == d_vrai)
373: {
374: profilage(s_etat_processus, "Interthread communications (SEND)");
375:
376: if ((*s_etat_processus).erreur_systeme != d_es)
377: {
378: return;
379: }
380: }
381:
382: tid = -3;
383:
384: attente.tv_sec = 0;
385: attente.tv_nsec = GRANULARITE_us * 1000;
386:
1.7 bertrand 387: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 388: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
389: {
390: (*s_etat_processus).erreur_systeme = d_es_processus;
391: return;
392: }
1.7 bertrand 393: # else
394: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
395: {
396: (*s_etat_processus).erreur_systeme = d_es_processus;
397: return;
398: }
399: # endif
1.1 bertrand 400:
401: while((longueur_ecriture = write_atomic(s_etat_processus,
402: (*s_etat_processus).pipe_nombre_objets_attente,
403: &tid, sizeof(tid))) != sizeof(tid))
404: {
1.7 bertrand 405: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 406: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1.7 bertrand 407: # else
408: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
409: # endif
1.1 bertrand 410: {
411: if (errno != EINTR)
412: {
413: (*s_etat_processus).erreur_systeme = d_es_processus;
414: return;
415: }
416: }
417:
418: if (longueur_ecriture == -1)
419: {
420: if ((*s_etat_processus).profilage == d_vrai)
421: {
422: profilage(s_etat_processus, NULL);
423: }
424:
425: (*s_etat_processus).erreur_systeme = d_es_processus;
426: return;
427: }
428:
429: nanosleep(&attente, NULL);
430: INCR_GRANULARITE(attente.tv_nsec);
431:
1.7 bertrand 432: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 433: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
434: {
435: (*s_etat_processus).erreur_systeme = d_es_processus;
436: return;
437: }
1.7 bertrand 438: # else
439: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
440: {
441: (*s_etat_processus).erreur_systeme = d_es_processus;
442: return;
443: }
444: # endif
1.1 bertrand 445: }
446:
447: tid = pthread_self();
448:
449: attente.tv_sec = 0;
450: attente.tv_nsec = GRANULARITE_us * 1000;
451:
452: while((longueur_ecriture = write_atomic(s_etat_processus,
453: (*s_etat_processus).pipe_nombre_objets_attente,
454: &tid, sizeof(tid))) != sizeof(tid))
455: {
1.7 bertrand 456: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 457: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1.7 bertrand 458: # else
459: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
460: # endif
1.1 bertrand 461: {
462: if (errno != EINTR)
463: {
464: (*s_etat_processus).erreur_systeme = d_es_processus;
465: return;
466: }
467: }
468:
469: if (longueur_ecriture == -1)
470: {
471: if ((*s_etat_processus).profilage == d_vrai)
472: {
473: profilage(s_etat_processus, NULL);
474: }
475:
476: (*s_etat_processus).erreur_systeme = d_es_processus;
477: return;
478: }
479:
480: nanosleep(&attente, NULL);
481: INCR_GRANULARITE(attente.tv_nsec);
482:
1.7 bertrand 483: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 484: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
485: {
486: (*s_etat_processus).erreur_systeme = d_es_processus;
487: return;
488: }
1.7 bertrand 489: # else
490: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
491: {
492: (*s_etat_processus).erreur_systeme = d_es_processus;
493: return;
494: }
495: # endif
1.1 bertrand 496: }
497:
1.7 bertrand 498: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 499: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1.7 bertrand 500: # else
501: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
502: # endif
1.1 bertrand 503: {
504: if (errno != EINTR)
505: {
506: (*s_etat_processus).erreur_systeme = d_es_processus;
507: return;
508: }
509: }
510: }
511:
512: (*s_etat_processus).nombre_objets_envoyes_non_lus++;
513:
514: attente.tv_sec = 0;
515: attente.tv_nsec = GRANULARITE_us * 1000;
516:
1.7 bertrand 517: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 518: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
519: {
520: (*s_etat_processus).erreur_systeme = d_es_processus;
521: return;
522: }
1.7 bertrand 523: # else
524: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
525: {
526: (*s_etat_processus).erreur_systeme = d_es_processus;
527: return;
528: }
529: # endif
1.1 bertrand 530:
531: while(read_atomic(s_etat_processus, (*s_etat_processus).pipe_acquittement,
532: &tampon, sizeof(unsigned char)) != sizeof(unsigned char))
533: {
1.7 bertrand 534: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 535: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1.7 bertrand 536: # else
537: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
538: # endif
1.1 bertrand 539: {
540: if (errno != EINTR)
541: {
542: (*s_etat_processus).erreur_systeme = d_es_processus;
543: return;
544: }
545: }
546:
547: nanosleep(&attente, NULL);
548: INCR_GRANULARITE(attente.tv_nsec);
549:
1.7 bertrand 550: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 551: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.7 bertrand 552: # else
553: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
554: # endif
1.1 bertrand 555: {
556: (*s_etat_processus).erreur_systeme = d_es_processus;
557: return;
558: }
559: }
560:
1.7 bertrand 561: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 562: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1.7 bertrand 563: # else
564: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
565: # endif
1.1 bertrand 566: {
567: if (errno != EINTR)
568: {
569: (*s_etat_processus).erreur_systeme = d_es_processus;
570: return;
571: }
572: }
573:
574: // Envoi d'un PID invalide (-1) pour ne pas bloquer le thread
575: // de surveillance.
576:
577: if ((*s_etat_processus).processus_detache == d_vrai)
578: {
579: pid = -1;
580:
581: attente.tv_sec = 0;
582: attente.tv_nsec = GRANULARITE_us * 1000;
583:
1.7 bertrand 584: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 585: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.7 bertrand 586: # else
587: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
588: # endif
1.1 bertrand 589: {
590: (*s_etat_processus).erreur_systeme = d_es_processus;
591: return;
592: }
593:
594: while((longueur_ecriture = write_atomic(s_etat_processus,
595: (*s_etat_processus).pipe_nombre_interruptions_attente,
596: &pid, sizeof(pid))) != sizeof(pid))
597: {
1.7 bertrand 598: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 599: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1.7 bertrand 600: # else
601: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
602: # endif
1.1 bertrand 603: {
604: if (errno != EINTR)
605: {
606: (*s_etat_processus).erreur_systeme = d_es_processus;
607: return;
608: }
609: }
610:
611: if (longueur_ecriture == -1)
612: {
613: if ((*s_etat_processus).profilage == d_vrai)
614: {
615: profilage(s_etat_processus, NULL);
616: }
617:
618: (*s_etat_processus).erreur_systeme = d_es_processus;
619: return;
620: }
621:
622: nanosleep(&attente, NULL);
623: INCR_GRANULARITE(attente.tv_nsec);
624:
1.7 bertrand 625: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 626: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
627: {
628: (*s_etat_processus).erreur_systeme = d_es_processus;
629: return;
630: }
1.7 bertrand 631: # else
632: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
633: {
634: (*s_etat_processus).erreur_systeme = d_es_processus;
635: return;
636: }
637: # endif
1.1 bertrand 638: }
639:
1.7 bertrand 640: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 641: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1.7 bertrand 642: # else
643: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
644: # endif
1.1 bertrand 645: {
646: if (errno != EINTR)
647: {
648: (*s_etat_processus).erreur_systeme = d_es_processus;
649: return;
650: }
651: }
652: }
653: else
654: {
655: tid = -1;
656:
657: attente.tv_sec = 0;
658: attente.tv_nsec = GRANULARITE_us * 1000;
659:
1.7 bertrand 660: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 661: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.7 bertrand 662: # else
663: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
664: # endif
1.1 bertrand 665: {
666: (*s_etat_processus).erreur_systeme = d_es_processus;
667: return;
668: }
669:
670: while((longueur_ecriture = write_atomic(s_etat_processus,
671: (*s_etat_processus).pipe_nombre_interruptions_attente,
672: &tid, sizeof(tid))) != sizeof(tid))
673: {
1.7 bertrand 674: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 675: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1.7 bertrand 676: # else
677: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
678: # endif
1.1 bertrand 679: {
680: if (errno != EINTR)
681: {
682: (*s_etat_processus).erreur_systeme = d_es_processus;
683: return;
684: }
685: }
686:
687: if (longueur_ecriture == -1)
688: {
689: if ((*s_etat_processus).profilage == d_vrai)
690: {
691: profilage(s_etat_processus, NULL);
692: }
693:
694: (*s_etat_processus).erreur_systeme = d_es_processus;
695: return;
696: }
697:
698: nanosleep(&attente, NULL);
699: INCR_GRANULARITE(attente.tv_nsec);
700:
1.7 bertrand 701: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 702: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.7 bertrand 703: # else
704: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
705: # endif
1.1 bertrand 706: {
707: (*s_etat_processus).erreur_systeme = d_es_processus;
708: return;
709: }
710: }
711:
1.7 bertrand 712: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 713: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1.7 bertrand 714: # else
715: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
716: # endif
1.1 bertrand 717: {
718: if (errno != EINTR)
719: {
720: (*s_etat_processus).erreur_systeme = d_es_processus;
721: return;
722: }
723: }
724: }
725:
726: // ecriture_pipe() ne peut être interrompu par un signal.
727:
1.7 bertrand 728: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 729: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
730: {
731: (*s_etat_processus).erreur_systeme = d_es_processus;
732: return;
733: }
1.7 bertrand 734: # else
735: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
736: {
737: (*s_etat_processus).erreur_systeme = d_es_processus;
738: return;
739: }
740: # endif
1.1 bertrand 741:
742: if (ecriture_pipe(s_etat_processus, (*s_etat_processus).pipe_donnees,
743: s_objet) == d_erreur)
744: {
1.7 bertrand 745: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 746: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1.7 bertrand 747: # else
748: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
749: # endif
1.1 bertrand 750: {
751: if (errno != EINTR)
752: {
753: (*s_etat_processus).erreur_systeme = d_es_processus;
754: return;
755: }
756: }
757:
758: if ((*s_etat_processus).profilage == d_vrai)
759: {
760: profilage(s_etat_processus, NULL);
761: }
762:
763: liberation(s_etat_processus, s_objet);
764: return;
765: }
766:
1.7 bertrand 767: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 768: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1.7 bertrand 769: # else
770: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
771: # endif
1.1 bertrand 772: {
773: if (errno != EINTR)
774: {
775: (*s_etat_processus).erreur_systeme = d_es_processus;
776: return;
777: }
778: }
779:
780: if ((*s_etat_processus).profilage == d_vrai)
781: {
782: profilage(s_etat_processus, NULL);
783: }
784:
785: if (registre == 0)
786: {
787: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1)
788: {
789: (*s_etat_processus).var_volatile_requete_arret = -1;
790: }
791:
792: (*s_etat_processus).var_volatile_traitement_retarde_stop = registre;
793: }
794:
795: liberation(s_etat_processus, s_objet);
796: return;
797: }
798:
799:
800: /*
801: ================================================================================
802: Fonction 'sqlquery'
803: ================================================================================
804: Entrées :
805: --------------------------------------------------------------------------------
806: Sorties :
807: --------------------------------------------------------------------------------
808: Effets de bord : néant
809: ================================================================================
810: */
811:
812: void
813: instruction_sqlquery(struct_processus *s_etat_processus)
814: {
815: # define d_LONGUEUR 1024
816:
817: logical1 connexion_permanente;
818: logical1 presence_resultat;
819:
820: struct_objet *s_copie_1;
821: struct_objet *s_objet_1;
822: struct_objet *s_copie_2;
823: struct_objet *s_objet_2;
824: struct_objet *s_objet_resultat;
825:
826: struct_liste_chainee *l_element_courant;
827: struct_liste_chainee *l_element_courant_ligne;
828:
829: unsigned char *tampon;
830:
831: unsigned int i;
832: unsigned int j;
833: unsigned int nombre_colonnes;
834: unsigned int nombre_lignes;
835:
836: (*s_etat_processus).erreur_execution = d_ex;
837:
838: if ((*s_etat_processus).affichage_arguments == 'Y')
839: {
840: printf("\n SQLQUERY ");
841:
842: if ((*s_etat_processus).langue == 'F')
843: {
844: printf("(requête SQL)\n\n");
845: }
846: else
847: {
848: printf("(SQL query)\n\n");
849: }
850:
851: printf(" 2: %s\n", d_CHN);
852: printf(" 1: %s\n", d_LST);
853: printf("-> 1: %s\n\n", d_LST);
854:
855: printf(" 2: %s\n", d_CHN);
856: printf(" 1: %s\n", d_SQL);
857: printf("-> 1: %s\n\n", d_LST);
858:
859: if ((*s_etat_processus).langue == 'F')
860: {
861: printf(" Utilisation :\n\n");
862: }
863: else
864: {
865: printf(" Usage:\n\n");
866: }
867:
868: printf(" \"select * from table\"\n");
869: printf(" { \"mysql\" \"server\" \"database\" "
870: "\"user\" \"password\" } SQLQUERY\n");
871: printf(" \"select field from table\"\n");
872: printf(" { \"postgresql:iso-8859-1\" \"server\" "
873: "\"database\" \"user\" \"password\" port }\n");
874: printf(" SQLQUERY\n");
875:
876: return;
877: }
878: else if ((*s_etat_processus).test_instruction == 'Y')
879: {
880: (*s_etat_processus).nombre_arguments = -1;
881: return;
882: }
883:
884: if (test_cfsf(s_etat_processus, 31) == d_vrai)
885: {
886: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
887: {
888: return;
889: }
890: }
891:
892: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
893: &s_objet_1) == d_erreur)
894: {
895: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
896: return;
897: }
898:
899: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
900: &s_objet_2) == d_erreur)
901: {
902: liberation(s_etat_processus, s_objet_1);
903:
904: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
905: return;
906: }
907:
908: if ((*s_objet_1).type == LST)
909: {
910: connexion_permanente = d_faux;
911:
912: s_copie_1 = s_objet_1;
913:
914: if ((s_objet_1 = parametres_sql(s_etat_processus, s_copie_1)) == NULL)
915: {
916: liberation(s_etat_processus, s_copie_1);
917: liberation(s_etat_processus, s_objet_2);
918: return;
919: }
920:
921: liberation(s_etat_processus, s_copie_1);
922: }
923: else
924: {
925: if ((*s_objet_1).type == SQL)
926: {
927: if (((*((struct_connecteur_sql *) (*s_objet_1).objet)).pid !=
928: getpid()) || (pthread_equal((*((struct_connecteur_sql *)
929: (*s_objet_1).objet)).tid, pthread_self()) == 0))
930: {
931: (*s_etat_processus).erreur_execution =
932: d_ex_fichier_hors_contexte;
933:
934: liberation(s_etat_processus, s_objet_1);
935: liberation(s_etat_processus, s_objet_2);
936: return;
937: }
938: }
939:
940: connexion_permanente = d_vrai;
941: }
942:
943: if (((*s_objet_1).type == SQL) && ((*s_objet_2).type == CHN))
944: {
945: if ((*((struct_connecteur_sql *) (*s_objet_1).objet)).locale != NULL)
946: {
947: /*
948: * Transcodage de la commande SQL
949: */
950:
951: if ((s_copie_2 = copie_objet(s_etat_processus, s_objet_2, 'O'))
952: == NULL)
953: {
954: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
955: return;
956: }
957:
958: liberation(s_etat_processus, s_objet_2);
959: s_objet_2 = s_copie_2;
960:
961: tampon = (*s_objet_2).objet;
962:
963: if (((*s_objet_2).objet = transliteration(s_etat_processus, tampon,
964: (*((struct_connecteur_sql *) (*s_objet_1).objet)).locale,
965: d_locale)) == NULL)
966: {
967: return;
968: }
969:
970: free(tampon);
971: }
972:
973: /*
974: * Pilote MySQL
975: */
976:
977: if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
978: "MYSQL") == 0)
979: {
980: # ifdef MYSQL_SUPPORT
981:
982: MYSQL_RES *resultat_mysql;
983: MYSQL_ROW ligne;
984:
985: if (mysql_real_query((*((struct_connecteur_sql *) (*s_objet_1)
986: .objet)).descripteur.mysql, (unsigned char *) (*s_objet_2)
987: .objet, strlen((unsigned char *) (*s_objet_2).objet)) != 0)
988: {
989: if (connexion_permanente == d_faux)
990: {
991: mysql_close((*((struct_connecteur_sql *) (*s_objet_1)
992: .objet)).descripteur.mysql);
993: }
994:
995: liberation(s_etat_processus, s_objet_1);
996: liberation(s_etat_processus, s_objet_2);
997:
998: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
999: return;
1000: }
1001:
1002: if ((resultat_mysql = mysql_store_result(
1003: (*((struct_connecteur_sql *) (*s_objet_1).objet))
1004: .descripteur.mysql)) == NULL)
1005: {
1006: // La requête ne renvoie rien (exemple : INSERT)
1007: presence_resultat = d_faux;
1008: nombre_colonnes = 0;
1009: }
1010: else
1011: {
1012: // La requête renvoie une ou plusieurs valeurs.
1013: presence_resultat = d_vrai;
1014: nombre_colonnes = mysql_field_count((*((struct_connecteur_sql *)
1015: (*s_objet_1).objet)).descripteur.mysql);
1016: }
1017:
1018: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1019: == NULL)
1020: {
1021: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1022: return;
1023: }
1024:
1025: (*s_objet_resultat).objet = NULL;
1026: l_element_courant = (*s_objet_resultat).objet;
1027:
1028: while(((presence_resultat == d_vrai) ?
1029: (ligne = mysql_fetch_row(resultat_mysql)) : NULL) != NULL)
1030: {
1031: unsigned long *longueurs;
1032:
1033: longueurs = mysql_fetch_lengths(resultat_mysql);
1034:
1035: if (l_element_courant == NULL)
1036: {
1037: if (((*s_objet_resultat).objet =
1038: allocation_maillon(s_etat_processus)) == NULL)
1039: {
1040: (*s_etat_processus).erreur_systeme =
1041: d_es_allocation_memoire;
1042: return;
1043: }
1044:
1045: l_element_courant = (struct_liste_chainee *)
1046: (*s_objet_resultat).objet;
1047: }
1048: else
1049: {
1050: if (((*l_element_courant).suivant =
1051: allocation_maillon(s_etat_processus)) == NULL)
1052: {
1053: (*s_etat_processus).erreur_systeme =
1054: d_es_allocation_memoire;
1055: return;
1056: }
1057:
1058: l_element_courant = (*l_element_courant).suivant;
1059: }
1060:
1061: (*l_element_courant).suivant = NULL;
1062:
1063: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1064: LST)) == NULL)
1065: {
1066: (*s_etat_processus).erreur_systeme =
1067: d_es_allocation_memoire;
1068: return;
1069: }
1070:
1071: (*(*l_element_courant).donnee).objet = NULL;
1072: l_element_courant_ligne = NULL;
1073:
1074: for(i = 0; i < nombre_colonnes; i++)
1075: {
1076: if (l_element_courant_ligne == NULL)
1077: {
1078: if (((*(*l_element_courant).donnee).objet =
1079: allocation_maillon(s_etat_processus)) == NULL)
1080: {
1081: (*s_etat_processus).erreur_systeme =
1082: d_es_allocation_memoire;
1083: return;
1084: }
1085:
1086: l_element_courant_ligne = (struct_liste_chainee *)
1087: (*(*l_element_courant).donnee).objet;
1088: }
1089: else
1090: {
1091: if (((*l_element_courant_ligne).suivant =
1092: allocation_maillon(s_etat_processus)) == NULL)
1093: {
1094: (*s_etat_processus).erreur_systeme =
1095: d_es_allocation_memoire;
1096: return;
1097: }
1098:
1099: l_element_courant_ligne =
1100: (*l_element_courant_ligne).suivant;
1101: }
1102:
1103: (*l_element_courant_ligne).suivant = NULL;
1104:
1105: if (((*l_element_courant_ligne).donnee =
1106: allocation(s_etat_processus, CHN)) == NULL)
1107: {
1108: (*s_etat_processus).erreur_systeme =
1109: d_es_allocation_memoire;
1110: return;
1111: }
1112:
1113: if (ligne[i] == NULL)
1114: {
1115: if (((*(*l_element_courant_ligne).donnee).objet =
1116: malloc(5 * sizeof(unsigned char))) == NULL)
1117: {
1118: (*s_etat_processus).erreur_systeme =
1119: d_es_allocation_memoire;
1120: return;
1121: }
1122:
1123: strcpy((unsigned char *) (*(*l_element_courant_ligne)
1124: .donnee).objet, "NULL");
1125: }
1126: else
1127: {
1128: if (((*(*l_element_courant_ligne).donnee).objet =
1129: malloc((longueurs[i] + 1) *
1130: sizeof(unsigned char))) == NULL)
1131: {
1132: (*s_etat_processus).erreur_systeme =
1133: d_es_allocation_memoire;
1134: return;
1135: }
1136:
1137: strcpy((unsigned char *) (*(*l_element_courant_ligne)
1138: .donnee).objet, ligne[i]);
1139: }
1140: }
1141: }
1142:
1143: mysql_free_result(resultat_mysql);
1144:
1145: if (connexion_permanente == d_faux)
1146: {
1147: mysql_close((*((struct_connecteur_sql *) (*s_objet_1).objet))
1148: .descripteur.mysql);
1149: }
1150:
1151: if (presence_resultat == d_vrai)
1152: {
1153: if (empilement(s_etat_processus,
1154: &((*s_etat_processus).l_base_pile),
1155: s_objet_resultat) == d_erreur)
1156: {
1157: return;
1158: }
1159: }
1160:
1161: # else
1162:
1163: if ((*s_etat_processus).langue == 'F')
1164: {
1165: printf("+++Attention : Support de MySQL non compilé !\n");
1166: }
1167: else
1168: {
1169: printf("+++Warning : MySQL support not available !\n");
1170: }
1171:
1172: fflush(stdout);
1173: # endif
1174: }
1175:
1176: /*
1177: * Pilote PostgreSQL
1178: */
1179:
1180: else if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
1181: "POSTGRESQL") == 0)
1182: {
1183: # ifdef POSTGRESQL_SUPPORT
1184:
1185: PGresult *resultat_postgresql;
1186:
1187: if (PQstatus((*((struct_connecteur_sql *) (*s_objet_1).objet))
1188: .descripteur.postgresql) != CONNECTION_OK)
1189: {
1190: if (connexion_permanente == d_faux)
1191: {
1192: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet))
1193: .descripteur.postgresql);
1194: }
1195:
1196: liberation(s_etat_processus, s_objet_1);
1197: liberation(s_etat_processus, s_objet_2);
1198:
1199: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1200: return;
1201: }
1202:
1203: resultat_postgresql = PQexec((*((struct_connecteur_sql *)
1204: (*s_objet_1).objet)).descripteur.postgresql,
1205: (unsigned char *) (*s_objet_2).objet);
1206: presence_resultat = d_faux;
1207:
1208: switch(PQresultStatus(resultat_postgresql))
1209: {
1210: case PGRES_COMMAND_OK :
1211: { // Commande qui ne renvoit rien
1212: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1213: == NULL)
1214: {
1215: (*s_etat_processus).erreur_systeme =
1216: d_es_allocation_memoire;
1217: return;
1218: }
1219:
1220: (*s_objet_resultat).objet = NULL;
1221: l_element_courant = (*s_objet_resultat).objet;
1222: presence_resultat = d_vrai;
1223:
1224: break;
1225: }
1226:
1227: case PGRES_TUPLES_OK :
1228: { // Commande renvoyant des données
1229: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1230: == NULL)
1231: {
1232: (*s_etat_processus).erreur_systeme =
1233: d_es_allocation_memoire;
1234: return;
1235: }
1236:
1237: (*s_objet_resultat).objet = NULL;
1238: l_element_courant = (*s_objet_resultat).objet;
1239: presence_resultat = d_vrai;
1240:
1241: nombre_colonnes = PQnfields(resultat_postgresql);
1242: nombre_lignes = PQntuples(resultat_postgresql);
1243:
1244: for(i = 0; i < nombre_lignes; i++)
1245: {
1246: // Chaînage d'un nouveau maillon de la liste résultat
1247:
1248: if (l_element_courant == NULL)
1249: {
1250: if (((*s_objet_resultat).objet =
1251: allocation_maillon(s_etat_processus))
1252: == NULL)
1253: {
1254: (*s_etat_processus).erreur_systeme =
1255: d_es_allocation_memoire;
1256: return;
1257: }
1258:
1259: l_element_courant = (struct_liste_chainee *)
1260: (*s_objet_resultat).objet;
1261: }
1262: else
1263: {
1264: if (((*l_element_courant).suivant =
1265: allocation_maillon(s_etat_processus))
1266: == NULL)
1267: {
1268: (*s_etat_processus).erreur_systeme =
1269: d_es_allocation_memoire;
1270: return;
1271: }
1272:
1273: l_element_courant = (*l_element_courant).suivant;
1274: }
1275:
1276: (*l_element_courant).suivant = NULL;
1277:
1278: // Création de la liste fille
1279:
1280: if (((*l_element_courant).donnee =
1281: allocation(s_etat_processus, LST)) == NULL)
1282: {
1283: (*s_etat_processus).erreur_systeme =
1284: d_es_allocation_memoire;
1285: return;
1286: }
1287:
1288: (*(*l_element_courant).donnee).objet = NULL;
1289: l_element_courant_ligne = NULL;
1290:
1291: for(j = 0; j < nombre_colonnes; j++)
1292: {
1293: if (l_element_courant_ligne == NULL)
1294: {
1295: if (((*(*l_element_courant).donnee).objet =
1296: allocation_maillon(s_etat_processus))
1297: == NULL)
1298: {
1299: (*s_etat_processus).erreur_systeme =
1300: d_es_allocation_memoire;
1301: return;
1302: }
1303:
1304: l_element_courant_ligne =
1305: (struct_liste_chainee *)
1306: (*(*l_element_courant).donnee).objet;
1307: }
1308: else
1309: {
1310: if (((*l_element_courant_ligne).suivant =
1311: allocation_maillon(s_etat_processus))
1312: == NULL)
1313: {
1314: l_element_courant_ligne =
1315: (*l_element_courant_ligne).suivant;
1316: }
1317:
1318: l_element_courant_ligne =
1319: (*l_element_courant_ligne).suivant;
1320: }
1321:
1322: (*l_element_courant_ligne).suivant = NULL;
1323:
1324: if (((*l_element_courant_ligne).donnee =
1325: allocation(s_etat_processus, CHN))
1326: == NULL)
1327: {
1328: (*s_etat_processus).erreur_systeme =
1329: d_es_allocation_memoire;
1330: return;
1331: }
1332:
1333: if (PQgetisnull(resultat_postgresql, i, j) != 0)
1334: {
1335: if (((*(*l_element_courant_ligne).donnee).objet
1336: = malloc(5 * sizeof(unsigned char)))
1337: == NULL)
1338: {
1339: (*s_etat_processus).erreur_systeme =
1340: d_es_allocation_memoire;
1341: return;
1342: }
1343:
1344: strcpy((unsigned char *)
1345: (*(*l_element_courant_ligne).donnee)
1346: .objet, "NULL");
1347: }
1348: else
1349: {
1350: if (((*(*l_element_courant_ligne).donnee).objet
1351: = malloc((PQgetlength(
1352: resultat_postgresql, i, j) + 1) *
1353: sizeof(unsigned char))) == NULL)
1354: {
1355: (*s_etat_processus).erreur_systeme =
1356: d_es_allocation_memoire;
1357: return;
1358: }
1359:
1360: strcpy((unsigned char *)
1361: (*(*l_element_courant_ligne).donnee)
1362: .objet, PQgetvalue(resultat_postgresql,
1363: i, j));
1364: }
1365: }
1366: }
1367:
1368: break;
1369: }
1370:
1371: case PGRES_EMPTY_QUERY :
1372: case PGRES_COPY_OUT :
1373: case PGRES_COPY_IN :
1374: case PGRES_BAD_RESPONSE :
1375: case PGRES_NONFATAL_ERROR :
1376: case PGRES_FATAL_ERROR :
1377: default :
1378: {
1379: printf("%s\n", PQresultErrorMessage(resultat_postgresql));
1380: PQclear(resultat_postgresql);
1381:
1382: if (connexion_permanente == d_faux)
1383: {
1384: PQfinish((*((struct_connecteur_sql *) (*s_objet_1)
1385: .objet)).descripteur.postgresql);
1386: }
1387:
1388: liberation(s_etat_processus, s_objet_1);
1389: liberation(s_etat_processus, s_objet_2);
1390:
1391: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1392:
1393: return;
1394: break;
1395: }
1396: }
1397:
1398: PQclear(resultat_postgresql);
1399:
1400: if (connexion_permanente == d_faux)
1401: {
1402: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet))
1403: .descripteur.postgresql);
1404: }
1405:
1406: if (presence_resultat == d_vrai)
1407: {
1408: if (empilement(s_etat_processus, &((*s_etat_processus)
1409: .l_base_pile), s_objet_resultat) == d_erreur)
1410: {
1411: return;
1412: }
1413: }
1414:
1415: # else
1416:
1417: if ((*s_etat_processus).langue == 'F')
1418: {
1419: printf("+++Attention : Support de PostgreSQL non compilé !\n");
1420: }
1421: else
1422: {
1423: printf("+++Warning : PostgreSQL support not available !\n");
1424: }
1425:
1426: fflush(stdout);
1427: # endif
1428: }
1429: else
1430: {
1431: liberation(s_etat_processus, s_objet_1);
1432: liberation(s_etat_processus, s_objet_2);
1433:
1434: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1435: return;
1436: }
1437: }
1438: else
1439: {
1440: liberation(s_etat_processus, s_objet_1);
1441: liberation(s_etat_processus, s_objet_2);
1442:
1443: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1444: return;
1445: }
1446:
1447: liberation(s_etat_processus, s_objet_1);
1448: liberation(s_etat_processus, s_objet_2);
1449:
1450: return;
1451: }
1452:
1453:
1454: /*
1455: ================================================================================
1456: Fonction 'stop'
1457: ================================================================================
1458: Entrées :
1459: --------------------------------------------------------------------------------
1460: Sorties :
1461: --------------------------------------------------------------------------------
1462: Effets de bord : néant
1463: ================================================================================
1464: */
1465:
1466: void
1467: instruction_stop(struct_processus *s_etat_processus)
1468: {
1469: struct_liste_chainee *l_element_courant;
1470:
1471: struct_objet *s_objet;
1472:
1473: struct timespec attente;
1474:
1475: attente.tv_sec = 0;
1476: attente.tv_nsec = GRANULARITE_us * 1000;
1477:
1478: (*s_etat_processus).erreur_execution = d_ex;
1479:
1480: if ((*s_etat_processus).affichage_arguments == 'Y')
1481: {
1482: printf("\n STOP ");
1483:
1484: if ((*s_etat_processus).langue == 'F')
1485: {
1486: printf("(arrêt d'un processus)\n\n");
1487: }
1488: else
1489: {
1490: printf("(kill process)\n\n");
1491: }
1492:
1493: printf(" 1: %s\n", d_PRC);
1494:
1495: return;
1496: }
1497: else if ((*s_etat_processus).test_instruction == 'Y')
1498: {
1499: (*s_etat_processus).nombre_arguments = -1;
1500: return;
1501: }
1502:
1503: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1504: {
1505: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1506: {
1507: return;
1508: }
1509: }
1510:
1511: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1512: &s_objet) == d_erreur)
1513: {
1514: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1515: return;
1516: }
1517:
1518: if ((*s_objet).type == PRC)
1519: {
1520: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1521: .processus_detache == d_vrai)
1522: {
1523: kill((*(*((struct_processus_fils *) (*s_objet).objet)).thread).pid,
1524: SIGFSTOP);
1525: }
1526: else
1527: {
1528: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
1529: {
1530: (*s_etat_processus).erreur_systeme = d_es_processus;
1531: return;
1532: }
1533:
1534: l_element_courant = (struct_liste_chainee *)
1535: (*s_etat_processus).l_base_pile_processus;
1536:
1537: while(l_element_courant != NULL)
1538: {
1539: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1540: .donnee).objet)).thread).processus_detache == d_faux)
1541: {
1542: if ((pthread_equal((*(*((struct_processus_fils *)
1.9 bertrand 1543: (*(*l_element_courant).donnee).objet)).thread).tid,
1.1 bertrand 1544: (*(*((struct_processus_fils *)
1545: (*s_objet).objet)).thread).tid) != 0) &&
1546: ((*(*((struct_processus_fils *)
1547: (*(*l_element_courant).donnee).objet)).thread).pid
1548: == (*(*((struct_processus_fils *)
1549: (*s_objet).objet)).thread).pid))
1550: {
1551: break;
1552: }
1553: }
1554:
1555: l_element_courant = (*l_element_courant).suivant;
1556: }
1557:
1558: if (l_element_courant != NULL)
1559: {
1560: // Le champ thread_actif est un pointeur sur un champ de la
1561: // structure s_argument_thread libéré par la fonction
1562: // retrait_thread_surveillance().
1563:
1564: if ((*(*((struct_processus_fils *)
1565: (*s_objet).objet)).thread).thread_actif == d_vrai)
1566: {
1567: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
1568: (*s_objet).objet)).thread).mutex)) != 0)
1569: {
1570: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
1571: != 0)
1572: {
1573: (*s_etat_processus).erreur_systeme = d_es_processus;
1574: return;
1575: }
1576:
1577: (*s_etat_processus).erreur_systeme = d_es_processus;
1578: return;
1579: }
1580:
1581: if ((*(*((struct_processus_fils *)
1582: (*s_objet).objet)).thread).thread_actif == d_vrai)
1583: {
1584: pthread_kill((*(*((struct_processus_fils *)
1585: (*s_objet).objet)).thread).tid, SIGFSTOP);
1586: }
1587:
1588: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
1589: (*s_objet).objet)).thread).mutex)) != 0)
1590: {
1591: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
1592: != 0)
1593: {
1594: (*s_etat_processus).erreur_systeme = d_es_processus;
1595: return;
1596: }
1597:
1598: (*s_etat_processus).erreur_systeme = d_es_processus;
1599: return;
1600: }
1601: }
1602: }
1603:
1604: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1605: {
1606: (*s_etat_processus).erreur_systeme = d_es_processus;
1607: return;
1608: }
1609: }
1610: }
1611: else
1612: {
1613: liberation(s_etat_processus, s_objet);
1614:
1615: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1616: return;
1617: }
1618:
1619: liberation(s_etat_processus, s_objet);
1620:
1621: return;
1622: }
1623:
1624: // vim: ts=4