File:
[local] /
rpl /
src /
instructions_s8.c
Revision
1.9:
download - view:
text,
annotated -
select for diffs -
revision graph
Thu Apr 29 07:30:57 2010 UTC (15 years ago) by
bertrand
Branches:
MAIN
CVS tags:
HEAD
Correction d'un point bloquant dans la gestion des processus
(affectation des interruptions logicielles survenant après l'arrêt du
processus père car le mutex de protection de la routine était déjà positionné
dans la fonction appelante). Ajout de la fonction CLRATEXIT.
1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.15
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:
23: #include "rpl.conv.h"
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:
250: # ifndef SEMAPHORES_NOMMES
251: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
252: {
253: (*s_etat_processus).erreur_systeme = d_es_processus;
254: return;
255: }
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
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: {
268: # ifndef SEMAPHORES_NOMMES
269: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
270: # else
271: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
272: # endif
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:
295: # ifndef SEMAPHORES_NOMMES
296: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
297: {
298: (*s_etat_processus).erreur_systeme = d_es_processus;
299: return;
300: }
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
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: {
319: # ifndef SEMAPHORES_NOMMES
320: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
321: # else
322: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
323: # endif
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:
346: # ifndef SEMAPHORES_NOMMES
347: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
348: # else
349: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
350: # endif
351: {
352: (*s_etat_processus).erreur_systeme = d_es_processus;
353: return;
354: }
355: }
356:
357: # ifndef SEMAPHORES_NOMMES
358: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
359: # else
360: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
361: # endif
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:
387: # ifndef SEMAPHORES_NOMMES
388: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
389: {
390: (*s_etat_processus).erreur_systeme = d_es_processus;
391: return;
392: }
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
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: {
405: # ifndef SEMAPHORES_NOMMES
406: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
407: # else
408: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
409: # endif
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:
432: # ifndef SEMAPHORES_NOMMES
433: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
434: {
435: (*s_etat_processus).erreur_systeme = d_es_processus;
436: return;
437: }
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
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: {
456: # ifndef SEMAPHORES_NOMMES
457: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
458: # else
459: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
460: # endif
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:
483: # ifndef SEMAPHORES_NOMMES
484: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
485: {
486: (*s_etat_processus).erreur_systeme = d_es_processus;
487: return;
488: }
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
496: }
497:
498: # ifndef SEMAPHORES_NOMMES
499: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
500: # else
501: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
502: # endif
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:
517: # ifndef SEMAPHORES_NOMMES
518: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
519: {
520: (*s_etat_processus).erreur_systeme = d_es_processus;
521: return;
522: }
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
530:
531: while(read_atomic(s_etat_processus, (*s_etat_processus).pipe_acquittement,
532: &tampon, sizeof(unsigned char)) != sizeof(unsigned char))
533: {
534: # ifndef SEMAPHORES_NOMMES
535: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
536: # else
537: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
538: # endif
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:
550: # ifndef SEMAPHORES_NOMMES
551: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
552: # else
553: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
554: # endif
555: {
556: (*s_etat_processus).erreur_systeme = d_es_processus;
557: return;
558: }
559: }
560:
561: # ifndef SEMAPHORES_NOMMES
562: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
563: # else
564: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
565: # endif
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:
584: # ifndef SEMAPHORES_NOMMES
585: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
586: # else
587: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
588: # endif
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: {
598: # ifndef SEMAPHORES_NOMMES
599: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
600: # else
601: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
602: # endif
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:
625: # ifndef SEMAPHORES_NOMMES
626: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
627: {
628: (*s_etat_processus).erreur_systeme = d_es_processus;
629: return;
630: }
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
638: }
639:
640: # ifndef SEMAPHORES_NOMMES
641: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
642: # else
643: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
644: # endif
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:
660: # ifndef SEMAPHORES_NOMMES
661: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
662: # else
663: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
664: # endif
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: {
674: # ifndef SEMAPHORES_NOMMES
675: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
676: # else
677: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
678: # endif
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:
701: # ifndef SEMAPHORES_NOMMES
702: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
703: # else
704: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
705: # endif
706: {
707: (*s_etat_processus).erreur_systeme = d_es_processus;
708: return;
709: }
710: }
711:
712: # ifndef SEMAPHORES_NOMMES
713: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
714: # else
715: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
716: # endif
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:
728: # ifndef SEMAPHORES_NOMMES
729: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
730: {
731: (*s_etat_processus).erreur_systeme = d_es_processus;
732: return;
733: }
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
741:
742: if (ecriture_pipe(s_etat_processus, (*s_etat_processus).pipe_donnees,
743: s_objet) == d_erreur)
744: {
745: # ifndef SEMAPHORES_NOMMES
746: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
747: # else
748: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
749: # endif
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:
767: # ifndef SEMAPHORES_NOMMES
768: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
769: # else
770: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
771: # endif
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 *)
1543: (*(*l_element_courant).donnee).objet)).thread).tid,
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
CVSweb interface <joel.bertrand@systella.fr>
![[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