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