![[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.51 bertrand 3: RPL/2 (R) version 4.1.12
1.55 ! bertrand 4: Copyright (C) 1989-2013 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:
105: encart(s_etat_processus, (unsigned long) (attente * 1E6));
106: }
107: else
108: {
109: liberation(s_etat_processus, s_objet);
110:
111: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
112: return;
113: }
114:
115: liberation(s_etat_processus, s_objet);
116:
117: return;
118: }
119:
120:
121: /*
122: ================================================================================
123: Fonction 'send'
124: ================================================================================
125: Entrées :
126: --------------------------------------------------------------------------------
127: Sorties :
128: --------------------------------------------------------------------------------
129: Effets de bord : néant
130: ================================================================================
131: */
132:
133: void
134: instruction_send(struct_processus *s_etat_processus)
135: {
136: pid_t pid;
137:
138: pthread_t tid;
139:
140: sig_atomic_t registre;
141:
142: ssize_t longueur_ecriture;
143:
144: struct_objet *s_objet;
145:
146: struct timespec attente;
147:
148: unsigned char tampon;
149:
150: (*s_etat_processus).erreur_execution = d_ex;
151:
152: if ((*s_etat_processus).affichage_arguments == 'Y')
153: {
154: printf("\n SEND ");
155:
156: if ((*s_etat_processus).langue == 'F')
157: {
158: printf("(envoi de données au processus père)\n\n");
159: }
160: else
161: {
162: printf("(send data to parent process)\n\n");
163: }
164:
165: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
166: " %s, %s, %s, %s, %s,\n"
167: " %s, %s, %s, %s, %s\n",
168: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
169: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_TAB);
170:
171: return;
172: }
173: else if ((*s_etat_processus).test_instruction == 'Y')
174: {
175: (*s_etat_processus).nombre_arguments = -1;
176: return;
177: }
178:
179: if (test_cfsf(s_etat_processus, 31) == d_vrai)
180: {
181: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
182: {
183: return;
184: }
185: }
186:
187: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
188: &s_objet) == d_erreur)
189: {
190: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
191: return;
192: }
193:
194: if ((*s_etat_processus).presence_pipes == d_faux)
195: {
196: liberation(s_etat_processus, s_objet);
197:
198: (*s_etat_processus).erreur_execution = d_ex_absence_processus_pere;
199: return;
200: }
201:
202: if (((*s_objet).type != INT) &&
203: ((*s_objet).type != REL) &&
204: ((*s_objet).type != CPL) &&
205: ((*s_objet).type != VIN) &&
206: ((*s_objet).type != VRL) &&
207: ((*s_objet).type != VCX) &&
208: ((*s_objet).type != MIN) &&
209: ((*s_objet).type != MRL) &&
210: ((*s_objet).type != MCX) &&
211: ((*s_objet).type != BIN) &&
212: ((*s_objet).type != NOM) &&
213: ((*s_objet).type != CHN) &&
214: ((*s_objet).type != LST) &&
215: ((*s_objet).type != ALG) &&
216: ((*s_objet).type != RPN) &&
217: ((*s_objet).type != TBL))
218: {
219: liberation(s_etat_processus, s_objet);
220:
221: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
222: return;
223: }
224:
225: /*
226: * On signale au processus père qu'il y a un objet de plus
227: * dans le pipe de données.
228: */
229:
230: registre = (*s_etat_processus).var_volatile_traitement_retarde_stop;
231: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
232:
233: if ((*s_etat_processus).processus_detache == d_vrai)
234: {
235: if ((*s_etat_processus).profilage == d_vrai)
236: {
237: profilage(s_etat_processus, "Interprocess communications (SEND)");
238:
239: if ((*s_etat_processus).erreur_systeme != d_es)
240: {
241: return;
242: }
243: }
244:
245: pid = -3;
246:
247: attente.tv_sec = 0;
248: attente.tv_nsec = GRANULARITE_us * 1000;
249:
1.38 bertrand 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
1.1 bertrand 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: {
1.38 bertrand 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
1.1 bertrand 269: {
1.37 bertrand 270: if (errno != EINTR)
271: {
272: (*s_etat_processus).erreur_systeme = d_es_processus;
273: return;
274: }
1.1 bertrand 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:
1.38 bertrand 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
1.7 bertrand 296: {
297: (*s_etat_processus).erreur_systeme = d_es_processus;
298: return;
299: }
1.35 bertrand 300:
301: scrutation_interruptions(s_etat_processus);
1.1 bertrand 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: {
1.38 bertrand 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
1.1 bertrand 318: {
1.37 bertrand 319: if (errno != EINTR)
320: {
321: (*s_etat_processus).erreur_systeme = d_es_processus;
322: return;
323: }
1.1 bertrand 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:
1.38 bertrand 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
1.1 bertrand 345: {
346: (*s_etat_processus).erreur_systeme = d_es_processus;
347: return;
348: }
1.35 bertrand 349:
350: scrutation_interruptions(s_etat_processus);
1.1 bertrand 351: }
352:
1.38 bertrand 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
1.1 bertrand 358: {
1.37 bertrand 359: if (errno != EINTR)
360: {
361: (*s_etat_processus).erreur_systeme = d_es_processus;
362: return;
363: }
1.1 bertrand 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:
1.48 bertrand 378: tid = (pthread_t) -3;
1.1 bertrand 379:
380: attente.tv_sec = 0;
381: attente.tv_nsec = GRANULARITE_us * 1000;
382:
1.38 bertrand 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
1.1 bertrand 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: {
1.38 bertrand 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
1.1 bertrand 402: {
1.34 bertrand 403: (*s_etat_processus).erreur_systeme = d_es_processus;
404: return;
1.1 bertrand 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:
1.38 bertrand 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
1.1 bertrand 426: {
427: (*s_etat_processus).erreur_systeme = d_es_processus;
428: return;
429: }
1.35 bertrand 430:
431: scrutation_interruptions(s_etat_processus);
1.1 bertrand 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: {
1.38 bertrand 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
1.1 bertrand 448: {
1.37 bertrand 449: if (errno != EINTR)
450: {
451: (*s_etat_processus).erreur_systeme = d_es_processus;
452: return;
453: }
1.1 bertrand 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:
1.38 bertrand 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
1.7 bertrand 475: {
476: (*s_etat_processus).erreur_systeme = d_es_processus;
477: return;
478: }
1.35 bertrand 479:
480: scrutation_interruptions(s_etat_processus);
1.1 bertrand 481: }
482:
1.38 bertrand 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
1.1 bertrand 488: {
1.34 bertrand 489: (*s_etat_processus).erreur_systeme = d_es_processus;
490: return;
1.1 bertrand 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:
1.38 bertrand 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
1.7 bertrand 504: {
505: (*s_etat_processus).erreur_systeme = d_es_processus;
506: return;
507: }
1.1 bertrand 508:
509: while(read_atomic(s_etat_processus, (*s_etat_processus).pipe_acquittement,
510: &tampon, sizeof(unsigned char)) != sizeof(unsigned char))
511: {
1.38 bertrand 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
1.1 bertrand 517: {
1.37 bertrand 518: if (errno != EINTR)
519: {
520: (*s_etat_processus).erreur_systeme = d_es_processus;
521: return;
522: }
1.1 bertrand 523: }
524:
525: nanosleep(&attente, NULL);
526: INCR_GRANULARITE(attente.tv_nsec);
527:
1.38 bertrand 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
1.1 bertrand 533: {
534: (*s_etat_processus).erreur_systeme = d_es_processus;
535: return;
536: }
1.35 bertrand 537:
538: scrutation_interruptions(s_etat_processus);
1.1 bertrand 539: }
540:
1.38 bertrand 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
1.1 bertrand 546: {
1.37 bertrand 547: if (errno != EINTR)
548: {
549: (*s_etat_processus).erreur_systeme = d_es_processus;
550: return;
551: }
1.1 bertrand 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:
1.38 bertrand 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
1.1 bertrand 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: {
1.38 bertrand 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
1.1 bertrand 583: {
1.34 bertrand 584: (*s_etat_processus).erreur_systeme = d_es_processus;
585: return;
1.1 bertrand 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:
1.38 bertrand 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
1.1 bertrand 607: {
608: (*s_etat_processus).erreur_systeme = d_es_processus;
609: return;
610: }
611: }
612:
1.38 bertrand 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
1.1 bertrand 618: {
1.37 bertrand 619: if (errno != EINTR)
620: {
621: (*s_etat_processus).erreur_systeme = d_es_processus;
622: return;
623: }
1.1 bertrand 624: }
1.35 bertrand 625:
626: scrutation_interruptions(s_etat_processus);
1.1 bertrand 627: }
628: else
629: {
1.48 bertrand 630: tid = (pthread_t) -1;
1.1 bertrand 631:
632: attente.tv_sec = 0;
633: attente.tv_nsec = GRANULARITE_us * 1000;
634:
1.38 bertrand 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
1.1 bertrand 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: {
1.38 bertrand 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
1.1 bertrand 654: {
1.37 bertrand 655: if (errno != EINTR)
656: {
657: (*s_etat_processus).erreur_systeme = d_es_processus;
658: return;
659: }
1.1 bertrand 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:
1.38 bertrand 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
1.1 bertrand 681: {
682: (*s_etat_processus).erreur_systeme = d_es_processus;
683: return;
684: }
1.35 bertrand 685:
686: scrutation_interruptions(s_etat_processus);
1.1 bertrand 687: }
688:
1.38 bertrand 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
1.1 bertrand 694: {
1.37 bertrand 695: if (errno != EINTR)
696: {
697: (*s_etat_processus).erreur_systeme = d_es_processus;
698: return;
699: }
1.1 bertrand 700: }
701: }
702:
703: // ecriture_pipe() ne peut être interrompu par un signal.
704:
1.38 bertrand 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
1.1 bertrand 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: {
1.38 bertrand 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
1.1 bertrand 723: {
1.37 bertrand 724: if (errno != EINTR)
725: {
726: (*s_etat_processus).erreur_systeme = d_es_processus;
727: return;
728: }
1.1 bertrand 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:
1.38 bertrand 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
1.1 bertrand 745: {
1.37 bertrand 746: if (errno != EINTR)
747: {
748: (*s_etat_processus).erreur_systeme = d_es_processus;
749: return;
750: }
1.1 bertrand 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: logical1 connexion_permanente;
789:
790: struct_objet *s_copie_1;
791: struct_objet *s_objet_1;
792: struct_objet *s_copie_2;
793: struct_objet *s_objet_2;
794:
795: unsigned char *tampon;
796:
797: (*s_etat_processus).erreur_execution = d_ex;
798:
799: if ((*s_etat_processus).affichage_arguments == 'Y')
800: {
801: printf("\n SQLQUERY ");
802:
803: if ((*s_etat_processus).langue == 'F')
804: {
805: printf("(requête SQL)\n\n");
806: }
807: else
808: {
809: printf("(SQL query)\n\n");
810: }
811:
812: printf(" 2: %s\n", d_CHN);
813: printf(" 1: %s\n", d_LST);
814: printf("-> 1: %s\n\n", d_LST);
815:
816: printf(" 2: %s\n", d_CHN);
817: printf(" 1: %s\n", d_SQL);
818: printf("-> 1: %s\n\n", d_LST);
819:
820: if ((*s_etat_processus).langue == 'F')
821: {
822: printf(" Utilisation :\n\n");
823: }
824: else
825: {
826: printf(" Usage:\n\n");
827: }
828:
829: printf(" \"select * from table\"\n");
830: printf(" { \"mysql\" \"server\" \"database\" "
831: "\"user\" \"password\" } SQLQUERY\n");
832: printf(" \"select field from table\"\n");
833: printf(" { \"postgresql:iso-8859-1\" \"server\" "
834: "\"database\" \"user\" \"password\" port }\n");
835: printf(" SQLQUERY\n");
1.53 bertrand 836: printf(" \"select * from table\"\n");
837: printf(" { \"sqlite\" \"file\" } SQLQUERY\n");
1.1 bertrand 838:
839: return;
840: }
841: else if ((*s_etat_processus).test_instruction == 'Y')
842: {
843: (*s_etat_processus).nombre_arguments = -1;
844: return;
845: }
846:
847: if (test_cfsf(s_etat_processus, 31) == d_vrai)
848: {
849: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
850: {
851: return;
852: }
853: }
854:
855: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
856: &s_objet_1) == d_erreur)
857: {
858: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
859: return;
860: }
861:
862: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
863: &s_objet_2) == d_erreur)
864: {
865: liberation(s_etat_processus, s_objet_1);
866:
867: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
868: return;
869: }
870:
871: if ((*s_objet_1).type == LST)
872: {
873: connexion_permanente = d_faux;
874:
875: s_copie_1 = s_objet_1;
876:
877: if ((s_objet_1 = parametres_sql(s_etat_processus, s_copie_1)) == NULL)
878: {
879: liberation(s_etat_processus, s_copie_1);
880: liberation(s_etat_processus, s_objet_2);
881: return;
882: }
883:
1.45 bertrand 884: if ((*s_etat_processus).erreur_execution ==
885: d_ex_instruction_indisponible)
886: {
887: liberation(s_etat_processus, s_objet_1);
888: liberation(s_etat_processus, s_objet_2);
889: liberation(s_etat_processus, s_copie_1);
890:
891: return;
892: }
893:
1.1 bertrand 894: liberation(s_etat_processus, s_copie_1);
895: }
896: else
897: {
898: if ((*s_objet_1).type == SQL)
899: {
900: if (((*((struct_connecteur_sql *) (*s_objet_1).objet)).pid !=
901: getpid()) || (pthread_equal((*((struct_connecteur_sql *)
902: (*s_objet_1).objet)).tid, pthread_self()) == 0))
903: {
904: (*s_etat_processus).erreur_execution =
905: d_ex_fichier_hors_contexte;
906:
907: liberation(s_etat_processus, s_objet_1);
908: liberation(s_etat_processus, s_objet_2);
909: return;
910: }
911: }
912:
913: connexion_permanente = d_vrai;
914: }
915:
916: if (((*s_objet_1).type == SQL) && ((*s_objet_2).type == CHN))
917: {
918: if ((*((struct_connecteur_sql *) (*s_objet_1).objet)).locale != NULL)
919: {
920: /*
921: * Transcodage de la commande SQL
922: */
923:
924: if ((s_copie_2 = copie_objet(s_etat_processus, s_objet_2, 'O'))
925: == NULL)
926: {
927: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
928: return;
929: }
930:
931: liberation(s_etat_processus, s_objet_2);
932: s_objet_2 = s_copie_2;
933:
934: tampon = (*s_objet_2).objet;
935:
936: if (((*s_objet_2).objet = transliteration(s_etat_processus, tampon,
937: (*((struct_connecteur_sql *) (*s_objet_1).objet)).locale,
938: d_locale)) == NULL)
939: {
940: return;
941: }
942:
943: free(tampon);
944: }
945:
946: /*
947: * Pilote MySQL
948: */
949:
950: if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
951: "MYSQL") == 0)
952: {
953: # ifdef MYSQL_SUPPORT
954:
1.40 bertrand 955: unsigned int i;
956: unsigned int nombre_colonnes;
957:
958: logical1 presence_resultat;
959:
960: MYSQL_RES *resultat_mysql;
961: MYSQL_ROW ligne;
962:
963: struct_objet *s_objet_resultat;
964:
965: struct_liste_chainee *l_element_courant;
966: struct_liste_chainee *l_element_courant_ligne;
1.1 bertrand 967:
968: if (mysql_real_query((*((struct_connecteur_sql *) (*s_objet_1)
969: .objet)).descripteur.mysql, (unsigned char *) (*s_objet_2)
970: .objet, strlen((unsigned char *) (*s_objet_2).objet)) != 0)
971: {
972: if (connexion_permanente == d_faux)
973: {
974: mysql_close((*((struct_connecteur_sql *) (*s_objet_1)
975: .objet)).descripteur.mysql);
976: }
977:
978: liberation(s_etat_processus, s_objet_1);
979: liberation(s_etat_processus, s_objet_2);
980:
981: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
982: return;
983: }
984:
985: if ((resultat_mysql = mysql_store_result(
986: (*((struct_connecteur_sql *) (*s_objet_1).objet))
987: .descripteur.mysql)) == NULL)
988: {
989: // La requête ne renvoie rien (exemple : INSERT)
990: presence_resultat = d_faux;
991: nombre_colonnes = 0;
992: }
993: else
994: {
995: // La requête renvoie une ou plusieurs valeurs.
996: presence_resultat = d_vrai;
997: nombre_colonnes = mysql_field_count((*((struct_connecteur_sql *)
998: (*s_objet_1).objet)).descripteur.mysql);
999: }
1000:
1001: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1002: == NULL)
1003: {
1004: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1005: return;
1006: }
1007:
1008: (*s_objet_resultat).objet = NULL;
1009: l_element_courant = (*s_objet_resultat).objet;
1010:
1011: while(((presence_resultat == d_vrai) ?
1012: (ligne = mysql_fetch_row(resultat_mysql)) : NULL) != NULL)
1013: {
1014: unsigned long *longueurs;
1015:
1016: longueurs = mysql_fetch_lengths(resultat_mysql);
1017:
1018: if (l_element_courant == NULL)
1019: {
1020: if (((*s_objet_resultat).objet =
1021: allocation_maillon(s_etat_processus)) == NULL)
1022: {
1023: (*s_etat_processus).erreur_systeme =
1024: d_es_allocation_memoire;
1025: return;
1026: }
1027:
1028: l_element_courant = (struct_liste_chainee *)
1029: (*s_objet_resultat).objet;
1030: }
1031: else
1032: {
1033: if (((*l_element_courant).suivant =
1034: allocation_maillon(s_etat_processus)) == NULL)
1035: {
1036: (*s_etat_processus).erreur_systeme =
1037: d_es_allocation_memoire;
1038: return;
1039: }
1040:
1041: l_element_courant = (*l_element_courant).suivant;
1042: }
1043:
1044: (*l_element_courant).suivant = NULL;
1045:
1046: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1047: LST)) == NULL)
1048: {
1049: (*s_etat_processus).erreur_systeme =
1050: d_es_allocation_memoire;
1051: return;
1052: }
1053:
1054: (*(*l_element_courant).donnee).objet = NULL;
1055: l_element_courant_ligne = NULL;
1056:
1057: for(i = 0; i < nombre_colonnes; i++)
1058: {
1059: if (l_element_courant_ligne == NULL)
1060: {
1061: if (((*(*l_element_courant).donnee).objet =
1062: allocation_maillon(s_etat_processus)) == NULL)
1063: {
1064: (*s_etat_processus).erreur_systeme =
1065: d_es_allocation_memoire;
1066: return;
1067: }
1068:
1069: l_element_courant_ligne = (struct_liste_chainee *)
1070: (*(*l_element_courant).donnee).objet;
1071: }
1072: else
1073: {
1074: if (((*l_element_courant_ligne).suivant =
1075: allocation_maillon(s_etat_processus)) == NULL)
1076: {
1077: (*s_etat_processus).erreur_systeme =
1078: d_es_allocation_memoire;
1079: return;
1080: }
1081:
1082: l_element_courant_ligne =
1083: (*l_element_courant_ligne).suivant;
1084: }
1085:
1086: (*l_element_courant_ligne).suivant = NULL;
1087:
1088: if (((*l_element_courant_ligne).donnee =
1089: allocation(s_etat_processus, CHN)) == NULL)
1090: {
1091: (*s_etat_processus).erreur_systeme =
1092: d_es_allocation_memoire;
1093: return;
1094: }
1095:
1096: if (ligne[i] == NULL)
1097: {
1098: if (((*(*l_element_courant_ligne).donnee).objet =
1099: malloc(5 * sizeof(unsigned char))) == NULL)
1100: {
1101: (*s_etat_processus).erreur_systeme =
1102: d_es_allocation_memoire;
1103: return;
1104: }
1105:
1106: strcpy((unsigned char *) (*(*l_element_courant_ligne)
1107: .donnee).objet, "NULL");
1108: }
1109: else
1110: {
1111: if (((*(*l_element_courant_ligne).donnee).objet =
1112: malloc((longueurs[i] + 1) *
1113: sizeof(unsigned char))) == NULL)
1114: {
1115: (*s_etat_processus).erreur_systeme =
1116: d_es_allocation_memoire;
1117: return;
1118: }
1119:
1120: strcpy((unsigned char *) (*(*l_element_courant_ligne)
1121: .donnee).objet, ligne[i]);
1122: }
1123: }
1124: }
1125:
1126: mysql_free_result(resultat_mysql);
1127:
1128: if (connexion_permanente == d_faux)
1129: {
1130: mysql_close((*((struct_connecteur_sql *) (*s_objet_1).objet))
1131: .descripteur.mysql);
1132: }
1133:
1134: if (presence_resultat == d_vrai)
1135: {
1136: if (empilement(s_etat_processus,
1137: &((*s_etat_processus).l_base_pile),
1138: s_objet_resultat) == d_erreur)
1139: {
1140: return;
1141: }
1142: }
1143:
1144: # else
1145:
1146: if ((*s_etat_processus).langue == 'F')
1147: {
1148: printf("+++Attention : Support de MySQL non compilé !\n");
1149: }
1150: else
1151: {
1152: printf("+++Warning : MySQL support not available !\n");
1153: }
1154:
1155: fflush(stdout);
1156: # endif
1157: }
1158:
1159: /*
1160: * Pilote PostgreSQL
1161: */
1162:
1163: else if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
1164: "POSTGRESQL") == 0)
1165: {
1166: # ifdef POSTGRESQL_SUPPORT
1167:
1.40 bertrand 1168: unsigned int i;
1169: unsigned int j;
1170: unsigned int nombre_colonnes;
1171: unsigned int nombre_lignes;
1172:
1173: logical1 presence_resultat;
1174:
1175: PGresult *resultat_postgresql;
1176:
1177: struct_objet *s_objet_resultat;
1178:
1179: struct_liste_chainee *l_element_courant;
1180: struct_liste_chainee *l_element_courant_ligne;
1.1 bertrand 1181:
1182: if (PQstatus((*((struct_connecteur_sql *) (*s_objet_1).objet))
1183: .descripteur.postgresql) != CONNECTION_OK)
1184: {
1185: if (connexion_permanente == d_faux)
1186: {
1187: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet))
1188: .descripteur.postgresql);
1189: }
1190:
1191: liberation(s_etat_processus, s_objet_1);
1192: liberation(s_etat_processus, s_objet_2);
1193:
1194: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1195: return;
1196: }
1197:
1198: resultat_postgresql = PQexec((*((struct_connecteur_sql *)
1199: (*s_objet_1).objet)).descripteur.postgresql,
1200: (unsigned char *) (*s_objet_2).objet);
1201: presence_resultat = d_faux;
1202:
1203: switch(PQresultStatus(resultat_postgresql))
1204: {
1205: case PGRES_COMMAND_OK :
1206: { // Commande qui ne renvoit rien
1207: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1208: == NULL)
1209: {
1210: (*s_etat_processus).erreur_systeme =
1211: d_es_allocation_memoire;
1212: return;
1213: }
1214:
1215: (*s_objet_resultat).objet = NULL;
1216: l_element_courant = (*s_objet_resultat).objet;
1217: presence_resultat = d_vrai;
1218:
1219: break;
1220: }
1221:
1222: case PGRES_TUPLES_OK :
1223: { // Commande renvoyant des données
1224: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1225: == NULL)
1226: {
1227: (*s_etat_processus).erreur_systeme =
1228: d_es_allocation_memoire;
1229: return;
1230: }
1231:
1232: (*s_objet_resultat).objet = NULL;
1233: l_element_courant = (*s_objet_resultat).objet;
1234: presence_resultat = d_vrai;
1235:
1236: nombre_colonnes = PQnfields(resultat_postgresql);
1237: nombre_lignes = PQntuples(resultat_postgresql);
1238:
1239: for(i = 0; i < nombre_lignes; i++)
1240: {
1241: // Chaînage d'un nouveau maillon de la liste résultat
1242:
1243: if (l_element_courant == NULL)
1244: {
1245: if (((*s_objet_resultat).objet =
1246: allocation_maillon(s_etat_processus))
1247: == NULL)
1248: {
1249: (*s_etat_processus).erreur_systeme =
1250: d_es_allocation_memoire;
1251: return;
1252: }
1253:
1254: l_element_courant = (struct_liste_chainee *)
1255: (*s_objet_resultat).objet;
1256: }
1257: else
1258: {
1259: if (((*l_element_courant).suivant =
1260: allocation_maillon(s_etat_processus))
1261: == NULL)
1262: {
1263: (*s_etat_processus).erreur_systeme =
1264: d_es_allocation_memoire;
1265: return;
1266: }
1267:
1268: l_element_courant = (*l_element_courant).suivant;
1269: }
1270:
1271: (*l_element_courant).suivant = NULL;
1272:
1273: // Création de la liste fille
1274:
1275: if (((*l_element_courant).donnee =
1276: allocation(s_etat_processus, LST)) == NULL)
1277: {
1278: (*s_etat_processus).erreur_systeme =
1279: d_es_allocation_memoire;
1280: return;
1281: }
1282:
1283: (*(*l_element_courant).donnee).objet = NULL;
1284: l_element_courant_ligne = NULL;
1285:
1286: for(j = 0; j < nombre_colonnes; j++)
1287: {
1288: if (l_element_courant_ligne == NULL)
1289: {
1290: if (((*(*l_element_courant).donnee).objet =
1291: allocation_maillon(s_etat_processus))
1292: == NULL)
1293: {
1294: (*s_etat_processus).erreur_systeme =
1295: d_es_allocation_memoire;
1296: return;
1297: }
1298:
1299: l_element_courant_ligne =
1300: (struct_liste_chainee *)
1301: (*(*l_element_courant).donnee).objet;
1302: }
1303: else
1304: {
1305: if (((*l_element_courant_ligne).suivant =
1306: allocation_maillon(s_etat_processus))
1307: == NULL)
1308: {
1309: l_element_courant_ligne =
1310: (*l_element_courant_ligne).suivant;
1311: }
1312:
1313: l_element_courant_ligne =
1314: (*l_element_courant_ligne).suivant;
1315: }
1316:
1317: (*l_element_courant_ligne).suivant = NULL;
1318:
1319: if (((*l_element_courant_ligne).donnee =
1320: allocation(s_etat_processus, CHN))
1321: == NULL)
1322: {
1323: (*s_etat_processus).erreur_systeme =
1324: d_es_allocation_memoire;
1325: return;
1326: }
1327:
1328: if (PQgetisnull(resultat_postgresql, i, j) != 0)
1329: {
1330: if (((*(*l_element_courant_ligne).donnee).objet
1331: = malloc(5 * sizeof(unsigned char)))
1332: == NULL)
1333: {
1334: (*s_etat_processus).erreur_systeme =
1335: d_es_allocation_memoire;
1336: return;
1337: }
1338:
1339: strcpy((unsigned char *)
1340: (*(*l_element_courant_ligne).donnee)
1341: .objet, "NULL");
1342: }
1343: else
1344: {
1345: if (((*(*l_element_courant_ligne).donnee).objet
1346: = malloc((PQgetlength(
1347: resultat_postgresql, i, j) + 1) *
1348: sizeof(unsigned char))) == NULL)
1349: {
1350: (*s_etat_processus).erreur_systeme =
1351: d_es_allocation_memoire;
1352: return;
1353: }
1354:
1355: strcpy((unsigned char *)
1356: (*(*l_element_courant_ligne).donnee)
1357: .objet, PQgetvalue(resultat_postgresql,
1358: i, j));
1359: }
1360: }
1361: }
1362:
1363: break;
1364: }
1365:
1366: case PGRES_EMPTY_QUERY :
1367: case PGRES_COPY_OUT :
1368: case PGRES_COPY_IN :
1369: case PGRES_BAD_RESPONSE :
1370: case PGRES_NONFATAL_ERROR :
1371: case PGRES_FATAL_ERROR :
1372: default :
1373: {
1374: printf("%s\n", PQresultErrorMessage(resultat_postgresql));
1375: PQclear(resultat_postgresql);
1376:
1377: if (connexion_permanente == d_faux)
1378: {
1379: PQfinish((*((struct_connecteur_sql *) (*s_objet_1)
1380: .objet)).descripteur.postgresql);
1381: }
1382:
1383: liberation(s_etat_processus, s_objet_1);
1384: liberation(s_etat_processus, s_objet_2);
1385:
1386: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1387:
1388: return;
1389: break;
1390: }
1391: }
1392:
1393: PQclear(resultat_postgresql);
1394:
1395: if (connexion_permanente == d_faux)
1396: {
1397: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet))
1398: .descripteur.postgresql);
1399: }
1400:
1401: if (presence_resultat == d_vrai)
1402: {
1403: if (empilement(s_etat_processus, &((*s_etat_processus)
1404: .l_base_pile), s_objet_resultat) == d_erreur)
1405: {
1406: return;
1407: }
1408: }
1409:
1410: # else
1411:
1412: if ((*s_etat_processus).langue == 'F')
1413: {
1414: printf("+++Attention : Support de PostgreSQL non compilé !\n");
1415: }
1416: else
1417: {
1418: printf("+++Warning : PostgreSQL support not available !\n");
1419: }
1420:
1421: fflush(stdout);
1422: # endif
1423: }
1.53 bertrand 1424: else if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
1425: "SQLITE") == 0)
1426: {
1427: const char *queue;
1428: const unsigned char *resultat;
1429:
1430: int ios;
1431:
1432: logical1 presence_resultat;
1433:
1434: sqlite3_stmt *ppStmt;
1435:
1436: struct_liste_chainee *l_element_courant;
1437: struct_liste_chainee *l_element_courant_ligne;
1438:
1439: struct_objet *s_objet_resultat;
1440:
1.54 bertrand 1441: struct timespec attente;
1442:
1.53 bertrand 1443: unsigned int i;
1444: unsigned int nombre_colonnes;
1445:
1446: if (sqlite3_prepare_v2((*((struct_connecteur_sql *)
1447: (*s_objet_1).objet)).descripteur.sqlite,
1448: (unsigned char *) (*s_objet_2).objet,
1449: strlen((unsigned char *) (*s_objet_2).objet),
1450: &ppStmt, &queue) != SQLITE_OK)
1451: {
1452: if (connexion_permanente == d_faux)
1453: {
1454: sqlite3_close((*((struct_connecteur_sql *)
1455: (*s_objet_1).objet)).descripteur.sqlite);
1456: }
1457:
1458: liberation(s_etat_processus, s_objet_1);
1459: liberation(s_etat_processus, s_objet_2);
1460:
1461: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1462: return;
1463: }
1464:
1465: presence_resultat = d_faux;
1466: s_objet_resultat = NULL;
1467: l_element_courant = NULL;
1468:
1.54 bertrand 1469: attente.tv_sec = 0;
1470: attente.tv_nsec = GRANULARITE_us * 1000;
1471:
1.53 bertrand 1472: do
1473: {
1474: switch(ios = sqlite3_step(ppStmt))
1475: {
1476: case SQLITE_ROW:
1477: {
1478: if (s_objet_resultat == NULL)
1479: {
1480: if ((s_objet_resultat =
1481: allocation(s_etat_processus, LST)) == NULL)
1482: {
1483: (*s_etat_processus).erreur_systeme =
1484: d_es_allocation_memoire;
1485: return;
1486: }
1487:
1488: presence_resultat = d_vrai;
1489:
1490: // Création d'une liste vide
1491:
1492: (*s_objet_resultat).objet = NULL;
1493: l_element_courant = (*s_objet_resultat).objet;
1494: }
1495:
1496: // Ajout d'une liste au bout de la liste
1497: // contenant les lignes
1498:
1499: if (l_element_courant == NULL)
1500: {
1501: if (((*s_objet_resultat).objet =
1502: allocation_maillon(s_etat_processus))
1503: == NULL)
1504: {
1505: (*s_etat_processus).erreur_systeme =
1506: d_es_allocation_memoire;
1507: }
1508:
1509: l_element_courant = (struct_liste_chainee *)
1510: (*s_objet_resultat).objet;
1511: }
1512: else
1513: {
1514: if (((*l_element_courant).suivant =
1515: allocation_maillon(s_etat_processus))
1516: == NULL)
1517: {
1518: (*s_etat_processus).erreur_systeme =
1519: d_es_allocation_memoire;
1520: return;
1521: }
1522:
1523: l_element_courant = (*l_element_courant).suivant;
1524: }
1525:
1526: (*l_element_courant).suivant = NULL;
1527:
1528: // Création de la liste fille
1529:
1530: if (((*l_element_courant).donnee =
1531: allocation(s_etat_processus, LST)) == NULL)
1532: {
1533: (*s_etat_processus).erreur_systeme =
1534: d_es_allocation_memoire;
1535: return;
1536: }
1537:
1538: (*(*l_element_courant).donnee).objet = NULL;
1539:
1540: // Lecture de la ligne
1541:
1542: nombre_colonnes = sqlite3_data_count(ppStmt);
1543: l_element_courant_ligne = NULL;
1544:
1545: for(i = 0; i < nombre_colonnes; i++)
1546: {
1547: if (l_element_courant_ligne == NULL)
1548: {
1549: if (((*(*l_element_courant).donnee).objet =
1550: allocation_maillon(s_etat_processus))
1551: == NULL)
1552: {
1553: (*s_etat_processus).erreur_systeme =
1554: d_es_allocation_memoire;
1555: return;
1556: }
1557:
1558: l_element_courant_ligne =
1559: (struct_liste_chainee *)
1560: (*(*l_element_courant).donnee).objet;
1561: }
1562: else
1563: {
1564: if (((*l_element_courant_ligne).suivant =
1565: allocation_maillon(s_etat_processus))
1566: == NULL)
1567: {
1568: l_element_courant_ligne =
1569: (*l_element_courant_ligne).suivant;
1570: }
1571:
1572: l_element_courant_ligne =
1573: (*l_element_courant_ligne).suivant;
1574: }
1575:
1576: (*l_element_courant_ligne).suivant = NULL;
1577:
1578: if (((*l_element_courant_ligne).donnee =
1579: allocation(s_etat_processus, CHN))
1580: == NULL)
1581: {
1582: (*s_etat_processus).erreur_systeme =
1583: d_es_allocation_memoire;
1584: return;
1585: }
1586:
1587: if (sqlite3_column_type(ppStmt, i) == SQLITE_NULL)
1588: {
1589: if (((*(*l_element_courant_ligne).donnee).objet
1590: = malloc(5 * sizeof(unsigned char)))
1591: == NULL)
1592: {
1593: (*s_etat_processus).erreur_systeme =
1594: d_es_allocation_memoire;
1595: return;
1596: }
1597:
1598: strcpy((unsigned char *)
1599: (*(*l_element_courant_ligne).donnee)
1600: .objet, "NULL");
1601: }
1602: else
1603: {
1604: if ((resultat = sqlite3_column_text(ppStmt, i))
1605: == NULL)
1606: {
1607: (*s_etat_processus).erreur_systeme =
1608: d_es_allocation_memoire;
1609: return;
1610: }
1611:
1612: if (((*(*l_element_courant_ligne).donnee).objet
1613: = malloc((strlen(resultat) + 1 ) *
1614: sizeof(unsigned char))) == NULL)
1615: {
1616: (*s_etat_processus).erreur_systeme =
1617: d_es_allocation_memoire;
1618: return;
1619: }
1620:
1621: strcpy((unsigned char *)
1622: (*(*l_element_courant_ligne).donnee)
1623: .objet, resultat);
1624: }
1625: }
1626:
1627: break;
1628: }
1629:
1630: case SQLITE_DONE:
1631: {
1632: // Fin de la lecture des données
1633: break;
1634: }
1635:
1.54 bertrand 1636: case SQLITE_BUSY:
1637: case SQLITE_LOCKED:
1638: {
1639: nanosleep(&attente, NULL);
1640: INCR_GRANULARITE(attente.tv_nsec);
1641: break;
1642: }
1643:
1.53 bertrand 1644: default:
1645: {
1646: (*s_etat_processus).erreur_systeme =
1647: d_es_erreur_fichier;
1648: return;
1649: }
1650: }
1651: } while(ios != SQLITE_DONE);
1652:
1653: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1654: {
1655: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1656: return;
1657: }
1658:
1659: if (connexion_permanente == d_faux)
1660: {
1661: sqlite3_close((*((struct_connecteur_sql *) (*s_objet_1).objet))
1662: .descripteur.sqlite);
1663: }
1664:
1665: if (presence_resultat == d_vrai)
1666: {
1667: if (empilement(s_etat_processus, &((*s_etat_processus)
1668: .l_base_pile), s_objet_resultat) == d_erreur)
1669: {
1670: return;
1671: }
1672: }
1673: }
1.1 bertrand 1674: else
1675: {
1676: liberation(s_etat_processus, s_objet_1);
1677: liberation(s_etat_processus, s_objet_2);
1678:
1679: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1680: return;
1681: }
1682: }
1683: else
1684: {
1685: liberation(s_etat_processus, s_objet_1);
1686: liberation(s_etat_processus, s_objet_2);
1687:
1688: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1689: return;
1690: }
1691:
1692: liberation(s_etat_processus, s_objet_1);
1693: liberation(s_etat_processus, s_objet_2);
1694:
1695: return;
1696: }
1697:
1698:
1699: /*
1700: ================================================================================
1701: Fonction 'stop'
1702: ================================================================================
1703: Entrées :
1704: --------------------------------------------------------------------------------
1705: Sorties :
1706: --------------------------------------------------------------------------------
1707: Effets de bord : néant
1708: ================================================================================
1709: */
1710:
1711: void
1712: instruction_stop(struct_processus *s_etat_processus)
1713: {
1714: struct_liste_chainee *l_element_courant;
1715:
1716: struct_objet *s_objet;
1717:
1718: (*s_etat_processus).erreur_execution = d_ex;
1719:
1720: if ((*s_etat_processus).affichage_arguments == 'Y')
1721: {
1722: printf("\n STOP ");
1723:
1724: if ((*s_etat_processus).langue == 'F')
1725: {
1726: printf("(arrêt d'un processus)\n\n");
1727: }
1728: else
1729: {
1730: printf("(kill process)\n\n");
1731: }
1732:
1733: printf(" 1: %s\n", d_PRC);
1734:
1735: return;
1736: }
1737: else if ((*s_etat_processus).test_instruction == 'Y')
1738: {
1739: (*s_etat_processus).nombre_arguments = -1;
1740: return;
1741: }
1742:
1743: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1744: {
1745: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1746: {
1747: return;
1748: }
1749: }
1750:
1751: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1752: &s_objet) == d_erreur)
1753: {
1754: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1755: return;
1756: }
1757:
1758: if ((*s_objet).type == PRC)
1759: {
1760: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1761: .processus_detache == d_vrai)
1762: {
1.33 bertrand 1763: envoi_signal_processus((*(*((struct_processus_fils *)
1764: (*s_objet).objet)).thread).pid, rpl_sigstop);
1.1 bertrand 1765: }
1766: else
1767: {
1768: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
1769: {
1770: (*s_etat_processus).erreur_systeme = d_es_processus;
1771: return;
1772: }
1773:
1774: l_element_courant = (struct_liste_chainee *)
1775: (*s_etat_processus).l_base_pile_processus;
1776:
1777: while(l_element_courant != NULL)
1778: {
1779: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1780: .donnee).objet)).thread).processus_detache == d_faux)
1781: {
1782: if ((pthread_equal((*(*((struct_processus_fils *)
1.9 bertrand 1783: (*(*l_element_courant).donnee).objet)).thread).tid,
1.1 bertrand 1784: (*(*((struct_processus_fils *)
1785: (*s_objet).objet)).thread).tid) != 0) &&
1786: ((*(*((struct_processus_fils *)
1787: (*(*l_element_courant).donnee).objet)).thread).pid
1788: == (*(*((struct_processus_fils *)
1789: (*s_objet).objet)).thread).pid))
1790: {
1791: break;
1792: }
1793: }
1794:
1795: l_element_courant = (*l_element_courant).suivant;
1796: }
1797:
1798: if (l_element_courant != NULL)
1799: {
1800: // Le champ thread_actif est un pointeur sur un champ de la
1801: // structure s_argument_thread libéré par la fonction
1802: // retrait_thread_surveillance().
1803:
1804: if ((*(*((struct_processus_fils *)
1805: (*s_objet).objet)).thread).thread_actif == d_vrai)
1806: {
1807: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
1808: (*s_objet).objet)).thread).mutex)) != 0)
1809: {
1810: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
1811: != 0)
1812: {
1813: (*s_etat_processus).erreur_systeme = d_es_processus;
1814: return;
1815: }
1816:
1817: (*s_etat_processus).erreur_systeme = d_es_processus;
1818: return;
1819: }
1820:
1821: if ((*(*((struct_processus_fils *)
1822: (*s_objet).objet)).thread).thread_actif == d_vrai)
1823: {
1.33 bertrand 1824: envoi_signal_thread((*(*((struct_processus_fils *)
1825: (*s_objet).objet)).thread).tid, rpl_sigstop);
1.1 bertrand 1826: }
1827:
1828: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
1829: (*s_objet).objet)).thread).mutex)) != 0)
1830: {
1831: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
1832: != 0)
1833: {
1834: (*s_etat_processus).erreur_systeme = d_es_processus;
1835: return;
1836: }
1837:
1838: (*s_etat_processus).erreur_systeme = d_es_processus;
1839: return;
1840: }
1841: }
1842: }
1843:
1844: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1845: {
1846: (*s_etat_processus).erreur_systeme = d_es_processus;
1847: return;
1848: }
1849: }
1850: }
1851: else
1852: {
1853: liberation(s_etat_processus, s_objet);
1854:
1855: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1856: return;
1857: }
1858:
1859: liberation(s_etat_processus, s_objet);
1860:
1861: return;
1862: }
1863:
1864: // vim: ts=4