1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.15
4: Copyright (C) 1989-2013 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: #include "convert-conv.h"
25:
26:
27: /*
28: ================================================================================
29: Fonction 'cov'
30: ================================================================================
31: Entrées :
32: --------------------------------------------------------------------------------
33: Sorties :
34: --------------------------------------------------------------------------------
35: Effets de bord : néant
36: ================================================================================
37: */
38:
39: void
40: instruction_cov(struct_processus *s_etat_processus)
41: {
42: logical1 erreur;
43:
44: struct_objet *s_objet_statistique;
45: struct_objet *s_objet_resultat;
46:
47: integer8 nombre_colonnes;
48:
49: (*s_etat_processus).erreur_execution = d_ex;
50:
51: if ((*s_etat_processus).affichage_arguments == 'Y')
52: {
53: printf("\n COV ");
54:
55: if ((*s_etat_processus).langue == 'F')
56: {
57: printf("(covariance)\n\n");
58: }
59: else
60: {
61: printf("(covariance)\n\n");
62: }
63:
64: printf("-> 1: %s\n", d_REL);
65:
66: return;
67: }
68: else if ((*s_etat_processus).test_instruction == 'Y')
69: {
70: (*s_etat_processus).nombre_arguments = -1;
71: return;
72: }
73:
74: if (test_cfsf(s_etat_processus, 31) == d_vrai)
75: {
76: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
77: {
78: return;
79: }
80: }
81:
82: /*
83: * Recherche d'une variable globale référencée par SIGMA
84: */
85:
86: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
87: {
88: /*
89: * Aucune variable SIGMA
90: */
91:
92: (*s_etat_processus).erreur_systeme = d_es;
93: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
94: return;
95: }
96: else
97: {
98: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
99: .type != MIN) && ((*(*(*s_etat_processus)
100: .pointeur_variable_courante).objet).type != MRL))
101: {
102: (*s_etat_processus).erreur_execution =
103: d_ex_matrice_statistique_invalide;
104: return;
105: }
106:
107: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
108: .pointeur_variable_courante).objet).objet)).nombre_colonnes;
109: }
110:
111: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
112: .objet;
113:
114: if (((*s_objet_statistique).type == MIN) ||
115: ((*s_objet_statistique).type == MRL))
116: {
117: if (((*s_etat_processus).colonne_statistique_1 < 1) ||
118: ((*s_etat_processus).colonne_statistique_2 < 1) ||
119: ((*s_etat_processus).colonne_statistique_1 > nombre_colonnes) ||
120: ((*s_etat_processus).colonne_statistique_2 > nombre_colonnes))
121: {
122: (*s_etat_processus).erreur_execution =
123: d_ex_observations_inexistantes;
124: return;
125: }
126:
127: if ((s_objet_resultat = allocation(s_etat_processus, REL))
128: == NULL)
129: {
130: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
131: return;
132: }
133:
134: (*((real8 *) (*s_objet_resultat).objet)) = covariance_statistique(
135: (struct_matrice *) (*s_objet_statistique).objet,
136: (*s_etat_processus).colonne_statistique_1,
137: (*s_etat_processus).colonne_statistique_2, 'E', &erreur);
138:
139: if (erreur == d_erreur)
140: {
141: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
142: return;
143: }
144: }
145: else
146: {
147: (*s_etat_processus).erreur_execution =
148: d_ex_matrice_statistique_invalide;
149: return;
150: }
151:
152: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
153: s_objet_resultat) == d_erreur)
154: {
155: return;
156: }
157:
158: return;
159: }
160:
161:
162: /*
163: ================================================================================
164: Fonction 'corr'
165: ================================================================================
166: Entrées :
167: --------------------------------------------------------------------------------
168: Sorties :
169: --------------------------------------------------------------------------------
170: Effets de bord : néant
171: ================================================================================
172: */
173:
174: void
175: instruction_corr(struct_processus *s_etat_processus)
176: {
177: logical1 erreur;
178:
179: struct_objet *s_objet_statistique;
180: struct_objet *s_objet_resultat;
181:
182: integer8 nombre_colonnes;
183:
184: (*s_etat_processus).erreur_execution = d_ex;
185:
186: if ((*s_etat_processus).affichage_arguments == 'Y')
187: {
188: printf("\n CORR ");
189:
190: if ((*s_etat_processus).langue == 'F')
191: {
192: printf("(corrélation)\n\n");
193: }
194: else
195: {
196: printf("(correlation)\n\n");
197: }
198:
199: printf("-> 1: %s\n", d_REL);
200:
201: return;
202: }
203: else if ((*s_etat_processus).test_instruction == 'Y')
204: {
205: (*s_etat_processus).nombre_arguments = -1;
206: return;
207: }
208:
209: if (test_cfsf(s_etat_processus, 31) == d_vrai)
210: {
211: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
212: {
213: return;
214: }
215: }
216:
217: /*
218: * Recherche d'une variable globale référencée par SIGMA
219: */
220:
221: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
222: {
223: /*
224: * Aucune variable SIGMA
225: */
226:
227: (*s_etat_processus).erreur_systeme = d_es;
228: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
229: return;
230: }
231: else
232: {
233: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
234: .type != MIN) && ((*(*(*s_etat_processus)
235: .pointeur_variable_courante).objet).type != MRL))
236: {
237: (*s_etat_processus).erreur_execution =
238: d_ex_matrice_statistique_invalide;
239: return;
240: }
241:
242: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
243: .pointeur_variable_courante).objet).objet))
244: .nombre_colonnes;
245: }
246:
247: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
248: .objet;
249:
250: if (((*s_objet_statistique).type == MIN) ||
251: ((*s_objet_statistique).type == MRL))
252: {
253: if (((*s_etat_processus).colonne_statistique_1 < 1) ||
254: ((*s_etat_processus).colonne_statistique_2 < 1) ||
255: ((*s_etat_processus).colonne_statistique_1 > (long)
256: nombre_colonnes) || ((*s_etat_processus).colonne_statistique_2
257: > (long) nombre_colonnes))
258: {
259: (*s_etat_processus).erreur_execution =
260: d_ex_observations_inexistantes;
261: return;
262: }
263:
264: if ((s_objet_resultat = allocation(s_etat_processus, REL))
265: == NULL)
266: {
267: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
268: return;
269: }
270:
271: (*((real8 *) (*s_objet_resultat).objet)) = correlation_statistique(
272: (struct_matrice *) (*s_objet_statistique).objet,
273: (*s_etat_processus).colonne_statistique_1,
274: (*s_etat_processus).colonne_statistique_2, &erreur);
275:
276: if (erreur == d_erreur)
277: {
278: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
279: return;
280: }
281: }
282: else
283: {
284: (*s_etat_processus).erreur_execution =
285: d_ex_matrice_statistique_invalide;
286: return;
287: }
288:
289: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
290: s_objet_resultat) == d_erreur)
291: {
292: return;
293: }
294:
295: return;
296: }
297:
298:
299: /*
300: ================================================================================
301: Fonction 'copyright'
302: ================================================================================
303: Entrées :
304: --------------------------------------------------------------------------------
305: Sorties :
306: --------------------------------------------------------------------------------
307: Effets de bord : néant
308: ================================================================================
309: */
310:
311: void
312: instruction_copyright(struct_processus *s_etat_processus)
313: {
314: # include "copyright-conv.h"
315:
316: (*s_etat_processus).erreur_execution = d_ex;
317:
318: if ((*s_etat_processus).affichage_arguments == 'Y')
319: {
320: printf("\n COPYRIGHT ");
321:
322: if ((*s_etat_processus).langue == 'F')
323: {
324: printf("(copyright)\n\n");
325: printf(" Aucun argument\n");
326: }
327: else
328: {
329: printf("(copyright)\n\n");
330: printf(" No argument\n");
331: }
332:
333: return;
334: }
335: else if ((*s_etat_processus).test_instruction == 'Y')
336: {
337: (*s_etat_processus).nombre_arguments = -1;
338: return;
339: }
340:
341: printf("\n RPL/2 (R) version %s\n", d_version_rpl);
342: printf("%s\n", ((*s_etat_processus).langue == 'F' )
343: ? copyright : copyright_anglais);
344:
345: if ((*s_etat_processus).hauteur_pile_operationnelle == 0)
346: {
347: printf("\n");
348: }
349:
350: return;
351: }
352:
353:
354: /*
355: ================================================================================
356: Fonction 'convert'
357: ================================================================================
358: Entrées :
359: --------------------------------------------------------------------------------
360: Sorties :
361: --------------------------------------------------------------------------------
362: Effets de bord : néant
363: ================================================================================
364: */
365:
366: void
367: instruction_convert(struct_processus *s_etat_processus)
368: {
369: file *pipe;
370:
371: int fin_fichier;
372:
373: logical1 last_valide;
374:
375: size_t longueur_chaine;
376:
377: logical1 presence_resultat;
378:
379: struct_objet *s_objet_argument_1;
380: struct_objet *s_objet_argument_2;
381: struct_objet *s_objet_argument_3;
382:
383: unsigned char *commande;
384: unsigned char *executable_candidat;
385: unsigned char ligne[1024 + 1];
386: unsigned char *tampon_instruction;
387:
388: (*s_etat_processus).erreur_execution = d_ex;
389:
390: if ((*s_etat_processus).affichage_arguments == 'Y')
391: {
392: printf("\n CONVERT ");
393:
394: if ((*s_etat_processus).langue == 'F')
395: {
396: printf("(conversion d'unités)\n\n");
397: }
398: else
399: {
400: printf("(units conversion)\n\n");
401: }
402:
403: printf(" 3: %s, %s\n", d_INT, d_REL);
404: printf(" 2: %s\n", d_CHN);
405: printf(" 1: %s\n", d_CHN);
406: printf("-> 2: %s, %s\n", d_INT, d_REL);
407: printf(" 1: %s\n", d_CHN);
408:
409: return;
410: }
411: else if ((*s_etat_processus).test_instruction == 'Y')
412: {
413: (*s_etat_processus).nombre_arguments = -1;
414: return;
415: }
416:
417: if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
418: {
419: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
420: {
421: return;
422: }
423: }
424:
425: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
426: &s_objet_argument_1) == d_erreur)
427: {
428: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
429: return;
430: }
431:
432: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
433: &s_objet_argument_2) == d_erreur)
434: {
435: liberation(s_etat_processus, s_objet_argument_1);
436:
437: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
438: return;
439: }
440:
441: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
442: &s_objet_argument_3) == d_erreur)
443: {
444: liberation(s_etat_processus, s_objet_argument_1);
445: liberation(s_etat_processus, s_objet_argument_2);
446:
447: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
448: return;
449: }
450:
451: if (((*s_objet_argument_1).type == CHN) &&
452: ((*s_objet_argument_2).type == CHN) &&
453: (((*s_objet_argument_3).type == INT) ||
454: ((*s_objet_argument_3).type == REL)))
455: {
456: if ((*s_etat_processus).rpl_home == NULL)
457: {
458: longueur_chaine = strlen(ds_rplconvert_commande) - 9
459: + strlen((unsigned char *) (*s_objet_argument_1).objet)
460: + strlen((unsigned char *) (*s_objet_argument_2).objet)
461: + (2 * strlen(d_exec_path));
462:
463: if ((commande = malloc((longueur_chaine + 1) *
464: sizeof(unsigned char))) == NULL)
465: {
466: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
467: return;
468: }
469:
470: sprintf(commande, ds_rplconvert_commande, d_exec_path, d_exec_path,
471: (unsigned char *) (*s_objet_argument_2).objet,
472: (unsigned char *) (*s_objet_argument_1).objet);
473:
474: if (alsprintf(&executable_candidat, "%s/bin/rplconvert",
475: d_exec_path) < 0)
476: {
477: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
478: return;
479: }
480:
481: if (controle_integrite(s_etat_processus, executable_candidat,
482: "rplconvert") != d_vrai)
483: {
484: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
485: return;
486: }
487:
488: free(executable_candidat);
489: }
490: else
491: {
492: longueur_chaine = strlen(ds_rplconvert_commande) - 9
493: + strlen((unsigned char *) (*s_objet_argument_1).objet)
494: + strlen((unsigned char *) (*s_objet_argument_2).objet)
495: + (2 * strlen((*s_etat_processus).rpl_home));
496:
497: if ((commande = malloc((longueur_chaine + 1) *
498: sizeof(unsigned char))) == NULL)
499: {
500: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
501: return;
502: }
503:
504: sprintf(commande, ds_rplconvert_commande,
505: (*s_etat_processus).rpl_home, (*s_etat_processus).rpl_home,
506: (unsigned char *) (*s_objet_argument_2).objet,
507: (unsigned char *) (*s_objet_argument_1).objet);
508:
509: if (alsprintf(&executable_candidat, "%s/bin/rplconvert",
510: (*s_etat_processus).rpl_home) < 0)
511: {
512: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
513: return;
514: }
515:
516: if (controle_integrite(s_etat_processus, executable_candidat,
517: "rplconvert") != d_vrai)
518: {
519: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
520: return;
521: }
522:
523: free(executable_candidat);
524: }
525:
526: if ((pipe = popen(commande, "r")) == NULL)
527: {
528: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
529: return;
530: }
531:
532: free(commande);
533:
534: presence_resultat = d_faux;
535:
536: do
537: {
538: fin_fichier = fscanf(pipe, "%1024s", ligne);
539:
540: if (strcmp(ligne, "*") == 0)
541: {
542: fin_fichier = fscanf(pipe, "%1024s", ligne);
543:
544: if (fin_fichier != EOF)
545: {
546: presence_resultat = d_vrai;
547:
548: tampon_instruction =
549: (*s_etat_processus).instruction_courante;
550: (*s_etat_processus).instruction_courante = ligne;
551:
552: recherche_type(s_etat_processus);
553:
554: (*s_etat_processus).instruction_courante =
555: tampon_instruction;
556:
557: if ((*s_etat_processus).erreur_execution != d_ex)
558: {
559: if (pclose(pipe) == -1)
560: {
561: (*s_etat_processus).erreur_systeme = d_es_processus;
562: return;
563: }
564:
565: liberation(s_etat_processus, s_objet_argument_1);
566: liberation(s_etat_processus, s_objet_argument_2);
567: liberation(s_etat_processus, s_objet_argument_3);
568:
569: return;
570: }
571: }
572: }
573: } while(fin_fichier != EOF);
574:
575: /*
576: * Récupération de la ligne renvoyée commencant par "*". Si une telle
577: * ligne n'existe par, rplconvert retourne une erreur de type
578: * « conformability error » ou « Unknown unit ».
579: */
580:
581: if (pclose(pipe) == -1)
582: {
583: (*s_etat_processus).erreur_systeme = d_es_processus;
584: return;
585: }
586:
587: if (presence_resultat == d_faux)
588: {
589: liberation(s_etat_processus, s_objet_argument_1);
590: liberation(s_etat_processus, s_objet_argument_2);
591: liberation(s_etat_processus, s_objet_argument_3);
592:
593: (*s_etat_processus).erreur_execution = d_ex_conversion_unite;
594: return;
595: }
596:
597: /*
598: * Retrait des espaces dans la chaîne unité renvoyée
599: */
600:
601: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
602: s_objet_argument_3) == d_erreur)
603: {
604: return;
605: }
606:
607: if (last_valide == d_vrai)
608: {
609: cf(s_etat_processus, 31);
610: }
611:
612: instruction_multiplication(s_etat_processus);
613:
614: if (last_valide == d_vrai)
615: {
616: sf(s_etat_processus, 31);
617: }
618: }
619: else
620: {
621: liberation(s_etat_processus, s_objet_argument_1);
622: liberation(s_etat_processus, s_objet_argument_2);
623: liberation(s_etat_processus, s_objet_argument_3);
624:
625: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
626: return;
627: }
628:
629: liberation(s_etat_processus, s_objet_argument_1);
630: liberation(s_etat_processus, s_objet_argument_2);
631:
632: return;
633: }
634:
635:
636: /*
637: ================================================================================
638: Fonction 'close'
639: ================================================================================
640: Entrées :
641: --------------------------------------------------------------------------------
642: Sorties :
643: --------------------------------------------------------------------------------
644: Effets de bord : néant
645: ================================================================================
646: */
647:
648: void
649: instruction_close(struct_processus *s_etat_processus)
650: {
651: const char *queue;
652:
653: int socket;
654:
655: logical1 socket_connectee;
656:
657: sqlite3_stmt *ppStmt;
658:
659: struct_descripteur_fichier *descripteur;
660:
661: struct_liste_chainee *l_element_courant;
662: struct_liste_chainee *l_element_precedent;
663:
664: struct_objet *s_objet_argument;
665:
666: (*s_etat_processus).erreur_execution = d_ex;
667:
668: if ((*s_etat_processus).affichage_arguments == 'Y')
669: {
670: printf("\n CLOSE ");
671:
672: if ((*s_etat_processus).langue == 'F')
673: {
674: printf("(fermeture d'un fichier, d'une socket ou d'un sémaphore)"
675: "\n\n");
676: }
677: else
678: {
679: printf("(close file, socket or semaphore)\n\n");
680: }
681:
682: printf(" 1: %s\n\n", d_FCH);
683:
684: printf(" 1: %s\n\n", d_SCK);
685:
686: printf(" 1: %s\n", d_SPH);
687:
688: return;
689: }
690: else if ((*s_etat_processus).test_instruction == 'Y')
691: {
692: (*s_etat_processus).nombre_arguments = -1;
693: return;
694: }
695:
696: if (test_cfsf(s_etat_processus, 31) == d_vrai)
697: {
698: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
699: {
700: return;
701: }
702: }
703:
704: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
705: &s_objet_argument) == d_erreur)
706: {
707: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
708: return;
709: }
710:
711: if ((*s_objet_argument).type == FCH)
712: {
713: /*
714: * Retrait du descripteur de la pile de fichiers
715: */
716:
717: l_element_courant = (*s_etat_processus).s_fichiers;
718: l_element_precedent = NULL;
719:
720: descripteur = NULL;
721:
722: while(l_element_courant != NULL)
723: {
724: if (((*((struct_descripteur_fichier *) (*l_element_courant).donnee))
725: .identifiant == (*((struct_fichier *) (*s_objet_argument)
726: .objet)).descripteur) && ((*((struct_descripteur_fichier *)
727: (*l_element_courant).donnee)).pid == getpid()) &&
728: (pthread_equal((*((struct_descripteur_fichier *)
729: (*l_element_courant).donnee)).tid, pthread_self()) != 0))
730: {
731: if (((*((struct_fichier *) (*s_objet_argument).objet)).pid ==
732: (*((struct_descripteur_fichier *) (*l_element_courant)
733: .donnee)).pid) && (pthread_equal((*((struct_fichier *)
734: (*s_objet_argument).objet)).tid,
735: (*((struct_descripteur_fichier *) (*l_element_courant)
736: .donnee)).tid) != 0))
737: {
738: descripteur = (struct_descripteur_fichier *)
739: (*l_element_courant).donnee;
740:
741: if (l_element_precedent == NULL)
742: {
743: (*s_etat_processus).s_fichiers =
744: (*l_element_courant).suivant;
745: }
746: else if ((*l_element_courant).suivant == NULL)
747: {
748: (*l_element_precedent).suivant = NULL;
749: }
750: else
751: {
752: (*l_element_precedent).suivant =
753: (*l_element_courant).suivant;
754: }
755:
756: free((*((struct_descripteur_fichier *)
757: (*l_element_courant).donnee)).nom);
758: free(l_element_courant);
759:
760: break;
761: }
762: }
763:
764: l_element_precedent = l_element_courant;
765: l_element_courant = (*l_element_courant).suivant;
766: }
767:
768: if (descripteur == NULL)
769: {
770: liberation(s_etat_processus, s_objet_argument);
771:
772: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
773: return;
774: }
775:
776: /*
777: * Fermeture du fichier
778: */
779:
780: if (fclose((*descripteur).descripteur_c) != 0)
781: {
782: free(descripteur);
783: liberation(s_etat_processus, s_objet_argument);
784:
785: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
786: return;
787: }
788:
789: if ((*descripteur).type != 'C')
790: {
791: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
792: "vacuum", 7, &ppStmt, &queue) != SQLITE_OK)
793: {
794: free(descripteur);
795: liberation(s_etat_processus, s_objet_argument);
796:
797: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
798: return;
799: }
800:
801: if (sqlite3_step(ppStmt) != SQLITE_DONE)
802: {
803: free(descripteur);
804: liberation(s_etat_processus, s_objet_argument);
805:
806: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
807: return;
808: }
809:
810: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
811: {
812: free(descripteur);
813: liberation(s_etat_processus, s_objet_argument);
814:
815: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
816: return;
817: }
818:
819: if (sqlite3_close((*descripteur).descripteur_sqlite) != SQLITE_OK)
820: {
821: free(descripteur);
822: liberation(s_etat_processus, s_objet_argument);
823:
824: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
825: return;
826: }
827:
828: free(descripteur);
829: }
830:
831: if ((*((struct_fichier *) (*s_objet_argument).objet)).ouverture == 'S')
832: {
833: if (destruction_fichier((*((struct_fichier *)
834: (*s_objet_argument).objet)).nom) == d_erreur)
835: {
836: liberation(s_etat_processus, s_objet_argument);
837:
838: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
839: return;
840: }
841: }
842: }
843: else if ((*s_objet_argument).type == SCK)
844: {
845: /*
846: * Retrait de la socket de la pile
847: */
848:
849: l_element_courant = (*s_etat_processus).s_sockets;
850: l_element_precedent = NULL;
851:
852: socket = -1;
853: socket_connectee = d_faux;
854:
855: while(l_element_courant != NULL)
856: {
857: if ((*((struct_socket *) (*(*l_element_courant).donnee).objet))
858: .socket == (*((struct_socket *) (*s_objet_argument)
859: .objet)).socket)
860: {
861: socket = (*((struct_socket *)
862: (*(*l_element_courant).donnee).objet)).socket;
863: socket_connectee = (*((struct_socket *)
864: (*(*l_element_courant).donnee).objet)).socket_connectee;
865:
866: if (l_element_precedent == NULL)
867: {
868: (*s_etat_processus).s_sockets =
869: (*l_element_courant).suivant;
870: }
871: else if ((*l_element_courant).suivant == NULL)
872: {
873: (*l_element_precedent).suivant = NULL;
874: }
875: else
876: {
877: (*l_element_precedent).suivant =
878: (*l_element_courant).suivant;
879: }
880:
881: liberation(s_etat_processus, (*l_element_courant).donnee);
882: free(l_element_courant);
883:
884: break;
885: }
886:
887: l_element_precedent = l_element_courant;
888: l_element_courant = (*l_element_courant).suivant;
889: }
890:
891: if (socket == -1)
892: {
893: liberation(s_etat_processus, s_objet_argument);
894:
895: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
896: return;
897: }
898:
899: /*
900: * Fermeture de la socket
901: */
902:
903: if (socket_connectee == d_vrai)
904: {
905: shutdown(socket, SHUT_RDWR);
906: }
907:
908: if (close(socket) != 0)
909: {
910: liberation(s_etat_processus, s_objet_argument);
911:
912: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
913: return;
914: }
915:
916: if ((*((struct_socket *) (*s_objet_argument).objet)).effacement == 'Y')
917: {
918: unlink((*((struct_socket *) (*s_objet_argument).objet)).adresse);
919: }
920: }
921: else if ((*s_objet_argument).type == SPH)
922: {
923: if (sem_close((*((struct_semaphore *) (*s_objet_argument).objet))
924: .semaphore) != 0)
925: {
926: (*s_etat_processus).erreur_execution = d_ex_semaphore;
927: return;
928: }
929: }
930: else
931: {
932: liberation(s_etat_processus, s_objet_argument);
933:
934: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
935: return;
936: }
937:
938: liberation(s_etat_processus, s_objet_argument);
939:
940: return;
941: }
942:
943:
944: /*
945: ================================================================================
946: Fonction 'create'
947: ================================================================================
948: Entrées :
949: --------------------------------------------------------------------------------
950: Sorties :
951: --------------------------------------------------------------------------------
952: Effets de bord : néant
953: ================================================================================
954: */
955:
956: void
957: instruction_create(struct_processus *s_etat_processus)
958: {
959: file *fichier;
960:
961: logical1 erreur;
962: logical1 existence;
963: logical1 ouverture;
964:
965: struct_objet *s_objet_argument;
966:
967: unsigned char *nom;
968:
969: unsigned long unite;
970:
971: (*s_etat_processus).erreur_execution = d_ex;
972:
973: if ((*s_etat_processus).affichage_arguments == 'Y')
974: {
975: printf("\n CREATE ");
976:
977: if ((*s_etat_processus).langue == 'F')
978: {
979: printf("(création d'un fichier)\n\n");
980: }
981: else
982: {
983: printf("(create file)\n\n");
984: }
985:
986: printf(" 1: %s\n", d_CHN);
987:
988: return;
989: }
990: else if ((*s_etat_processus).test_instruction == 'Y')
991: {
992: (*s_etat_processus).nombre_arguments = -1;
993: return;
994: }
995:
996: if (test_cfsf(s_etat_processus, 31) == d_vrai)
997: {
998: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
999: {
1000: return;
1001: }
1002: }
1003:
1004: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1005: &s_objet_argument) == d_erreur)
1006: {
1007: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1008: return;
1009: }
1010:
1011: if ((*s_objet_argument).type == CHN)
1012: {
1013: if ((nom = transliteration(s_etat_processus, (unsigned char *)
1014: (*s_objet_argument).objet, d_locale, "UTF-8")) == NULL)
1015: {
1016: liberation(s_etat_processus, s_objet_argument);
1017: return;
1018: }
1019:
1020: erreur = caracteristiques_fichier(s_etat_processus, nom,
1021: &existence, &ouverture, &unite);
1022:
1023: if ((erreur != d_absence_erreur) || (existence == d_vrai))
1024: {
1025: liberation(s_etat_processus, s_objet_argument);
1026: free(nom);
1027:
1028: (*s_etat_processus).erreur_execution =
1029: d_ex_erreur_acces_fichier;
1030: return;
1031: }
1032:
1033: if ((fichier = fopen(nom, "w")) == NULL)
1034: {
1035: liberation(s_etat_processus, s_objet_argument);
1036: free(nom);
1037:
1038: (*s_etat_processus).erreur_execution =
1039: d_ex_erreur_acces_fichier;
1040: return;
1041: }
1042:
1043: free(nom);
1044:
1045: if (fclose(fichier) != 0)
1046: {
1047: liberation(s_etat_processus, s_objet_argument);
1048:
1049: (*s_etat_processus).erreur_execution =
1050: d_ex_erreur_acces_fichier;
1051: return;
1052: }
1053: }
1054: else
1055: {
1056: liberation(s_etat_processus, s_objet_argument);
1057:
1058: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1059: return;
1060: }
1061:
1062: liberation(s_etat_processus, s_objet_argument);
1063:
1064: return;
1065: }
1066:
1067:
1068: /*
1069: ================================================================================
1070: Fonction 'cswp'
1071: ================================================================================
1072: Entrées :
1073: --------------------------------------------------------------------------------
1074: Sorties :
1075: --------------------------------------------------------------------------------
1076: Effets de bord : néant
1077: ================================================================================
1078: */
1079:
1080: void
1081: instruction_cswp(struct_processus *s_etat_processus)
1082: {
1083: struct_objet *s_copie_argument_3;
1084: struct_objet *s_objet_argument_1;
1085: struct_objet *s_objet_argument_2;
1086: struct_objet *s_objet_argument_3;
1087:
1088: integer8 colonne_1;
1089: integer8 colonne_2;
1090: integer8 i;
1091:
1092: (*s_etat_processus).erreur_execution = d_ex;
1093:
1094: if ((*s_etat_processus).affichage_arguments == 'Y')
1095: {
1096: printf("\n CSWP ");
1097:
1098: if ((*s_etat_processus).langue == 'F')
1099: {
1100: printf("(échange de deux colonnes d'une matrice)\n\n");
1101: }
1102: else
1103: {
1104: printf("(swap two columns of a matrix)\n\n");
1105: }
1106:
1107: printf(" 3: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1108: printf(" 2: %s\n", d_INT);
1109: printf(" 1: %s\n", d_INT);
1110: printf("-> 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1111:
1112: return;
1113: }
1114: else if ((*s_etat_processus).test_instruction == 'Y')
1115: {
1116: (*s_etat_processus).nombre_arguments = -1;
1117: return;
1118: }
1119:
1120: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1121: {
1122: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
1123: {
1124: return;
1125: }
1126: }
1127:
1128: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1129: &s_objet_argument_1) == d_erreur)
1130: {
1131: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1132: return;
1133: }
1134:
1135: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1136: &s_objet_argument_2) == d_erreur)
1137: {
1138: liberation(s_etat_processus, s_objet_argument_1);
1139:
1140: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1141: return;
1142: }
1143:
1144: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1145: &s_objet_argument_3) == d_erreur)
1146: {
1147: liberation(s_etat_processus, s_objet_argument_1);
1148: liberation(s_etat_processus, s_objet_argument_2);
1149:
1150: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1151: return;
1152: }
1153:
1154: if (((*s_objet_argument_1).type == INT) &&
1155: ((*s_objet_argument_2).type == INT))
1156: {
1157: colonne_1 = (*((integer8 *) (*s_objet_argument_1).objet)) - 1;
1158: colonne_2 = (*((integer8 *) (*s_objet_argument_2).objet)) - 1;
1159:
1160: if ((*s_objet_argument_3).type == MIN)
1161: {
1162: if ((colonne_1 < 0) || (colonne_1 >
1163: (*((struct_matrice *) (*s_objet_argument_3).objet))
1164: .nombre_colonnes - 1) || (colonne_2 < 0) || (colonne_2 >
1165: (*((struct_matrice *)
1166: (*s_objet_argument_3).objet)).nombre_colonnes - 1))
1167: {
1168: liberation(s_etat_processus, s_objet_argument_1);
1169: liberation(s_etat_processus, s_objet_argument_2);
1170: liberation(s_etat_processus, s_objet_argument_3);
1171:
1172: (*s_etat_processus).erreur_execution =
1173: d_ex_dimensions_invalides;
1174: return;
1175: }
1176:
1177: if ((s_copie_argument_3 = copie_objet(s_etat_processus,
1178: s_objet_argument_3, 'Q')) == NULL)
1179: {
1180: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1181: return;
1182: }
1183:
1184: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_3).objet))
1185: .nombre_lignes; i++)
1186: {
1187: ((integer8 **) (*((struct_matrice *)
1188: (*s_copie_argument_3).objet)).tableau)
1189: [i][colonne_1] = ((integer8 **) (*((struct_matrice *)
1190: (*s_objet_argument_3).objet)).tableau)[i][colonne_2];
1191: ((integer8 **) (*((struct_matrice *)
1192: (*s_copie_argument_3).objet)).tableau)
1193: [i][colonne_2] = ((integer8 **) (*((struct_matrice *)
1194: (*s_objet_argument_3).objet)).tableau)[i][colonne_1];
1195: }
1196: }
1197: else if ((*s_objet_argument_3).type == MRL)
1198: {
1199: if ((colonne_1 < 0) || (colonne_1 >
1200: (*((struct_matrice *) (*s_objet_argument_3).objet))
1201: .nombre_colonnes - 1) || (colonne_2 < 0) || (colonne_2 >
1202: (*((struct_matrice *)
1203: (*s_objet_argument_3).objet)).nombre_colonnes - 1))
1204: {
1205: liberation(s_etat_processus, s_objet_argument_1);
1206: liberation(s_etat_processus, s_objet_argument_2);
1207: liberation(s_etat_processus, s_objet_argument_3);
1208:
1209: (*s_etat_processus).erreur_execution =
1210: d_ex_dimensions_invalides;
1211: return;
1212: }
1213:
1214: if ((s_copie_argument_3 = copie_objet(s_etat_processus,
1215: s_objet_argument_3, 'O')) == NULL)
1216: {
1217: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1218: return;
1219: }
1220:
1221: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_3).objet))
1222: .nombre_lignes; i++)
1223: {
1224: ((real8 **) (*((struct_matrice *)
1225: (*s_copie_argument_3).objet)).tableau)
1226: [i][colonne_1] = ((real8 **) (*((struct_matrice *)
1227: (*s_objet_argument_3).objet)).tableau)[i][colonne_2];
1228: ((real8 **) (*((struct_matrice *)
1229: (*s_copie_argument_3).objet)).tableau)
1230: [i][colonne_2] = ((real8 **) (*((struct_matrice *)
1231: (*s_objet_argument_3).objet)).tableau)[i][colonne_1];
1232: }
1233: }
1234: else if ((*s_objet_argument_3).type == MCX)
1235: {
1236: if ((colonne_1 < 0) || (colonne_1 >
1237: (*((struct_matrice *) (*s_objet_argument_3).objet))
1238: .nombre_colonnes - 1) || (colonne_2 < 0) || (colonne_2 >
1239: (*((struct_matrice *)
1240: (*s_objet_argument_3).objet)).nombre_colonnes - 1))
1241: {
1242: liberation(s_etat_processus, s_objet_argument_1);
1243: liberation(s_etat_processus, s_objet_argument_2);
1244: liberation(s_etat_processus, s_objet_argument_3);
1245:
1246: (*s_etat_processus).erreur_execution =
1247: d_ex_dimensions_invalides;
1248: return;
1249: }
1250:
1251: if ((s_copie_argument_3 = copie_objet(s_etat_processus,
1252: s_objet_argument_3, 'O')) == NULL)
1253: {
1254: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1255: return;
1256: }
1257:
1258: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_3).objet))
1259: .nombre_lignes; i++)
1260: {
1261: ((complex16 **) (*((struct_matrice *)
1262: (*s_copie_argument_3).objet)).tableau)
1263: [i][colonne_1].partie_reelle =
1264: ((complex16 **) (*((struct_matrice *)
1265: (*s_objet_argument_3).objet)).tableau)[i][colonne_2]
1266: .partie_reelle;
1267: ((complex16 **) (*((struct_matrice *)
1268: (*s_copie_argument_3).objet)).tableau)
1269: [i][colonne_1].partie_imaginaire =
1270: ((complex16 **) (*((struct_matrice *)
1271: (*s_objet_argument_3).objet)).tableau)[i][colonne_2]
1272: .partie_imaginaire;
1273: ((complex16 **) (*((struct_matrice *)
1274: (*s_copie_argument_3).objet)).tableau)
1275: [i][colonne_2].partie_reelle =
1276: ((complex16 **) (*((struct_matrice *)
1277: (*s_objet_argument_3).objet)).tableau)[i][colonne_1]
1278: .partie_reelle;
1279: ((complex16 **) (*((struct_matrice *)
1280: (*s_copie_argument_3).objet)).tableau)
1281: [i][colonne_2].partie_imaginaire =
1282: ((complex16 **) (*((struct_matrice *)
1283: (*s_objet_argument_3).objet)).tableau)[i][colonne_1]
1284: .partie_imaginaire;
1285: }
1286: }
1287: else
1288: {
1289: liberation(s_etat_processus, s_objet_argument_1);
1290: liberation(s_etat_processus, s_objet_argument_2);
1291: liberation(s_etat_processus, s_objet_argument_3);
1292:
1293: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1294: return;
1295: }
1296: }
1297: else
1298: {
1299: liberation(s_etat_processus, s_objet_argument_1);
1300: liberation(s_etat_processus, s_objet_argument_2);
1301: liberation(s_etat_processus, s_objet_argument_3);
1302:
1303: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1304: return;
1305: }
1306:
1307: liberation(s_etat_processus, s_objet_argument_1);
1308: liberation(s_etat_processus, s_objet_argument_2);
1309: liberation(s_etat_processus, s_objet_argument_3);
1310:
1311: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1312: s_copie_argument_3) == d_erreur)
1313: {
1314: return;
1315: }
1316:
1317: return;
1318: }
1319:
1320: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_c4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src