![[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.91 ! bertrand 3: RPL/2 (R) version 4.1.35
! 4: Copyright (C) 1989-2023 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
1.86 bertrand 389: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1.38 bertrand 390: # else
1.86 bertrand 391: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
1.38 bertrand 392: # endif
1.1 bertrand 393: {
1.86 bertrand 394: if (errno != EINTR)
395: {
396: (*s_etat_processus).erreur_systeme = d_es_processus;
397: return;
398: }
1.1 bertrand 399: }
400: }
401:
402: (*s_etat_processus).nombre_objets_envoyes_non_lus++;
403:
404: attente.tv_sec = 0;
405: attente.tv_nsec = GRANULARITE_us * 1000;
406:
1.38 bertrand 407: # ifndef SEMAPHORES_NOMMES
408: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
409: # else
410: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
411: # endif
1.7 bertrand 412: {
413: (*s_etat_processus).erreur_systeme = d_es_processus;
414: return;
415: }
1.1 bertrand 416:
417: while(read_atomic(s_etat_processus, (*s_etat_processus).pipe_acquittement,
418: &tampon, sizeof(unsigned char)) != sizeof(unsigned char))
419: {
1.38 bertrand 420: # ifndef SEMAPHORES_NOMMES
421: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
422: # else
423: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
424: # endif
1.1 bertrand 425: {
1.37 bertrand 426: if (errno != EINTR)
427: {
428: (*s_etat_processus).erreur_systeme = d_es_processus;
429: return;
430: }
1.1 bertrand 431: }
432:
433: nanosleep(&attente, NULL);
434: INCR_GRANULARITE(attente.tv_nsec);
435:
1.38 bertrand 436: # ifndef SEMAPHORES_NOMMES
437: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
438: # else
439: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
440: # endif
1.1 bertrand 441: {
442: (*s_etat_processus).erreur_systeme = d_es_processus;
443: return;
444: }
1.35 bertrand 445:
446: scrutation_interruptions(s_etat_processus);
1.1 bertrand 447: }
448:
1.38 bertrand 449: # ifndef SEMAPHORES_NOMMES
450: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
451: # else
452: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
453: # endif
1.1 bertrand 454: {
1.37 bertrand 455: if (errno != EINTR)
456: {
457: (*s_etat_processus).erreur_systeme = d_es_processus;
458: return;
459: }
1.1 bertrand 460: }
461:
462: // ecriture_pipe() ne peut être interrompu par un signal.
463:
1.38 bertrand 464: # ifndef SEMAPHORES_NOMMES
465: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
466: # else
467: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
468: # endif
1.1 bertrand 469: {
470: (*s_etat_processus).erreur_systeme = d_es_processus;
471: return;
472: }
473:
474: if (ecriture_pipe(s_etat_processus, (*s_etat_processus).pipe_donnees,
475: s_objet) == d_erreur)
476: {
1.38 bertrand 477: # ifndef SEMAPHORES_NOMMES
478: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
479: # else
480: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
481: # endif
1.1 bertrand 482: {
1.37 bertrand 483: if (errno != EINTR)
484: {
485: (*s_etat_processus).erreur_systeme = d_es_processus;
486: return;
487: }
1.1 bertrand 488: }
489:
490: if ((*s_etat_processus).profilage == d_vrai)
491: {
492: profilage(s_etat_processus, NULL);
493: }
494:
495: liberation(s_etat_processus, s_objet);
496: return;
497: }
498:
1.38 bertrand 499: # ifndef SEMAPHORES_NOMMES
500: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
501: # else
502: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
503: # endif
1.1 bertrand 504: {
1.37 bertrand 505: if (errno != EINTR)
506: {
507: (*s_etat_processus).erreur_systeme = d_es_processus;
508: return;
509: }
1.1 bertrand 510: }
511:
512: if ((*s_etat_processus).profilage == d_vrai)
513: {
514: profilage(s_etat_processus, NULL);
515: }
516:
517: if (registre == 0)
518: {
519: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1)
520: {
521: (*s_etat_processus).var_volatile_requete_arret = -1;
522: }
523:
524: (*s_etat_processus).var_volatile_traitement_retarde_stop = registre;
525: }
526:
527: liberation(s_etat_processus, s_objet);
528: return;
529: }
530:
531:
532: /*
533: ================================================================================
534: Fonction 'sqlquery'
535: ================================================================================
536: Entrées :
537: --------------------------------------------------------------------------------
538: Sorties :
539: --------------------------------------------------------------------------------
540: Effets de bord : néant
541: ================================================================================
542: */
543:
544: void
545: instruction_sqlquery(struct_processus *s_etat_processus)
546: {
547: logical1 connexion_permanente;
548:
549: struct_objet *s_copie_1;
550: struct_objet *s_objet_1;
551: struct_objet *s_copie_2;
552: struct_objet *s_objet_2;
553:
554: unsigned char *tampon;
555:
556: (*s_etat_processus).erreur_execution = d_ex;
557:
558: if ((*s_etat_processus).affichage_arguments == 'Y')
559: {
560: printf("\n SQLQUERY ");
561:
562: if ((*s_etat_processus).langue == 'F')
563: {
564: printf("(requête SQL)\n\n");
565: }
566: else
567: {
568: printf("(SQL query)\n\n");
569: }
570:
571: printf(" 2: %s\n", d_CHN);
572: printf(" 1: %s\n", d_LST);
573: printf("-> 1: %s\n\n", d_LST);
574:
575: printf(" 2: %s\n", d_CHN);
576: printf(" 1: %s\n", d_SQL);
577: printf("-> 1: %s\n\n", d_LST);
578:
579: if ((*s_etat_processus).langue == 'F')
580: {
581: printf(" Utilisation :\n\n");
582: }
583: else
584: {
585: printf(" Usage:\n\n");
586: }
587:
588: printf(" \"select * from table\"\n");
589: printf(" { \"mysql\" \"server\" \"database\" "
590: "\"user\" \"password\" } SQLQUERY\n");
591: printf(" \"select field from table\"\n");
592: printf(" { \"postgresql:iso-8859-1\" \"server\" "
593: "\"database\" \"user\" \"password\" port }\n");
594: printf(" SQLQUERY\n");
1.53 bertrand 595: printf(" \"select * from table\"\n");
596: printf(" { \"sqlite\" \"file\" } SQLQUERY\n");
1.1 bertrand 597:
598: return;
599: }
600: else if ((*s_etat_processus).test_instruction == 'Y')
601: {
602: (*s_etat_processus).nombre_arguments = -1;
603: return;
604: }
605:
606: if (test_cfsf(s_etat_processus, 31) == d_vrai)
607: {
608: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
609: {
610: return;
611: }
612: }
613:
614: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
615: &s_objet_1) == d_erreur)
616: {
617: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
618: return;
619: }
620:
621: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
622: &s_objet_2) == d_erreur)
623: {
624: liberation(s_etat_processus, s_objet_1);
625:
626: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
627: return;
628: }
629:
630: if ((*s_objet_1).type == LST)
631: {
632: connexion_permanente = d_faux;
633:
634: s_copie_1 = s_objet_1;
635:
636: if ((s_objet_1 = parametres_sql(s_etat_processus, s_copie_1)) == NULL)
637: {
638: liberation(s_etat_processus, s_copie_1);
639: liberation(s_etat_processus, s_objet_2);
640: return;
641: }
642:
1.45 bertrand 643: if ((*s_etat_processus).erreur_execution ==
644: d_ex_instruction_indisponible)
645: {
646: liberation(s_etat_processus, s_objet_1);
647: liberation(s_etat_processus, s_objet_2);
648: liberation(s_etat_processus, s_copie_1);
649:
650: return;
651: }
652:
1.1 bertrand 653: liberation(s_etat_processus, s_copie_1);
654: }
655: else
656: {
657: if ((*s_objet_1).type == SQL)
658: {
659: if (((*((struct_connecteur_sql *) (*s_objet_1).objet)).pid !=
660: getpid()) || (pthread_equal((*((struct_connecteur_sql *)
661: (*s_objet_1).objet)).tid, pthread_self()) == 0))
662: {
663: (*s_etat_processus).erreur_execution =
664: d_ex_fichier_hors_contexte;
665:
666: liberation(s_etat_processus, s_objet_1);
667: liberation(s_etat_processus, s_objet_2);
668: return;
669: }
670: }
671:
672: connexion_permanente = d_vrai;
673: }
674:
675: if (((*s_objet_1).type == SQL) && ((*s_objet_2).type == CHN))
676: {
677: if ((*((struct_connecteur_sql *) (*s_objet_1).objet)).locale != NULL)
678: {
679: /*
680: * Transcodage de la commande SQL
681: */
682:
683: if ((s_copie_2 = copie_objet(s_etat_processus, s_objet_2, 'O'))
684: == NULL)
685: {
686: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
687: return;
688: }
689:
690: liberation(s_etat_processus, s_objet_2);
691: s_objet_2 = s_copie_2;
692:
693: tampon = (*s_objet_2).objet;
694:
695: if (((*s_objet_2).objet = transliteration(s_etat_processus, tampon,
696: (*((struct_connecteur_sql *) (*s_objet_1).objet)).locale,
697: d_locale)) == NULL)
698: {
699: return;
700: }
701:
702: free(tampon);
703: }
704:
705: /*
706: * Pilote MySQL
707: */
708:
709: if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
710: "MYSQL") == 0)
711: {
712: # ifdef MYSQL_SUPPORT
713:
1.40 bertrand 714: unsigned int i;
715: unsigned int nombre_colonnes;
716:
717: logical1 presence_resultat;
718:
719: MYSQL_RES *resultat_mysql;
720: MYSQL_ROW ligne;
721:
722: struct_objet *s_objet_resultat;
723:
724: struct_liste_chainee *l_element_courant;
725: struct_liste_chainee *l_element_courant_ligne;
1.1 bertrand 726:
727: if (mysql_real_query((*((struct_connecteur_sql *) (*s_objet_1)
728: .objet)).descripteur.mysql, (unsigned char *) (*s_objet_2)
729: .objet, strlen((unsigned char *) (*s_objet_2).objet)) != 0)
730: {
731: if (connexion_permanente == d_faux)
732: {
733: mysql_close((*((struct_connecteur_sql *) (*s_objet_1)
734: .objet)).descripteur.mysql);
735: }
736:
737: liberation(s_etat_processus, s_objet_1);
738: liberation(s_etat_processus, s_objet_2);
739:
740: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
741: return;
742: }
743:
744: if ((resultat_mysql = mysql_store_result(
745: (*((struct_connecteur_sql *) (*s_objet_1).objet))
746: .descripteur.mysql)) == NULL)
747: {
748: // La requête ne renvoie rien (exemple : INSERT)
749: presence_resultat = d_faux;
750: nombre_colonnes = 0;
751: }
752: else
753: {
754: // La requête renvoie une ou plusieurs valeurs.
755: presence_resultat = d_vrai;
756: nombre_colonnes = mysql_field_count((*((struct_connecteur_sql *)
757: (*s_objet_1).objet)).descripteur.mysql);
758: }
759:
760: if ((s_objet_resultat = allocation(s_etat_processus, LST))
761: == NULL)
762: {
763: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
764: return;
765: }
766:
767: (*s_objet_resultat).objet = NULL;
768: l_element_courant = (*s_objet_resultat).objet;
769:
770: while(((presence_resultat == d_vrai) ?
771: (ligne = mysql_fetch_row(resultat_mysql)) : NULL) != NULL)
772: {
773: unsigned long *longueurs;
774:
775: longueurs = mysql_fetch_lengths(resultat_mysql);
776:
777: if (l_element_courant == NULL)
778: {
779: if (((*s_objet_resultat).objet =
780: allocation_maillon(s_etat_processus)) == NULL)
781: {
782: (*s_etat_processus).erreur_systeme =
783: d_es_allocation_memoire;
784: return;
785: }
786:
787: l_element_courant = (struct_liste_chainee *)
788: (*s_objet_resultat).objet;
789: }
790: else
791: {
792: if (((*l_element_courant).suivant =
793: allocation_maillon(s_etat_processus)) == NULL)
794: {
795: (*s_etat_processus).erreur_systeme =
796: d_es_allocation_memoire;
797: return;
798: }
799:
800: l_element_courant = (*l_element_courant).suivant;
801: }
802:
803: (*l_element_courant).suivant = NULL;
804:
805: if (((*l_element_courant).donnee = allocation(s_etat_processus,
806: LST)) == NULL)
807: {
808: (*s_etat_processus).erreur_systeme =
809: d_es_allocation_memoire;
810: return;
811: }
812:
813: (*(*l_element_courant).donnee).objet = NULL;
814: l_element_courant_ligne = NULL;
815:
816: for(i = 0; i < nombre_colonnes; i++)
817: {
818: if (l_element_courant_ligne == NULL)
819: {
820: if (((*(*l_element_courant).donnee).objet =
821: allocation_maillon(s_etat_processus)) == NULL)
822: {
823: (*s_etat_processus).erreur_systeme =
824: d_es_allocation_memoire;
825: return;
826: }
827:
828: l_element_courant_ligne = (struct_liste_chainee *)
829: (*(*l_element_courant).donnee).objet;
830: }
831: else
832: {
833: if (((*l_element_courant_ligne).suivant =
834: allocation_maillon(s_etat_processus)) == NULL)
835: {
836: (*s_etat_processus).erreur_systeme =
837: d_es_allocation_memoire;
838: return;
839: }
840:
841: l_element_courant_ligne =
842: (*l_element_courant_ligne).suivant;
843: }
844:
845: (*l_element_courant_ligne).suivant = NULL;
846:
847: if (((*l_element_courant_ligne).donnee =
848: allocation(s_etat_processus, CHN)) == NULL)
849: {
850: (*s_etat_processus).erreur_systeme =
851: d_es_allocation_memoire;
852: return;
853: }
854:
855: if (ligne[i] == NULL)
856: {
857: if (((*(*l_element_courant_ligne).donnee).objet =
858: malloc(5 * sizeof(unsigned char))) == NULL)
859: {
860: (*s_etat_processus).erreur_systeme =
861: d_es_allocation_memoire;
862: return;
863: }
864:
865: strcpy((unsigned char *) (*(*l_element_courant_ligne)
866: .donnee).objet, "NULL");
867: }
868: else
869: {
870: if (((*(*l_element_courant_ligne).donnee).objet =
871: malloc((longueurs[i] + 1) *
872: sizeof(unsigned char))) == NULL)
873: {
874: (*s_etat_processus).erreur_systeme =
875: d_es_allocation_memoire;
876: return;
877: }
878:
879: strcpy((unsigned char *) (*(*l_element_courant_ligne)
880: .donnee).objet, ligne[i]);
881: }
882: }
883: }
884:
885: mysql_free_result(resultat_mysql);
886:
887: if (connexion_permanente == d_faux)
888: {
889: mysql_close((*((struct_connecteur_sql *) (*s_objet_1).objet))
890: .descripteur.mysql);
891: }
892:
1.74 bertrand 893: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
894: s_objet_resultat) == d_erreur)
1.1 bertrand 895: {
1.74 bertrand 896: return;
1.1 bertrand 897: }
898:
899: # else
900:
901: if ((*s_etat_processus).langue == 'F')
902: {
903: printf("+++Attention : Support de MySQL non compilé !\n");
904: }
905: else
906: {
907: printf("+++Warning : MySQL support not available !\n");
908: }
909:
910: fflush(stdout);
911: # endif
912: }
913:
914: /*
915: * Pilote PostgreSQL
916: */
917:
918: else if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
919: "POSTGRESQL") == 0)
920: {
921: # ifdef POSTGRESQL_SUPPORT
922:
1.57 bertrand 923: int i;
924: int j;
925: int nombre_colonnes;
926: int nombre_lignes;
1.40 bertrand 927:
928: logical1 presence_resultat;
929:
930: PGresult *resultat_postgresql;
931:
932: struct_objet *s_objet_resultat;
933:
934: struct_liste_chainee *l_element_courant;
935: struct_liste_chainee *l_element_courant_ligne;
1.1 bertrand 936:
937: if (PQstatus((*((struct_connecteur_sql *) (*s_objet_1).objet))
938: .descripteur.postgresql) != CONNECTION_OK)
939: {
940: if (connexion_permanente == d_faux)
941: {
942: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet))
943: .descripteur.postgresql);
944: }
945:
946: liberation(s_etat_processus, s_objet_1);
947: liberation(s_etat_processus, s_objet_2);
948:
949: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
950: return;
951: }
952:
953: resultat_postgresql = PQexec((*((struct_connecteur_sql *)
954: (*s_objet_1).objet)).descripteur.postgresql,
955: (unsigned char *) (*s_objet_2).objet);
956: presence_resultat = d_faux;
957:
958: switch(PQresultStatus(resultat_postgresql))
959: {
960: case PGRES_COMMAND_OK :
961: { // Commande qui ne renvoit rien
962: if ((s_objet_resultat = allocation(s_etat_processus, LST))
963: == NULL)
964: {
965: (*s_etat_processus).erreur_systeme =
966: d_es_allocation_memoire;
967: return;
968: }
969:
970: (*s_objet_resultat).objet = NULL;
971: l_element_courant = (*s_objet_resultat).objet;
972: presence_resultat = d_vrai;
973:
974: break;
975: }
976:
977: case PGRES_TUPLES_OK :
978: { // Commande renvoyant des données
979: if ((s_objet_resultat = allocation(s_etat_processus, LST))
980: == NULL)
981: {
982: (*s_etat_processus).erreur_systeme =
983: d_es_allocation_memoire;
984: return;
985: }
986:
987: (*s_objet_resultat).objet = NULL;
988: l_element_courant = (*s_objet_resultat).objet;
989: presence_resultat = d_vrai;
990:
991: nombre_colonnes = PQnfields(resultat_postgresql);
992: nombre_lignes = PQntuples(resultat_postgresql);
993:
994: for(i = 0; i < nombre_lignes; i++)
995: {
996: // Chaînage d'un nouveau maillon de la liste résultat
997:
998: if (l_element_courant == NULL)
999: {
1000: if (((*s_objet_resultat).objet =
1001: allocation_maillon(s_etat_processus))
1002: == NULL)
1003: {
1004: (*s_etat_processus).erreur_systeme =
1005: d_es_allocation_memoire;
1006: return;
1007: }
1008:
1009: l_element_courant = (struct_liste_chainee *)
1010: (*s_objet_resultat).objet;
1011: }
1012: else
1013: {
1014: if (((*l_element_courant).suivant =
1015: allocation_maillon(s_etat_processus))
1016: == NULL)
1017: {
1018: (*s_etat_processus).erreur_systeme =
1019: d_es_allocation_memoire;
1020: return;
1021: }
1022:
1023: l_element_courant = (*l_element_courant).suivant;
1024: }
1025:
1026: (*l_element_courant).suivant = NULL;
1027:
1028: // Création de la liste fille
1029:
1030: if (((*l_element_courant).donnee =
1031: allocation(s_etat_processus, LST)) == NULL)
1032: {
1033: (*s_etat_processus).erreur_systeme =
1034: d_es_allocation_memoire;
1035: return;
1036: }
1037:
1038: (*(*l_element_courant).donnee).objet = NULL;
1039: l_element_courant_ligne = NULL;
1040:
1041: for(j = 0; j < nombre_colonnes; j++)
1042: {
1043: if (l_element_courant_ligne == NULL)
1044: {
1045: if (((*(*l_element_courant).donnee).objet =
1046: allocation_maillon(s_etat_processus))
1047: == NULL)
1048: {
1049: (*s_etat_processus).erreur_systeme =
1050: d_es_allocation_memoire;
1051: return;
1052: }
1053:
1054: l_element_courant_ligne =
1055: (struct_liste_chainee *)
1056: (*(*l_element_courant).donnee).objet;
1057: }
1058: else
1059: {
1060: if (((*l_element_courant_ligne).suivant =
1061: allocation_maillon(s_etat_processus))
1062: == NULL)
1063: {
1064: l_element_courant_ligne =
1065: (*l_element_courant_ligne).suivant;
1066: }
1067:
1068: l_element_courant_ligne =
1069: (*l_element_courant_ligne).suivant;
1070: }
1071:
1072: (*l_element_courant_ligne).suivant = NULL;
1073:
1074: if (((*l_element_courant_ligne).donnee =
1075: allocation(s_etat_processus, CHN))
1076: == NULL)
1077: {
1078: (*s_etat_processus).erreur_systeme =
1079: d_es_allocation_memoire;
1080: return;
1081: }
1082:
1083: if (PQgetisnull(resultat_postgresql, i, j) != 0)
1084: {
1085: if (((*(*l_element_courant_ligne).donnee).objet
1086: = malloc(5 * sizeof(unsigned char)))
1087: == NULL)
1088: {
1089: (*s_etat_processus).erreur_systeme =
1090: d_es_allocation_memoire;
1091: return;
1092: }
1093:
1094: strcpy((unsigned char *)
1095: (*(*l_element_courant_ligne).donnee)
1096: .objet, "NULL");
1097: }
1098: else
1099: {
1100: if (((*(*l_element_courant_ligne).donnee).objet
1.57 bertrand 1101: = malloc(((size_t) (PQgetlength(
1102: resultat_postgresql, i, j) + 1)) *
1.1 bertrand 1103: sizeof(unsigned char))) == NULL)
1104: {
1105: (*s_etat_processus).erreur_systeme =
1106: d_es_allocation_memoire;
1107: return;
1108: }
1109:
1110: strcpy((unsigned char *)
1111: (*(*l_element_courant_ligne).donnee)
1112: .objet, PQgetvalue(resultat_postgresql,
1113: i, j));
1114: }
1115: }
1116: }
1117:
1118: break;
1119: }
1120:
1121: case PGRES_EMPTY_QUERY :
1122: case PGRES_COPY_OUT :
1123: case PGRES_COPY_IN :
1124: case PGRES_BAD_RESPONSE :
1125: case PGRES_NONFATAL_ERROR :
1126: case PGRES_FATAL_ERROR :
1127: default :
1128: {
1129: printf("%s\n", PQresultErrorMessage(resultat_postgresql));
1130: PQclear(resultat_postgresql);
1131:
1132: if (connexion_permanente == d_faux)
1133: {
1134: PQfinish((*((struct_connecteur_sql *) (*s_objet_1)
1135: .objet)).descripteur.postgresql);
1136: }
1137:
1138: liberation(s_etat_processus, s_objet_1);
1139: liberation(s_etat_processus, s_objet_2);
1140:
1141: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1142:
1143: return;
1144: break;
1145: }
1146: }
1147:
1148: PQclear(resultat_postgresql);
1149:
1150: if (connexion_permanente == d_faux)
1151: {
1152: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet))
1153: .descripteur.postgresql);
1154: }
1155:
1156: if (presence_resultat == d_vrai)
1157: {
1158: if (empilement(s_etat_processus, &((*s_etat_processus)
1159: .l_base_pile), s_objet_resultat) == d_erreur)
1160: {
1161: return;
1162: }
1163: }
1164:
1165: # else
1166:
1167: if ((*s_etat_processus).langue == 'F')
1168: {
1169: printf("+++Attention : Support de PostgreSQL non compilé !\n");
1170: }
1171: else
1172: {
1173: printf("+++Warning : PostgreSQL support not available !\n");
1174: }
1175:
1176: fflush(stdout);
1177: # endif
1178: }
1.53 bertrand 1179: else if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
1180: "SQLITE") == 0)
1181: {
1182: const char *queue;
1183: const unsigned char *resultat;
1184:
1.57 bertrand 1185: int i;
1.53 bertrand 1186: int ios;
1.57 bertrand 1187: int nombre_colonnes;
1.53 bertrand 1188:
1189: sqlite3_stmt *ppStmt;
1190:
1191: struct_liste_chainee *l_element_courant;
1192: struct_liste_chainee *l_element_courant_ligne;
1193:
1194: struct_objet *s_objet_resultat;
1195:
1.54 bertrand 1196: struct timespec attente;
1197:
1.53 bertrand 1198: if (sqlite3_prepare_v2((*((struct_connecteur_sql *)
1199: (*s_objet_1).objet)).descripteur.sqlite,
1200: (unsigned char *) (*s_objet_2).objet,
1.57 bertrand 1201: (int) strlen((unsigned char *) (*s_objet_2).objet),
1.53 bertrand 1202: &ppStmt, &queue) != SQLITE_OK)
1203: {
1204: if (connexion_permanente == d_faux)
1205: {
1206: sqlite3_close((*((struct_connecteur_sql *)
1207: (*s_objet_1).objet)).descripteur.sqlite);
1208: }
1209:
1210: liberation(s_etat_processus, s_objet_1);
1211: liberation(s_etat_processus, s_objet_2);
1212:
1213: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1214: return;
1215: }
1216:
1217: s_objet_resultat = NULL;
1218: l_element_courant = NULL;
1219:
1.54 bertrand 1220: attente.tv_sec = 0;
1221: attente.tv_nsec = GRANULARITE_us * 1000;
1222:
1.74 bertrand 1223: if ((s_objet_resultat =
1224: allocation(s_etat_processus, LST)) == NULL)
1225: {
1226: (*s_etat_processus).erreur_systeme =
1227: d_es_allocation_memoire;
1228: return;
1229: }
1230:
1231: // Création d'une liste vide
1232:
1233: (*s_objet_resultat).objet = NULL;
1234: l_element_courant = (*s_objet_resultat).objet;
1235:
1.53 bertrand 1236: do
1237: {
1238: switch(ios = sqlite3_step(ppStmt))
1239: {
1240: case SQLITE_ROW:
1241: {
1242: // Ajout d'une liste au bout de la liste
1243: // contenant les lignes
1244:
1245: if (l_element_courant == NULL)
1246: {
1247: if (((*s_objet_resultat).objet =
1248: allocation_maillon(s_etat_processus))
1249: == NULL)
1250: {
1251: (*s_etat_processus).erreur_systeme =
1252: d_es_allocation_memoire;
1253: }
1254:
1255: l_element_courant = (struct_liste_chainee *)
1256: (*s_objet_resultat).objet;
1257: }
1258: else
1259: {
1260: if (((*l_element_courant).suivant =
1261: allocation_maillon(s_etat_processus))
1262: == NULL)
1263: {
1264: (*s_etat_processus).erreur_systeme =
1265: d_es_allocation_memoire;
1266: return;
1267: }
1268:
1269: l_element_courant = (*l_element_courant).suivant;
1270: }
1271:
1272: (*l_element_courant).suivant = NULL;
1273:
1274: // Création de la liste fille
1275:
1276: if (((*l_element_courant).donnee =
1277: allocation(s_etat_processus, LST)) == NULL)
1278: {
1279: (*s_etat_processus).erreur_systeme =
1280: d_es_allocation_memoire;
1281: return;
1282: }
1283:
1284: (*(*l_element_courant).donnee).objet = NULL;
1285:
1286: // Lecture de la ligne
1287:
1288: nombre_colonnes = sqlite3_data_count(ppStmt);
1289: l_element_courant_ligne = NULL;
1290:
1291: for(i = 0; i < nombre_colonnes; i++)
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 (sqlite3_column_type(ppStmt, i) == SQLITE_NULL)
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 ((resultat = sqlite3_column_text(ppStmt, i))
1351: == NULL)
1352: {
1353: (*s_etat_processus).erreur_systeme =
1354: d_es_allocation_memoire;
1355: return;
1356: }
1357:
1358: if (((*(*l_element_courant_ligne).donnee).objet
1359: = malloc((strlen(resultat) + 1 ) *
1360: sizeof(unsigned char))) == NULL)
1361: {
1362: (*s_etat_processus).erreur_systeme =
1363: d_es_allocation_memoire;
1364: return;
1365: }
1366:
1367: strcpy((unsigned char *)
1368: (*(*l_element_courant_ligne).donnee)
1369: .objet, resultat);
1370: }
1371: }
1372:
1373: break;
1374: }
1375:
1376: case SQLITE_DONE:
1377: {
1378: // Fin de la lecture des données
1379: break;
1380: }
1381:
1.54 bertrand 1382: case SQLITE_BUSY:
1383: case SQLITE_LOCKED:
1384: {
1385: nanosleep(&attente, NULL);
1386: INCR_GRANULARITE(attente.tv_nsec);
1387: break;
1388: }
1389:
1.53 bertrand 1390: default:
1391: {
1392: (*s_etat_processus).erreur_systeme =
1393: d_es_erreur_fichier;
1394: return;
1395: }
1396: }
1397: } while(ios != SQLITE_DONE);
1398:
1399: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1400: {
1401: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1402: return;
1403: }
1404:
1405: if (connexion_permanente == d_faux)
1406: {
1407: sqlite3_close((*((struct_connecteur_sql *) (*s_objet_1).objet))
1408: .descripteur.sqlite);
1409: }
1410:
1.74 bertrand 1411: if (empilement(s_etat_processus, &((*s_etat_processus)
1412: .l_base_pile), s_objet_resultat) == d_erreur)
1.53 bertrand 1413: {
1.74 bertrand 1414: return;
1.53 bertrand 1415: }
1416: }
1.1 bertrand 1417: else
1418: {
1419: liberation(s_etat_processus, s_objet_1);
1420: liberation(s_etat_processus, s_objet_2);
1421:
1422: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1423: return;
1424: }
1425: }
1426: else
1427: {
1428: liberation(s_etat_processus, s_objet_1);
1429: liberation(s_etat_processus, s_objet_2);
1430:
1431: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1432: return;
1433: }
1434:
1435: liberation(s_etat_processus, s_objet_1);
1436: liberation(s_etat_processus, s_objet_2);
1437:
1438: return;
1439: }
1440:
1441:
1442: /*
1443: ================================================================================
1444: Fonction 'stop'
1445: ================================================================================
1446: Entrées :
1447: --------------------------------------------------------------------------------
1448: Sorties :
1449: --------------------------------------------------------------------------------
1450: Effets de bord : néant
1451: ================================================================================
1452: */
1453:
1454: void
1455: instruction_stop(struct_processus *s_etat_processus)
1456: {
1457: struct_liste_chainee *l_element_courant;
1458:
1459: struct_objet *s_objet;
1460:
1461: (*s_etat_processus).erreur_execution = d_ex;
1462:
1463: if ((*s_etat_processus).affichage_arguments == 'Y')
1464: {
1465: printf("\n STOP ");
1466:
1467: if ((*s_etat_processus).langue == 'F')
1468: {
1469: printf("(arrêt d'un processus)\n\n");
1470: }
1471: else
1472: {
1473: printf("(kill process)\n\n");
1474: }
1475:
1476: printf(" 1: %s\n", d_PRC);
1477:
1478: return;
1479: }
1480: else if ((*s_etat_processus).test_instruction == 'Y')
1481: {
1482: (*s_etat_processus).nombre_arguments = -1;
1483: return;
1484: }
1485:
1486: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1487: {
1488: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1489: {
1490: return;
1491: }
1492: }
1493:
1494: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1495: &s_objet) == d_erreur)
1496: {
1497: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1498: return;
1499: }
1500:
1501: if ((*s_objet).type == PRC)
1502: {
1503: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1504: .processus_detache == d_vrai)
1505: {
1.33 bertrand 1506: envoi_signal_processus((*(*((struct_processus_fils *)
1.75 bertrand 1507: (*s_objet).objet)).thread).pid, rpl_sigstop, d_faux);
1.1 bertrand 1508: }
1509: else
1510: {
1.60 bertrand 1511: if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus))
1512: != 0)
1.1 bertrand 1513: {
1514: (*s_etat_processus).erreur_systeme = d_es_processus;
1515: return;
1516: }
1517:
1518: l_element_courant = (struct_liste_chainee *)
1519: (*s_etat_processus).l_base_pile_processus;
1520:
1521: while(l_element_courant != NULL)
1522: {
1523: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1524: .donnee).objet)).thread).processus_detache == d_faux)
1525: {
1526: if ((pthread_equal((*(*((struct_processus_fils *)
1.9 bertrand 1527: (*(*l_element_courant).donnee).objet)).thread).tid,
1.1 bertrand 1528: (*(*((struct_processus_fils *)
1529: (*s_objet).objet)).thread).tid) != 0) &&
1530: ((*(*((struct_processus_fils *)
1531: (*(*l_element_courant).donnee).objet)).thread).pid
1532: == (*(*((struct_processus_fils *)
1533: (*s_objet).objet)).thread).pid))
1534: {
1535: break;
1536: }
1537: }
1538:
1539: l_element_courant = (*l_element_courant).suivant;
1540: }
1541:
1542: if (l_element_courant != NULL)
1543: {
1544: // Le champ thread_actif est un pointeur sur un champ de la
1545: // structure s_argument_thread libéré par la fonction
1546: // retrait_thread_surveillance().
1547:
1548: if ((*(*((struct_processus_fils *)
1549: (*s_objet).objet)).thread).thread_actif == d_vrai)
1550: {
1551: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
1552: (*s_objet).objet)).thread).mutex)) != 0)
1553: {
1.60 bertrand 1554: if (pthread_mutex_unlock(&((*s_etat_processus)
1555: .mutex_pile_processus)) != 0)
1.1 bertrand 1556: {
1557: (*s_etat_processus).erreur_systeme = d_es_processus;
1558: return;
1559: }
1560:
1561: (*s_etat_processus).erreur_systeme = d_es_processus;
1562: return;
1563: }
1564:
1565: if ((*(*((struct_processus_fils *)
1566: (*s_objet).objet)).thread).thread_actif == d_vrai)
1567: {
1.86 bertrand 1568: envoi_signal_thread(s_etat_processus,
1569: (*(*((struct_processus_fils *)
1.33 bertrand 1570: (*s_objet).objet)).thread).tid, rpl_sigstop);
1.1 bertrand 1571: }
1572:
1573: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
1574: (*s_objet).objet)).thread).mutex)) != 0)
1575: {
1.60 bertrand 1576: if (pthread_mutex_unlock(&((*s_etat_processus)
1577: .mutex_pile_processus)) != 0)
1.1 bertrand 1578: {
1579: (*s_etat_processus).erreur_systeme = d_es_processus;
1580: return;
1581: }
1582:
1583: (*s_etat_processus).erreur_systeme = d_es_processus;
1584: return;
1585: }
1586: }
1587: }
1588:
1.60 bertrand 1589: if (pthread_mutex_unlock(&((*s_etat_processus)
1590: .mutex_pile_processus)) != 0)
1.1 bertrand 1591: {
1592: (*s_etat_processus).erreur_systeme = d_es_processus;
1593: return;
1594: }
1595: }
1596: }
1597: else
1598: {
1599: liberation(s_etat_processus, s_objet);
1600:
1601: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1602: return;
1603: }
1604:
1605: liberation(s_etat_processus, s_objet);
1606:
1607: return;
1608: }
1609:
1610: // vim: ts=4