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