![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_s8.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to instructions_s8.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.32 bertrand 3: RPL/2 (R) version 4.1.3
1.20 bertrand 4: Copyright (C) 1989-2011 Dr. BERTRAND Joël
1.1 bertrand 5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
1.15 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'splash'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_splash(struct_processus *s_etat_processus)
40: {
41: real8 attente;
42:
43: struct_objet *s_objet;
44:
45: (*s_etat_processus).erreur_execution = d_ex;
46:
47: if ((*s_etat_processus).affichage_arguments == 'Y')
48: {
49: printf("\n SPLASH ");
50:
51: if ((*s_etat_processus).langue == 'F')
52: {
53: printf("(écran RPL/2)\n\n");
54: }
55: else
56: {
57: printf("(RPL/2 splash screen)\n\n");
58: }
59:
60: printf(" 1: %s, %s\n", d_INT, d_REL);
61:
62: return;
63: }
64: else if ((*s_etat_processus).test_instruction == 'Y')
65: {
66: (*s_etat_processus).nombre_arguments = -1;
67: return;
68: }
69:
70: if (test_cfsf(s_etat_processus, 31) == d_vrai)
71: {
72: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
73: {
74: return;
75: }
76: }
77:
78: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
79: &s_objet) == d_erreur)
80: {
81: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
82: return;
83: }
84:
85: if (((*s_objet).type == INT) ||
86: ((*s_objet).type == REL))
87: {
88: if ((*s_objet).type == INT)
89: {
90: attente = (real8) (*((integer8 *) (*s_objet).objet));
91: }
92: else
93: {
94: attente = (*((real8 *) (*s_objet).objet));
95: }
96:
97: if (attente < 0)
98: {
99: liberation(s_etat_processus, s_objet);
100:
101: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
102: return;
103: }
104:
105: encart(s_etat_processus, (unsigned long) (attente * 1E6));
106: }
107: else
108: {
109: liberation(s_etat_processus, s_objet);
110:
111: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
112: return;
113: }
114:
115: liberation(s_etat_processus, s_objet);
116:
117: return;
118: }
119:
120:
121: /*
122: ================================================================================
123: Fonction 'send'
124: ================================================================================
125: Entrées :
126: --------------------------------------------------------------------------------
127: Sorties :
128: --------------------------------------------------------------------------------
129: Effets de bord : néant
130: ================================================================================
131: */
132:
133: void
134: instruction_send(struct_processus *s_etat_processus)
135: {
136: pid_t pid;
137:
138: pthread_t tid;
139:
140: sig_atomic_t registre;
141:
142: ssize_t longueur_ecriture;
143:
144: struct_objet *s_objet;
145:
146: struct timespec attente;
147:
148: unsigned char tampon;
149:
150: (*s_etat_processus).erreur_execution = d_ex;
151:
152: if ((*s_etat_processus).affichage_arguments == 'Y')
153: {
154: printf("\n SEND ");
155:
156: if ((*s_etat_processus).langue == 'F')
157: {
158: printf("(envoi de données au processus père)\n\n");
159: }
160: else
161: {
162: printf("(send data to parent process)\n\n");
163: }
164:
165: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
166: " %s, %s, %s, %s, %s,\n"
167: " %s, %s, %s, %s, %s\n",
168: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
169: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_TAB);
170:
171: return;
172: }
173: else if ((*s_etat_processus).test_instruction == 'Y')
174: {
175: (*s_etat_processus).nombre_arguments = -1;
176: return;
177: }
178:
179: if (test_cfsf(s_etat_processus, 31) == d_vrai)
180: {
181: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
182: {
183: return;
184: }
185: }
186:
187: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
188: &s_objet) == d_erreur)
189: {
190: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
191: return;
192: }
193:
194: if ((*s_etat_processus).presence_pipes == d_faux)
195: {
196: liberation(s_etat_processus, s_objet);
197:
198: (*s_etat_processus).erreur_execution = d_ex_absence_processus_pere;
199: return;
200: }
201:
202: if (((*s_objet).type != INT) &&
203: ((*s_objet).type != REL) &&
204: ((*s_objet).type != CPL) &&
205: ((*s_objet).type != VIN) &&
206: ((*s_objet).type != VRL) &&
207: ((*s_objet).type != VCX) &&
208: ((*s_objet).type != MIN) &&
209: ((*s_objet).type != MRL) &&
210: ((*s_objet).type != MCX) &&
211: ((*s_objet).type != BIN) &&
212: ((*s_objet).type != NOM) &&
213: ((*s_objet).type != CHN) &&
214: ((*s_objet).type != LST) &&
215: ((*s_objet).type != ALG) &&
216: ((*s_objet).type != RPN) &&
217: ((*s_objet).type != TBL))
218: {
219: liberation(s_etat_processus, s_objet);
220:
221: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
222: return;
223: }
224:
225: /*
226: * On signale au processus père qu'il y a un objet de plus
227: * dans le pipe de données.
228: */
229:
230: registre = (*s_etat_processus).var_volatile_traitement_retarde_stop;
231: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
232:
233: if ((*s_etat_processus).processus_detache == d_vrai)
234: {
235: if ((*s_etat_processus).profilage == d_vrai)
236: {
237: profilage(s_etat_processus, "Interprocess communications (SEND)");
238:
239: if ((*s_etat_processus).erreur_systeme != d_es)
240: {
241: return;
242: }
243: }
244:
245: pid = -3;
246:
247: attente.tv_sec = 0;
248: attente.tv_nsec = GRANULARITE_us * 1000;
249:
1.36 ! bertrand 250: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 251: {
252: (*s_etat_processus).erreur_systeme = d_es_processus;
253: return;
254: }
255:
256: while((longueur_ecriture = write_atomic(s_etat_processus,
257: (*s_etat_processus).pipe_nombre_objets_attente,
258: &pid, sizeof(pid))) != sizeof(pid))
259: {
1.36 ! bertrand 260: if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 261: {
1.34 bertrand 262: (*s_etat_processus).erreur_systeme = d_es_processus;
263: return;
1.1 bertrand 264: }
265:
266: if (longueur_ecriture == -1)
267: {
268: if ((*s_etat_processus).profilage == d_vrai)
269: {
270: profilage(s_etat_processus, NULL);
271: }
272:
273: (*s_etat_processus).erreur_systeme = d_es_processus;
274: return;
275: }
276:
277: nanosleep(&attente, NULL);
278: INCR_GRANULARITE(attente.tv_nsec);
279:
1.36 ! bertrand 280: if (sem_post(&((*s_etat_processus).semaphore_fork))
1.34 bertrand 281: != 0)
1.7 bertrand 282: {
283: (*s_etat_processus).erreur_systeme = d_es_processus;
284: return;
285: }
1.35 bertrand 286:
287: scrutation_interruptions(s_etat_processus);
1.1 bertrand 288: }
289:
290: pid = getpid();
291:
292: attente.tv_sec = 0;
293: attente.tv_nsec = GRANULARITE_us * 1000;
294:
295: while((longueur_ecriture = write_atomic(s_etat_processus,
296: (*s_etat_processus).pipe_nombre_objets_attente,
297: &pid, sizeof(pid))) != sizeof(pid))
298: {
1.36 ! bertrand 299: if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 300: {
1.34 bertrand 301: (*s_etat_processus).erreur_systeme = d_es_processus;
302: return;
1.1 bertrand 303: }
304:
305: if (longueur_ecriture == -1)
306: {
307: if ((*s_etat_processus).profilage == d_vrai)
308: {
309: profilage(s_etat_processus, NULL);
310: }
311:
312: (*s_etat_processus).erreur_systeme = d_es_processus;
313: return;
314: }
315:
316: nanosleep(&attente, NULL);
317: INCR_GRANULARITE(attente.tv_nsec);
318:
1.36 ! bertrand 319: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 320: {
321: (*s_etat_processus).erreur_systeme = d_es_processus;
322: return;
323: }
1.35 bertrand 324:
325: scrutation_interruptions(s_etat_processus);
1.1 bertrand 326: }
327:
1.36 ! bertrand 328: if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 329: {
1.34 bertrand 330: (*s_etat_processus).erreur_systeme = d_es_processus;
331: return;
1.1 bertrand 332: }
333: }
334: else
335: {
336: if ((*s_etat_processus).profilage == d_vrai)
337: {
338: profilage(s_etat_processus, "Interthread communications (SEND)");
339:
340: if ((*s_etat_processus).erreur_systeme != d_es)
341: {
342: return;
343: }
344: }
345:
346: tid = -3;
347:
348: attente.tv_sec = 0;
349: attente.tv_nsec = GRANULARITE_us * 1000;
350:
1.36 ! bertrand 351: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 352: {
353: (*s_etat_processus).erreur_systeme = d_es_processus;
354: return;
355: }
356:
357: while((longueur_ecriture = write_atomic(s_etat_processus,
358: (*s_etat_processus).pipe_nombre_objets_attente,
359: &tid, sizeof(tid))) != sizeof(tid))
360: {
1.36 ! bertrand 361: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 362: {
1.34 bertrand 363: (*s_etat_processus).erreur_systeme = d_es_processus;
364: return;
1.1 bertrand 365: }
366:
367: if (longueur_ecriture == -1)
368: {
369: if ((*s_etat_processus).profilage == d_vrai)
370: {
371: profilage(s_etat_processus, NULL);
372: }
373:
374: (*s_etat_processus).erreur_systeme = d_es_processus;
375: return;
376: }
377:
378: nanosleep(&attente, NULL);
379: INCR_GRANULARITE(attente.tv_nsec);
380:
1.36 ! bertrand 381: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 382: {
383: (*s_etat_processus).erreur_systeme = d_es_processus;
384: return;
385: }
1.35 bertrand 386:
387: scrutation_interruptions(s_etat_processus);
1.1 bertrand 388: }
389:
390: tid = pthread_self();
391:
392: attente.tv_sec = 0;
393: attente.tv_nsec = GRANULARITE_us * 1000;
394:
395: while((longueur_ecriture = write_atomic(s_etat_processus,
396: (*s_etat_processus).pipe_nombre_objets_attente,
397: &tid, sizeof(tid))) != sizeof(tid))
398: {
1.36 ! bertrand 399: if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 400: {
1.34 bertrand 401: (*s_etat_processus).erreur_systeme = d_es_processus;
402: return;
1.1 bertrand 403: }
404:
405: if (longueur_ecriture == -1)
406: {
407: if ((*s_etat_processus).profilage == d_vrai)
408: {
409: profilage(s_etat_processus, NULL);
410: }
411:
412: (*s_etat_processus).erreur_systeme = d_es_processus;
413: return;
414: }
415:
416: nanosleep(&attente, NULL);
417: INCR_GRANULARITE(attente.tv_nsec);
418:
1.36 ! bertrand 419: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.7 bertrand 420: {
421: (*s_etat_processus).erreur_systeme = d_es_processus;
422: return;
423: }
1.35 bertrand 424:
425: scrutation_interruptions(s_etat_processus);
1.1 bertrand 426: }
427:
1.36 ! bertrand 428: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 429: {
1.34 bertrand 430: (*s_etat_processus).erreur_systeme = d_es_processus;
431: return;
1.1 bertrand 432: }
433: }
434:
435: (*s_etat_processus).nombre_objets_envoyes_non_lus++;
436:
437: attente.tv_sec = 0;
438: attente.tv_nsec = GRANULARITE_us * 1000;
439:
1.36 ! bertrand 440: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.7 bertrand 441: {
442: (*s_etat_processus).erreur_systeme = d_es_processus;
443: return;
444: }
1.1 bertrand 445:
446: while(read_atomic(s_etat_processus, (*s_etat_processus).pipe_acquittement,
447: &tampon, sizeof(unsigned char)) != sizeof(unsigned char))
448: {
1.36 ! bertrand 449: if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 450: {
1.34 bertrand 451: (*s_etat_processus).erreur_systeme = d_es_processus;
452: return;
1.1 bertrand 453: }
454:
455: nanosleep(&attente, NULL);
456: INCR_GRANULARITE(attente.tv_nsec);
457:
1.36 ! bertrand 458: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 459: {
460: (*s_etat_processus).erreur_systeme = d_es_processus;
461: return;
462: }
1.35 bertrand 463:
464: scrutation_interruptions(s_etat_processus);
1.1 bertrand 465: }
466:
1.36 ! bertrand 467: if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 468: {
1.34 bertrand 469: (*s_etat_processus).erreur_systeme = d_es_processus;
470: return;
1.1 bertrand 471: }
472:
473: // Envoi d'un PID invalide (-1) pour ne pas bloquer le thread
474: // de surveillance.
475:
476: if ((*s_etat_processus).processus_detache == d_vrai)
477: {
478: pid = -1;
479:
480: attente.tv_sec = 0;
481: attente.tv_nsec = GRANULARITE_us * 1000;
482:
1.36 ! bertrand 483: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 484: {
485: (*s_etat_processus).erreur_systeme = d_es_processus;
486: return;
487: }
488:
489: while((longueur_ecriture = write_atomic(s_etat_processus,
490: (*s_etat_processus).pipe_nombre_interruptions_attente,
491: &pid, sizeof(pid))) != sizeof(pid))
492: {
1.36 ! bertrand 493: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 494: {
1.34 bertrand 495: (*s_etat_processus).erreur_systeme = d_es_processus;
496: return;
1.1 bertrand 497: }
498:
499: if (longueur_ecriture == -1)
500: {
501: if ((*s_etat_processus).profilage == d_vrai)
502: {
503: profilage(s_etat_processus, NULL);
504: }
505:
506: (*s_etat_processus).erreur_systeme = d_es_processus;
507: return;
508: }
509:
510: nanosleep(&attente, NULL);
511: INCR_GRANULARITE(attente.tv_nsec);
512:
1.36 ! bertrand 513: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 514: {
515: (*s_etat_processus).erreur_systeme = d_es_processus;
516: return;
517: }
518: }
519:
1.36 ! bertrand 520: if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 521: {
1.34 bertrand 522: (*s_etat_processus).erreur_systeme = d_es_processus;
523: return;
1.1 bertrand 524: }
1.35 bertrand 525:
526: scrutation_interruptions(s_etat_processus);
1.1 bertrand 527: }
528: else
529: {
530: tid = -1;
531:
532: attente.tv_sec = 0;
533: attente.tv_nsec = GRANULARITE_us * 1000;
534:
1.36 ! bertrand 535: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 536: {
537: (*s_etat_processus).erreur_systeme = d_es_processus;
538: return;
539: }
540:
541: while((longueur_ecriture = write_atomic(s_etat_processus,
542: (*s_etat_processus).pipe_nombre_interruptions_attente,
543: &tid, sizeof(tid))) != sizeof(tid))
544: {
1.36 ! bertrand 545: if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 546: {
1.34 bertrand 547: (*s_etat_processus).erreur_systeme = d_es_processus;
548: return;
1.1 bertrand 549: }
550:
551: if (longueur_ecriture == -1)
552: {
553: if ((*s_etat_processus).profilage == d_vrai)
554: {
555: profilage(s_etat_processus, NULL);
556: }
557:
558: (*s_etat_processus).erreur_systeme = d_es_processus;
559: return;
560: }
561:
562: nanosleep(&attente, NULL);
563: INCR_GRANULARITE(attente.tv_nsec);
564:
1.36 ! bertrand 565: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 566: {
567: (*s_etat_processus).erreur_systeme = d_es_processus;
568: return;
569: }
1.35 bertrand 570:
571: scrutation_interruptions(s_etat_processus);
1.1 bertrand 572: }
573:
1.36 ! bertrand 574: if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 575: {
1.34 bertrand 576: (*s_etat_processus).erreur_systeme = d_es_processus;
577: return;
1.1 bertrand 578: }
579: }
580:
581: // ecriture_pipe() ne peut être interrompu par un signal.
582:
1.36 ! bertrand 583: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 584: {
585: (*s_etat_processus).erreur_systeme = d_es_processus;
586: return;
587: }
588:
589: if (ecriture_pipe(s_etat_processus, (*s_etat_processus).pipe_donnees,
590: s_objet) == d_erreur)
591: {
1.36 ! bertrand 592: if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 593: {
1.34 bertrand 594: (*s_etat_processus).erreur_systeme = d_es_processus;
595: return;
1.1 bertrand 596: }
597:
598: if ((*s_etat_processus).profilage == d_vrai)
599: {
600: profilage(s_etat_processus, NULL);
601: }
602:
603: liberation(s_etat_processus, s_objet);
604: return;
605: }
606:
1.36 ! bertrand 607: if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1.1 bertrand 608: {
1.34 bertrand 609: (*s_etat_processus).erreur_systeme = d_es_processus;
610: return;
1.1 bertrand 611: }
612:
613: if ((*s_etat_processus).profilage == d_vrai)
614: {
615: profilage(s_etat_processus, NULL);
616: }
617:
618: if (registre == 0)
619: {
620: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1)
621: {
622: (*s_etat_processus).var_volatile_requete_arret = -1;
623: }
624:
625: (*s_etat_processus).var_volatile_traitement_retarde_stop = registre;
626: }
627:
628: liberation(s_etat_processus, s_objet);
629: return;
630: }
631:
632:
633: /*
634: ================================================================================
635: Fonction 'sqlquery'
636: ================================================================================
637: Entrées :
638: --------------------------------------------------------------------------------
639: Sorties :
640: --------------------------------------------------------------------------------
641: Effets de bord : néant
642: ================================================================================
643: */
644:
645: void
646: instruction_sqlquery(struct_processus *s_etat_processus)
647: {
648: # define d_LONGUEUR 1024
649:
650: logical1 connexion_permanente;
651: logical1 presence_resultat;
652:
653: struct_objet *s_copie_1;
654: struct_objet *s_objet_1;
655: struct_objet *s_copie_2;
656: struct_objet *s_objet_2;
657: struct_objet *s_objet_resultat;
658:
659: struct_liste_chainee *l_element_courant;
660: struct_liste_chainee *l_element_courant_ligne;
661:
662: unsigned char *tampon;
663:
664: unsigned int i;
665: unsigned int j;
666: unsigned int nombre_colonnes;
667: unsigned int nombre_lignes;
668:
669: (*s_etat_processus).erreur_execution = d_ex;
670:
671: if ((*s_etat_processus).affichage_arguments == 'Y')
672: {
673: printf("\n SQLQUERY ");
674:
675: if ((*s_etat_processus).langue == 'F')
676: {
677: printf("(requête SQL)\n\n");
678: }
679: else
680: {
681: printf("(SQL query)\n\n");
682: }
683:
684: printf(" 2: %s\n", d_CHN);
685: printf(" 1: %s\n", d_LST);
686: printf("-> 1: %s\n\n", d_LST);
687:
688: printf(" 2: %s\n", d_CHN);
689: printf(" 1: %s\n", d_SQL);
690: printf("-> 1: %s\n\n", d_LST);
691:
692: if ((*s_etat_processus).langue == 'F')
693: {
694: printf(" Utilisation :\n\n");
695: }
696: else
697: {
698: printf(" Usage:\n\n");
699: }
700:
701: printf(" \"select * from table\"\n");
702: printf(" { \"mysql\" \"server\" \"database\" "
703: "\"user\" \"password\" } SQLQUERY\n");
704: printf(" \"select field from table\"\n");
705: printf(" { \"postgresql:iso-8859-1\" \"server\" "
706: "\"database\" \"user\" \"password\" port }\n");
707: printf(" SQLQUERY\n");
708:
709: return;
710: }
711: else if ((*s_etat_processus).test_instruction == 'Y')
712: {
713: (*s_etat_processus).nombre_arguments = -1;
714: return;
715: }
716:
717: if (test_cfsf(s_etat_processus, 31) == d_vrai)
718: {
719: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
720: {
721: return;
722: }
723: }
724:
725: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
726: &s_objet_1) == d_erreur)
727: {
728: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
729: return;
730: }
731:
732: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
733: &s_objet_2) == d_erreur)
734: {
735: liberation(s_etat_processus, s_objet_1);
736:
737: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
738: return;
739: }
740:
741: if ((*s_objet_1).type == LST)
742: {
743: connexion_permanente = d_faux;
744:
745: s_copie_1 = s_objet_1;
746:
747: if ((s_objet_1 = parametres_sql(s_etat_processus, s_copie_1)) == NULL)
748: {
749: liberation(s_etat_processus, s_copie_1);
750: liberation(s_etat_processus, s_objet_2);
751: return;
752: }
753:
754: liberation(s_etat_processus, s_copie_1);
755: }
756: else
757: {
758: if ((*s_objet_1).type == SQL)
759: {
760: if (((*((struct_connecteur_sql *) (*s_objet_1).objet)).pid !=
761: getpid()) || (pthread_equal((*((struct_connecteur_sql *)
762: (*s_objet_1).objet)).tid, pthread_self()) == 0))
763: {
764: (*s_etat_processus).erreur_execution =
765: d_ex_fichier_hors_contexte;
766:
767: liberation(s_etat_processus, s_objet_1);
768: liberation(s_etat_processus, s_objet_2);
769: return;
770: }
771: }
772:
773: connexion_permanente = d_vrai;
774: }
775:
776: if (((*s_objet_1).type == SQL) && ((*s_objet_2).type == CHN))
777: {
778: if ((*((struct_connecteur_sql *) (*s_objet_1).objet)).locale != NULL)
779: {
780: /*
781: * Transcodage de la commande SQL
782: */
783:
784: if ((s_copie_2 = copie_objet(s_etat_processus, s_objet_2, 'O'))
785: == NULL)
786: {
787: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
788: return;
789: }
790:
791: liberation(s_etat_processus, s_objet_2);
792: s_objet_2 = s_copie_2;
793:
794: tampon = (*s_objet_2).objet;
795:
796: if (((*s_objet_2).objet = transliteration(s_etat_processus, tampon,
797: (*((struct_connecteur_sql *) (*s_objet_1).objet)).locale,
798: d_locale)) == NULL)
799: {
800: return;
801: }
802:
803: free(tampon);
804: }
805:
806: /*
807: * Pilote MySQL
808: */
809:
810: if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
811: "MYSQL") == 0)
812: {
813: # ifdef MYSQL_SUPPORT
814:
815: MYSQL_RES *resultat_mysql;
816: MYSQL_ROW ligne;
817:
818: if (mysql_real_query((*((struct_connecteur_sql *) (*s_objet_1)
819: .objet)).descripteur.mysql, (unsigned char *) (*s_objet_2)
820: .objet, strlen((unsigned char *) (*s_objet_2).objet)) != 0)
821: {
822: if (connexion_permanente == d_faux)
823: {
824: mysql_close((*((struct_connecteur_sql *) (*s_objet_1)
825: .objet)).descripteur.mysql);
826: }
827:
828: liberation(s_etat_processus, s_objet_1);
829: liberation(s_etat_processus, s_objet_2);
830:
831: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
832: return;
833: }
834:
835: if ((resultat_mysql = mysql_store_result(
836: (*((struct_connecteur_sql *) (*s_objet_1).objet))
837: .descripteur.mysql)) == NULL)
838: {
839: // La requête ne renvoie rien (exemple : INSERT)
840: presence_resultat = d_faux;
841: nombre_colonnes = 0;
842: }
843: else
844: {
845: // La requête renvoie une ou plusieurs valeurs.
846: presence_resultat = d_vrai;
847: nombre_colonnes = mysql_field_count((*((struct_connecteur_sql *)
848: (*s_objet_1).objet)).descripteur.mysql);
849: }
850:
851: if ((s_objet_resultat = allocation(s_etat_processus, LST))
852: == NULL)
853: {
854: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
855: return;
856: }
857:
858: (*s_objet_resultat).objet = NULL;
859: l_element_courant = (*s_objet_resultat).objet;
860:
861: while(((presence_resultat == d_vrai) ?
862: (ligne = mysql_fetch_row(resultat_mysql)) : NULL) != NULL)
863: {
864: unsigned long *longueurs;
865:
866: longueurs = mysql_fetch_lengths(resultat_mysql);
867:
868: if (l_element_courant == NULL)
869: {
870: if (((*s_objet_resultat).objet =
871: allocation_maillon(s_etat_processus)) == NULL)
872: {
873: (*s_etat_processus).erreur_systeme =
874: d_es_allocation_memoire;
875: return;
876: }
877:
878: l_element_courant = (struct_liste_chainee *)
879: (*s_objet_resultat).objet;
880: }
881: else
882: {
883: if (((*l_element_courant).suivant =
884: allocation_maillon(s_etat_processus)) == NULL)
885: {
886: (*s_etat_processus).erreur_systeme =
887: d_es_allocation_memoire;
888: return;
889: }
890:
891: l_element_courant = (*l_element_courant).suivant;
892: }
893:
894: (*l_element_courant).suivant = NULL;
895:
896: if (((*l_element_courant).donnee = allocation(s_etat_processus,
897: LST)) == NULL)
898: {
899: (*s_etat_processus).erreur_systeme =
900: d_es_allocation_memoire;
901: return;
902: }
903:
904: (*(*l_element_courant).donnee).objet = NULL;
905: l_element_courant_ligne = NULL;
906:
907: for(i = 0; i < nombre_colonnes; i++)
908: {
909: if (l_element_courant_ligne == NULL)
910: {
911: if (((*(*l_element_courant).donnee).objet =
912: allocation_maillon(s_etat_processus)) == NULL)
913: {
914: (*s_etat_processus).erreur_systeme =
915: d_es_allocation_memoire;
916: return;
917: }
918:
919: l_element_courant_ligne = (struct_liste_chainee *)
920: (*(*l_element_courant).donnee).objet;
921: }
922: else
923: {
924: if (((*l_element_courant_ligne).suivant =
925: allocation_maillon(s_etat_processus)) == NULL)
926: {
927: (*s_etat_processus).erreur_systeme =
928: d_es_allocation_memoire;
929: return;
930: }
931:
932: l_element_courant_ligne =
933: (*l_element_courant_ligne).suivant;
934: }
935:
936: (*l_element_courant_ligne).suivant = NULL;
937:
938: if (((*l_element_courant_ligne).donnee =
939: allocation(s_etat_processus, CHN)) == NULL)
940: {
941: (*s_etat_processus).erreur_systeme =
942: d_es_allocation_memoire;
943: return;
944: }
945:
946: if (ligne[i] == NULL)
947: {
948: if (((*(*l_element_courant_ligne).donnee).objet =
949: malloc(5 * sizeof(unsigned char))) == NULL)
950: {
951: (*s_etat_processus).erreur_systeme =
952: d_es_allocation_memoire;
953: return;
954: }
955:
956: strcpy((unsigned char *) (*(*l_element_courant_ligne)
957: .donnee).objet, "NULL");
958: }
959: else
960: {
961: if (((*(*l_element_courant_ligne).donnee).objet =
962: malloc((longueurs[i] + 1) *
963: sizeof(unsigned char))) == NULL)
964: {
965: (*s_etat_processus).erreur_systeme =
966: d_es_allocation_memoire;
967: return;
968: }
969:
970: strcpy((unsigned char *) (*(*l_element_courant_ligne)
971: .donnee).objet, ligne[i]);
972: }
973: }
974: }
975:
976: mysql_free_result(resultat_mysql);
977:
978: if (connexion_permanente == d_faux)
979: {
980: mysql_close((*((struct_connecteur_sql *) (*s_objet_1).objet))
981: .descripteur.mysql);
982: }
983:
984: if (presence_resultat == d_vrai)
985: {
986: if (empilement(s_etat_processus,
987: &((*s_etat_processus).l_base_pile),
988: s_objet_resultat) == d_erreur)
989: {
990: return;
991: }
992: }
993:
994: # else
995:
996: if ((*s_etat_processus).langue == 'F')
997: {
998: printf("+++Attention : Support de MySQL non compilé !\n");
999: }
1000: else
1001: {
1002: printf("+++Warning : MySQL support not available !\n");
1003: }
1004:
1005: fflush(stdout);
1006: # endif
1007: }
1008:
1009: /*
1010: * Pilote PostgreSQL
1011: */
1012:
1013: else if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
1014: "POSTGRESQL") == 0)
1015: {
1016: # ifdef POSTGRESQL_SUPPORT
1017:
1018: PGresult *resultat_postgresql;
1019:
1020: if (PQstatus((*((struct_connecteur_sql *) (*s_objet_1).objet))
1021: .descripteur.postgresql) != CONNECTION_OK)
1022: {
1023: if (connexion_permanente == d_faux)
1024: {
1025: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet))
1026: .descripteur.postgresql);
1027: }
1028:
1029: liberation(s_etat_processus, s_objet_1);
1030: liberation(s_etat_processus, s_objet_2);
1031:
1032: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1033: return;
1034: }
1035:
1036: resultat_postgresql = PQexec((*((struct_connecteur_sql *)
1037: (*s_objet_1).objet)).descripteur.postgresql,
1038: (unsigned char *) (*s_objet_2).objet);
1039: presence_resultat = d_faux;
1040:
1041: switch(PQresultStatus(resultat_postgresql))
1042: {
1043: case PGRES_COMMAND_OK :
1044: { // Commande qui ne renvoit rien
1045: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1046: == NULL)
1047: {
1048: (*s_etat_processus).erreur_systeme =
1049: d_es_allocation_memoire;
1050: return;
1051: }
1052:
1053: (*s_objet_resultat).objet = NULL;
1054: l_element_courant = (*s_objet_resultat).objet;
1055: presence_resultat = d_vrai;
1056:
1057: break;
1058: }
1059:
1060: case PGRES_TUPLES_OK :
1061: { // Commande renvoyant des données
1062: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1063: == NULL)
1064: {
1065: (*s_etat_processus).erreur_systeme =
1066: d_es_allocation_memoire;
1067: return;
1068: }
1069:
1070: (*s_objet_resultat).objet = NULL;
1071: l_element_courant = (*s_objet_resultat).objet;
1072: presence_resultat = d_vrai;
1073:
1074: nombre_colonnes = PQnfields(resultat_postgresql);
1075: nombre_lignes = PQntuples(resultat_postgresql);
1076:
1077: for(i = 0; i < nombre_lignes; i++)
1078: {
1079: // Chaînage d'un nouveau maillon de la liste résultat
1080:
1081: if (l_element_courant == NULL)
1082: {
1083: if (((*s_objet_resultat).objet =
1084: allocation_maillon(s_etat_processus))
1085: == NULL)
1086: {
1087: (*s_etat_processus).erreur_systeme =
1088: d_es_allocation_memoire;
1089: return;
1090: }
1091:
1092: l_element_courant = (struct_liste_chainee *)
1093: (*s_objet_resultat).objet;
1094: }
1095: else
1096: {
1097: if (((*l_element_courant).suivant =
1098: allocation_maillon(s_etat_processus))
1099: == NULL)
1100: {
1101: (*s_etat_processus).erreur_systeme =
1102: d_es_allocation_memoire;
1103: return;
1104: }
1105:
1106: l_element_courant = (*l_element_courant).suivant;
1107: }
1108:
1109: (*l_element_courant).suivant = NULL;
1110:
1111: // Création de la liste fille
1112:
1113: if (((*l_element_courant).donnee =
1114: allocation(s_etat_processus, LST)) == NULL)
1115: {
1116: (*s_etat_processus).erreur_systeme =
1117: d_es_allocation_memoire;
1118: return;
1119: }
1120:
1121: (*(*l_element_courant).donnee).objet = NULL;
1122: l_element_courant_ligne = NULL;
1123:
1124: for(j = 0; j < nombre_colonnes; j++)
1125: {
1126: if (l_element_courant_ligne == NULL)
1127: {
1128: if (((*(*l_element_courant).donnee).objet =
1129: allocation_maillon(s_etat_processus))
1130: == NULL)
1131: {
1132: (*s_etat_processus).erreur_systeme =
1133: d_es_allocation_memoire;
1134: return;
1135: }
1136:
1137: l_element_courant_ligne =
1138: (struct_liste_chainee *)
1139: (*(*l_element_courant).donnee).objet;
1140: }
1141: else
1142: {
1143: if (((*l_element_courant_ligne).suivant =
1144: allocation_maillon(s_etat_processus))
1145: == NULL)
1146: {
1147: l_element_courant_ligne =
1148: (*l_element_courant_ligne).suivant;
1149: }
1150:
1151: l_element_courant_ligne =
1152: (*l_element_courant_ligne).suivant;
1153: }
1154:
1155: (*l_element_courant_ligne).suivant = NULL;
1156:
1157: if (((*l_element_courant_ligne).donnee =
1158: allocation(s_etat_processus, CHN))
1159: == NULL)
1160: {
1161: (*s_etat_processus).erreur_systeme =
1162: d_es_allocation_memoire;
1163: return;
1164: }
1165:
1166: if (PQgetisnull(resultat_postgresql, i, j) != 0)
1167: {
1168: if (((*(*l_element_courant_ligne).donnee).objet
1169: = malloc(5 * sizeof(unsigned char)))
1170: == NULL)
1171: {
1172: (*s_etat_processus).erreur_systeme =
1173: d_es_allocation_memoire;
1174: return;
1175: }
1176:
1177: strcpy((unsigned char *)
1178: (*(*l_element_courant_ligne).donnee)
1179: .objet, "NULL");
1180: }
1181: else
1182: {
1183: if (((*(*l_element_courant_ligne).donnee).objet
1184: = malloc((PQgetlength(
1185: resultat_postgresql, i, j) + 1) *
1186: sizeof(unsigned char))) == NULL)
1187: {
1188: (*s_etat_processus).erreur_systeme =
1189: d_es_allocation_memoire;
1190: return;
1191: }
1192:
1193: strcpy((unsigned char *)
1194: (*(*l_element_courant_ligne).donnee)
1195: .objet, PQgetvalue(resultat_postgresql,
1196: i, j));
1197: }
1198: }
1199: }
1200:
1201: break;
1202: }
1203:
1204: case PGRES_EMPTY_QUERY :
1205: case PGRES_COPY_OUT :
1206: case PGRES_COPY_IN :
1207: case PGRES_BAD_RESPONSE :
1208: case PGRES_NONFATAL_ERROR :
1209: case PGRES_FATAL_ERROR :
1210: default :
1211: {
1212: printf("%s\n", PQresultErrorMessage(resultat_postgresql));
1213: PQclear(resultat_postgresql);
1214:
1215: if (connexion_permanente == d_faux)
1216: {
1217: PQfinish((*((struct_connecteur_sql *) (*s_objet_1)
1218: .objet)).descripteur.postgresql);
1219: }
1220:
1221: liberation(s_etat_processus, s_objet_1);
1222: liberation(s_etat_processus, s_objet_2);
1223:
1224: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1225:
1226: return;
1227: break;
1228: }
1229: }
1230:
1231: PQclear(resultat_postgresql);
1232:
1233: if (connexion_permanente == d_faux)
1234: {
1235: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet))
1236: .descripteur.postgresql);
1237: }
1238:
1239: if (presence_resultat == d_vrai)
1240: {
1241: if (empilement(s_etat_processus, &((*s_etat_processus)
1242: .l_base_pile), s_objet_resultat) == d_erreur)
1243: {
1244: return;
1245: }
1246: }
1247:
1248: # else
1249:
1250: if ((*s_etat_processus).langue == 'F')
1251: {
1252: printf("+++Attention : Support de PostgreSQL non compilé !\n");
1253: }
1254: else
1255: {
1256: printf("+++Warning : PostgreSQL support not available !\n");
1257: }
1258:
1259: fflush(stdout);
1260: # endif
1261: }
1262: else
1263: {
1264: liberation(s_etat_processus, s_objet_1);
1265: liberation(s_etat_processus, s_objet_2);
1266:
1267: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1268: return;
1269: }
1270: }
1271: else
1272: {
1273: liberation(s_etat_processus, s_objet_1);
1274: liberation(s_etat_processus, s_objet_2);
1275:
1276: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1277: return;
1278: }
1279:
1280: liberation(s_etat_processus, s_objet_1);
1281: liberation(s_etat_processus, s_objet_2);
1282:
1283: return;
1284: }
1285:
1286:
1287: /*
1288: ================================================================================
1289: Fonction 'stop'
1290: ================================================================================
1291: Entrées :
1292: --------------------------------------------------------------------------------
1293: Sorties :
1294: --------------------------------------------------------------------------------
1295: Effets de bord : néant
1296: ================================================================================
1297: */
1298:
1299: void
1300: instruction_stop(struct_processus *s_etat_processus)
1301: {
1302: struct_liste_chainee *l_element_courant;
1303:
1304: struct_objet *s_objet;
1305:
1306: (*s_etat_processus).erreur_execution = d_ex;
1307:
1308: if ((*s_etat_processus).affichage_arguments == 'Y')
1309: {
1310: printf("\n STOP ");
1311:
1312: if ((*s_etat_processus).langue == 'F')
1313: {
1314: printf("(arrêt d'un processus)\n\n");
1315: }
1316: else
1317: {
1318: printf("(kill process)\n\n");
1319: }
1320:
1321: printf(" 1: %s\n", d_PRC);
1322:
1323: return;
1324: }
1325: else if ((*s_etat_processus).test_instruction == 'Y')
1326: {
1327: (*s_etat_processus).nombre_arguments = -1;
1328: return;
1329: }
1330:
1331: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1332: {
1333: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1334: {
1335: return;
1336: }
1337: }
1338:
1339: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1340: &s_objet) == d_erreur)
1341: {
1342: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1343: return;
1344: }
1345:
1346: if ((*s_objet).type == PRC)
1347: {
1348: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1349: .processus_detache == d_vrai)
1350: {
1.33 bertrand 1351: envoi_signal_processus((*(*((struct_processus_fils *)
1352: (*s_objet).objet)).thread).pid, rpl_sigstop);
1.1 bertrand 1353: }
1354: else
1355: {
1356: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
1357: {
1358: (*s_etat_processus).erreur_systeme = d_es_processus;
1359: return;
1360: }
1361:
1362: l_element_courant = (struct_liste_chainee *)
1363: (*s_etat_processus).l_base_pile_processus;
1364:
1365: while(l_element_courant != NULL)
1366: {
1367: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1368: .donnee).objet)).thread).processus_detache == d_faux)
1369: {
1370: if ((pthread_equal((*(*((struct_processus_fils *)
1.9 bertrand 1371: (*(*l_element_courant).donnee).objet)).thread).tid,
1.1 bertrand 1372: (*(*((struct_processus_fils *)
1373: (*s_objet).objet)).thread).tid) != 0) &&
1374: ((*(*((struct_processus_fils *)
1375: (*(*l_element_courant).donnee).objet)).thread).pid
1376: == (*(*((struct_processus_fils *)
1377: (*s_objet).objet)).thread).pid))
1378: {
1379: break;
1380: }
1381: }
1382:
1383: l_element_courant = (*l_element_courant).suivant;
1384: }
1385:
1386: if (l_element_courant != NULL)
1387: {
1388: // Le champ thread_actif est un pointeur sur un champ de la
1389: // structure s_argument_thread libéré par la fonction
1390: // retrait_thread_surveillance().
1391:
1392: if ((*(*((struct_processus_fils *)
1393: (*s_objet).objet)).thread).thread_actif == d_vrai)
1394: {
1395: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
1396: (*s_objet).objet)).thread).mutex)) != 0)
1397: {
1398: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
1399: != 0)
1400: {
1401: (*s_etat_processus).erreur_systeme = d_es_processus;
1402: return;
1403: }
1404:
1405: (*s_etat_processus).erreur_systeme = d_es_processus;
1406: return;
1407: }
1408:
1409: if ((*(*((struct_processus_fils *)
1410: (*s_objet).objet)).thread).thread_actif == d_vrai)
1411: {
1.33 bertrand 1412: envoi_signal_thread((*(*((struct_processus_fils *)
1413: (*s_objet).objet)).thread).tid, rpl_sigstop);
1.1 bertrand 1414: }
1415:
1416: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
1417: (*s_objet).objet)).thread).mutex)) != 0)
1418: {
1419: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
1420: != 0)
1421: {
1422: (*s_etat_processus).erreur_systeme = d_es_processus;
1423: return;
1424: }
1425:
1426: (*s_etat_processus).erreur_systeme = d_es_processus;
1427: return;
1428: }
1429: }
1430: }
1431:
1432: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1433: {
1434: (*s_etat_processus).erreur_systeme = d_es_processus;
1435: return;
1436: }
1437: }
1438: }
1439: else
1440: {
1441: liberation(s_etat_processus, s_objet);
1442:
1443: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1444: return;
1445: }
1446:
1447: liberation(s_etat_processus, s_objet);
1448:
1449: return;
1450: }
1451:
1452: // vim: ts=4