1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.2
4: Copyright (C) 1989-2011 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'mem'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_mem(struct_processus *s_etat_processus)
40: {
41: int j;
42: int nb_variables;
43:
44: struct_liste_chainee *l_element_courant;
45:
46: struct_objet *s_objet_resultat;
47:
48: struct_tableau_variables *tableau;
49:
50: unsigned long i;
51:
52: (*s_etat_processus).erreur_execution = d_ex;
53:
54: if ((*s_etat_processus).affichage_arguments == 'Y')
55: {
56: printf("\n MEM ");
57:
58: if ((*s_etat_processus).langue == 'F')
59: {
60: printf("(mémoire occupée)\n\n");
61: }
62: else
63: {
64: printf("(used memory)\n\n");
65: }
66:
67: printf("-> 1: %s\n", d_LST);
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: if ((s_objet_resultat = allocation(s_etat_processus, LST))
86: == NULL)
87: {
88: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
89: return;
90: }
91:
92: if (((*s_objet_resultat).objet =
93: allocation_maillon(s_etat_processus)) == NULL)
94: {
95: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
96: return;
97: }
98:
99: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)).donnee =
100: allocation(s_etat_processus, INT)) == NULL)
101: {
102: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
103: return;
104: }
105:
106: /*
107: * Décompte de la mémoire utilisée dans la pile
108: */
109:
110: (*((integer8 *) (*((*((struct_liste_chainee *) (*s_objet_resultat).objet))
111: .donnee)).objet)) = 0;
112:
113: l_element_courant = (*s_etat_processus).l_base_pile;
114:
115: while(l_element_courant != NULL)
116: {
117: (*((integer8 *) (*((*((struct_liste_chainee *) (*s_objet_resultat)
118: .objet)).donnee)).objet)) += occupation_memoire(
119: (*l_element_courant).donnee);
120: l_element_courant = (*l_element_courant).suivant;
121: }
122:
123: /*
124: * Décompte de la mémoire utilisée pour les différentes variables
125: */
126:
127: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant
128: = allocation_maillon(s_etat_processus)) == NULL)
129: {
130: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
131: return;
132: }
133:
134: if (((*((*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant))
135: .donnee = allocation(s_etat_processus, INT)) == NULL)
136: {
137: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
138: return;
139: }
140:
141: (*((*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant))
142: .suivant = NULL;
143:
144: (*((integer8 *) (*((*((*((struct_liste_chainee *)
145: (*s_objet_resultat).objet)).suivant)).donnee)).objet)) = 0;
146:
147: nb_variables = nombre_variables(s_etat_processus,
148: (*s_etat_processus).s_arbre_variables);
149:
150: if ((tableau = malloc(nb_variables * sizeof(struct_tableau_variables)))
151: == NULL)
152: {
153: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
154: return;
155: }
156:
157: liste_variables(s_etat_processus, tableau, 0,
158: (*s_etat_processus).s_arbre_variables);
159:
160: for(j = 0; j < nb_variables; j++)
161: {
162: (*((integer8 *) (*((*((*((struct_liste_chainee *) (*s_objet_resultat)
163: .objet)).suivant)).donnee)).objet)) += sizeof(unsigned char) *
164: strlen(tableau[j].nom);
165: (*((integer8 *) (*((*((*((struct_liste_chainee *) (*s_objet_resultat)
166: .objet)).suivant)).donnee)).objet)) += occupation_memoire(
167: tableau[j].objet);
168: }
169:
170: free(tableau);
171:
172: for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
173: {
174: // Comptabilisation des empreintes mémoire des variables
175: // statiques qui ne sont pas accessibles, les variables statiques
176: // accessibles étant déjà comptabilitées par la boucle précédente.
177:
178: if ((*s_etat_processus).s_liste_variables_statiques[i].objet != NULL)
179: {
180: (*((integer8 *) (*((*((*((struct_liste_chainee *)
181: (*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=
182: sizeof(unsigned char) * strlen((*s_etat_processus)
183: .s_liste_variables_statiques[i].nom);
184: (*((integer8 *) (*((*((*((struct_liste_chainee *)
185: (*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=
186: occupation_memoire((*s_etat_processus)
187: .s_liste_variables_statiques[i].objet);
188: }
189: }
190:
191: for(i = 0; i < (*(*s_etat_processus).s_liste_variables_partagees)
192: .nombre_variables; i++)
193: {
194: (*((integer8 *) (*((*((*((struct_liste_chainee *)
195: (*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=
196: sizeof(unsigned char) * strlen((*(*s_etat_processus)
197: .s_liste_variables_partagees).table[i].nom);
198: (*((integer8 *) (*((*((*((struct_liste_chainee *)
199: (*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=
200: occupation_memoire((*(*s_etat_processus)
201: .s_liste_variables_partagees).table[i].objet);
202: }
203:
204: /*
205: * Empilement du résultat
206: */
207:
208: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
209: s_objet_resultat) == d_erreur)
210: {
211: return;
212: }
213:
214: return;
215: }
216:
217:
218: /*
219: ================================================================================
220: Fonction 'mclrin'
221: ================================================================================
222: Entrées :
223: --------------------------------------------------------------------------------
224: Sorties :
225: --------------------------------------------------------------------------------
226: Effets de bord : néant
227: ================================================================================
228: */
229:
230: void
231: instruction_mclrin(struct_processus *s_etat_processus)
232: {
233: logical1 last_valide;
234:
235: struct_liste_chainee *l_liste;
236:
237: struct_objet *s_objet;
238:
239: (*s_etat_processus).erreur_execution = d_ex;
240:
241: if ((*s_etat_processus).affichage_arguments == 'Y')
242: {
243: printf("\n MCLRIN ");
244:
245: if ((*s_etat_processus).langue == 'F')
246: {
247: printf("(série de MacLaurin)\n\n");
248: }
249: else
250: {
251: printf("(MacLaurin serie)\n\n");
252: }
253:
254: printf(" 3: %s\n", d_ALG);
255: printf(" 2: %s\n", d_NOM);
256: printf(" 1: %s\n", d_INT);
257: printf("-> 1: %s\n", d_ALG);
258:
259: return;
260: }
261: else if ((*s_etat_processus).test_instruction == 'Y')
262: {
263: (*s_etat_processus).nombre_arguments = -1;
264: return;
265: }
266:
267: if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
268: {
269: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
270: {
271: return;
272: }
273: }
274:
275: if ((*s_etat_processus).hauteur_pile_operationnelle < 3)
276: {
277: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
278: return;
279: }
280:
281: if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
282: {
283: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
284: return;
285: }
286:
287: (*((integer8 *) (*s_objet).objet)) = 0;
288:
289: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
290: s_objet) == d_erreur)
291: {
292: return;
293: }
294:
295: l_liste = (*s_etat_processus).l_base_pile;
296: (*s_etat_processus).l_base_pile = (*l_liste).suivant;
297: (*l_liste).suivant = (*(*s_etat_processus).l_base_pile).suivant;
298: (*(*s_etat_processus).l_base_pile).suivant = l_liste;
299:
300: if (last_valide == d_vrai)
301: {
302: cf(s_etat_processus, 31);
303: }
304:
305: instruction_taylr(s_etat_processus);
306:
307: if (last_valide == d_vrai)
308: {
309: sf(s_etat_processus, 31);
310: }
311:
312: return;
313: }
314:
315:
316: /*
317: ================================================================================
318: Fonction 'mtxlock'
319: ================================================================================
320: Entrées :
321: --------------------------------------------------------------------------------
322: Sorties :
323: --------------------------------------------------------------------------------
324: Effets de bord : néant
325: ================================================================================
326: */
327:
328: void
329: instruction_mtxlock(struct_processus *s_etat_processus)
330: {
331: struct_liste_chainee *l_element_courant;
332:
333: struct_objet *s_objet_argument;
334:
335: unsigned char *tampon;
336:
337: (*s_etat_processus).erreur_execution = d_ex;
338:
339: if ((*s_etat_processus).affichage_arguments == 'Y')
340: {
341: printf("\n MTXLOCK ");
342:
343: if ((*s_etat_processus).langue == 'F')
344: {
345: printf("(verrouille un mutex)\n\n");
346: }
347: else
348: {
349: printf("(lock mutex)\n\n");
350: }
351:
352: printf(" 1: %s\n", d_MTX);
353:
354: return;
355: }
356: else if ((*s_etat_processus).test_instruction == 'Y')
357: {
358: (*s_etat_processus).nombre_arguments = -1;
359: return;
360: }
361:
362: if (test_cfsf(s_etat_processus, 31) == d_vrai)
363: {
364: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
365: {
366: return;
367: }
368: }
369:
370: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
371: &s_objet_argument) == d_erreur)
372: {
373: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
374: return;
375: }
376:
377: if ((*s_objet_argument).type == MTX)
378: {
379: l_element_courant = (*s_etat_processus).liste_mutexes;
380:
381: while(l_element_courant != NULL)
382: {
383: if (&((*((struct_mutex *) (*(*l_element_courant).donnee).objet))
384: .mutex) == &((*((struct_mutex *) (*s_objet_argument).objet))
385: .mutex))
386: {
387: break;
388: }
389:
390: l_element_courant = (*l_element_courant).suivant;
391: }
392:
393: if (l_element_courant == NULL)
394: {
395: (*s_etat_processus).erreur_execution = d_ex_mutex;
396:
397: liberation(s_etat_processus, s_objet_argument);
398: return;
399: }
400:
401: if ((*s_etat_processus).profilage == d_vrai)
402: {
403: if ((tampon = formateur(s_etat_processus, 0, s_objet_argument))
404: == NULL)
405: {
406: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
407: return;
408: }
409:
410: profilage(s_etat_processus, tampon);
411: free(tampon);
412:
413: if ((*s_etat_processus).erreur_systeme != d_es)
414: {
415: return;
416: }
417: }
418:
419: # ifndef SEMAPHORES_NOMMES
420: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
421: {
422: (*s_etat_processus).erreur_systeme = d_es_processus;
423: return;
424: }
425: # else
426: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
427: {
428: (*s_etat_processus).erreur_systeme = d_es_processus;
429: return;
430: }
431: # endif
432:
433: if (pthread_mutex_lock(&((*((struct_mutex *) (*s_objet_argument).objet))
434: .mutex)) != 0)
435: {
436: # ifndef SEMAPHORES_NOMMES
437: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
438: # else
439: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
440: # endif
441: {
442: if ((*s_etat_processus).profilage == d_vrai)
443: {
444: profilage(s_etat_processus, NULL);
445: }
446:
447: if (errno != EINTR)
448: {
449: (*s_etat_processus).erreur_systeme = d_es_processus;
450: return;
451: }
452: }
453:
454: liberation(s_etat_processus, s_objet_argument);
455:
456: if ((*s_etat_processus).profilage == d_vrai)
457: {
458: profilage(s_etat_processus, NULL);
459: }
460:
461: (*s_etat_processus).erreur_systeme = d_es_processus;
462: return;
463: }
464:
465: # ifndef SEMAPHORES_NOMMES
466: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
467: # else
468: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
469: # endif
470: {
471: if (errno != EINTR)
472: {
473: (*s_etat_processus).erreur_systeme = d_es_processus;
474: return;
475: }
476: }
477:
478: if ((*s_etat_processus).profilage == d_vrai)
479: {
480: profilage(s_etat_processus, NULL);
481: }
482: }
483: else
484: {
485: liberation(s_etat_processus, s_objet_argument);
486:
487: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
488: return;
489: }
490:
491: liberation(s_etat_processus, s_objet_argument);
492:
493: return;
494: }
495:
496:
497: /*
498: ================================================================================
499: Fonction 'mtxtrylock'
500: ================================================================================
501: Entrées :
502: --------------------------------------------------------------------------------
503: Sorties :
504: --------------------------------------------------------------------------------
505: Effets de bord : néant
506: ================================================================================
507: */
508:
509: void
510: instruction_mtxtrylock(struct_processus *s_etat_processus)
511: {
512: int ios;
513:
514: struct_liste_chainee *l_element_courant;
515:
516: struct_objet *s_objet_argument;
517: struct_objet *s_objet_resultat;
518:
519: unsigned char *tampon;
520:
521: (*s_etat_processus).erreur_execution = d_ex;
522:
523: if ((*s_etat_processus).affichage_arguments == 'Y')
524: {
525: printf("\n MTXTRYLOCK ");
526:
527: if ((*s_etat_processus).langue == 'F')
528: {
529: printf("(essai de verrouillage du mutex)\n\n");
530: }
531: else
532: {
533: printf("(try to lock mutex)\n\n");
534: }
535:
536: printf(" 1: %s\n", d_MTX);
537: printf("-> 1: %s\n", d_INT);
538:
539: return;
540: }
541: else if ((*s_etat_processus).test_instruction == 'Y')
542: {
543: (*s_etat_processus).nombre_arguments = -1;
544: return;
545: }
546:
547: if (test_cfsf(s_etat_processus, 31) == d_vrai)
548: {
549: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
550: {
551: return;
552: }
553: }
554:
555: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
556: &s_objet_argument) == d_erreur)
557: {
558: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
559: return;
560: }
561:
562: if ((*s_objet_argument).type == MTX)
563: {
564: l_element_courant = (*s_etat_processus).liste_mutexes;
565:
566: while(l_element_courant != NULL)
567: {
568: if (&((*((struct_mutex *) (*(*l_element_courant).donnee).objet))
569: .mutex) == &((*((struct_mutex *) (*s_objet_argument).objet))
570: .mutex))
571: {
572: break;
573: }
574:
575: l_element_courant = (*l_element_courant).suivant;
576: }
577:
578: if (l_element_courant == NULL)
579: {
580: (*s_etat_processus).erreur_execution = d_ex_mutex;
581:
582: liberation(s_etat_processus, s_objet_argument);
583: return;
584: }
585:
586: if ((*s_etat_processus).profilage == d_vrai)
587: {
588: if ((tampon = formateur(s_etat_processus, 0, s_objet_argument))
589: == NULL)
590: {
591: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
592: return;
593: }
594:
595: profilage(s_etat_processus, tampon);
596: free(tampon);
597:
598: if ((*s_etat_processus).erreur_systeme != d_es)
599: {
600: return;
601: }
602: }
603:
604: if ((ios = pthread_mutex_trylock(&((*((struct_mutex *)
605: (*s_objet_argument).objet)).mutex))) != 0)
606: {
607: if (ios != EBUSY)
608: {
609: liberation(s_etat_processus, s_objet_argument);
610:
611: if ((*s_etat_processus).profilage == d_vrai)
612: {
613: profilage(s_etat_processus, NULL);
614: }
615:
616: (*s_etat_processus).erreur_systeme = d_es_processus;
617: return;
618: }
619: }
620:
621: if ((*s_etat_processus).profilage == d_vrai)
622: {
623: profilage(s_etat_processus, NULL);
624: }
625: }
626: else
627: {
628: liberation(s_etat_processus, s_objet_argument);
629:
630: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
631: return;
632: }
633:
634: liberation(s_etat_processus, s_objet_argument);
635:
636: if ((s_objet_resultat = allocation(s_etat_processus, INT))
637: == NULL)
638: {
639: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
640: return;
641: }
642:
643: (*((integer8 *) (*s_objet_resultat).objet)) = (ios == 0) ? 0 : -1;
644:
645: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
646: s_objet_resultat) == d_erreur)
647: {
648: return;
649: }
650:
651: return;
652: }
653:
654: /*
655: ================================================================================
656: Fonction 'mtxstatus'
657: ================================================================================
658: Entrées :
659: --------------------------------------------------------------------------------
660: Sorties :
661: --------------------------------------------------------------------------------
662: Effets de bord : néant
663: ================================================================================
664: */
665:
666: void
667: instruction_mtxstatus(struct_processus *s_etat_processus)
668: {
669: int ios;
670:
671: struct_liste_chainee *l_element_courant;
672:
673: struct_objet *s_objet_argument;
674: struct_objet *s_objet_resultat;
675:
676: unsigned char *tampon;
677:
678: (*s_etat_processus).erreur_execution = d_ex;
679:
680: if ((*s_etat_processus).affichage_arguments == 'Y')
681: {
682: printf("\n MTXSTATUS ");
683:
684: if ((*s_etat_processus).langue == 'F')
685: {
686: printf("(statut du mutex)\n\n");
687: }
688: else
689: {
690: printf("(mutex status)\n\n");
691: }
692:
693: printf(" 1: %s\n", d_MTX);
694: printf("-> 1: %s\n", d_INT);
695:
696: return;
697: }
698: else if ((*s_etat_processus).test_instruction == 'Y')
699: {
700: (*s_etat_processus).nombre_arguments = -1;
701: return;
702: }
703:
704: if (test_cfsf(s_etat_processus, 31) == d_vrai)
705: {
706: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
707: {
708: return;
709: }
710: }
711:
712: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
713: &s_objet_argument) == d_erreur)
714: {
715: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
716: return;
717: }
718:
719: if ((*s_objet_argument).type == MTX)
720: {
721: l_element_courant = (*s_etat_processus).liste_mutexes;
722:
723: while(l_element_courant != NULL)
724: {
725: if (&((*((struct_mutex *) (*(*l_element_courant).donnee).objet))
726: .mutex) == &((*((struct_mutex *) (*s_objet_argument).objet))
727: .mutex))
728: {
729: break;
730: }
731:
732: l_element_courant = (*l_element_courant).suivant;
733: }
734:
735: if (l_element_courant == NULL)
736: {
737: (*s_etat_processus).erreur_execution = d_ex_mutex;
738:
739: liberation(s_etat_processus, s_objet_argument);
740: return;
741: }
742:
743: if ((*s_etat_processus).profilage == d_vrai)
744: {
745: if ((tampon = formateur(s_etat_processus, 0, s_objet_argument))
746: == NULL)
747: {
748: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
749: return;
750: }
751:
752: profilage(s_etat_processus, tampon);
753: free(tampon);
754:
755: if ((*s_etat_processus).erreur_systeme != d_es)
756: {
757: return;
758: }
759: }
760:
761: if ((ios = pthread_mutex_trylock(&((*((struct_mutex *)
762: (*s_objet_argument).objet)).mutex))) != 0)
763: {
764: if (ios != EBUSY)
765: {
766: liberation(s_etat_processus, s_objet_argument);
767:
768: if ((*s_etat_processus).profilage == d_vrai)
769: {
770: profilage(s_etat_processus, NULL);
771: }
772:
773: (*s_etat_processus).erreur_systeme = d_es_processus;
774: return;
775: }
776: }
777:
778: if (pthread_mutex_unlock(&((*((struct_mutex *)
779: (*s_objet_argument).objet)).mutex)) != 0)
780: {
781: liberation(s_etat_processus, s_objet_argument);
782:
783: if ((*s_etat_processus).profilage == d_vrai)
784: {
785: profilage(s_etat_processus, NULL);
786: }
787:
788: (*s_etat_processus).erreur_systeme = d_es_processus;
789: return;
790: }
791:
792: if ((*s_etat_processus).profilage == d_vrai)
793: {
794: profilage(s_etat_processus, NULL);
795: }
796: }
797: else
798: {
799: liberation(s_etat_processus, s_objet_argument);
800:
801: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
802: return;
803: }
804:
805: liberation(s_etat_processus, s_objet_argument);
806:
807: if ((s_objet_resultat = allocation(s_etat_processus, INT))
808: == NULL)
809: {
810: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
811: return;
812: }
813:
814: (*((integer8 *) (*s_objet_resultat).objet)) = (ios == 0) ? 0 : -1;
815:
816: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
817: s_objet_resultat) == d_erreur)
818: {
819: return;
820: }
821:
822: return;
823: }
824:
825:
826: /*
827: ================================================================================
828: Fonction 'mtxunlock'
829: ================================================================================
830: Entrées :
831: --------------------------------------------------------------------------------
832: Sorties :
833: --------------------------------------------------------------------------------
834: Effets de bord : néant
835: ================================================================================
836: */
837:
838: void
839: instruction_mtxunlock(struct_processus *s_etat_processus)
840: {
841: struct_liste_chainee *l_element_courant;
842:
843: struct_objet *s_objet_argument;
844:
845: (*s_etat_processus).erreur_execution = d_ex;
846:
847: if ((*s_etat_processus).affichage_arguments == 'Y')
848: {
849: printf("\n MTXUNLOCK ");
850:
851: if ((*s_etat_processus).langue == 'F')
852: {
853: printf("(déverrouille un mutex)\n\n");
854: }
855: else
856: {
857: printf("(unlock mutex)\n\n");
858: }
859:
860: printf(" 1: %s\n", d_MTX);
861:
862: return;
863: }
864: else if ((*s_etat_processus).test_instruction == 'Y')
865: {
866: (*s_etat_processus).nombre_arguments = -1;
867: return;
868: }
869:
870: if (test_cfsf(s_etat_processus, 31) == d_vrai)
871: {
872: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
873: {
874: return;
875: }
876: }
877:
878: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
879: &s_objet_argument) == d_erreur)
880: {
881: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
882: return;
883: }
884:
885: if ((*s_objet_argument).type == MTX)
886: {
887: l_element_courant = (*s_etat_processus).liste_mutexes;
888:
889: while(l_element_courant != NULL)
890: {
891: if (&((*((struct_mutex *) (*(*l_element_courant).donnee).objet))
892: .mutex) == &((*((struct_mutex *) (*s_objet_argument).objet))
893: .mutex))
894: {
895: break;
896: }
897:
898: l_element_courant = (*l_element_courant).suivant;
899: }
900:
901: if (l_element_courant == NULL)
902: {
903: (*s_etat_processus).erreur_execution = d_ex_mutex;
904:
905: liberation(s_etat_processus, s_objet_argument);
906: return;
907: }
908:
909: if (pthread_mutex_trylock(&((*((struct_mutex *)
910: (*s_objet_argument).objet)).mutex)) == EINVAL)
911: {
912: liberation(s_etat_processus, s_objet_argument);
913:
914: (*s_etat_processus).erreur_systeme = d_es_processus;
915: return;
916: }
917:
918: if (pthread_mutex_unlock(&((*((struct_mutex *)
919: (*s_objet_argument).objet)).mutex)) != 0)
920: {
921: liberation(s_etat_processus, s_objet_argument);
922:
923: (*s_etat_processus).erreur_systeme = d_es_processus;
924: return;
925: }
926: }
927: else
928: {
929: liberation(s_etat_processus, s_objet_argument);
930:
931: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
932: return;
933: }
934:
935: liberation(s_etat_processus, s_objet_argument);
936:
937: return;
938: }
939:
940:
941: /*
942: ================================================================================
943: Fonction 'mark'
944: ================================================================================
945: Entrées :
946: --------------------------------------------------------------------------------
947: Sorties :
948: --------------------------------------------------------------------------------
949: Effets de bord : néant
950: ================================================================================
951: */
952:
953: void
954: instruction_mark(struct_processus *s_etat_processus)
955: {
956: struct_marque *marque;
957:
958: struct_objet *s_objet_argument;
959: struct_objet *s_objet_label;
960:
961: (*s_etat_processus).erreur_execution = d_ex;
962:
963: if ((*s_etat_processus).affichage_arguments == 'Y')
964: {
965: printf("\n MARK ");
966:
967: if ((*s_etat_processus).langue == 'F')
968: {
969: printf("(ajoute une marque à un graphique)\n\n");
970: }
971: else
972: {
973: printf("(add mark to graph)\n\n");
974: }
975:
976: printf(" 2: %s\n", d_CHN);
977: printf(" 1: %s\n", d_CPL);
978:
979: return;
980: }
981: else if ((*s_etat_processus).test_instruction == 'Y')
982: {
983: (*s_etat_processus).nombre_arguments = -1;
984: return;
985: }
986:
987: if (test_cfsf(s_etat_processus, 31) == d_vrai)
988: {
989: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
990: {
991: return;
992: }
993: }
994:
995: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
996: &s_objet_argument) == d_erreur)
997: {
998: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
999: return;
1000: }
1001:
1002: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1003: &s_objet_label) == d_erreur)
1004: {
1005: liberation(s_etat_processus, s_objet_argument);
1006:
1007: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1008: return;
1009: }
1010:
1011: if (((*s_objet_argument).type == CPL) && ((*s_objet_label).type == CHN))
1012: {
1013: if ((marque = malloc(sizeof(struct_marque))) == NULL)
1014: {
1015: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1016: return;
1017: }
1018:
1019: if (((*marque).label = malloc((strlen((unsigned char *)
1020: (*s_objet_label).objet) + 1) * sizeof(unsigned char))) == NULL)
1021: {
1022: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1023: return;
1024: }
1025:
1026: sprintf((*marque).label, "%s",
1027: (unsigned char *) (*s_objet_label).objet);
1028:
1029: if (((*marque).position = malloc(64 * sizeof(unsigned char))) == NULL)
1030: {
1031: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1032: return;
1033: }
1034:
1035: sprintf((*marque).position, "%f,%f",
1036: (*((complex16 *) (*s_objet_argument).objet)).partie_reelle,
1037: (*((complex16 *) (*s_objet_argument).objet)).partie_imaginaire);
1038:
1039: (*marque).suivant = (*s_etat_processus).s_marques;
1040: (*s_etat_processus).s_marques = marque;
1041:
1042: (*s_etat_processus).mise_a_jour_trace_requise = d_vrai;
1043: }
1044: else
1045: {
1046: liberation(s_etat_processus, s_objet_argument);
1047: liberation(s_etat_processus, s_objet_label);
1048:
1049: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1050: return;
1051: }
1052:
1053: liberation(s_etat_processus, s_objet_argument);
1054: liberation(s_etat_processus, s_objet_label);
1055:
1056: return;
1057: }
1058:
1059: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_m4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src