1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.23
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: 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: # ifndef SEMAPHORES_NOMMES
400: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
401: {
402: (*s_etat_processus).erreur_systeme = d_es_processus;
403: return;
404: }
405: # else
406: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
407: {
408: (*s_etat_processus).erreur_systeme = d_es_processus;
409: return;
410: }
411: # endif
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)) == -1)
418: # else
419: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
420: # endif
421: {
422: if ((*s_etat_processus).profilage == d_vrai)
423: {
424: profilage(s_etat_processus, NULL);
425: }
426:
427: if (errno != EINTR)
428: {
429: (*s_etat_processus).erreur_systeme = d_es_processus;
430: return;
431: }
432: }
433:
434: liberation(s_etat_processus, s_objet_argument);
435:
436: if ((*s_etat_processus).profilage == d_vrai)
437: {
438: profilage(s_etat_processus, NULL);
439: }
440:
441: (*s_etat_processus).erreur_systeme = d_es_processus;
442: return;
443: }
444:
445: # ifndef SEMAPHORES_NOMMES
446: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
447: # else
448: while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
449: # endif
450: {
451: if (errno != EINTR)
452: {
453: (*s_etat_processus).erreur_systeme = d_es_processus;
454: return;
455: }
456: }
457:
458: if ((*s_etat_processus).profilage == d_vrai)
459: {
460: profilage(s_etat_processus, NULL);
461: }
462: }
463: else
464: {
465: liberation(s_etat_processus, s_objet_argument);
466:
467: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
468: return;
469: }
470:
471: liberation(s_etat_processus, s_objet_argument);
472:
473: return;
474: }
475:
476:
477: /*
478: ================================================================================
479: Fonction 'mtxtrylock'
480: ================================================================================
481: Entrées :
482: --------------------------------------------------------------------------------
483: Sorties :
484: --------------------------------------------------------------------------------
485: Effets de bord : néant
486: ================================================================================
487: */
488:
489: void
490: instruction_mtxtrylock(struct_processus *s_etat_processus)
491: {
492: int ios;
493:
494: struct_liste_chainee *l_element_courant;
495:
496: struct_objet *s_objet_argument;
497: struct_objet *s_objet_resultat;
498:
499: unsigned char *tampon;
500:
501: (*s_etat_processus).erreur_execution = d_ex;
502:
503: if ((*s_etat_processus).affichage_arguments == 'Y')
504: {
505: printf("\n MTXTRYLOCK ");
506:
507: if ((*s_etat_processus).langue == 'F')
508: {
509: printf("(essai de verrouillage du mutex)\n\n");
510: }
511: else
512: {
513: printf("(try to lock mutex)\n\n");
514: }
515:
516: printf(" 1: %s\n", d_MTX);
517: printf("-> 1: %s\n", d_INT);
518:
519: return;
520: }
521: else if ((*s_etat_processus).test_instruction == 'Y')
522: {
523: (*s_etat_processus).nombre_arguments = -1;
524: return;
525: }
526:
527: if (test_cfsf(s_etat_processus, 31) == d_vrai)
528: {
529: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
530: {
531: return;
532: }
533: }
534:
535: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
536: &s_objet_argument) == d_erreur)
537: {
538: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
539: return;
540: }
541:
542: if ((*s_objet_argument).type == MTX)
543: {
544: l_element_courant = (*s_etat_processus).liste_mutexes;
545:
546: while(l_element_courant != NULL)
547: {
548: if (&((*((struct_mutex *) (*(*l_element_courant).donnee).objet))
549: .mutex) == &((*((struct_mutex *) (*s_objet_argument).objet))
550: .mutex))
551: {
552: break;
553: }
554:
555: l_element_courant = (*l_element_courant).suivant;
556: }
557:
558: if (l_element_courant == NULL)
559: {
560: (*s_etat_processus).erreur_execution = d_ex_mutex;
561:
562: liberation(s_etat_processus, s_objet_argument);
563: return;
564: }
565:
566: if ((*s_etat_processus).profilage == d_vrai)
567: {
568: if ((tampon = formateur(s_etat_processus, 0, s_objet_argument))
569: == NULL)
570: {
571: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
572: return;
573: }
574:
575: profilage(s_etat_processus, tampon);
576: free(tampon);
577:
578: if ((*s_etat_processus).erreur_systeme != d_es)
579: {
580: return;
581: }
582: }
583:
584: if ((ios = pthread_mutex_trylock(&((*((struct_mutex *)
585: (*s_objet_argument).objet)).mutex))) != 0)
586: {
587: if (ios != EBUSY)
588: {
589: liberation(s_etat_processus, s_objet_argument);
590:
591: if ((*s_etat_processus).profilage == d_vrai)
592: {
593: profilage(s_etat_processus, NULL);
594: }
595:
596: (*s_etat_processus).erreur_systeme = d_es_processus;
597: return;
598: }
599: }
600:
601: if ((*s_etat_processus).profilage == d_vrai)
602: {
603: profilage(s_etat_processus, NULL);
604: }
605: }
606: else
607: {
608: liberation(s_etat_processus, s_objet_argument);
609:
610: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
611: return;
612: }
613:
614: liberation(s_etat_processus, s_objet_argument);
615:
616: if ((s_objet_resultat = allocation(s_etat_processus, INT))
617: == NULL)
618: {
619: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
620: return;
621: }
622:
623: (*((integer8 *) (*s_objet_resultat).objet)) = (ios == 0) ? 0 : -1;
624:
625: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
626: s_objet_resultat) == d_erreur)
627: {
628: return;
629: }
630:
631: return;
632: }
633:
634: /*
635: ================================================================================
636: Fonction 'mtxstatus'
637: ================================================================================
638: Entrées :
639: --------------------------------------------------------------------------------
640: Sorties :
641: --------------------------------------------------------------------------------
642: Effets de bord : néant
643: ================================================================================
644: */
645:
646: void
647: instruction_mtxstatus(struct_processus *s_etat_processus)
648: {
649: int ios;
650:
651: struct_liste_chainee *l_element_courant;
652:
653: struct_objet *s_objet_argument;
654: struct_objet *s_objet_resultat;
655:
656: unsigned char *tampon;
657:
658: (*s_etat_processus).erreur_execution = d_ex;
659:
660: if ((*s_etat_processus).affichage_arguments == 'Y')
661: {
662: printf("\n MTXSTATUS ");
663:
664: if ((*s_etat_processus).langue == 'F')
665: {
666: printf("(statut du mutex)\n\n");
667: }
668: else
669: {
670: printf("(mutex status)\n\n");
671: }
672:
673: printf(" 1: %s\n", d_MTX);
674: printf("-> 1: %s\n", d_INT);
675:
676: return;
677: }
678: else if ((*s_etat_processus).test_instruction == 'Y')
679: {
680: (*s_etat_processus).nombre_arguments = -1;
681: return;
682: }
683:
684: if (test_cfsf(s_etat_processus, 31) == d_vrai)
685: {
686: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
687: {
688: return;
689: }
690: }
691:
692: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
693: &s_objet_argument) == d_erreur)
694: {
695: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
696: return;
697: }
698:
699: if ((*s_objet_argument).type == MTX)
700: {
701: l_element_courant = (*s_etat_processus).liste_mutexes;
702:
703: while(l_element_courant != NULL)
704: {
705: if (&((*((struct_mutex *) (*(*l_element_courant).donnee).objet))
706: .mutex) == &((*((struct_mutex *) (*s_objet_argument).objet))
707: .mutex))
708: {
709: break;
710: }
711:
712: l_element_courant = (*l_element_courant).suivant;
713: }
714:
715: if (l_element_courant == NULL)
716: {
717: (*s_etat_processus).erreur_execution = d_ex_mutex;
718:
719: liberation(s_etat_processus, s_objet_argument);
720: return;
721: }
722:
723: if ((*s_etat_processus).profilage == d_vrai)
724: {
725: if ((tampon = formateur(s_etat_processus, 0, s_objet_argument))
726: == NULL)
727: {
728: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
729: return;
730: }
731:
732: profilage(s_etat_processus, tampon);
733: free(tampon);
734:
735: if ((*s_etat_processus).erreur_systeme != d_es)
736: {
737: return;
738: }
739: }
740:
741: if ((ios = pthread_mutex_trylock(&((*((struct_mutex *)
742: (*s_objet_argument).objet)).mutex))) != 0)
743: {
744: if (ios != EBUSY)
745: {
746: liberation(s_etat_processus, s_objet_argument);
747:
748: if ((*s_etat_processus).profilage == d_vrai)
749: {
750: profilage(s_etat_processus, NULL);
751: }
752:
753: (*s_etat_processus).erreur_systeme = d_es_processus;
754: return;
755: }
756: }
757:
758: if (pthread_mutex_unlock(&((*((struct_mutex *)
759: (*s_objet_argument).objet)).mutex)) != 0)
760: {
761: liberation(s_etat_processus, s_objet_argument);
762:
763: if ((*s_etat_processus).profilage == d_vrai)
764: {
765: profilage(s_etat_processus, NULL);
766: }
767:
768: (*s_etat_processus).erreur_systeme = d_es_processus;
769: return;
770: }
771:
772: if ((*s_etat_processus).profilage == d_vrai)
773: {
774: profilage(s_etat_processus, NULL);
775: }
776: }
777: else
778: {
779: liberation(s_etat_processus, s_objet_argument);
780:
781: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
782: return;
783: }
784:
785: liberation(s_etat_processus, s_objet_argument);
786:
787: if ((s_objet_resultat = allocation(s_etat_processus, INT))
788: == NULL)
789: {
790: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
791: return;
792: }
793:
794: (*((integer8 *) (*s_objet_resultat).objet)) = (ios == 0) ? 0 : -1;
795:
796: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
797: s_objet_resultat) == d_erreur)
798: {
799: return;
800: }
801:
802: return;
803: }
804:
805:
806: /*
807: ================================================================================
808: Fonction 'mtxunlock'
809: ================================================================================
810: Entrées :
811: --------------------------------------------------------------------------------
812: Sorties :
813: --------------------------------------------------------------------------------
814: Effets de bord : néant
815: ================================================================================
816: */
817:
818: void
819: instruction_mtxunlock(struct_processus *s_etat_processus)
820: {
821: struct_liste_chainee *l_element_courant;
822:
823: struct_objet *s_objet_argument;
824:
825: (*s_etat_processus).erreur_execution = d_ex;
826:
827: if ((*s_etat_processus).affichage_arguments == 'Y')
828: {
829: printf("\n MTXUNLOCK ");
830:
831: if ((*s_etat_processus).langue == 'F')
832: {
833: printf("(déverrouille un mutex)\n\n");
834: }
835: else
836: {
837: printf("(unlock mutex)\n\n");
838: }
839:
840: printf(" 1: %s\n", d_MTX);
841:
842: return;
843: }
844: else if ((*s_etat_processus).test_instruction == 'Y')
845: {
846: (*s_etat_processus).nombre_arguments = -1;
847: return;
848: }
849:
850: if (test_cfsf(s_etat_processus, 31) == d_vrai)
851: {
852: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
853: {
854: return;
855: }
856: }
857:
858: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
859: &s_objet_argument) == d_erreur)
860: {
861: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
862: return;
863: }
864:
865: if ((*s_objet_argument).type == MTX)
866: {
867: l_element_courant = (*s_etat_processus).liste_mutexes;
868:
869: while(l_element_courant != NULL)
870: {
871: if (&((*((struct_mutex *) (*(*l_element_courant).donnee).objet))
872: .mutex) == &((*((struct_mutex *) (*s_objet_argument).objet))
873: .mutex))
874: {
875: break;
876: }
877:
878: l_element_courant = (*l_element_courant).suivant;
879: }
880:
881: if (l_element_courant == NULL)
882: {
883: (*s_etat_processus).erreur_execution = d_ex_mutex;
884:
885: liberation(s_etat_processus, s_objet_argument);
886: return;
887: }
888:
889: if (pthread_mutex_trylock(&((*((struct_mutex *)
890: (*s_objet_argument).objet)).mutex)) == EINVAL)
891: {
892: liberation(s_etat_processus, s_objet_argument);
893:
894: (*s_etat_processus).erreur_systeme = d_es_processus;
895: return;
896: }
897:
898: if (pthread_mutex_unlock(&((*((struct_mutex *)
899: (*s_objet_argument).objet)).mutex)) != 0)
900: {
901: liberation(s_etat_processus, s_objet_argument);
902:
903: (*s_etat_processus).erreur_systeme = d_es_processus;
904: return;
905: }
906: }
907: else
908: {
909: liberation(s_etat_processus, s_objet_argument);
910:
911: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
912: return;
913: }
914:
915: liberation(s_etat_processus, s_objet_argument);
916:
917: return;
918: }
919:
920:
921: /*
922: ================================================================================
923: Fonction 'mark'
924: ================================================================================
925: Entrées :
926: --------------------------------------------------------------------------------
927: Sorties :
928: --------------------------------------------------------------------------------
929: Effets de bord : néant
930: ================================================================================
931: */
932:
933: void
934: instruction_mark(struct_processus *s_etat_processus)
935: {
936: struct_marque *marque;
937:
938: struct_objet *s_objet_argument;
939: struct_objet *s_objet_label;
940:
941: (*s_etat_processus).erreur_execution = d_ex;
942:
943: if ((*s_etat_processus).affichage_arguments == 'Y')
944: {
945: printf("\n MARK ");
946:
947: if ((*s_etat_processus).langue == 'F')
948: {
949: printf("(ajoute une marque à un graphique)\n\n");
950: }
951: else
952: {
953: printf("(add mark to graph)\n\n");
954: }
955:
956: printf(" 2: %s\n", d_CHN);
957: printf(" 1: %s\n", d_CPL);
958:
959: return;
960: }
961: else if ((*s_etat_processus).test_instruction == 'Y')
962: {
963: (*s_etat_processus).nombre_arguments = -1;
964: return;
965: }
966:
967: if (test_cfsf(s_etat_processus, 31) == d_vrai)
968: {
969: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
970: {
971: return;
972: }
973: }
974:
975: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
976: &s_objet_argument) == d_erreur)
977: {
978: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
979: return;
980: }
981:
982: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
983: &s_objet_label) == d_erreur)
984: {
985: liberation(s_etat_processus, s_objet_argument);
986:
987: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
988: return;
989: }
990:
991: if (((*s_objet_argument).type == CPL) && ((*s_objet_label).type == CHN))
992: {
993: if ((marque = malloc(sizeof(struct_marque))) == NULL)
994: {
995: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
996: return;
997: }
998:
999: if (((*marque).label = malloc((strlen((unsigned char *)
1000: (*s_objet_label).objet) + 1) * sizeof(unsigned char))) == NULL)
1001: {
1002: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1003: return;
1004: }
1005:
1006: sprintf((*marque).label, "%s",
1007: (unsigned char *) (*s_objet_label).objet);
1008:
1009: if (((*marque).position = malloc(64 * sizeof(unsigned char))) == NULL)
1010: {
1011: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1012: return;
1013: }
1014:
1015: sprintf((*marque).position, "%f,%f",
1016: (*((complex16 *) (*s_objet_argument).objet)).partie_reelle,
1017: (*((complex16 *) (*s_objet_argument).objet)).partie_imaginaire);
1018:
1019: (*marque).suivant = (*s_etat_processus).s_marques;
1020: (*s_etat_processus).s_marques = marque;
1021:
1022: (*s_etat_processus).mise_a_jour_trace_requise = d_vrai;
1023: }
1024: else
1025: {
1026: liberation(s_etat_processus, s_objet_argument);
1027: liberation(s_etat_processus, s_objet_label);
1028:
1029: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1030: return;
1031: }
1032:
1033: liberation(s_etat_processus, s_objet_argument);
1034: liberation(s_etat_processus, s_objet_label);
1035:
1036: return;
1037: }
1038:
1039: // 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