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