1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.25
4: Copyright (C) 1989-2016 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 (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
891: s_objet_resultat) == d_erreur)
892: {
893: return;
894: }
895:
896: # else
897:
898: if ((*s_etat_processus).langue == 'F')
899: {
900: printf("+++Attention : Support de MySQL non compilé !\n");
901: }
902: else
903: {
904: printf("+++Warning : MySQL support not available !\n");
905: }
906:
907: fflush(stdout);
908: # endif
909: }
910:
911: /*
912: * Pilote PostgreSQL
913: */
914:
915: else if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
916: "POSTGRESQL") == 0)
917: {
918: # ifdef POSTGRESQL_SUPPORT
919:
920: int i;
921: int j;
922: int nombre_colonnes;
923: int nombre_lignes;
924:
925: logical1 presence_resultat;
926:
927: PGresult *resultat_postgresql;
928:
929: struct_objet *s_objet_resultat;
930:
931: struct_liste_chainee *l_element_courant;
932: struct_liste_chainee *l_element_courant_ligne;
933:
934: if (PQstatus((*((struct_connecteur_sql *) (*s_objet_1).objet))
935: .descripteur.postgresql) != CONNECTION_OK)
936: {
937: if (connexion_permanente == d_faux)
938: {
939: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet))
940: .descripteur.postgresql);
941: }
942:
943: liberation(s_etat_processus, s_objet_1);
944: liberation(s_etat_processus, s_objet_2);
945:
946: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
947: return;
948: }
949:
950: resultat_postgresql = PQexec((*((struct_connecteur_sql *)
951: (*s_objet_1).objet)).descripteur.postgresql,
952: (unsigned char *) (*s_objet_2).objet);
953: presence_resultat = d_faux;
954:
955: switch(PQresultStatus(resultat_postgresql))
956: {
957: case PGRES_COMMAND_OK :
958: { // Commande qui ne renvoit rien
959: if ((s_objet_resultat = allocation(s_etat_processus, LST))
960: == NULL)
961: {
962: (*s_etat_processus).erreur_systeme =
963: d_es_allocation_memoire;
964: return;
965: }
966:
967: (*s_objet_resultat).objet = NULL;
968: l_element_courant = (*s_objet_resultat).objet;
969: presence_resultat = d_vrai;
970:
971: break;
972: }
973:
974: case PGRES_TUPLES_OK :
975: { // Commande renvoyant des données
976: if ((s_objet_resultat = allocation(s_etat_processus, LST))
977: == NULL)
978: {
979: (*s_etat_processus).erreur_systeme =
980: d_es_allocation_memoire;
981: return;
982: }
983:
984: (*s_objet_resultat).objet = NULL;
985: l_element_courant = (*s_objet_resultat).objet;
986: presence_resultat = d_vrai;
987:
988: nombre_colonnes = PQnfields(resultat_postgresql);
989: nombre_lignes = PQntuples(resultat_postgresql);
990:
991: for(i = 0; i < nombre_lignes; i++)
992: {
993: // Chaînage d'un nouveau maillon de la liste résultat
994:
995: if (l_element_courant == NULL)
996: {
997: if (((*s_objet_resultat).objet =
998: allocation_maillon(s_etat_processus))
999: == NULL)
1000: {
1001: (*s_etat_processus).erreur_systeme =
1002: d_es_allocation_memoire;
1003: return;
1004: }
1005:
1006: l_element_courant = (struct_liste_chainee *)
1007: (*s_objet_resultat).objet;
1008: }
1009: else
1010: {
1011: if (((*l_element_courant).suivant =
1012: allocation_maillon(s_etat_processus))
1013: == NULL)
1014: {
1015: (*s_etat_processus).erreur_systeme =
1016: d_es_allocation_memoire;
1017: return;
1018: }
1019:
1020: l_element_courant = (*l_element_courant).suivant;
1021: }
1022:
1023: (*l_element_courant).suivant = NULL;
1024:
1025: // Création de la liste fille
1026:
1027: if (((*l_element_courant).donnee =
1028: allocation(s_etat_processus, LST)) == NULL)
1029: {
1030: (*s_etat_processus).erreur_systeme =
1031: d_es_allocation_memoire;
1032: return;
1033: }
1034:
1035: (*(*l_element_courant).donnee).objet = NULL;
1036: l_element_courant_ligne = NULL;
1037:
1038: for(j = 0; j < nombre_colonnes; j++)
1039: {
1040: if (l_element_courant_ligne == NULL)
1041: {
1042: if (((*(*l_element_courant).donnee).objet =
1043: allocation_maillon(s_etat_processus))
1044: == NULL)
1045: {
1046: (*s_etat_processus).erreur_systeme =
1047: d_es_allocation_memoire;
1048: return;
1049: }
1050:
1051: l_element_courant_ligne =
1052: (struct_liste_chainee *)
1053: (*(*l_element_courant).donnee).objet;
1054: }
1055: else
1056: {
1057: if (((*l_element_courant_ligne).suivant =
1058: allocation_maillon(s_etat_processus))
1059: == NULL)
1060: {
1061: l_element_courant_ligne =
1062: (*l_element_courant_ligne).suivant;
1063: }
1064:
1065: l_element_courant_ligne =
1066: (*l_element_courant_ligne).suivant;
1067: }
1068:
1069: (*l_element_courant_ligne).suivant = NULL;
1070:
1071: if (((*l_element_courant_ligne).donnee =
1072: allocation(s_etat_processus, CHN))
1073: == NULL)
1074: {
1075: (*s_etat_processus).erreur_systeme =
1076: d_es_allocation_memoire;
1077: return;
1078: }
1079:
1080: if (PQgetisnull(resultat_postgresql, i, j) != 0)
1081: {
1082: if (((*(*l_element_courant_ligne).donnee).objet
1083: = malloc(5 * sizeof(unsigned char)))
1084: == NULL)
1085: {
1086: (*s_etat_processus).erreur_systeme =
1087: d_es_allocation_memoire;
1088: return;
1089: }
1090:
1091: strcpy((unsigned char *)
1092: (*(*l_element_courant_ligne).donnee)
1093: .objet, "NULL");
1094: }
1095: else
1096: {
1097: if (((*(*l_element_courant_ligne).donnee).objet
1098: = malloc(((size_t) (PQgetlength(
1099: resultat_postgresql, i, j) + 1)) *
1100: sizeof(unsigned char))) == NULL)
1101: {
1102: (*s_etat_processus).erreur_systeme =
1103: d_es_allocation_memoire;
1104: return;
1105: }
1106:
1107: strcpy((unsigned char *)
1108: (*(*l_element_courant_ligne).donnee)
1109: .objet, PQgetvalue(resultat_postgresql,
1110: i, j));
1111: }
1112: }
1113: }
1114:
1115: break;
1116: }
1117:
1118: case PGRES_EMPTY_QUERY :
1119: case PGRES_COPY_OUT :
1120: case PGRES_COPY_IN :
1121: case PGRES_BAD_RESPONSE :
1122: case PGRES_NONFATAL_ERROR :
1123: case PGRES_FATAL_ERROR :
1124: default :
1125: {
1126: printf("%s\n", PQresultErrorMessage(resultat_postgresql));
1127: PQclear(resultat_postgresql);
1128:
1129: if (connexion_permanente == d_faux)
1130: {
1131: PQfinish((*((struct_connecteur_sql *) (*s_objet_1)
1132: .objet)).descripteur.postgresql);
1133: }
1134:
1135: liberation(s_etat_processus, s_objet_1);
1136: liberation(s_etat_processus, s_objet_2);
1137:
1138: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1139:
1140: return;
1141: break;
1142: }
1143: }
1144:
1145: PQclear(resultat_postgresql);
1146:
1147: if (connexion_permanente == d_faux)
1148: {
1149: PQfinish((*((struct_connecteur_sql *) (*s_objet_1).objet))
1150: .descripteur.postgresql);
1151: }
1152:
1153: if (presence_resultat == d_vrai)
1154: {
1155: if (empilement(s_etat_processus, &((*s_etat_processus)
1156: .l_base_pile), s_objet_resultat) == d_erreur)
1157: {
1158: return;
1159: }
1160: }
1161:
1162: # else
1163:
1164: if ((*s_etat_processus).langue == 'F')
1165: {
1166: printf("+++Attention : Support de PostgreSQL non compilé !\n");
1167: }
1168: else
1169: {
1170: printf("+++Warning : PostgreSQL support not available !\n");
1171: }
1172:
1173: fflush(stdout);
1174: # endif
1175: }
1176: else if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
1177: "SQLITE") == 0)
1178: {
1179: const char *queue;
1180: const unsigned char *resultat;
1181:
1182: int i;
1183: int ios;
1184: int nombre_colonnes;
1185:
1186: logical1 presence_resultat;
1187:
1188: sqlite3_stmt *ppStmt;
1189:
1190: struct_liste_chainee *l_element_courant;
1191: struct_liste_chainee *l_element_courant_ligne;
1192:
1193: struct_objet *s_objet_resultat;
1194:
1195: struct timespec attente;
1196:
1197: if (sqlite3_prepare_v2((*((struct_connecteur_sql *)
1198: (*s_objet_1).objet)).descripteur.sqlite,
1199: (unsigned char *) (*s_objet_2).objet,
1200: (int) strlen((unsigned char *) (*s_objet_2).objet),
1201: &ppStmt, &queue) != SQLITE_OK)
1202: {
1203: if (connexion_permanente == d_faux)
1204: {
1205: sqlite3_close((*((struct_connecteur_sql *)
1206: (*s_objet_1).objet)).descripteur.sqlite);
1207: }
1208:
1209: liberation(s_etat_processus, s_objet_1);
1210: liberation(s_etat_processus, s_objet_2);
1211:
1212: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1213: return;
1214: }
1215:
1216: presence_resultat = d_faux;
1217: s_objet_resultat = NULL;
1218: l_element_courant = NULL;
1219:
1220: attente.tv_sec = 0;
1221: attente.tv_nsec = GRANULARITE_us * 1000;
1222:
1223: if ((s_objet_resultat =
1224: allocation(s_etat_processus, LST)) == NULL)
1225: {
1226: (*s_etat_processus).erreur_systeme =
1227: d_es_allocation_memoire;
1228: return;
1229: }
1230:
1231: // Création d'une liste vide
1232:
1233: (*s_objet_resultat).objet = NULL;
1234: l_element_courant = (*s_objet_resultat).objet;
1235:
1236: do
1237: {
1238: switch(ios = sqlite3_step(ppStmt))
1239: {
1240: case SQLITE_ROW:
1241: {
1242: // Ajout d'une liste au bout de la liste
1243: // contenant les lignes
1244:
1245: if (l_element_courant == NULL)
1246: {
1247: if (((*s_objet_resultat).objet =
1248: allocation_maillon(s_etat_processus))
1249: == NULL)
1250: {
1251: (*s_etat_processus).erreur_systeme =
1252: d_es_allocation_memoire;
1253: }
1254:
1255: l_element_courant = (struct_liste_chainee *)
1256: (*s_objet_resultat).objet;
1257: }
1258: else
1259: {
1260: if (((*l_element_courant).suivant =
1261: allocation_maillon(s_etat_processus))
1262: == NULL)
1263: {
1264: (*s_etat_processus).erreur_systeme =
1265: d_es_allocation_memoire;
1266: return;
1267: }
1268:
1269: l_element_courant = (*l_element_courant).suivant;
1270: }
1271:
1272: (*l_element_courant).suivant = NULL;
1273:
1274: // Création de la liste fille
1275:
1276: if (((*l_element_courant).donnee =
1277: allocation(s_etat_processus, LST)) == NULL)
1278: {
1279: (*s_etat_processus).erreur_systeme =
1280: d_es_allocation_memoire;
1281: return;
1282: }
1283:
1284: (*(*l_element_courant).donnee).objet = NULL;
1285:
1286: // Lecture de la ligne
1287:
1288: nombre_colonnes = sqlite3_data_count(ppStmt);
1289: l_element_courant_ligne = NULL;
1290:
1291: for(i = 0; i < nombre_colonnes; i++)
1292: {
1293: if (l_element_courant_ligne == NULL)
1294: {
1295: if (((*(*l_element_courant).donnee).objet =
1296: allocation_maillon(s_etat_processus))
1297: == NULL)
1298: {
1299: (*s_etat_processus).erreur_systeme =
1300: d_es_allocation_memoire;
1301: return;
1302: }
1303:
1304: l_element_courant_ligne =
1305: (struct_liste_chainee *)
1306: (*(*l_element_courant).donnee).objet;
1307: }
1308: else
1309: {
1310: if (((*l_element_courant_ligne).suivant =
1311: allocation_maillon(s_etat_processus))
1312: == NULL)
1313: {
1314: l_element_courant_ligne =
1315: (*l_element_courant_ligne).suivant;
1316: }
1317:
1318: l_element_courant_ligne =
1319: (*l_element_courant_ligne).suivant;
1320: }
1321:
1322: (*l_element_courant_ligne).suivant = NULL;
1323:
1324: if (((*l_element_courant_ligne).donnee =
1325: allocation(s_etat_processus, CHN))
1326: == NULL)
1327: {
1328: (*s_etat_processus).erreur_systeme =
1329: d_es_allocation_memoire;
1330: return;
1331: }
1332:
1333: if (sqlite3_column_type(ppStmt, i) == SQLITE_NULL)
1334: {
1335: if (((*(*l_element_courant_ligne).donnee).objet
1336: = malloc(5 * sizeof(unsigned char)))
1337: == NULL)
1338: {
1339: (*s_etat_processus).erreur_systeme =
1340: d_es_allocation_memoire;
1341: return;
1342: }
1343:
1344: strcpy((unsigned char *)
1345: (*(*l_element_courant_ligne).donnee)
1346: .objet, "NULL");
1347: }
1348: else
1349: {
1350: if ((resultat = sqlite3_column_text(ppStmt, i))
1351: == NULL)
1352: {
1353: (*s_etat_processus).erreur_systeme =
1354: d_es_allocation_memoire;
1355: return;
1356: }
1357:
1358: if (((*(*l_element_courant_ligne).donnee).objet
1359: = malloc((strlen(resultat) + 1 ) *
1360: sizeof(unsigned char))) == NULL)
1361: {
1362: (*s_etat_processus).erreur_systeme =
1363: d_es_allocation_memoire;
1364: return;
1365: }
1366:
1367: strcpy((unsigned char *)
1368: (*(*l_element_courant_ligne).donnee)
1369: .objet, resultat);
1370: }
1371: }
1372:
1373: break;
1374: }
1375:
1376: case SQLITE_DONE:
1377: {
1378: // Fin de la lecture des données
1379: break;
1380: }
1381:
1382: case SQLITE_BUSY:
1383: case SQLITE_LOCKED:
1384: {
1385: nanosleep(&attente, NULL);
1386: INCR_GRANULARITE(attente.tv_nsec);
1387: break;
1388: }
1389:
1390: default:
1391: {
1392: (*s_etat_processus).erreur_systeme =
1393: d_es_erreur_fichier;
1394: return;
1395: }
1396: }
1397: } while(ios != SQLITE_DONE);
1398:
1399: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1400: {
1401: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1402: return;
1403: }
1404:
1405: if (connexion_permanente == d_faux)
1406: {
1407: sqlite3_close((*((struct_connecteur_sql *) (*s_objet_1).objet))
1408: .descripteur.sqlite);
1409: }
1410:
1411: if (empilement(s_etat_processus, &((*s_etat_processus)
1412: .l_base_pile), s_objet_resultat) == d_erreur)
1413: {
1414: return;
1415: }
1416: }
1417: else
1418: {
1419: liberation(s_etat_processus, s_objet_1);
1420: liberation(s_etat_processus, s_objet_2);
1421:
1422: (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
1423: return;
1424: }
1425: }
1426: else
1427: {
1428: liberation(s_etat_processus, s_objet_1);
1429: liberation(s_etat_processus, s_objet_2);
1430:
1431: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1432: return;
1433: }
1434:
1435: liberation(s_etat_processus, s_objet_1);
1436: liberation(s_etat_processus, s_objet_2);
1437:
1438: return;
1439: }
1440:
1441:
1442: /*
1443: ================================================================================
1444: Fonction 'stop'
1445: ================================================================================
1446: Entrées :
1447: --------------------------------------------------------------------------------
1448: Sorties :
1449: --------------------------------------------------------------------------------
1450: Effets de bord : néant
1451: ================================================================================
1452: */
1453:
1454: void
1455: instruction_stop(struct_processus *s_etat_processus)
1456: {
1457: struct_liste_chainee *l_element_courant;
1458:
1459: struct_objet *s_objet;
1460:
1461: (*s_etat_processus).erreur_execution = d_ex;
1462:
1463: if ((*s_etat_processus).affichage_arguments == 'Y')
1464: {
1465: printf("\n STOP ");
1466:
1467: if ((*s_etat_processus).langue == 'F')
1468: {
1469: printf("(arrêt d'un processus)\n\n");
1470: }
1471: else
1472: {
1473: printf("(kill process)\n\n");
1474: }
1475:
1476: printf(" 1: %s\n", d_PRC);
1477:
1478: return;
1479: }
1480: else if ((*s_etat_processus).test_instruction == 'Y')
1481: {
1482: (*s_etat_processus).nombre_arguments = -1;
1483: return;
1484: }
1485:
1486: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1487: {
1488: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1489: {
1490: return;
1491: }
1492: }
1493:
1494: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1495: &s_objet) == d_erreur)
1496: {
1497: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1498: return;
1499: }
1500:
1501: if ((*s_objet).type == PRC)
1502: {
1503: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1504: .processus_detache == d_vrai)
1505: {
1506: envoi_signal_processus((*(*((struct_processus_fils *)
1507: (*s_objet).objet)).thread).pid, rpl_sigstop);
1508: }
1509: else
1510: {
1511: if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus))
1512: != 0)
1513: {
1514: (*s_etat_processus).erreur_systeme = d_es_processus;
1515: return;
1516: }
1517:
1518: l_element_courant = (struct_liste_chainee *)
1519: (*s_etat_processus).l_base_pile_processus;
1520:
1521: while(l_element_courant != NULL)
1522: {
1523: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1524: .donnee).objet)).thread).processus_detache == d_faux)
1525: {
1526: if ((pthread_equal((*(*((struct_processus_fils *)
1527: (*(*l_element_courant).donnee).objet)).thread).tid,
1528: (*(*((struct_processus_fils *)
1529: (*s_objet).objet)).thread).tid) != 0) &&
1530: ((*(*((struct_processus_fils *)
1531: (*(*l_element_courant).donnee).objet)).thread).pid
1532: == (*(*((struct_processus_fils *)
1533: (*s_objet).objet)).thread).pid))
1534: {
1535: break;
1536: }
1537: }
1538:
1539: l_element_courant = (*l_element_courant).suivant;
1540: }
1541:
1542: if (l_element_courant != NULL)
1543: {
1544: // Le champ thread_actif est un pointeur sur un champ de la
1545: // structure s_argument_thread libéré par la fonction
1546: // retrait_thread_surveillance().
1547:
1548: if ((*(*((struct_processus_fils *)
1549: (*s_objet).objet)).thread).thread_actif == d_vrai)
1550: {
1551: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
1552: (*s_objet).objet)).thread).mutex)) != 0)
1553: {
1554: if (pthread_mutex_unlock(&((*s_etat_processus)
1555: .mutex_pile_processus)) != 0)
1556: {
1557: (*s_etat_processus).erreur_systeme = d_es_processus;
1558: return;
1559: }
1560:
1561: (*s_etat_processus).erreur_systeme = d_es_processus;
1562: return;
1563: }
1564:
1565: if ((*(*((struct_processus_fils *)
1566: (*s_objet).objet)).thread).thread_actif == d_vrai)
1567: {
1568: envoi_signal_thread((*(*((struct_processus_fils *)
1569: (*s_objet).objet)).thread).tid, rpl_sigstop);
1570: }
1571:
1572: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
1573: (*s_objet).objet)).thread).mutex)) != 0)
1574: {
1575: if (pthread_mutex_unlock(&((*s_etat_processus)
1576: .mutex_pile_processus)) != 0)
1577: {
1578: (*s_etat_processus).erreur_systeme = d_es_processus;
1579: return;
1580: }
1581:
1582: (*s_etat_processus).erreur_systeme = d_es_processus;
1583: return;
1584: }
1585: }
1586: }
1587:
1588: if (pthread_mutex_unlock(&((*s_etat_processus)
1589: .mutex_pile_processus)) != 0)
1590: {
1591: (*s_etat_processus).erreur_systeme = d_es_processus;
1592: return;
1593: }
1594: }
1595: }
1596: else
1597: {
1598: liberation(s_etat_processus, s_objet);
1599:
1600: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1601: return;
1602: }
1603:
1604: liberation(s_etat_processus, s_objet);
1605:
1606: return;
1607: }
1608:
1609: // 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