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