File:  [local] / rpl / src / instructions_s2.c
Revision 1.73: download - view: text, annotated - select for diffs - revision graph
Fri Jan 10 11:15:48 2020 UTC (4 years, 2 months ago) by bertrand
Branches: MAIN
CVS tags: rpl-4_1_32, HEAD
Modification du copyright.

    1: /*
    2: ================================================================================
    3:   RPL/2 (R) version 4.1.32
    4:   Copyright (C) 1989-2020 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 'sin'
   29: ================================================================================
   30:   Entrées : pointeur sur une structure struct_processus
   31: --------------------------------------------------------------------------------
   32:   Sorties :
   33: --------------------------------------------------------------------------------
   34:   Effets de bord : néant
   35: ================================================================================
   36: */
   37: 
   38: void
   39: instruction_sin(struct_processus *s_etat_processus)
   40: {
   41:     real8                           angle;
   42: 
   43:     struct_liste_chainee            *l_element_courant;
   44:     struct_liste_chainee            *l_element_precedent;
   45: 
   46:     struct_objet                    *s_copie_argument;
   47:     struct_objet                    *s_objet_argument;
   48:     struct_objet                    *s_objet_resultat;
   49: 
   50:     (*s_etat_processus).erreur_execution = d_ex;
   51: 
   52:     if ((*s_etat_processus).affichage_arguments == 'Y')
   53:     {
   54:         printf("\n  SIN ");
   55: 
   56:         if ((*s_etat_processus).langue == 'F')
   57:         {
   58:             printf("(sinus)\n\n");
   59:         }
   60:         else
   61:         {
   62:             printf("(sine)\n\n");
   63:         }
   64: 
   65:         printf("    1: %s, %s\n", d_INT, d_REL);
   66:         printf("->  1: %s\n\n", d_REL);
   67: 
   68:         printf("    1: %s\n", d_CPL);
   69:         printf("->  1: %s\n\n", d_CPL);
   70: 
   71:         printf("    1: %s, %s\n", d_NOM, d_ALG);
   72:         printf("->  1: %s\n\n", d_ALG);
   73: 
   74:         printf("    1: %s\n", d_RPN);
   75:         printf("->  1: %s\n", d_RPN);
   76: 
   77:         return;
   78:     }
   79:     else if ((*s_etat_processus).test_instruction == 'Y')
   80:     {
   81:         (*s_etat_processus).nombre_arguments = 1;
   82:         return;
   83:     }
   84: 
   85:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
   86:     {
   87:         if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
   88:         {
   89:             return;
   90:         }
   91:     }
   92: 
   93:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
   94:             &s_objet_argument) == d_erreur)
   95:     {
   96:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
   97:         return;
   98:     }
   99: 
  100: /*
  101: --------------------------------------------------------------------------------
  102:   Sinus d'un entier ou d'un réel
  103: --------------------------------------------------------------------------------
  104: */
  105: 
  106:     if (((*s_objet_argument).type == INT) ||
  107:             ((*s_objet_argument).type == REL))
  108:     {
  109:         if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
  110:         {
  111:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  112:             return;
  113:         }
  114: 
  115:         if ((*s_objet_argument).type == INT)
  116:         {
  117:             angle = (real8) (*((integer8 *) (*s_objet_argument).objet));
  118:         }
  119:         else
  120:         {
  121:             angle = (*((real8 *) (*s_objet_argument).objet));
  122:         }
  123: 
  124:         if (test_cfsf(s_etat_processus, 60) == d_faux)
  125:         {
  126:             conversion_degres_vers_radians(&angle);
  127:         }
  128: 
  129:         (*((real8 *) (*s_objet_resultat).objet)) = sin(angle);
  130:     }
  131: 
  132: /*
  133: --------------------------------------------------------------------------------
  134:   Sinus d'un complexe
  135: --------------------------------------------------------------------------------
  136: */
  137: 
  138:     else if ((*s_objet_argument).type == CPL)
  139:     {
  140:         if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL)
  141:         {
  142:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  143:             return;
  144:         }
  145: 
  146:         f77sin_((struct_complexe16 *) (*s_objet_argument).objet,
  147:                 (struct_complexe16 *) (*s_objet_resultat).objet);
  148:     }
  149: 
  150: /*
  151: --------------------------------------------------------------------------------
  152:   Sinus d'un nom
  153: --------------------------------------------------------------------------------
  154: */
  155: 
  156:     else if ((*s_objet_argument).type == NOM)
  157:     {
  158:         if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
  159:         {
  160:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  161:             return;
  162:         }
  163: 
  164:         if (((*s_objet_resultat).objet =
  165:                 allocation_maillon(s_etat_processus)) == NULL)
  166:         {
  167:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  168:             return;
  169:         }
  170: 
  171:         l_element_courant = (*s_objet_resultat).objet;
  172: 
  173:         if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
  174:                 == NULL)
  175:         {
  176:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  177:             return;
  178:         }
  179: 
  180:         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  181:                 .nombre_arguments = 0;
  182:         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  183:                 .fonction = instruction_vers_niveau_superieur;
  184: 
  185:         if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  186:                 .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
  187:         {
  188:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  189:             return;
  190:         }
  191: 
  192:         strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  193:                 .nom_fonction, "<<");
  194: 
  195:         if (((*l_element_courant).suivant =
  196:                 allocation_maillon(s_etat_processus)) == NULL)
  197:         {
  198:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  199:             return;
  200:         }
  201: 
  202:         l_element_courant = (*l_element_courant).suivant;
  203:         (*l_element_courant).donnee = s_objet_argument;
  204: 
  205:         if (((*l_element_courant).suivant =
  206:                 allocation_maillon(s_etat_processus)) == NULL)
  207:         {
  208:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  209:             return;
  210:         }
  211: 
  212:         l_element_courant = (*l_element_courant).suivant;
  213: 
  214:         if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
  215:                 == NULL)
  216:         {
  217:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  218:             return;
  219:         }
  220: 
  221:         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  222:                 .nombre_arguments = 1;
  223:         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  224:                 .fonction = instruction_sin;
  225: 
  226:         if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  227:                 .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
  228:         {
  229:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  230:             return;
  231:         }
  232: 
  233:         strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  234:                 .nom_fonction, "SIN");
  235: 
  236:         if (((*l_element_courant).suivant =
  237:                 allocation_maillon(s_etat_processus)) == NULL)
  238:         {
  239:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  240:             return;
  241:         }
  242: 
  243:         l_element_courant = (*l_element_courant).suivant;
  244: 
  245:         if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
  246:                 == NULL)
  247:         {
  248:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  249:             return;
  250:         }
  251: 
  252:         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  253:                 .nombre_arguments = 0;
  254:         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  255:                 .fonction = instruction_vers_niveau_inferieur;
  256: 
  257:         if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  258:                 .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
  259:         {
  260:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  261:             return;
  262:         }
  263: 
  264:         strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  265:                 .nom_fonction, ">>");
  266: 
  267:         (*l_element_courant).suivant = NULL;
  268:         s_objet_argument = NULL;
  269:     }
  270: 
  271: /*
  272: --------------------------------------------------------------------------------
  273:   Sinus d'une expression
  274: --------------------------------------------------------------------------------
  275: */
  276: 
  277:     else if (((*s_objet_argument).type == ALG) ||
  278:             ((*s_objet_argument).type == RPN))
  279:     {
  280:         if ((s_copie_argument = copie_objet(s_etat_processus, s_objet_argument,
  281:                 'N')) == NULL)
  282:         {
  283:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  284:             return;
  285:         }
  286: 
  287:         l_element_courant = (struct_liste_chainee *)
  288:                 (*s_copie_argument).objet;
  289:         l_element_precedent = l_element_courant;
  290: 
  291:         while((*l_element_courant).suivant != NULL)
  292:         {
  293:             l_element_precedent = l_element_courant;
  294:             l_element_courant = (*l_element_courant).suivant;
  295:         }
  296: 
  297:         if (((*l_element_precedent).suivant =
  298:                 allocation_maillon(s_etat_processus)) == NULL)
  299:         {
  300:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  301:             return;
  302:         }
  303: 
  304:         if (((*(*l_element_precedent).suivant).donnee =
  305:                 allocation(s_etat_processus, FCT)) == NULL)
  306:         {
  307:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  308:             return;
  309:         }
  310: 
  311:         (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
  312:                 .donnee).objet)).nombre_arguments = 1;
  313:         (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
  314:                 .donnee).objet)).fonction = instruction_sin;
  315: 
  316:         if (((*((struct_fonction *) (*(*(*l_element_precedent)
  317:                 .suivant).donnee).objet)).nom_fonction =
  318:                 malloc(4 * sizeof(unsigned char))) == NULL)
  319:         {
  320:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  321:             return;
  322:         }
  323: 
  324:         strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
  325:                 .suivant).donnee).objet)).nom_fonction, "SIN");
  326: 
  327:         (*(*l_element_precedent).suivant).suivant = l_element_courant;
  328: 
  329:         s_objet_resultat = s_copie_argument;
  330:     }
  331: 
  332: /*
  333: --------------------------------------------------------------------------------
  334:   Réalisation impossible de la fonction sinus
  335: --------------------------------------------------------------------------------
  336: */
  337: 
  338:     else
  339:     {
  340:         liberation(s_etat_processus, s_objet_argument);
  341: 
  342:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  343:         return;
  344:     }
  345: 
  346:     liberation(s_etat_processus, s_objet_argument);
  347: 
  348:     if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  349:             s_objet_resultat) == d_erreur)
  350:     {
  351:         return;
  352:     }
  353: 
  354:     return;
  355: }
  356: 
  357: 
  358: /*
  359: ================================================================================
  360:   Fonction 'sinh'
  361: ================================================================================
  362:   Entrées : pointeur sur une structure struct_processus
  363: --------------------------------------------------------------------------------
  364:   Sorties :
  365: --------------------------------------------------------------------------------
  366:   Effets de bord : néant
  367: ================================================================================
  368: */
  369: 
  370: void
  371: instruction_sinh(struct_processus *s_etat_processus)
  372: {
  373:     real8                           argument;
  374: 
  375:     struct_liste_chainee            *l_element_courant;
  376:     struct_liste_chainee            *l_element_precedent;
  377: 
  378:     struct_objet                    *s_copie_argument;
  379:     struct_objet                    *s_objet_argument;
  380:     struct_objet                    *s_objet_resultat;
  381: 
  382:     (*s_etat_processus).erreur_execution = d_ex;
  383: 
  384:     if ((*s_etat_processus).affichage_arguments == 'Y')
  385:     {
  386:         printf("\n  SINH ");
  387: 
  388:         if ((*s_etat_processus).langue == 'F')
  389:         {
  390:             printf("(sinus hyperbolique)\n\n");
  391:         }
  392:         else
  393:         {
  394:             printf("(hyperbolic sine)\n\n");
  395:         }
  396: 
  397:         printf("    1: %s, %s\n", d_INT, d_REL);
  398:         printf("->  1: %s\n\n", d_INT);
  399: 
  400:         printf("    1: %s\n", d_CPL);
  401:         printf("->  1: %s\n\n", d_CPL);
  402: 
  403:         printf("    1: %s, %s\n", d_NOM, d_ALG);
  404:         printf("->  1: %s\n\n", d_ALG);
  405: 
  406:         printf("    1: %s\n", d_RPN);
  407:         printf("->  1: %s\n", d_RPN);
  408: 
  409:         return;
  410:     }
  411:     else if ((*s_etat_processus).test_instruction == 'Y')
  412:     {
  413:         (*s_etat_processus).nombre_arguments = 1;
  414:         return;
  415:     }
  416: 
  417:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  418:     {
  419:         if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
  420:         {
  421:             return;
  422:         }
  423:     }
  424: 
  425:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  426:             &s_objet_argument) == d_erreur)
  427:     {
  428:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
  429:         return;
  430:     }
  431: 
  432: /*
  433: --------------------------------------------------------------------------------
  434:   Sinus hyperbolique d'un entier ou d'un réel
  435: --------------------------------------------------------------------------------
  436: */
  437: 
  438:     if (((*s_objet_argument).type == INT) ||
  439:             ((*s_objet_argument).type == REL))
  440:     {
  441:         if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
  442:         {
  443:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  444:             return;
  445:         }
  446: 
  447:         if ((*s_objet_argument).type == INT)
  448:         {
  449:             argument = (real8) (*((integer8 *) (*s_objet_argument).objet));
  450:         }
  451:         else
  452:         {
  453:             argument = (*((real8 *) (*s_objet_argument).objet));
  454:         }
  455: 
  456:         (*((real8 *) (*s_objet_resultat).objet)) = sinh(argument);
  457:     }
  458: 
  459: /*
  460: --------------------------------------------------------------------------------
  461:   Sinus hyperbolique d'un complexe
  462: --------------------------------------------------------------------------------
  463: */
  464: 
  465:     else if ((*s_objet_argument).type == CPL)
  466:     {
  467:         if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL)
  468:         {
  469:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  470:             return;
  471:         }
  472: 
  473:         f77sinh_((struct_complexe16 *) (*s_objet_argument).objet,
  474:                 (struct_complexe16 *) (*s_objet_resultat).objet);
  475:     }
  476: 
  477: /*
  478: --------------------------------------------------------------------------------
  479:   Sinus hyperbolique d'un nom
  480: --------------------------------------------------------------------------------
  481: */
  482: 
  483:     else if ((*s_objet_argument).type == NOM)
  484:     {
  485:         if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
  486:         {
  487:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  488:             return;
  489:         }
  490: 
  491:         if (((*s_objet_resultat).objet =
  492:                 allocation_maillon(s_etat_processus)) == NULL)
  493:         {
  494:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  495:             return;
  496:         }
  497: 
  498:         l_element_courant = (*s_objet_resultat).objet;
  499: 
  500:         if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
  501:                 == NULL)
  502:         {
  503:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  504:             return;
  505:         }
  506: 
  507:         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  508:                 .nombre_arguments = 0;
  509:         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  510:                 .fonction = instruction_vers_niveau_inferieur;
  511: 
  512:         if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  513:                 .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
  514:         {
  515:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  516:             return;
  517:         }
  518: 
  519:         strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  520:                 .nom_fonction, "<<");
  521: 
  522:         if (((*l_element_courant).suivant =
  523:                 allocation_maillon(s_etat_processus)) == NULL)
  524:         {
  525:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  526:             return;
  527:         }
  528: 
  529:         l_element_courant = (*l_element_courant).suivant;
  530:         (*l_element_courant).donnee = s_objet_argument;
  531: 
  532:         if (((*l_element_courant).suivant =
  533:                 allocation_maillon(s_etat_processus)) == NULL)
  534:         {
  535:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  536:             return;
  537:         }
  538: 
  539:         l_element_courant = (*l_element_courant).suivant;
  540: 
  541:         if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
  542:                 == NULL)
  543:         {
  544:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  545:             return;
  546:         }
  547: 
  548:         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  549:                 .nombre_arguments = 1;
  550:         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  551:                 .fonction = instruction_sinh;
  552: 
  553:         if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  554:                 .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
  555:         {
  556:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  557:             return;
  558:         }
  559: 
  560:         strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  561:                 .nom_fonction, "SINH");
  562: 
  563:         if (((*l_element_courant).suivant =
  564:                 allocation_maillon(s_etat_processus)) == NULL)
  565:         {
  566:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  567:             return;
  568:         }
  569: 
  570:         l_element_courant = (*l_element_courant).suivant;
  571: 
  572:         if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
  573:                 == NULL)
  574:         {
  575:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  576:             return;
  577:         }
  578: 
  579:         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  580:                 .nombre_arguments = 0;
  581:         (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  582:                 .fonction = instruction_vers_niveau_inferieur;
  583: 
  584:         if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  585:                 .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
  586:         {
  587:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  588:             return;
  589:         }
  590: 
  591:         strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
  592:                 .nom_fonction, ">>");
  593: 
  594:         (*l_element_courant).suivant = NULL;
  595:         s_objet_argument = NULL;
  596:     }
  597: 
  598: /*
  599: --------------------------------------------------------------------------------
  600:   Sinus hyperbolique d'une expression
  601: --------------------------------------------------------------------------------
  602: */
  603: 
  604:     else if (((*s_objet_argument).type == ALG) ||
  605:             ((*s_objet_argument).type == RPN))
  606:     {
  607:         if ((s_copie_argument = copie_objet(s_etat_processus, s_objet_argument,
  608:                 'N')) == NULL)
  609:         {
  610:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  611:             return;
  612:         }
  613: 
  614:         l_element_courant = (struct_liste_chainee *)
  615:                 (*s_copie_argument).objet;
  616:         l_element_precedent = l_element_courant;
  617: 
  618:         while((*l_element_courant).suivant != NULL)
  619:         {
  620:             l_element_precedent = l_element_courant;
  621:             l_element_courant = (*l_element_courant).suivant;
  622:         }
  623: 
  624:         if (((*l_element_precedent).suivant =
  625:                 allocation_maillon(s_etat_processus)) == NULL)
  626:         {
  627:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  628:             return;
  629:         }
  630: 
  631:         if (((*(*l_element_precedent).suivant).donnee =
  632:                 allocation(s_etat_processus, FCT)) == NULL)
  633:         {
  634:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  635:             return;
  636:         }
  637: 
  638:         (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
  639:                 .donnee).objet)).nombre_arguments = 1;
  640:         (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
  641:                 .donnee).objet)).fonction = instruction_sinh;
  642: 
  643:         if (((*((struct_fonction *) (*(*(*l_element_precedent)
  644:                 .suivant).donnee).objet)).nom_fonction =
  645:                 malloc(5 * sizeof(unsigned char))) == NULL)
  646:         {
  647:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  648:             return;
  649:         }
  650: 
  651:         strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
  652:                 .suivant).donnee).objet)).nom_fonction, "SINH");
  653: 
  654:         (*(*l_element_precedent).suivant).suivant = l_element_courant;
  655: 
  656:         s_objet_resultat = s_copie_argument;
  657:     }
  658: 
  659: /*
  660: --------------------------------------------------------------------------------
  661:   Réalisation impossible de la fonction sinus hyperbolique
  662: --------------------------------------------------------------------------------
  663: */
  664: 
  665:     else
  666:     {
  667:         liberation(s_etat_processus, s_objet_argument);
  668: 
  669:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  670:         return;
  671:     }
  672: 
  673:     liberation(s_etat_processus, s_objet_argument);
  674: 
  675:     if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  676:             s_objet_resultat) == d_erreur)
  677:     {
  678:         return;
  679:     }
  680: 
  681:     return;
  682: }
  683: 
  684: 
  685: /*
  686: ================================================================================
  687:   Fonction 'size'
  688: ================================================================================
  689:   Entrées : pointeur sur une structure struct_processus
  690: --------------------------------------------------------------------------------
  691:   Sorties :
  692: --------------------------------------------------------------------------------
  693:   Effets de bord : néant
  694: ================================================================================
  695: */
  696: 
  697: void
  698: instruction_size(struct_processus *s_etat_processus)
  699: {
  700:     struct_liste_chainee            *l_element_courant;
  701: 
  702:     struct_objet                    *s_objet_argument;
  703:     struct_objet                    *s_objet_resultat;
  704: 
  705:     (*s_etat_processus).erreur_execution = d_ex;
  706: 
  707:     if ((*s_etat_processus).affichage_arguments == 'Y')
  708:     {
  709:         printf("\n  SIZE ");
  710: 
  711:         if ((*s_etat_processus).langue == 'F')
  712:         {
  713:             printf("(taille d'un objet)\n\n");
  714:         }
  715:         else
  716:         {
  717:             printf("(object size)\n\n");
  718:         }
  719: 
  720:         printf("    1: %s, %s, %s, %s\n", d_CHN, d_LST, d_ALG, d_TAB);
  721:         printf("->  1: %s\n\n", d_INT);
  722: 
  723:         printf("    1: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
  724:         printf("->  1: %s\n\n", d_LST);
  725: 
  726:         printf("    1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
  727:         printf("->  1: %s\n", d_LST);
  728: 
  729:         return;
  730:     }
  731:     else if ((*s_etat_processus).test_instruction == 'Y')
  732:     {
  733:         (*s_etat_processus).nombre_arguments = -1;
  734:         return;
  735:     }
  736: 
  737:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  738:     {
  739:         if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
  740:         {
  741:             return;
  742:         }
  743:     }
  744: 
  745:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  746:             &s_objet_argument) == d_erreur)
  747:     {
  748:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
  749:         return;
  750:     }
  751: 
  752: /*
  753: --------------------------------------------------------------------------------
  754:   Chaîne de caractères
  755: --------------------------------------------------------------------------------
  756: */
  757: 
  758:     if ((*s_objet_argument).type == CHN)
  759:     {
  760:         if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
  761:         {
  762:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  763:             return;
  764:         }
  765: 
  766:         (*((integer8 *) (*s_objet_resultat).objet)) =
  767:                 longueur_chaine(s_etat_processus,
  768:                 (unsigned char *) (*s_objet_argument).objet);
  769:     }
  770: 
  771: /*
  772: --------------------------------------------------------------------------------
  773:   Liste
  774: --------------------------------------------------------------------------------
  775: */
  776: 
  777:     else if ((*s_objet_argument).type == LST)
  778:     {
  779:         if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
  780:         {
  781:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  782:             return;
  783:         }
  784: 
  785:         (*((integer8 *) (*s_objet_resultat).objet)) = 0;
  786:         l_element_courant = (*s_objet_argument).objet;
  787: 
  788:         while(l_element_courant != NULL)
  789:         {
  790:             (*((integer8 *) (*s_objet_resultat).objet))++;
  791:             l_element_courant = (*l_element_courant).suivant;
  792:         }
  793:     }
  794: 
  795: /*
  796: --------------------------------------------------------------------------------
  797:   Expression algébrique
  798: --------------------------------------------------------------------------------
  799: */
  800:     
  801:     else if ((*s_objet_argument).type == ALG)
  802:     {
  803:         if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
  804:         {
  805:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  806:             return;
  807:         }
  808: 
  809:         (*((integer8 *) (*s_objet_resultat).objet)) = 0;
  810:         l_element_courant = (*s_objet_argument).objet;
  811: 
  812:         while(l_element_courant != NULL)
  813:         {
  814:             (*((integer8 *) (*s_objet_resultat).objet))++;
  815:             l_element_courant = (*l_element_courant).suivant;
  816:         }
  817: 
  818:         (*((integer8 *) (*s_objet_resultat).objet)) -= 2;
  819:     }
  820: 
  821: /*
  822: --------------------------------------------------------------------------------
  823:   Table
  824: --------------------------------------------------------------------------------
  825: */
  826:     
  827:     else if ((*s_objet_argument).type == TBL)
  828:     {
  829:         if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
  830:         {
  831:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  832:             return;
  833:         }
  834: 
  835:         (*((integer8 *) (*s_objet_resultat).objet)) = (*((struct_tableau *)
  836:                 (*s_objet_argument).objet)).nombre_elements;
  837:     }
  838: 
  839: /*
  840: --------------------------------------------------------------------------------
  841:   Vecteur
  842: --------------------------------------------------------------------------------
  843: */
  844: 
  845:     else if (((*s_objet_argument).type == VIN) ||
  846:             ((*s_objet_argument).type == VRL) ||
  847:             ((*s_objet_argument).type == VCX))
  848:     {
  849:         if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
  850:         {
  851:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  852:             return;
  853:         }
  854: 
  855:         if (((*s_objet_resultat).objet =
  856:                 allocation_maillon(s_etat_processus)) == NULL)
  857:         {
  858:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  859:             return;
  860:         }
  861: 
  862:         l_element_courant = (*s_objet_resultat).objet;
  863:         (*l_element_courant).suivant = NULL;
  864: 
  865:         if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
  866:                 == NULL)
  867:         {
  868:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  869:             return;
  870:         }
  871: 
  872:         (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
  873:                 (*((struct_vecteur *) (*s_objet_argument).objet)).taille;
  874:     }
  875: 
  876: /*
  877: --------------------------------------------------------------------------------
  878:   Matrice
  879: --------------------------------------------------------------------------------
  880: */
  881: 
  882:     else if (((*s_objet_argument).type == MIN) ||
  883:             ((*s_objet_argument).type == MRL) ||
  884:             ((*s_objet_argument).type == MCX))
  885:     {
  886:         if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
  887:         {
  888:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  889:             return;
  890:         }
  891: 
  892:         if (((*s_objet_resultat).objet =
  893:                 allocation_maillon(s_etat_processus)) == NULL)
  894:         {
  895:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  896:             return;
  897:         }
  898: 
  899:         l_element_courant = (*s_objet_resultat).objet;
  900: 
  901:         if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
  902:                 == NULL)
  903:         {
  904:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  905:             return;
  906:         }
  907: 
  908:         (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
  909:                 (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes;
  910: 
  911:         if (((*l_element_courant).suivant =
  912:                 allocation_maillon(s_etat_processus)) == NULL)
  913:         {
  914:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  915:             return;
  916:         }
  917: 
  918:         l_element_courant = (*l_element_courant).suivant;
  919:         (*l_element_courant).suivant = NULL;
  920: 
  921:         if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
  922:                 == NULL)
  923:         {
  924:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  925:             return;
  926:         }
  927: 
  928:         (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
  929:                 (*((struct_matrice *) (*s_objet_argument).objet))
  930:                 .nombre_colonnes;
  931:     }
  932: 
  933: /*
  934: --------------------------------------------------------------------------------
  935:   Type d'argument invalide
  936: --------------------------------------------------------------------------------
  937: */
  938: 
  939:     else
  940:     {
  941:         liberation(s_etat_processus, s_objet_argument);
  942: 
  943:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  944:         return;
  945:     }
  946: 
  947:     liberation(s_etat_processus, s_objet_argument);
  948: 
  949:     if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  950:             s_objet_resultat) == d_erreur)
  951:     {
  952:         return;
  953:     }
  954: 
  955:     return;
  956: }
  957: 
  958: 
  959: /*
  960: ================================================================================
  961:   Fonction 'sst'
  962: ================================================================================
  963:   Entrées : pointeur sur une structure struct_processus
  964: --------------------------------------------------------------------------------
  965:   Sorties :
  966: --------------------------------------------------------------------------------
  967:   Effets de bord : néant
  968: ================================================================================
  969: */
  970: 
  971: void
  972: instruction_sst(struct_processus *s_etat_processus)
  973: {
  974:     (*s_etat_processus).erreur_execution = d_ex;
  975: 
  976:     if ((*s_etat_processus).affichage_arguments == 'Y')
  977:     {
  978:         printf("\n  SST ");
  979: 
  980:         if ((*s_etat_processus).langue == 'F')
  981:         {
  982:             printf("(avance d'un pas)\n\n");
  983:             printf("  Aucun argument\n");
  984:         }
  985:         else
  986:         {
  987:             printf("(single step)\n\n");
  988:             printf("  No argument\n");
  989:         }
  990: 
  991:         return;
  992:     }
  993:     else if ((*s_etat_processus).test_instruction == 'Y')
  994:     {
  995:         (*s_etat_processus).nombre_arguments = -1;
  996:         return;
  997:     }
  998: 
  999:     if ((*s_etat_processus).traitement_instruction_halt == d_vrai)
 1000:     {
 1001:         (*s_etat_processus).execution_pas_suivant = d_vrai;
 1002:     }
 1003: 
 1004:     return;
 1005: }
 1006: 
 1007: 
 1008: /*
 1009: ================================================================================
 1010:   Fonction 'str->'
 1011: ================================================================================
 1012:   Entrées : pointeur sur une structure struct_processus
 1013: --------------------------------------------------------------------------------
 1014:   Sorties :
 1015: --------------------------------------------------------------------------------
 1016:   Effets de bord : néant
 1017: ================================================================================
 1018: */
 1019: 
 1020: void
 1021: instruction_str_fleche(struct_processus *s_etat_processus)
 1022: {
 1023:     logical1                        drapeau45;
 1024:     logical1                        presence_chaine;
 1025: 
 1026:     struct_objet                    *s_objet;
 1027:     struct_objet                    *s_sous_objet;
 1028: 
 1029:     unsigned char                   *commande;
 1030:     unsigned char                   *chaine_convertie;
 1031:     unsigned char                   *ptr_e;
 1032:     unsigned char                   *ptr_l;
 1033:     unsigned char                   *registre_definitions_chainees;
 1034:     unsigned char                   *registre_instruction_courante;
 1035:     unsigned char                   registre_interruption;
 1036:     unsigned char                   *tampon;
 1037: 
 1038:     integer8                        nombre_caracteres_supplementaires;
 1039:     integer8                        position_courante;
 1040: 
 1041:     (*s_etat_processus).erreur_execution = d_ex;
 1042: 
 1043:     if ((*s_etat_processus).affichage_arguments == 'Y')
 1044:     {
 1045:         printf("\n  STR-> ");
 1046: 
 1047:         if ((*s_etat_processus).langue == 'F')
 1048:         {
 1049:             printf("(conversion d'une chaîne)\n\n");
 1050:         }
 1051:         else
 1052:         {
 1053:             printf("(conversion from a string of chars)\n\n");
 1054:         }
 1055: 
 1056:         printf("    1: %s\n", d_INT);
 1057:         printf("->  n: %s, %s, %s, %s, %s, %s,\n"
 1058:                 "       %s, %s, %s, %s, %s,\n"
 1059:                 "       %s, %s, %s, %s, %s,\n"
 1060:                 "       %s\n",
 1061:                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
 1062:                 d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
 1063:         printf("    ...\n");
 1064:         printf("->  1: %s, %s, %s, %s, %s, %s,\n"
 1065:                 "       %s, %s, %s, %s, %s,\n"
 1066:                 "       %s, %s, %s, %s, %s,\n"
 1067:                 "       %s\n",
 1068:                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
 1069:                 d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
 1070: 
 1071:         return;
 1072:     }
 1073:     else if ((*s_etat_processus).test_instruction == 'Y')
 1074:     {
 1075:         (*s_etat_processus).nombre_arguments = -1;
 1076:         return;
 1077:     }
 1078: 
 1079:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
 1080:     {
 1081:         if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
 1082:         {
 1083:             return;
 1084:         }
 1085:     }
 1086: 
 1087:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 1088:             &s_objet) == d_erreur)
 1089:     {
 1090:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
 1091:         return;
 1092:     }
 1093: 
 1094:     if ((*s_objet).type == CHN)
 1095:     {
 1096:         // Comptage des caractères à protéger.
 1097: 
 1098:         drapeau45 = test_cfsf(s_etat_processus, 45);
 1099:         cf(s_etat_processus, 45);
 1100: 
 1101:         tampon = formateur(s_etat_processus, 0, s_objet);
 1102: 
 1103:         if (drapeau45 == d_vrai)
 1104:         {
 1105:             sf(s_etat_processus, 45);
 1106:         }
 1107:         else
 1108:         {
 1109:             cf(s_etat_processus, 45);
 1110:         }
 1111: 
 1112:         ptr_l = tampon;
 1113:         presence_chaine = d_faux;
 1114:         nombre_caracteres_supplementaires = 0;
 1115: 
 1116:         while((*ptr_l) != d_code_fin_chaine)
 1117:         {
 1118:             if ((*ptr_l) == '"')
 1119:             {
 1120:                 presence_chaine = (presence_chaine == d_faux) ? d_vrai : d_faux;
 1121:             }
 1122: 
 1123:             if (presence_chaine == d_vrai)
 1124:             {
 1125:                 switch(*ptr_l)
 1126:                 {
 1127:                     case '\\':
 1128:                     case '\t':
 1129:                     case '\b':
 1130:                     case '\n':
 1131:                     {
 1132:                         nombre_caracteres_supplementaires++;
 1133:                         break;
 1134:                     }
 1135:                 }
 1136:             }
 1137:             else
 1138:             {
 1139:                 switch(*ptr_l)
 1140:                 {
 1141:                     case '\n':
 1142:                     case '\b':
 1143:                     case '\t':
 1144:                     {
 1145:                         nombre_caracteres_supplementaires--;
 1146:                         break;
 1147:                     }
 1148:                 }
 1149:             }
 1150: 
 1151:             ptr_l++;
 1152:         }
 1153: 
 1154:         // Échappement des caractères et remplacement dans les chaînes
 1155:         // de caractères incluses. Le seul caractère protégé est le '\'
 1156:         // qui est doublé.
 1157: 
 1158:         if ((chaine_convertie = malloc((strlen(tampon) + ((size_t)
 1159:                 nombre_caracteres_supplementaires) + 1) *
 1160:                 sizeof(unsigned char))) == NULL)
 1161:         {
 1162:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 1163:             return;
 1164:         }
 1165: 
 1166:         ptr_l = tampon;
 1167:         ptr_e = chaine_convertie;
 1168:         presence_chaine = d_faux;
 1169: 
 1170:         while((*ptr_l) != d_code_fin_chaine)
 1171:         {
 1172:             if ((*ptr_l) == '"')
 1173:             {
 1174:                 presence_chaine = (presence_chaine == d_faux) ? d_vrai : d_faux;
 1175:             }
 1176: 
 1177:             (*ptr_e) = (*ptr_l);
 1178: 
 1179:             if (presence_chaine == d_vrai)
 1180:             {
 1181:                 switch(*ptr_l)
 1182:                 {
 1183:                     case '\\':
 1184:                     {
 1185:                         (*(++ptr_e)) = '\\';
 1186:                         break;
 1187:                     }
 1188: 
 1189:                     case '\t':
 1190:                     {
 1191:                         (*ptr_e) = '\\';
 1192:                         (*(++ptr_e)) = 't';
 1193:                         break;
 1194:                     }
 1195: 
 1196:                     case '\b':
 1197:                     {
 1198:                         (*ptr_e) = '\\';
 1199:                         (*(++ptr_e)) = 'b';
 1200:                         break;
 1201:                     }
 1202: 
 1203:                     case '\n':
 1204:                     {
 1205:                         (*ptr_e) = '\\';
 1206:                         (*(++ptr_e)) = 'n';
 1207:                         break;
 1208:                     }
 1209:                 }
 1210:             }
 1211:             else
 1212:             {
 1213:                 switch(*ptr_l)
 1214:                 {
 1215:                     case '\n':
 1216:                     case '\b':
 1217:                     case '\t':
 1218:                     {
 1219:                         ptr_e--;
 1220:                         break;
 1221:                     }
 1222:                 }
 1223:             }
 1224: 
 1225:             ptr_l++;
 1226:             ptr_e++;
 1227:         }
 1228: 
 1229:         (*ptr_e) = d_code_fin_chaine;
 1230: 
 1231:         position_courante = (*s_etat_processus).position_courante;
 1232:         registre_definitions_chainees = (*s_etat_processus)
 1233:                 .definitions_chainees;
 1234:         registre_instruction_courante = (*s_etat_processus)
 1235:                 .instruction_courante;
 1236:         (*s_etat_processus).position_courante = 0;
 1237:         (*s_etat_processus).definitions_chainees = chaine_convertie;
 1238:         free(tampon);
 1239: 
 1240:         if ((*s_etat_processus).definitions_chainees == NULL)
 1241:         {
 1242:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 1243:             return;
 1244:         }
 1245: 
 1246:         if (analyse_syntaxique(s_etat_processus) == d_absence_erreur)
 1247:         {
 1248:             if ((commande = malloc((strlen((unsigned char *)
 1249:                     (*s_objet).objet) + 7) * sizeof(unsigned char))) == NULL)
 1250:             {
 1251:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 1252:                 return;
 1253:             }
 1254: 
 1255:             sprintf(commande, "<< %s >>", (*s_etat_processus)
 1256:                     .definitions_chainees);
 1257:             (*s_etat_processus).instruction_courante = commande;
 1258: 
 1259:             (*s_etat_processus).type_en_cours = NON;
 1260:             recherche_type(s_etat_processus);
 1261: 
 1262:             if (((*s_etat_processus).erreur_execution != d_ex) ||
 1263:                     ((*s_etat_processus).erreur_systeme != d_es))
 1264:             {
 1265:                 liberation(s_etat_processus, s_objet);
 1266: 
 1267:                 free((*s_etat_processus).definitions_chainees);
 1268:                 free((*s_etat_processus).instruction_courante);
 1269: 
 1270:                 (*s_etat_processus).definitions_chainees =
 1271:                         registre_definitions_chainees;
 1272:                 (*s_etat_processus).instruction_courante =
 1273:                         registre_instruction_courante;
 1274:                 (*s_etat_processus).position_courante =
 1275:                         position_courante;
 1276: 
 1277:                 return;
 1278:             }
 1279: 
 1280:             if (depilement(s_etat_processus, &((*s_etat_processus)
 1281:                     .l_base_pile), &s_sous_objet) == d_erreur)
 1282:             {
 1283:                 liberation(s_etat_processus, s_objet);
 1284:                 free((*s_etat_processus).definitions_chainees);
 1285:                 free((*s_etat_processus).instruction_courante);
 1286: 
 1287:                 (*s_etat_processus).definitions_chainees =
 1288:                         registre_definitions_chainees;
 1289:                 (*s_etat_processus).instruction_courante =
 1290:                         registre_instruction_courante;
 1291:                 (*s_etat_processus).position_courante =
 1292:                         position_courante;
 1293: 
 1294:                 (*s_etat_processus).erreur_execution = d_ex_manque_argument;
 1295:                 return;
 1296:             }
 1297: 
 1298:             registre_interruption = (*s_etat_processus)
 1299:                     .traitement_interruptible;
 1300:             (*s_etat_processus).traitement_interruptible = 'N';
 1301: 
 1302:             if (evaluation(s_etat_processus, s_sous_objet, 'I') == d_erreur)
 1303:             {
 1304:                 liberation(s_etat_processus, s_sous_objet);
 1305:                 liberation(s_etat_processus, s_objet);
 1306: 
 1307:                 free((*s_etat_processus).definitions_chainees);
 1308:                 free((*s_etat_processus).instruction_courante);
 1309: 
 1310:                 (*s_etat_processus).definitions_chainees =
 1311:                         registre_definitions_chainees;
 1312:                 (*s_etat_processus).instruction_courante =
 1313:                         registre_instruction_courante;
 1314:                 (*s_etat_processus).position_courante =
 1315:                         position_courante;
 1316: 
 1317:                 (*s_etat_processus).traitement_interruptible =
 1318:                         registre_interruption;
 1319: 
 1320:                 if ((*s_etat_processus).erreur_systeme == d_es)
 1321:                 {
 1322:                     (*s_etat_processus).erreur_execution =
 1323:                             d_ex_expression_invalide;
 1324:                 }
 1325:                 else
 1326:                 {
 1327:                     (*s_etat_processus).erreur_systeme =
 1328:                             d_es_allocation_memoire;
 1329:                 }
 1330: 
 1331:                 return;
 1332:             }
 1333:         }
 1334:         else
 1335:         {
 1336:             liberation(s_etat_processus, s_objet);
 1337: 
 1338:             free((*s_etat_processus).definitions_chainees);
 1339:             free((*s_etat_processus).instruction_courante);
 1340: 
 1341:             (*s_etat_processus).definitions_chainees =
 1342:                     registre_definitions_chainees;
 1343:             (*s_etat_processus).instruction_courante =
 1344:                     registre_instruction_courante;
 1345:             (*s_etat_processus).position_courante =
 1346:                     position_courante;
 1347: 
 1348:             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
 1349: 
 1350:             return;
 1351:         }
 1352: 
 1353: 
 1354:         (*s_etat_processus).traitement_interruptible =
 1355:                 registre_interruption;
 1356: 
 1357:         liberation(s_etat_processus, s_sous_objet);
 1358: 
 1359:         free((*s_etat_processus).definitions_chainees);
 1360:         free((*s_etat_processus).instruction_courante);
 1361: 
 1362:         (*s_etat_processus).definitions_chainees =
 1363:                 registre_definitions_chainees;
 1364:         (*s_etat_processus).instruction_courante =
 1365:                 registre_instruction_courante;
 1366:         (*s_etat_processus).position_courante =
 1367:                 position_courante;
 1368:     }
 1369:     else
 1370:     {
 1371:         liberation(s_etat_processus, s_objet);
 1372: 
 1373:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
 1374:         return;
 1375:     }
 1376: 
 1377:     liberation(s_etat_processus, s_objet);
 1378: 
 1379:     return;
 1380: }
 1381: 
 1382: // vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>