1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.12
4: Copyright (C) 1989-2012 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'splash'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_splash(struct_processus *s_etat_processus)
40: {
41: real8 attente;
42:
43: struct_objet *s_objet;
44:
45: (*s_etat_processus).erreur_execution = d_ex;
46:
47: if ((*s_etat_processus).affichage_arguments == 'Y')
48: {
49: printf("\n SPLASH ");
50:
51: if ((*s_etat_processus).langue == 'F')
52: {
53: printf("(écran RPL/2)\n\n");
54: }
55: else
56: {
57: printf("(RPL/2 splash screen)\n\n");
58: }
59:
60: printf(" 1: %s, %s\n", d_INT, d_REL);
61:
62: return;
63: }
64: else if ((*s_etat_processus).test_instruction == 'Y')
65: {
66: (*s_etat_processus).nombre_arguments = -1;
67: return;
68: }
69:
70: if (test_cfsf(s_etat_processus, 31) == d_vrai)
71: {
72: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
73: {
74: return;
75: }
76: }
77:
78: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
79: &s_objet) == d_erreur)
80: {
81: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
82: return;
83: }
84:
85: if (((*s_objet).type == INT) ||
86: ((*s_objet).type == REL))
87: {
88: if ((*s_objet).type == INT)
89: {
90: attente = (real8) (*((integer8 *) (*s_objet).objet));
91: }
92: else
93: {
94: attente = (*((real8 *) (*s_objet).objet));
95: }
96:
97: if (attente < 0)
98: {
99: liberation(s_etat_processus, s_objet);
100:
101: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
102: return;
103: }
104:
105: encart(s_etat_processus, (unsigned long) (attente * 1E6));
106: }
107: else
108: {
109: liberation(s_etat_processus, s_objet);
110:
111: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
112: return;
113: }
114:
115: liberation(s_etat_processus, s_objet);
116:
117: return;
118: }
119:
120:
121: /*
122: ================================================================================
123: Fonction 'send'
124: ================================================================================
125: Entrées :
126: --------------------------------------------------------------------------------
127: Sorties :
128: --------------------------------------------------------------------------------
129: Effets de bord : néant
130: ================================================================================
131: */
132:
133: void
134: instruction_send(struct_processus *s_etat_processus)
135: {
136: pid_t pid;
137:
138: pthread_t tid;
139:
140: sig_atomic_t registre;
141:
142: ssize_t longueur_ecriture;
143:
144: struct_objet *s_objet;
145:
146: struct timespec attente;
147:
148: unsigned char tampon;
149:
150: (*s_etat_processus).erreur_execution = d_ex;
151:
152: if ((*s_etat_processus).affichage_arguments == 'Y')
153: {
154: printf("\n SEND ");
155:
156: if ((*s_etat_processus).langue == 'F')
157: {
158: printf("(envoi de données au processus père)\n\n");
159: }
160: else
161: {
162: printf("(send data to parent process)\n\n");
163: }
164:
165: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
166: " %s, %s, %s, %s, %s,\n"
167: " %s, %s, %s, %s, %s\n",
168: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
169: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_TAB);
170:
171: return;
172: }
173: else if ((*s_etat_processus).test_instruction == 'Y')
174: {
175: (*s_etat_processus).nombre_arguments = -1;
176: return;
177: }
178:
179: if (test_cfsf(s_etat_processus, 31) == d_vrai)
180: {
181: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
182: {
183: return;
184: }
185: }
186:
187: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
188: &s_objet) == d_erreur)
189: {
190: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
191: return;
192: }
193:
194: if ((*s_etat_processus).presence_pipes == d_faux)
195: {
196: liberation(s_etat_processus, s_objet);
197:
198: (*s_etat_processus).erreur_execution = d_ex_absence_processus_pere;
199: return;
200: }
201:
202: if (((*s_objet).type != INT) &&
203: ((*s_objet).type != REL) &&
204: ((*s_objet).type != CPL) &&
205: ((*s_objet).type != VIN) &&
206: ((*s_objet).type != VRL) &&
207: ((*s_objet).type != VCX) &&
208: ((*s_objet).type != MIN) &&
209: ((*s_objet).type != MRL) &&
210: ((*s_objet).type != MCX) &&
211: ((*s_objet).type != BIN) &&
212: ((*s_objet).type != NOM) &&
213: ((*s_objet).type != CHN) &&
214: ((*s_objet).type != LST) &&
215: ((*s_objet).type != ALG) &&
216: ((*s_objet).type != RPN) &&
217: ((*s_objet).type != TBL))
218: {
219: liberation(s_etat_processus, s_objet);
220:
221: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
222: return;
223: }
224:
225: /*
226: * On signale au processus père qu'il y a un objet de plus
227: * dans le pipe de données.
228: */
229:
230: registre = (*s_etat_processus).var_volatile_traitement_retarde_stop;
231: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
232:
233: if ((*s_etat_processus).processus_detache == d_vrai)
234: {
235: if ((*s_etat_processus).profilage == d_vrai)
236: {
237: profilage(s_etat_processus, "Interprocess communications (SEND)");
238:
239: if ((*s_etat_processus).erreur_systeme != d_es)
240: {
241: return;
242: }
243: }
244:
245: pid = -3;
246:
247: attente.tv_sec = 0;
248: attente.tv_nsec = GRANULARITE_us * 1000;
249:
250: # ifndef SEMAPHORES_NOMMES
251: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
252: # else
253: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
254: # endif
255: {
256: (*s_etat_processus).erreur_systeme = d_es_processus;
257: return;
258: }
259:
260: while((longueur_ecriture = write_atomic(s_etat_processus,
261: (*s_etat_processus).pipe_nombre_objets_attente,
262: &pid, sizeof(pid))) != sizeof(pid))
263: {
264: # ifndef SEMAPHORES_NOMMES
265: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
266: # else
267: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
268: # endif
269: {
270: if (errno != EINTR)
271: {
272: (*s_etat_processus).erreur_systeme = d_es_processus;
273: return;
274: }
275: }
276:
277: if (longueur_ecriture == -1)
278: {
279: if ((*s_etat_processus).profilage == d_vrai)
280: {
281: profilage(s_etat_processus, NULL);
282: }
283:
284: (*s_etat_processus).erreur_systeme = d_es_processus;
285: return;
286: }
287:
288: nanosleep(&attente, NULL);
289: INCR_GRANULARITE(attente.tv_nsec);
290:
291: # ifndef SEMAPHORES_NOMMES
292: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
293: # else
294: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
295: # endif
296: {
297: (*s_etat_processus).erreur_systeme = d_es_processus;
298: return;
299: }
300:
301: scrutation_interruptions(s_etat_processus);
302: }
303:
304: pid = getpid();
305:
306: attente.tv_sec = 0;
307: attente.tv_nsec = GRANULARITE_us * 1000;
308:
309: while((longueur_ecriture = write_atomic(s_etat_processus,
310: (*s_etat_processus).pipe_nombre_objets_attente,
311: &pid, sizeof(pid))) != sizeof(pid))
312: {
313: # ifndef SEMAPHORES_NOMMES
314: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
315: # else
316: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
317: # endif
318: {
319: if (errno != EINTR)
320: {
321: (*s_etat_processus).erreur_systeme = d_es_processus;
322: return;
323: }
324: }
325:
326: if (longueur_ecriture == -1)
327: {
328: if ((*s_etat_processus).profilage == d_vrai)
329: {
330: profilage(s_etat_processus, NULL);
331: }
332:
333: (*s_etat_processus).erreur_systeme = d_es_processus;
334: return;
335: }
336:
337: nanosleep(&attente, NULL);
338: INCR_GRANULARITE(attente.tv_nsec);
339:
340: # ifndef SEMAPHORES_NOMMES
341: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
342: # else
343: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
344: # endif
345: {
346: (*s_etat_processus).erreur_systeme = d_es_processus;
347: return;
348: }
349:
350: scrutation_interruptions(s_etat_processus);
351: }
352:
353: # ifndef SEMAPHORES_NOMMES
354: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
355: # else
356: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
357: # endif
358: {
359: if (errno != EINTR)
360: {
361: (*s_etat_processus).erreur_systeme = d_es_processus;
362: return;
363: }
364: }
365: }
366: else
367: {
368: if ((*s_etat_processus).profilage == d_vrai)
369: {
370: profilage(s_etat_processus, "Interthread communications (SEND)");
371:
372: if ((*s_etat_processus).erreur_systeme != d_es)
373: {
374: return;
375: }
376: }
377:
378: tid = (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: 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;
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: }
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:
1441: unsigned int i;
1442: unsigned int nombre_colonnes;
1443:
1444: if (sqlite3_prepare_v2((*((struct_connecteur_sql *)
1445: (*s_objet_1).objet)).descripteur.sqlite,
1446: (unsigned char *) (*s_objet_2).objet,
1447: strlen((unsigned char *) (*s_objet_2).objet),
1448: &ppStmt, &queue) != SQLITE_OK)
1449: {
1450: if (connexion_permanente == d_faux)
1451: {
1452: sqlite3_close((*((struct_connecteur_sql *)
1453: (*s_objet_1).objet)).descripteur.sqlite);
1454: }
1455:
1456: liberation(s_etat_processus, s_objet_1);
1457: liberation(s_etat_processus, s_objet_2);
1458:
1459: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1460: return;
1461: }
1462:
1463: presence_resultat = d_faux;
1464: s_objet_resultat = NULL;
1465: l_element_courant = NULL;
1466:
1467: do
1468: {
1469: switch(ios = sqlite3_step(ppStmt))
1470: {
1471: case SQLITE_ROW:
1472: {
1473: if (s_objet_resultat == NULL)
1474: {
1475: if ((s_objet_resultat =
1476: allocation(s_etat_processus, LST)) == NULL)
1477: {
1478: (*s_etat_processus).erreur_systeme =
1479: d_es_allocation_memoire;
1480: return;
1481: }
1482:
1483: presence_resultat = d_vrai;
1484:
1485: // Création d'une liste vide
1486:
1487: (*s_objet_resultat).objet = NULL;
1488: l_element_courant = (*s_objet_resultat).objet;
1489: }
1490:
1491: // Ajout d'une liste au bout de la liste
1492: // contenant les lignes
1493:
1494: if (l_element_courant == NULL)
1495: {
1496: if (((*s_objet_resultat).objet =
1497: allocation_maillon(s_etat_processus))
1498: == NULL)
1499: {
1500: (*s_etat_processus).erreur_systeme =
1501: d_es_allocation_memoire;
1502: }
1503:
1504: l_element_courant = (struct_liste_chainee *)
1505: (*s_objet_resultat).objet;
1506: }
1507: else
1508: {
1509: if (((*l_element_courant).suivant =
1510: allocation_maillon(s_etat_processus))
1511: == NULL)
1512: {
1513: (*s_etat_processus).erreur_systeme =
1514: d_es_allocation_memoire;
1515: return;
1516: }
1517:
1518: l_element_courant = (*l_element_courant).suivant;
1519: }
1520:
1521: (*l_element_courant).suivant = NULL;
1522:
1523: // Création de la liste fille
1524:
1525: if (((*l_element_courant).donnee =
1526: allocation(s_etat_processus, LST)) == NULL)
1527: {
1528: (*s_etat_processus).erreur_systeme =
1529: d_es_allocation_memoire;
1530: return;
1531: }
1532:
1533: (*(*l_element_courant).donnee).objet = NULL;
1534:
1535: // Lecture de la ligne
1536:
1537: nombre_colonnes = sqlite3_data_count(ppStmt);
1538: l_element_courant_ligne = NULL;
1539:
1540: for(i = 0; i < nombre_colonnes; i++)
1541: {
1542: if (l_element_courant_ligne == NULL)
1543: {
1544: if (((*(*l_element_courant).donnee).objet =
1545: allocation_maillon(s_etat_processus))
1546: == NULL)
1547: {
1548: (*s_etat_processus).erreur_systeme =
1549: d_es_allocation_memoire;
1550: return;
1551: }
1552:
1553: l_element_courant_ligne =
1554: (struct_liste_chainee *)
1555: (*(*l_element_courant).donnee).objet;
1556: }
1557: else
1558: {
1559: if (((*l_element_courant_ligne).suivant =
1560: allocation_maillon(s_etat_processus))
1561: == NULL)
1562: {
1563: l_element_courant_ligne =
1564: (*l_element_courant_ligne).suivant;
1565: }
1566:
1567: l_element_courant_ligne =
1568: (*l_element_courant_ligne).suivant;
1569: }
1570:
1571: (*l_element_courant_ligne).suivant = NULL;
1572:
1573: if (((*l_element_courant_ligne).donnee =
1574: allocation(s_etat_processus, CHN))
1575: == NULL)
1576: {
1577: (*s_etat_processus).erreur_systeme =
1578: d_es_allocation_memoire;
1579: return;
1580: }
1581:
1582: if (sqlite3_column_type(ppStmt, i) == SQLITE_NULL)
1583: {
1584: if (((*(*l_element_courant_ligne).donnee).objet
1585: = malloc(5 * sizeof(unsigned char)))
1586: == NULL)
1587: {
1588: (*s_etat_processus).erreur_systeme =
1589: d_es_allocation_memoire;
1590: return;
1591: }
1592:
1593: strcpy((unsigned char *)
1594: (*(*l_element_courant_ligne).donnee)
1595: .objet, "NULL");
1596: }
1597: else
1598: {
1599: if ((resultat = sqlite3_column_text(ppStmt, i))
1600: == NULL)
1601: {
1602: (*s_etat_processus).erreur_systeme =
1603: d_es_allocation_memoire;
1604: return;
1605: }
1606:
1607: if (((*(*l_element_courant_ligne).donnee).objet
1608: = malloc((strlen(resultat) + 1 ) *
1609: sizeof(unsigned char))) == NULL)
1610: {
1611: (*s_etat_processus).erreur_systeme =
1612: d_es_allocation_memoire;
1613: return;
1614: }
1615:
1616: strcpy((unsigned char *)
1617: (*(*l_element_courant_ligne).donnee)
1618: .objet, resultat);
1619: }
1620: }
1621:
1622: break;
1623: }
1624:
1625: case SQLITE_DONE:
1626: {
1627: // Fin de la lecture des données
1628: break;
1629: }
1630:
1631: default:
1632: {
1633: (*s_etat_processus).erreur_systeme =
1634: d_es_erreur_fichier;
1635: return;
1636: }
1637: }
1638: } while(ios != SQLITE_DONE);
1639:
1640: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1641: {
1642: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1643: return;
1644: }
1645:
1646: if (connexion_permanente == d_faux)
1647: {
1648: sqlite3_close((*((struct_connecteur_sql *) (*s_objet_1).objet))
1649: .descripteur.sqlite);
1650: }
1651:
1652: if (presence_resultat == d_vrai)
1653: {
1654: if (empilement(s_etat_processus, &((*s_etat_processus)
1655: .l_base_pile), s_objet_resultat) == d_erreur)
1656: {
1657: return;
1658: }
1659: }
1660: }
1661: else
1662: {
1663: liberation(s_etat_processus, s_objet_1);
1664: liberation(s_etat_processus, s_objet_2);
1665:
1666: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1667: return;
1668: }
1669: }
1670: else
1671: {
1672: liberation(s_etat_processus, s_objet_1);
1673: liberation(s_etat_processus, s_objet_2);
1674:
1675: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1676: return;
1677: }
1678:
1679: liberation(s_etat_processus, s_objet_1);
1680: liberation(s_etat_processus, s_objet_2);
1681:
1682: return;
1683: }
1684:
1685:
1686: /*
1687: ================================================================================
1688: Fonction 'stop'
1689: ================================================================================
1690: Entrées :
1691: --------------------------------------------------------------------------------
1692: Sorties :
1693: --------------------------------------------------------------------------------
1694: Effets de bord : néant
1695: ================================================================================
1696: */
1697:
1698: void
1699: instruction_stop(struct_processus *s_etat_processus)
1700: {
1701: struct_liste_chainee *l_element_courant;
1702:
1703: struct_objet *s_objet;
1704:
1705: (*s_etat_processus).erreur_execution = d_ex;
1706:
1707: if ((*s_etat_processus).affichage_arguments == 'Y')
1708: {
1709: printf("\n STOP ");
1710:
1711: if ((*s_etat_processus).langue == 'F')
1712: {
1713: printf("(arrêt d'un processus)\n\n");
1714: }
1715: else
1716: {
1717: printf("(kill process)\n\n");
1718: }
1719:
1720: printf(" 1: %s\n", d_PRC);
1721:
1722: return;
1723: }
1724: else if ((*s_etat_processus).test_instruction == 'Y')
1725: {
1726: (*s_etat_processus).nombre_arguments = -1;
1727: return;
1728: }
1729:
1730: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1731: {
1732: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1733: {
1734: return;
1735: }
1736: }
1737:
1738: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1739: &s_objet) == d_erreur)
1740: {
1741: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1742: return;
1743: }
1744:
1745: if ((*s_objet).type == PRC)
1746: {
1747: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1748: .processus_detache == d_vrai)
1749: {
1750: envoi_signal_processus((*(*((struct_processus_fils *)
1751: (*s_objet).objet)).thread).pid, rpl_sigstop);
1752: }
1753: else
1754: {
1755: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
1756: {
1757: (*s_etat_processus).erreur_systeme = d_es_processus;
1758: return;
1759: }
1760:
1761: l_element_courant = (struct_liste_chainee *)
1762: (*s_etat_processus).l_base_pile_processus;
1763:
1764: while(l_element_courant != NULL)
1765: {
1766: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1767: .donnee).objet)).thread).processus_detache == d_faux)
1768: {
1769: if ((pthread_equal((*(*((struct_processus_fils *)
1770: (*(*l_element_courant).donnee).objet)).thread).tid,
1771: (*(*((struct_processus_fils *)
1772: (*s_objet).objet)).thread).tid) != 0) &&
1773: ((*(*((struct_processus_fils *)
1774: (*(*l_element_courant).donnee).objet)).thread).pid
1775: == (*(*((struct_processus_fils *)
1776: (*s_objet).objet)).thread).pid))
1777: {
1778: break;
1779: }
1780: }
1781:
1782: l_element_courant = (*l_element_courant).suivant;
1783: }
1784:
1785: if (l_element_courant != NULL)
1786: {
1787: // Le champ thread_actif est un pointeur sur un champ de la
1788: // structure s_argument_thread libéré par la fonction
1789: // retrait_thread_surveillance().
1790:
1791: if ((*(*((struct_processus_fils *)
1792: (*s_objet).objet)).thread).thread_actif == d_vrai)
1793: {
1794: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
1795: (*s_objet).objet)).thread).mutex)) != 0)
1796: {
1797: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
1798: != 0)
1799: {
1800: (*s_etat_processus).erreur_systeme = d_es_processus;
1801: return;
1802: }
1803:
1804: (*s_etat_processus).erreur_systeme = d_es_processus;
1805: return;
1806: }
1807:
1808: if ((*(*((struct_processus_fils *)
1809: (*s_objet).objet)).thread).thread_actif == d_vrai)
1810: {
1811: envoi_signal_thread((*(*((struct_processus_fils *)
1812: (*s_objet).objet)).thread).tid, rpl_sigstop);
1813: }
1814:
1815: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
1816: (*s_objet).objet)).thread).mutex)) != 0)
1817: {
1818: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
1819: != 0)
1820: {
1821: (*s_etat_processus).erreur_systeme = d_es_processus;
1822: return;
1823: }
1824:
1825: (*s_etat_processus).erreur_systeme = d_es_processus;
1826: return;
1827: }
1828: }
1829: }
1830:
1831: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1832: {
1833: (*s_etat_processus).erreur_systeme = d_es_processus;
1834: return;
1835: }
1836: }
1837: }
1838: else
1839: {
1840: liberation(s_etat_processus, s_objet);
1841:
1842: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1843: return;
1844: }
1845:
1846: liberation(s_etat_processus, s_objet);
1847:
1848: return;
1849: }
1850:
1851: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>