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