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