1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.13
4: Copyright (C) 1989-2013 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, (integer8) (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 = (pthread_t) -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 = (pthread_t) -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: 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");
836: printf(" \"select * from table\"\n");
837: printf(" { \"sqlite\" \"file\" } SQLQUERY\n");
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:
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:
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:
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;
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:
1168: int i;
1169: int j;
1170: int nombre_colonnes;
1171: 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;
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(((size_t) (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: }
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 i;
1431: int ios;
1432: int nombre_colonnes;
1433:
1434: logical1 presence_resultat;
1435:
1436: sqlite3_stmt *ppStmt;
1437:
1438: struct_liste_chainee *l_element_courant;
1439: struct_liste_chainee *l_element_courant_ligne;
1440:
1441: struct_objet *s_objet_resultat;
1442:
1443: struct timespec attente;
1444:
1445: if (sqlite3_prepare_v2((*((struct_connecteur_sql *)
1446: (*s_objet_1).objet)).descripteur.sqlite,
1447: (unsigned char *) (*s_objet_2).objet,
1448: (int) strlen((unsigned char *) (*s_objet_2).objet),
1449: &ppStmt, &queue) != SQLITE_OK)
1450: {
1451: if (connexion_permanente == d_faux)
1452: {
1453: sqlite3_close((*((struct_connecteur_sql *)
1454: (*s_objet_1).objet)).descripteur.sqlite);
1455: }
1456:
1457: liberation(s_etat_processus, s_objet_1);
1458: liberation(s_etat_processus, s_objet_2);
1459:
1460: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1461: return;
1462: }
1463:
1464: presence_resultat = d_faux;
1465: s_objet_resultat = NULL;
1466: l_element_courant = NULL;
1467:
1468: attente.tv_sec = 0;
1469: attente.tv_nsec = GRANULARITE_us * 1000;
1470:
1471: do
1472: {
1473: switch(ios = sqlite3_step(ppStmt))
1474: {
1475: case SQLITE_ROW:
1476: {
1477: if (s_objet_resultat == NULL)
1478: {
1479: if ((s_objet_resultat =
1480: allocation(s_etat_processus, LST)) == NULL)
1481: {
1482: (*s_etat_processus).erreur_systeme =
1483: d_es_allocation_memoire;
1484: return;
1485: }
1486:
1487: presence_resultat = d_vrai;
1488:
1489: // Création d'une liste vide
1490:
1491: (*s_objet_resultat).objet = NULL;
1492: l_element_courant = (*s_objet_resultat).objet;
1493: }
1494:
1495: // Ajout d'une liste au bout de la liste
1496: // contenant les lignes
1497:
1498: if (l_element_courant == NULL)
1499: {
1500: if (((*s_objet_resultat).objet =
1501: allocation_maillon(s_etat_processus))
1502: == NULL)
1503: {
1504: (*s_etat_processus).erreur_systeme =
1505: d_es_allocation_memoire;
1506: }
1507:
1508: l_element_courant = (struct_liste_chainee *)
1509: (*s_objet_resultat).objet;
1510: }
1511: else
1512: {
1513: if (((*l_element_courant).suivant =
1514: allocation_maillon(s_etat_processus))
1515: == NULL)
1516: {
1517: (*s_etat_processus).erreur_systeme =
1518: d_es_allocation_memoire;
1519: return;
1520: }
1521:
1522: l_element_courant = (*l_element_courant).suivant;
1523: }
1524:
1525: (*l_element_courant).suivant = NULL;
1526:
1527: // Création de la liste fille
1528:
1529: if (((*l_element_courant).donnee =
1530: allocation(s_etat_processus, LST)) == NULL)
1531: {
1532: (*s_etat_processus).erreur_systeme =
1533: d_es_allocation_memoire;
1534: return;
1535: }
1536:
1537: (*(*l_element_courant).donnee).objet = NULL;
1538:
1539: // Lecture de la ligne
1540:
1541: nombre_colonnes = sqlite3_data_count(ppStmt);
1542: l_element_courant_ligne = NULL;
1543:
1544: for(i = 0; i < nombre_colonnes; i++)
1545: {
1546: if (l_element_courant_ligne == NULL)
1547: {
1548: if (((*(*l_element_courant).donnee).objet =
1549: allocation_maillon(s_etat_processus))
1550: == NULL)
1551: {
1552: (*s_etat_processus).erreur_systeme =
1553: d_es_allocation_memoire;
1554: return;
1555: }
1556:
1557: l_element_courant_ligne =
1558: (struct_liste_chainee *)
1559: (*(*l_element_courant).donnee).objet;
1560: }
1561: else
1562: {
1563: if (((*l_element_courant_ligne).suivant =
1564: allocation_maillon(s_etat_processus))
1565: == NULL)
1566: {
1567: l_element_courant_ligne =
1568: (*l_element_courant_ligne).suivant;
1569: }
1570:
1571: l_element_courant_ligne =
1572: (*l_element_courant_ligne).suivant;
1573: }
1574:
1575: (*l_element_courant_ligne).suivant = NULL;
1576:
1577: if (((*l_element_courant_ligne).donnee =
1578: allocation(s_etat_processus, CHN))
1579: == NULL)
1580: {
1581: (*s_etat_processus).erreur_systeme =
1582: d_es_allocation_memoire;
1583: return;
1584: }
1585:
1586: if (sqlite3_column_type(ppStmt, i) == SQLITE_NULL)
1587: {
1588: if (((*(*l_element_courant_ligne).donnee).objet
1589: = malloc(5 * sizeof(unsigned char)))
1590: == NULL)
1591: {
1592: (*s_etat_processus).erreur_systeme =
1593: d_es_allocation_memoire;
1594: return;
1595: }
1596:
1597: strcpy((unsigned char *)
1598: (*(*l_element_courant_ligne).donnee)
1599: .objet, "NULL");
1600: }
1601: else
1602: {
1603: if ((resultat = sqlite3_column_text(ppStmt, i))
1604: == NULL)
1605: {
1606: (*s_etat_processus).erreur_systeme =
1607: d_es_allocation_memoire;
1608: return;
1609: }
1610:
1611: if (((*(*l_element_courant_ligne).donnee).objet
1612: = malloc((strlen(resultat) + 1 ) *
1613: sizeof(unsigned char))) == NULL)
1614: {
1615: (*s_etat_processus).erreur_systeme =
1616: d_es_allocation_memoire;
1617: return;
1618: }
1619:
1620: strcpy((unsigned char *)
1621: (*(*l_element_courant_ligne).donnee)
1622: .objet, resultat);
1623: }
1624: }
1625:
1626: break;
1627: }
1628:
1629: case SQLITE_DONE:
1630: {
1631: // Fin de la lecture des données
1632: break;
1633: }
1634:
1635: case SQLITE_BUSY:
1636: case SQLITE_LOCKED:
1637: {
1638: nanosleep(&attente, NULL);
1639: INCR_GRANULARITE(attente.tv_nsec);
1640: break;
1641: }
1642:
1643: default:
1644: {
1645: (*s_etat_processus).erreur_systeme =
1646: d_es_erreur_fichier;
1647: return;
1648: }
1649: }
1650: } while(ios != SQLITE_DONE);
1651:
1652: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1653: {
1654: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1655: return;
1656: }
1657:
1658: if (connexion_permanente == d_faux)
1659: {
1660: sqlite3_close((*((struct_connecteur_sql *) (*s_objet_1).objet))
1661: .descripteur.sqlite);
1662: }
1663:
1664: if (presence_resultat == d_vrai)
1665: {
1666: if (empilement(s_etat_processus, &((*s_etat_processus)
1667: .l_base_pile), s_objet_resultat) == d_erreur)
1668: {
1669: return;
1670: }
1671: }
1672: }
1673: else
1674: {
1675: liberation(s_etat_processus, s_objet_1);
1676: liberation(s_etat_processus, s_objet_2);
1677:
1678: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1679: return;
1680: }
1681: }
1682: else
1683: {
1684: liberation(s_etat_processus, s_objet_1);
1685: liberation(s_etat_processus, s_objet_2);
1686:
1687: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1688: return;
1689: }
1690:
1691: liberation(s_etat_processus, s_objet_1);
1692: liberation(s_etat_processus, s_objet_2);
1693:
1694: return;
1695: }
1696:
1697:
1698: /*
1699: ================================================================================
1700: Fonction 'stop'
1701: ================================================================================
1702: Entrées :
1703: --------------------------------------------------------------------------------
1704: Sorties :
1705: --------------------------------------------------------------------------------
1706: Effets de bord : néant
1707: ================================================================================
1708: */
1709:
1710: void
1711: instruction_stop(struct_processus *s_etat_processus)
1712: {
1713: struct_liste_chainee *l_element_courant;
1714:
1715: struct_objet *s_objet;
1716:
1717: (*s_etat_processus).erreur_execution = d_ex;
1718:
1719: if ((*s_etat_processus).affichage_arguments == 'Y')
1720: {
1721: printf("\n STOP ");
1722:
1723: if ((*s_etat_processus).langue == 'F')
1724: {
1725: printf("(arrêt d'un processus)\n\n");
1726: }
1727: else
1728: {
1729: printf("(kill process)\n\n");
1730: }
1731:
1732: printf(" 1: %s\n", d_PRC);
1733:
1734: return;
1735: }
1736: else if ((*s_etat_processus).test_instruction == 'Y')
1737: {
1738: (*s_etat_processus).nombre_arguments = -1;
1739: return;
1740: }
1741:
1742: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1743: {
1744: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1745: {
1746: return;
1747: }
1748: }
1749:
1750: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1751: &s_objet) == d_erreur)
1752: {
1753: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1754: return;
1755: }
1756:
1757: if ((*s_objet).type == PRC)
1758: {
1759: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1760: .processus_detache == d_vrai)
1761: {
1762: envoi_signal_processus((*(*((struct_processus_fils *)
1763: (*s_objet).objet)).thread).pid, rpl_sigstop);
1764: }
1765: else
1766: {
1767: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
1768: {
1769: (*s_etat_processus).erreur_systeme = d_es_processus;
1770: return;
1771: }
1772:
1773: l_element_courant = (struct_liste_chainee *)
1774: (*s_etat_processus).l_base_pile_processus;
1775:
1776: while(l_element_courant != NULL)
1777: {
1778: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1779: .donnee).objet)).thread).processus_detache == d_faux)
1780: {
1781: if ((pthread_equal((*(*((struct_processus_fils *)
1782: (*(*l_element_courant).donnee).objet)).thread).tid,
1783: (*(*((struct_processus_fils *)
1784: (*s_objet).objet)).thread).tid) != 0) &&
1785: ((*(*((struct_processus_fils *)
1786: (*(*l_element_courant).donnee).objet)).thread).pid
1787: == (*(*((struct_processus_fils *)
1788: (*s_objet).objet)).thread).pid))
1789: {
1790: break;
1791: }
1792: }
1793:
1794: l_element_courant = (*l_element_courant).suivant;
1795: }
1796:
1797: if (l_element_courant != NULL)
1798: {
1799: // Le champ thread_actif est un pointeur sur un champ de la
1800: // structure s_argument_thread libéré par la fonction
1801: // retrait_thread_surveillance().
1802:
1803: if ((*(*((struct_processus_fils *)
1804: (*s_objet).objet)).thread).thread_actif == d_vrai)
1805: {
1806: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
1807: (*s_objet).objet)).thread).mutex)) != 0)
1808: {
1809: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
1810: != 0)
1811: {
1812: (*s_etat_processus).erreur_systeme = d_es_processus;
1813: return;
1814: }
1815:
1816: (*s_etat_processus).erreur_systeme = d_es_processus;
1817: return;
1818: }
1819:
1820: if ((*(*((struct_processus_fils *)
1821: (*s_objet).objet)).thread).thread_actif == d_vrai)
1822: {
1823: envoi_signal_thread((*(*((struct_processus_fils *)
1824: (*s_objet).objet)).thread).tid, rpl_sigstop);
1825: }
1826:
1827: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
1828: (*s_objet).objet)).thread).mutex)) != 0)
1829: {
1830: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
1831: != 0)
1832: {
1833: (*s_etat_processus).erreur_systeme = d_es_processus;
1834: return;
1835: }
1836:
1837: (*s_etat_processus).erreur_systeme = d_es_processus;
1838: return;
1839: }
1840: }
1841: }
1842:
1843: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1844: {
1845: (*s_etat_processus).erreur_systeme = d_es_processus;
1846: return;
1847: }
1848: }
1849: }
1850: else
1851: {
1852: liberation(s_etat_processus, s_objet);
1853:
1854: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1855: return;
1856: }
1857:
1858: liberation(s_etat_processus, s_objet);
1859:
1860: return;
1861: }
1862:
1863: // 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