Annotation of rpl/src/instructions_c4.c, revision 1.87
1.1 bertrand 1: /*
2: ================================================================================
1.85 bertrand 3: RPL/2 (R) version 4.1.36
1.87 ! bertrand 4: Copyright (C) 1989-2025 Dr. BERTRAND Joël
1.1 bertrand 5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
1.14 bertrand 23: #include "rpl-conv.h"
24: #include "convert-conv.h"
1.1 bertrand 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:
1.40 bertrand 47: integer8 nombre_colonnes;
1.39 bertrand 48:
1.1 bertrand 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:
1.22 bertrand 86: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
1.1 bertrand 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: {
1.22 bertrand 98: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
99: .type != MIN) && ((*(*(*s_etat_processus)
100: .pointeur_variable_courante).objet).type != MRL))
1.1 bertrand 101: {
1.22 bertrand 102: (*s_etat_processus).erreur_execution =
103: d_ex_matrice_statistique_invalide;
1.1 bertrand 104: return;
105: }
106:
1.22 bertrand 107: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
108: .pointeur_variable_courante).objet).objet)).nombre_colonnes;
1.1 bertrand 109: }
110:
1.22 bertrand 111: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
112: .objet;
1.1 bertrand 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:
1.49 bertrand 182: integer8 nombre_colonnes;
1.1 bertrand 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:
1.22 bertrand 221: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
1.1 bertrand 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: {
1.22 bertrand 233: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
234: .type != MIN) && ((*(*(*s_etat_processus)
235: .pointeur_variable_courante).objet).type != MRL))
1.1 bertrand 236: {
1.22 bertrand 237: (*s_etat_processus).erreur_execution =
238: d_ex_matrice_statistique_invalide;
1.1 bertrand 239: return;
240: }
241:
1.22 bertrand 242: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
243: .pointeur_variable_courante).objet).objet))
244: .nombre_colonnes;
1.1 bertrand 245: }
246:
1.22 bertrand 247: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
248: .objet;
1.1 bertrand 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: {
1.14 bertrand 314: # include "copyright-conv.h"
1.1 bertrand 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:
1.49 bertrand 375: size_t longueur_chaine;
1.1 bertrand 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;
1.6 bertrand 384: unsigned char *executable_candidat;
1.1 bertrand 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: {
1.5 bertrand 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));
1.1 bertrand 462:
1.5 bertrand 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);
1.6 bertrand 473:
1.62 bertrand 474: if (alsprintf(s_etat_processus, &executable_candidat,
475: "%s/bin/rplconvert", d_exec_path) < 0)
1.6 bertrand 476: {
477: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
478: return;
479: }
480:
1.35 bertrand 481: if (controle_integrite(s_etat_processus, executable_candidat,
482: "rplconvert") != d_vrai)
1.6 bertrand 483: {
484: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
485: return;
486: }
487:
488: free(executable_candidat);
1.5 bertrand 489: }
490: else
1.1 bertrand 491: {
1.5 bertrand 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);
1.6 bertrand 508:
1.62 bertrand 509: if (alsprintf(s_etat_processus, &executable_candidat,
510: "%s/bin/rplconvert", (*s_etat_processus).rpl_home) < 0)
1.6 bertrand 511: {
512: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
513: return;
514: }
515:
1.35 bertrand 516: if (controle_integrite(s_etat_processus, executable_candidat,
517: "rplconvert") != d_vrai)
1.6 bertrand 518: {
519: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
520: return;
521: }
522:
523: free(executable_candidat);
1.1 bertrand 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:
1.59 bertrand 552: (*s_etat_processus).type_en_cours = NON;
1.1 bertrand 553: recherche_type(s_etat_processus);
554:
555: (*s_etat_processus).instruction_courante =
556: tampon_instruction;
557:
558: if ((*s_etat_processus).erreur_execution != d_ex)
559: {
560: if (pclose(pipe) == -1)
561: {
562: (*s_etat_processus).erreur_systeme = d_es_processus;
563: return;
564: }
565:
566: liberation(s_etat_processus, s_objet_argument_1);
567: liberation(s_etat_processus, s_objet_argument_2);
568: liberation(s_etat_processus, s_objet_argument_3);
569:
570: return;
571: }
572: }
573: }
574: } while(fin_fichier != EOF);
575:
576: /*
577: * Récupération de la ligne renvoyée commencant par "*". Si une telle
578: * ligne n'existe par, rplconvert retourne une erreur de type
579: * « conformability error » ou « Unknown unit ».
580: */
581:
582: if (pclose(pipe) == -1)
583: {
584: (*s_etat_processus).erreur_systeme = d_es_processus;
585: return;
586: }
587:
588: if (presence_resultat == d_faux)
589: {
590: liberation(s_etat_processus, s_objet_argument_1);
591: liberation(s_etat_processus, s_objet_argument_2);
592: liberation(s_etat_processus, s_objet_argument_3);
593:
594: (*s_etat_processus).erreur_execution = d_ex_conversion_unite;
595: return;
596: }
597:
598: /*
599: * Retrait des espaces dans la chaîne unité renvoyée
600: */
601:
602: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
603: s_objet_argument_3) == d_erreur)
604: {
605: return;
606: }
607:
608: if (last_valide == d_vrai)
609: {
610: cf(s_etat_processus, 31);
611: }
612:
613: instruction_multiplication(s_etat_processus);
614:
615: if (last_valide == d_vrai)
616: {
617: sf(s_etat_processus, 31);
618: }
619: }
620: else
621: {
622: liberation(s_etat_processus, s_objet_argument_1);
623: liberation(s_etat_processus, s_objet_argument_2);
624: liberation(s_etat_processus, s_objet_argument_3);
625:
626: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
627: return;
628: }
629:
630: liberation(s_etat_processus, s_objet_argument_1);
631: liberation(s_etat_processus, s_objet_argument_2);
632:
633: return;
634: }
635:
636:
637: /*
638: ================================================================================
639: Fonction 'close'
640: ================================================================================
641: Entrées :
642: --------------------------------------------------------------------------------
643: Sorties :
644: --------------------------------------------------------------------------------
645: Effets de bord : néant
646: ================================================================================
647: */
648:
649: void
650: instruction_close(struct_processus *s_etat_processus)
651: {
1.7 bertrand 652: const char *queue;
1.1 bertrand 653:
654: int socket;
655:
656: logical1 socket_connectee;
657:
1.7 bertrand 658: sqlite3_stmt *ppStmt;
659:
660: struct_descripteur_fichier *descripteur;
661:
1.1 bertrand 662: struct_liste_chainee *l_element_courant;
663: struct_liste_chainee *l_element_precedent;
664:
665: struct_objet *s_objet_argument;
666:
1.83 bertrand 667: unsigned char socket_en_ecoute;
668:
1.1 bertrand 669: (*s_etat_processus).erreur_execution = d_ex;
670:
671: if ((*s_etat_processus).affichage_arguments == 'Y')
672: {
673: printf("\n CLOSE ");
674:
675: if ((*s_etat_processus).langue == 'F')
676: {
677: printf("(fermeture d'un fichier, d'une socket ou d'un sémaphore)"
678: "\n\n");
679: }
680: else
681: {
682: printf("(close file, socket or semaphore)\n\n");
683: }
684:
685: printf(" 1: %s\n\n", d_FCH);
686:
687: printf(" 1: %s\n\n", d_SCK);
688:
689: printf(" 1: %s\n", d_SPH);
690:
691: return;
692: }
693: else if ((*s_etat_processus).test_instruction == 'Y')
694: {
695: (*s_etat_processus).nombre_arguments = -1;
696: return;
697: }
698:
699: if (test_cfsf(s_etat_processus, 31) == d_vrai)
700: {
701: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
702: {
703: return;
704: }
705: }
706:
707: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
708: &s_objet_argument) == d_erreur)
709: {
710: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
711: return;
712: }
713:
714: if ((*s_objet_argument).type == FCH)
715: {
716: /*
717: * Retrait du descripteur de la pile de fichiers
718: */
719:
720: l_element_courant = (*s_etat_processus).s_fichiers;
721: l_element_precedent = NULL;
722:
723: descripteur = NULL;
724:
725: while(l_element_courant != NULL)
726: {
727: if (((*((struct_descripteur_fichier *) (*l_element_courant).donnee))
728: .identifiant == (*((struct_fichier *) (*s_objet_argument)
729: .objet)).descripteur) && ((*((struct_descripteur_fichier *)
730: (*l_element_courant).donnee)).pid == getpid()) &&
731: (pthread_equal((*((struct_descripteur_fichier *)
732: (*l_element_courant).donnee)).tid, pthread_self()) != 0))
733: {
734: if (((*((struct_fichier *) (*s_objet_argument).objet)).pid ==
735: (*((struct_descripteur_fichier *) (*l_element_courant)
736: .donnee)).pid) && (pthread_equal((*((struct_fichier *)
737: (*s_objet_argument).objet)).tid,
738: (*((struct_descripteur_fichier *) (*l_element_courant)
739: .donnee)).tid) != 0))
740: {
1.7 bertrand 741: descripteur = (struct_descripteur_fichier *)
742: (*l_element_courant).donnee;
1.1 bertrand 743:
744: if (l_element_precedent == NULL)
745: {
746: (*s_etat_processus).s_fichiers =
747: (*l_element_courant).suivant;
748: }
749: else if ((*l_element_courant).suivant == NULL)
750: {
751: (*l_element_precedent).suivant = NULL;
752: }
753: else
754: {
755: (*l_element_precedent).suivant =
756: (*l_element_courant).suivant;
757: }
758:
759: free((*((struct_descripteur_fichier *)
760: (*l_element_courant).donnee)).nom);
761: free(l_element_courant);
762:
763: break;
764: }
765: }
766:
767: l_element_precedent = l_element_courant;
768: l_element_courant = (*l_element_courant).suivant;
769: }
770:
771: if (descripteur == NULL)
772: {
773: liberation(s_etat_processus, s_objet_argument);
774:
775: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
776: return;
777: }
778:
779: /*
780: * Fermeture du fichier
781: */
782:
1.7 bertrand 783: if ((*descripteur).type != 'C')
784: {
785: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
786: "vacuum", 7, &ppStmt, &queue) != SQLITE_OK)
787: {
788: free(descripteur);
789: liberation(s_etat_processus, s_objet_argument);
790:
791: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
792: return;
793: }
794:
795: if (sqlite3_step(ppStmt) != SQLITE_DONE)
796: {
797: free(descripteur);
798: liberation(s_etat_processus, s_objet_argument);
799:
800: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
801: return;
802: }
803:
804: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
805: {
806: free(descripteur);
807: liberation(s_etat_processus, s_objet_argument);
808:
809: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
810: return;
811: }
812:
813: if (sqlite3_close((*descripteur).descripteur_sqlite) != SQLITE_OK)
814: {
815: free(descripteur);
816: liberation(s_etat_processus, s_objet_argument);
817:
818: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
819: return;
820: }
821:
822: free(descripteur);
823: }
1.86 bertrand 824: else
825: {
826: if (fclose((*descripteur).descripteur_c) != 0)
827: {
828: free(descripteur);
829: liberation(s_etat_processus, s_objet_argument);
830:
831: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
832: return;
833: }
834: }
1.7 bertrand 835:
1.1 bertrand 836: if ((*((struct_fichier *) (*s_objet_argument).objet)).ouverture == 'S')
837: {
838: if (destruction_fichier((*((struct_fichier *)
839: (*s_objet_argument).objet)).nom) == d_erreur)
840: {
841: liberation(s_etat_processus, s_objet_argument);
842:
843: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
844: return;
845: }
846: }
847: }
848: else if ((*s_objet_argument).type == SCK)
849: {
850: /*
851: * Retrait de la socket de la pile
852: */
853:
854: l_element_courant = (*s_etat_processus).s_sockets;
855: l_element_precedent = NULL;
856:
857: socket = -1;
858: socket_connectee = d_faux;
1.83 bertrand 859: socket_en_ecoute = 'Y';
1.1 bertrand 860:
861: while(l_element_courant != NULL)
862: {
863: if ((*((struct_socket *) (*(*l_element_courant).donnee).objet))
864: .socket == (*((struct_socket *) (*s_objet_argument)
865: .objet)).socket)
866: {
867: socket = (*((struct_socket *)
868: (*(*l_element_courant).donnee).objet)).socket;
869: socket_connectee = (*((struct_socket *)
870: (*(*l_element_courant).donnee).objet)).socket_connectee;
1.83 bertrand 871: socket_en_ecoute = (*((struct_socket *)
872: (*(*l_element_courant).donnee).objet)).socket_en_ecoute;
1.1 bertrand 873:
874: if (l_element_precedent == NULL)
875: {
876: (*s_etat_processus).s_sockets =
877: (*l_element_courant).suivant;
878: }
879: else if ((*l_element_courant).suivant == NULL)
880: {
881: (*l_element_precedent).suivant = NULL;
882: }
883: else
884: {
885: (*l_element_precedent).suivant =
886: (*l_element_courant).suivant;
887: }
888:
889: liberation(s_etat_processus, (*l_element_courant).donnee);
890: free(l_element_courant);
891:
892: break;
893: }
894:
895: l_element_precedent = l_element_courant;
896: l_element_courant = (*l_element_courant).suivant;
897: }
898:
899: if (socket == -1)
900: {
901: liberation(s_etat_processus, s_objet_argument);
902:
903: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
904: return;
905: }
906:
907: /*
908: * Fermeture de la socket
909: */
910:
911: if (socket_connectee == d_vrai)
912: {
1.83 bertrand 913: if (socket_en_ecoute == 'N')
914: {
915: shutdown(socket, SHUT_RDWR);
916: }
1.1 bertrand 917: }
918:
919: if (close(socket) != 0)
920: {
921: liberation(s_etat_processus, s_objet_argument);
922:
923: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
924: return;
925: }
926:
927: if ((*((struct_socket *) (*s_objet_argument).objet)).effacement == 'Y')
928: {
929: unlink((*((struct_socket *) (*s_objet_argument).objet)).adresse);
930: }
931: }
932: else if ((*s_objet_argument).type == SPH)
933: {
934: if (sem_close((*((struct_semaphore *) (*s_objet_argument).objet))
935: .semaphore) != 0)
936: {
937: (*s_etat_processus).erreur_execution = d_ex_semaphore;
938: return;
939: }
940: }
941: else
942: {
943: liberation(s_etat_processus, s_objet_argument);
944:
945: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
946: return;
947: }
948:
949: liberation(s_etat_processus, s_objet_argument);
950:
951: return;
952: }
953:
954:
955: /*
956: ================================================================================
957: Fonction 'create'
958: ================================================================================
959: Entrées :
960: --------------------------------------------------------------------------------
961: Sorties :
962: --------------------------------------------------------------------------------
963: Effets de bord : néant
964: ================================================================================
965: */
966:
967: void
968: instruction_create(struct_processus *s_etat_processus)
969: {
970: file *fichier;
971:
972: logical1 erreur;
973: logical1 existence;
974: logical1 ouverture;
975:
976: struct_objet *s_objet_argument;
977:
1.7 bertrand 978: unsigned char *nom;
979:
1.1 bertrand 980: unsigned long unite;
981:
982: (*s_etat_processus).erreur_execution = d_ex;
983:
984: if ((*s_etat_processus).affichage_arguments == 'Y')
985: {
986: printf("\n CREATE ");
987:
988: if ((*s_etat_processus).langue == 'F')
989: {
990: printf("(création d'un fichier)\n\n");
991: }
992: else
993: {
994: printf("(create file)\n\n");
995: }
996:
997: printf(" 1: %s\n", d_CHN);
998:
999: return;
1000: }
1001: else if ((*s_etat_processus).test_instruction == 'Y')
1002: {
1003: (*s_etat_processus).nombre_arguments = -1;
1004: return;
1005: }
1006:
1007: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1008: {
1009: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1010: {
1011: return;
1012: }
1013: }
1014:
1015: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1016: &s_objet_argument) == d_erreur)
1017: {
1018: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1019: return;
1020: }
1021:
1022: if ((*s_objet_argument).type == CHN)
1023: {
1.7 bertrand 1024: if ((nom = transliteration(s_etat_processus, (unsigned char *)
1025: (*s_objet_argument).objet, d_locale, "UTF-8")) == NULL)
1026: {
1027: liberation(s_etat_processus, s_objet_argument);
1028: return;
1029: }
1030:
1031: erreur = caracteristiques_fichier(s_etat_processus, nom,
1032: &existence, &ouverture, &unite);
1.1 bertrand 1033:
1034: if ((erreur != d_absence_erreur) || (existence == d_vrai))
1035: {
1036: liberation(s_etat_processus, s_objet_argument);
1.7 bertrand 1037: free(nom);
1.1 bertrand 1038:
1039: (*s_etat_processus).erreur_execution =
1040: d_ex_erreur_acces_fichier;
1041: return;
1042: }
1043:
1.7 bertrand 1044: if ((fichier = fopen(nom, "w")) == NULL)
1.1 bertrand 1045: {
1046: liberation(s_etat_processus, s_objet_argument);
1.7 bertrand 1047: free(nom);
1.1 bertrand 1048:
1049: (*s_etat_processus).erreur_execution =
1050: d_ex_erreur_acces_fichier;
1051: return;
1052: }
1053:
1.7 bertrand 1054: free(nom);
1055:
1.1 bertrand 1056: if (fclose(fichier) != 0)
1057: {
1058: liberation(s_etat_processus, s_objet_argument);
1059:
1060: (*s_etat_processus).erreur_execution =
1061: d_ex_erreur_acces_fichier;
1062: return;
1063: }
1064: }
1065: else
1066: {
1067: liberation(s_etat_processus, s_objet_argument);
1068:
1069: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1070: return;
1071: }
1072:
1073: liberation(s_etat_processus, s_objet_argument);
1074:
1075: return;
1076: }
1077:
1078:
1079: /*
1080: ================================================================================
1081: Fonction 'cswp'
1082: ================================================================================
1083: Entrées :
1084: --------------------------------------------------------------------------------
1085: Sorties :
1086: --------------------------------------------------------------------------------
1087: Effets de bord : néant
1088: ================================================================================
1089: */
1090:
1091: void
1092: instruction_cswp(struct_processus *s_etat_processus)
1093: {
1094: struct_objet *s_copie_argument_3;
1095: struct_objet *s_objet_argument_1;
1096: struct_objet *s_objet_argument_2;
1097: struct_objet *s_objet_argument_3;
1098:
1.49 bertrand 1099: integer8 colonne_1;
1100: integer8 colonne_2;
1101: integer8 i;
1.1 bertrand 1102:
1103: (*s_etat_processus).erreur_execution = d_ex;
1104:
1105: if ((*s_etat_processus).affichage_arguments == 'Y')
1106: {
1107: printf("\n CSWP ");
1108:
1109: if ((*s_etat_processus).langue == 'F')
1110: {
1111: printf("(échange de deux colonnes d'une matrice)\n\n");
1112: }
1113: else
1114: {
1115: printf("(swap two columns of a matrix)\n\n");
1116: }
1117:
1118: printf(" 3: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1119: printf(" 2: %s\n", d_INT);
1120: printf(" 1: %s\n", d_INT);
1121: printf("-> 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1122:
1123: return;
1124: }
1125: else if ((*s_etat_processus).test_instruction == 'Y')
1126: {
1127: (*s_etat_processus).nombre_arguments = -1;
1128: return;
1129: }
1130:
1131: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1132: {
1133: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
1134: {
1135: return;
1136: }
1137: }
1138:
1139: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1140: &s_objet_argument_1) == d_erreur)
1141: {
1142: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1143: return;
1144: }
1145:
1146: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1147: &s_objet_argument_2) == d_erreur)
1148: {
1149: liberation(s_etat_processus, s_objet_argument_1);
1150:
1151: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1152: return;
1153: }
1154:
1155: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1156: &s_objet_argument_3) == d_erreur)
1157: {
1158: liberation(s_etat_processus, s_objet_argument_1);
1159: liberation(s_etat_processus, s_objet_argument_2);
1160:
1161: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1162: return;
1163: }
1164:
1165: if (((*s_objet_argument_1).type == INT) &&
1166: ((*s_objet_argument_2).type == INT))
1167: {
1168: colonne_1 = (*((integer8 *) (*s_objet_argument_1).objet)) - 1;
1169: colonne_2 = (*((integer8 *) (*s_objet_argument_2).objet)) - 1;
1170:
1171: if ((*s_objet_argument_3).type == MIN)
1172: {
1.50 bertrand 1173: if ((colonne_1 < 0) || (colonne_1 >
1.1 bertrand 1174: (*((struct_matrice *) (*s_objet_argument_3).objet))
1.50 bertrand 1175: .nombre_colonnes - 1) || (colonne_2 < 0) || (colonne_2 >
1176: (*((struct_matrice *)
1177: (*s_objet_argument_3).objet)).nombre_colonnes - 1))
1.1 bertrand 1178: {
1179: liberation(s_etat_processus, s_objet_argument_1);
1180: liberation(s_etat_processus, s_objet_argument_2);
1181: liberation(s_etat_processus, s_objet_argument_3);
1182:
1183: (*s_etat_processus).erreur_execution =
1184: d_ex_dimensions_invalides;
1185: return;
1186: }
1187:
1188: if ((s_copie_argument_3 = copie_objet(s_etat_processus,
1189: s_objet_argument_3, 'Q')) == NULL)
1190: {
1191: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1192: return;
1193: }
1194:
1195: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_3).objet))
1196: .nombre_lignes; i++)
1197: {
1198: ((integer8 **) (*((struct_matrice *)
1199: (*s_copie_argument_3).objet)).tableau)
1200: [i][colonne_1] = ((integer8 **) (*((struct_matrice *)
1201: (*s_objet_argument_3).objet)).tableau)[i][colonne_2];
1202: ((integer8 **) (*((struct_matrice *)
1203: (*s_copie_argument_3).objet)).tableau)
1204: [i][colonne_2] = ((integer8 **) (*((struct_matrice *)
1205: (*s_objet_argument_3).objet)).tableau)[i][colonne_1];
1206: }
1207: }
1208: else if ((*s_objet_argument_3).type == MRL)
1209: {
1.50 bertrand 1210: if ((colonne_1 < 0) || (colonne_1 >
1.1 bertrand 1211: (*((struct_matrice *) (*s_objet_argument_3).objet))
1.50 bertrand 1212: .nombre_colonnes - 1) || (colonne_2 < 0) || (colonne_2 >
1213: (*((struct_matrice *)
1214: (*s_objet_argument_3).objet)).nombre_colonnes - 1))
1.1 bertrand 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, 'O')) == 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: ((real8 **) (*((struct_matrice *)
1236: (*s_copie_argument_3).objet)).tableau)
1237: [i][colonne_1] = ((real8 **) (*((struct_matrice *)
1238: (*s_objet_argument_3).objet)).tableau)[i][colonne_2];
1239: ((real8 **) (*((struct_matrice *)
1240: (*s_copie_argument_3).objet)).tableau)
1241: [i][colonne_2] = ((real8 **) (*((struct_matrice *)
1242: (*s_objet_argument_3).objet)).tableau)[i][colonne_1];
1243: }
1244: }
1245: else if ((*s_objet_argument_3).type == MCX)
1246: {
1.50 bertrand 1247: if ((colonne_1 < 0) || (colonne_1 >
1.1 bertrand 1248: (*((struct_matrice *) (*s_objet_argument_3).objet))
1.50 bertrand 1249: .nombre_colonnes - 1) || (colonne_2 < 0) || (colonne_2 >
1250: (*((struct_matrice *)
1251: (*s_objet_argument_3).objet)).nombre_colonnes - 1))
1.1 bertrand 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: ((complex16 **) (*((struct_matrice *)
1273: (*s_copie_argument_3).objet)).tableau)
1274: [i][colonne_1].partie_reelle =
1275: ((complex16 **) (*((struct_matrice *)
1276: (*s_objet_argument_3).objet)).tableau)[i][colonne_2]
1277: .partie_reelle;
1278: ((complex16 **) (*((struct_matrice *)
1279: (*s_copie_argument_3).objet)).tableau)
1280: [i][colonne_1].partie_imaginaire =
1281: ((complex16 **) (*((struct_matrice *)
1282: (*s_objet_argument_3).objet)).tableau)[i][colonne_2]
1283: .partie_imaginaire;
1284: ((complex16 **) (*((struct_matrice *)
1285: (*s_copie_argument_3).objet)).tableau)
1286: [i][colonne_2].partie_reelle =
1287: ((complex16 **) (*((struct_matrice *)
1288: (*s_objet_argument_3).objet)).tableau)[i][colonne_1]
1289: .partie_reelle;
1290: ((complex16 **) (*((struct_matrice *)
1291: (*s_copie_argument_3).objet)).tableau)
1292: [i][colonne_2].partie_imaginaire =
1293: ((complex16 **) (*((struct_matrice *)
1294: (*s_objet_argument_3).objet)).tableau)[i][colonne_1]
1295: .partie_imaginaire;
1296: }
1297: }
1298: else
1299: {
1300: liberation(s_etat_processus, s_objet_argument_1);
1301: liberation(s_etat_processus, s_objet_argument_2);
1302: liberation(s_etat_processus, s_objet_argument_3);
1303:
1304: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1305: return;
1306: }
1307: }
1308: else
1309: {
1310: liberation(s_etat_processus, s_objet_argument_1);
1311: liberation(s_etat_processus, s_objet_argument_2);
1312: liberation(s_etat_processus, s_objet_argument_3);
1313:
1314: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1315: return;
1316: }
1317:
1318: liberation(s_etat_processus, s_objet_argument_1);
1319: liberation(s_etat_processus, s_objet_argument_2);
1320: liberation(s_etat_processus, s_objet_argument_3);
1321:
1322: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1323: s_copie_argument_3) == d_erreur)
1324: {
1325: return;
1326: }
1327:
1328: return;
1329: }
1330:
1331: // 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