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