Annotation of rpl/src/instructions_d3.c, revision 1.28

1.1       bertrand    1: /*
                      2: ================================================================================
1.28    ! bertrand    3:   RPL/2 (R) version 4.1.2
1.15      bertrand    4:   Copyright (C) 1989-2011 Dr. BERTRAND Joël
1.1       bertrand    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: 
1.11      bertrand   23: #include "rpl-conv.h"
1.1       bertrand   24: 
                     25: 
                     26: /*
                     27: ================================================================================
                     28:   Fonction 'draw'
                     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_draw(struct_processus *s_etat_processus)
                     40: {
                     41:    file                        *entree_standard;
                     42:    file                        *fichier;
                     43: 
                     44:    int                         dimensions;
                     45: 
                     46:    logical1                    last_valide;
                     47:    logical1                    premiere_iteration;
                     48:    logical1                    retour_suite_erreur;
                     49: 
                     50:    long                        hauteur_pile;
                     51: 
                     52:    real8                       borne_maximale_x;
                     53:    real8                       borne_maximale_y;
                     54:    real8                       borne_minimale_x;
                     55:    real8                       borne_minimale_y;
                     56:    real8                       dernier_point_valide[3];
                     57:    real8                       r;
                     58:    real8                       t;
                     59:    real8                       x;
                     60:    real8                       y;
                     61: 
                     62:    struct_fichier_graphique    *l_fichier_courant;
                     63:    struct_fichier_graphique    *l_fichier_precedent;
                     64: 
                     65:    struct_liste_chainee        *l_element_courant;
                     66: 
                     67:    struct_liste_pile_systeme   *l_position_normale;
                     68: 
                     69:    struct_objet                *s_objet;
                     70:    struct_objet                *s_objet_evalue;
                     71: 
                     72:    struct_variable             s_variable_x;
                     73:    struct_variable             s_variable_y;
                     74: 
                     75:    unsigned char               mode_evaluation_expression;
                     76:    unsigned char               *nom_fichier;
                     77:    unsigned char               *nom_fichier_converti;
                     78:    unsigned char               *nom_x;
                     79:    unsigned char               *nom_y;
                     80: 
                     81:    unsigned long               niveau_courant;
                     82: 
                     83:    (*s_etat_processus).erreur_execution = d_ex;
                     84: 
                     85:    if ((*s_etat_processus).affichage_arguments == 'Y')
                     86:    {
                     87:        printf("\n  DRAW ");
                     88: 
                     89:        if ((*s_etat_processus).langue == 'F')
                     90:        {
                     91:            printf("(trace un graphe)\n\n");
                     92:            printf("  Aucun argument\n");
                     93:        }
                     94:        else
                     95:        {
                     96:            printf("(plot a graphic)\n\n");
                     97:            printf("  No argument\n");
                     98:        }
                     99: 
                    100:        return;
                    101:    }
                    102:    else if ((*s_etat_processus).test_instruction == 'Y')
                    103:    {
                    104:        (*s_etat_processus).nombre_arguments = -1;
                    105:        return;
                    106:    }
                    107: 
                    108:    if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
                    109:    {
                    110:        if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
                    111:        {
                    112:            return;
                    113:        }
                    114: 
                    115:        cf(s_etat_processus, 31);
                    116:    }
                    117: 
                    118:    /*
                    119:     * Tracé y=f(x)
                    120:     * Les bornes de variation de X sont données dans l'ordre
                    121:     * - soit sous la forme "{ X X_min X_max } INDEP" ;
                    122:     * - soit par les parties réelles de PMIN et PMAX.
                    123:     * INDEP et DEPND testent leurs arguments pour que les pointeurs
                    124:     * indep et depend désignent des objets de type NOM ou LST à
                    125:     * trois éléments.
                    126:     */
                    127: 
                    128:    if ((strcmp((*s_etat_processus).type_trace_eq, "FONCTION") == 0) ||
                    129:            (strcmp((*s_etat_processus).type_trace_eq, "ECHANTILLONS") == 0))
                    130:    {
                    131:        dimensions = 2;
                    132: 
                    133:        /*
                    134:         * Vérification de la présence de la variable globale EQ
                    135:         */
                    136:        
1.19      bertrand  137:        if (recherche_variable_globale(s_etat_processus, "EQ") == d_faux)
1.1       bertrand  138:        {
                    139:            /*
                    140:             * Aucune variable "EQ" n'existe.
                    141:             */
                    142: 
1.19      bertrand  143:            if ((*s_etat_processus).erreur_execution == d_ex)
1.1       bertrand  144:            {
1.19      bertrand  145:                (*s_etat_processus).erreur_execution = d_ex_absence_equation;
1.1       bertrand  146:            }
                    147: 
1.19      bertrand  148:            (*s_etat_processus).erreur_systeme = d_es;
1.1       bertrand  149: 
                    150:            if (last_valide == d_vrai)
                    151:            {
                    152:                sf(s_etat_processus, 31);
                    153:            }
                    154: 
                    155:            return;
                    156:        }
                    157: 
                    158:        /*
                    159:         * Création du fichier graphique temporaire
                    160:         */
                    161: 
                    162:        if ((nom_fichier = creation_nom_fichier(s_etat_processus,
                    163:                (*s_etat_processus).chemin_fichiers_temporaires)) == NULL)
                    164:        {
                    165:            (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    166:            return;
                    167:        }
                    168: 
                    169:        if ((fichier = fopen(nom_fichier, "w+")) == NULL)
                    170:        {
                    171:            (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    172:            return;
                    173:        }
                    174: 
                    175:        /*
                    176:         * Récupération du domaine de variation de x
                    177:         */
                    178: 
                    179:        if ((*(*s_etat_processus).indep).type == LST)
                    180:        {
                    181:            l_element_courant = (*(*s_etat_processus).indep).objet;
                    182: 
                    183:            if ((s_variable_x.nom = malloc((strlen((*((struct_nom *)
                    184:                    (*(*l_element_courant).donnee).objet)).nom) + 1) *
                    185:                    sizeof(unsigned char))) == NULL)
                    186:            {
                    187:                if (fclose(fichier) != 0)
                    188:                {
                    189:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    190:                    return;
                    191:                }
                    192: 
                    193:                if (destruction_fichier(nom_fichier) == d_erreur)
                    194:                {
                    195:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    196:                    return;
                    197:                }
                    198: 
                    199:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    200:                return;
                    201:            }
                    202: 
                    203:            strcpy(s_variable_x.nom, (*((struct_nom *) (*(*l_element_courant)
                    204:                    .donnee).objet)).nom);
                    205: 
                    206:            if ((nom_x = malloc((strlen(s_variable_x.nom) + 1) *
                    207:                    sizeof(unsigned char))) == NULL)
                    208:            {
                    209:                if (fclose(fichier) != 0)
                    210:                {
                    211:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    212:                    return;
                    213:                }
                    214: 
                    215:                if (destruction_fichier(nom_fichier) == d_erreur)
                    216:                {
                    217:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    218:                    return;
                    219:                }
                    220: 
                    221:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    222:                return;
                    223:            }
                    224: 
                    225:            strcpy(nom_x, s_variable_x.nom);
                    226: 
                    227:            l_element_courant = (*l_element_courant).suivant;
                    228: 
                    229:            if ((*(*l_element_courant).donnee).type == INT)
                    230:            {
                    231:                borne_minimale_x = (real8) (*((integer8 *)
                    232:                        (*(*l_element_courant).donnee).objet));
                    233:            }
                    234:            else if ((*(*l_element_courant).donnee).type == REL)
                    235:            {
                    236:                borne_minimale_x = (*((real8 *) (*(*l_element_courant)
                    237:                        .donnee).objet));
                    238:            }
                    239:            else
                    240:            {
                    241:                if (evaluation(s_etat_processus, (*l_element_courant).donnee,
                    242:                        'N') == d_erreur)
                    243:                {
                    244:                    free(s_variable_x.nom);
                    245:                    free(nom_x);
                    246: 
                    247:                    if (fclose(fichier) != 0)
                    248:                    {
                    249:                        (*s_etat_processus).erreur_systeme =
                    250:                                d_es_erreur_fichier;
                    251:                        return;
                    252:                    }
                    253: 
                    254:                    if (destruction_fichier(nom_fichier) == d_erreur)
                    255:                    {
                    256:                        (*s_etat_processus).erreur_systeme =
                    257:                                d_es_erreur_fichier;
                    258:                        return;
                    259:                    }
                    260: 
                    261:                    if (last_valide == d_vrai)
                    262:                    {
                    263:                        sf(s_etat_processus, 31);
                    264:                    }
                    265: 
                    266:                    free(nom_fichier);
                    267:                    return;
                    268:                }
                    269: 
                    270:                if (depilement(s_etat_processus, &((*s_etat_processus)
                    271:                        .l_base_pile), &s_objet_evalue) == d_erreur)
                    272:                {
                    273:                    free(s_variable_x.nom);
                    274:                    free(nom_x);
                    275: 
                    276:                    if (fclose(fichier) != 0)
                    277:                    {
                    278:                        (*s_etat_processus).erreur_systeme =
                    279:                                d_es_erreur_fichier;
                    280:                        return;
                    281:                    }
                    282: 
                    283:                    if (destruction_fichier(nom_fichier) == d_erreur)
                    284:                    {
                    285:                        (*s_etat_processus).erreur_systeme =
                    286:                                d_es_erreur_fichier;
                    287:                        return;
                    288:                    }
                    289: 
                    290:                    (*s_etat_processus).erreur_execution =
                    291:                            d_ex_manque_argument;
                    292: 
                    293:                    if (last_valide == d_vrai)
                    294:                    {
                    295:                        sf(s_etat_processus, 31);
                    296:                    }
                    297: 
                    298:                    free(nom_fichier);
                    299:                    return;
                    300:                }
                    301: 
                    302:                if ((*s_objet_evalue).type == INT)
                    303:                {
                    304:                    borne_minimale_x = (real8) (*((integer8 *)
                    305:                            (*s_objet_evalue).objet));
                    306:                }
                    307:                else if ((*s_objet_evalue).type == REL)
                    308:                {
                    309:                    borne_minimale_x = (*((real8 *) (*s_objet_evalue).objet));
                    310:                }
                    311:                else
                    312:                {
                    313:                    if (fclose(fichier) != 0)
                    314:                    {
                    315:                        (*s_etat_processus).erreur_systeme =
                    316:                                d_es_erreur_fichier;
                    317:                        return;
                    318:                    }
                    319: 
                    320:                    if (destruction_fichier(nom_fichier) == d_erreur)
                    321:                    {
                    322:                        (*s_etat_processus).erreur_systeme =
                    323:                                d_es_erreur_fichier;
                    324:                        return;
                    325:                    }
                    326: 
                    327:                    free(s_variable_x.nom);
                    328:                    free(nom_x);
                    329:                    free(nom_fichier);
                    330:                    liberation(s_etat_processus, s_objet_evalue);
                    331: 
                    332:                    if (last_valide == d_vrai)
                    333:                    {
                    334:                        sf(s_etat_processus, 31);
                    335:                    }
                    336: 
                    337:                    (*s_etat_processus).erreur_execution =
                    338:                            d_ex_erreur_type_argument;
                    339:                    return;
                    340:                }
                    341: 
                    342:                liberation(s_etat_processus, s_objet_evalue);
                    343:            }
                    344: 
                    345:            l_element_courant = (*l_element_courant).suivant;
                    346: 
                    347:            if ((*(*l_element_courant).donnee).type == INT)
                    348:            {
                    349:                borne_maximale_x = (real8) (*((integer8 *)
                    350:                        (*(*l_element_courant).donnee).objet));
                    351:            }
                    352:            else if ((*(*l_element_courant).donnee).type == REL)
                    353:            {
                    354:                borne_maximale_x = (*((real8 *) (*(*l_element_courant)
                    355:                        .donnee).objet));
                    356:            }
                    357:            else
                    358:            {
                    359:                if (evaluation(s_etat_processus, (*l_element_courant).donnee,
                    360:                        'N') == d_erreur)
                    361:                {
                    362:                    free(s_variable_x.nom);
                    363:                    free(nom_x);
                    364: 
                    365:                    if (fclose(fichier) != 0)
                    366:                    {
                    367:                        (*s_etat_processus).erreur_systeme =
                    368:                                d_es_erreur_fichier;
                    369:                        return;
                    370:                    }
                    371: 
                    372:                    if (destruction_fichier(nom_fichier) == d_erreur)
                    373:                    {
                    374:                        (*s_etat_processus).erreur_systeme =
                    375:                                d_es_erreur_fichier;
                    376:                        return;
                    377:                    }
                    378: 
                    379:                    if (last_valide == d_vrai)
                    380:                    {
                    381:                        sf(s_etat_processus, 31);
                    382:                    }
                    383: 
                    384:                    free(nom_fichier);
                    385:                    return;
                    386:                }
                    387: 
                    388:                if (depilement(s_etat_processus, &((*s_etat_processus)
                    389:                        .l_base_pile), &s_objet_evalue) == d_erreur)
                    390:                {
                    391:                    free(s_variable_x.nom);
                    392:                    free(nom_x);
                    393: 
                    394:                    if (fclose(fichier) != 0)
                    395:                    {
                    396:                        (*s_etat_processus).erreur_systeme =
                    397:                                d_es_erreur_fichier;
                    398:                        return;
                    399:                    }
                    400: 
                    401:                    if (destruction_fichier(nom_fichier) == d_erreur)
                    402:                    {
                    403:                        (*s_etat_processus).erreur_systeme =
                    404:                                d_es_erreur_fichier;
                    405:                        return;
                    406:                    }
                    407: 
                    408:                    (*s_etat_processus).erreur_execution =
                    409:                            d_ex_manque_argument;
                    410: 
                    411:                    if (last_valide == d_vrai)
                    412:                    {
                    413:                        sf(s_etat_processus, 31);
                    414:                    }
                    415: 
                    416:                    free(nom_fichier);
                    417:                    return;
                    418:                }
                    419: 
                    420:                if ((*s_objet_evalue).type == INT)
                    421:                {
                    422:                    borne_maximale_x = (real8) (*((integer8 *)
                    423:                            (*s_objet_evalue).objet));
                    424:                }
                    425:                else if ((*s_objet_evalue).type == REL)
                    426:                {
                    427:                    borne_maximale_x = (*((real8 *) (*s_objet_evalue).objet));
                    428:                }
                    429:                else
                    430:                {
                    431:                    free(s_variable_x.nom);
                    432:                    free(nom_x);
                    433: 
                    434:                    if (fclose(fichier) != 0)
                    435:                    {
                    436:                        (*s_etat_processus).erreur_systeme =
                    437:                                d_es_erreur_fichier;
                    438:                        return;
                    439:                    }
                    440: 
                    441:                    if (destruction_fichier(nom_fichier) == d_erreur)
                    442:                    {
                    443:                        (*s_etat_processus).erreur_systeme =
                    444:                                d_es_erreur_fichier;
                    445:                        return;
                    446:                    }
                    447: 
                    448:                    liberation(s_etat_processus, s_objet_evalue);
                    449: 
                    450:                    (*s_etat_processus).erreur_execution =
                    451:                            d_ex_erreur_type_argument;
                    452: 
                    453:                    if (last_valide == d_vrai)
                    454:                    {
                    455:                        sf(s_etat_processus, 31);
                    456:                    }
                    457: 
                    458:                    free(nom_fichier);
                    459:                    return;
                    460:                }
                    461: 
                    462:                liberation(s_etat_processus, s_objet_evalue);
                    463:            }
                    464:        }
                    465:        else
                    466:        {
                    467:            if ((s_variable_x.nom =
                    468:                    malloc((strlen((*((struct_nom *) (*(*s_etat_processus)
                    469:                    .indep).objet)).nom) + 1) * sizeof(unsigned char))) == NULL)
                    470:            {
                    471:                if (fclose(fichier) != 0)
                    472:                {
                    473:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    474:                    return;
                    475:                }
                    476: 
                    477:                if (destruction_fichier(nom_fichier) == d_erreur)
                    478:                {
                    479:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    480:                    return;
                    481:                }
                    482: 
                    483:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    484:                return;
                    485:            }
                    486: 
                    487:            strcpy(s_variable_x.nom, (*((struct_nom *) (*(*s_etat_processus)
                    488:                    .indep).objet)).nom);
                    489: 
                    490:            if ((nom_x = malloc((strlen(s_variable_x.nom) + 1)
                    491:                    * sizeof(unsigned char))) == NULL)
                    492:            {
                    493:                if (fclose(fichier) != 0)
                    494:                {
                    495:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    496:                    return;
                    497:                }
                    498: 
                    499:                if (destruction_fichier(nom_fichier) == d_erreur)
                    500:                {
                    501:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    502:                    return;
                    503:                }
                    504: 
                    505:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    506:                return;
                    507:            }
                    508: 
                    509:            strcpy(nom_x, s_variable_x.nom);
                    510: 
                    511:            if ((*s_etat_processus).systeme_axes == 0)
                    512:            {
                    513:                borne_minimale_x = (*s_etat_processus).x_min;
                    514:                borne_maximale_x = (*s_etat_processus).x_max;
                    515:            }
                    516:            else
                    517:            {
                    518:                borne_minimale_x = (*s_etat_processus).x2_min;
                    519:                borne_maximale_x = (*s_etat_processus).x2_max;
                    520:            }
                    521:        }
                    522: 
                    523:        /*
                    524:         * Création d'une variable locale du nom pointé par INDEP
                    525:         */
                    526: 
                    527:        (*s_etat_processus).niveau_courant++;
                    528:        s_variable_x.niveau = (*s_etat_processus).niveau_courant;
                    529: 
                    530:        if ((s_variable_x.objet = allocation(s_etat_processus, REL))
                    531:                == NULL)
                    532:        {
                    533:            if (fclose(fichier) != 0)
                    534:            {
                    535:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    536:                return;
                    537:            }
                    538: 
                    539:            if (destruction_fichier(nom_fichier) == d_erreur)
                    540:            {
                    541:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    542:                return;
                    543:            }
                    544: 
                    545:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    546:            return;
                    547:        }
                    548: 
                    549:        if (creation_variable(s_etat_processus, &s_variable_x, 'V', 'P')
                    550:                == d_erreur)
                    551:        {
                    552:            if (fclose(fichier) != 0)
                    553:            {
                    554:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    555:                return;
                    556:            }
                    557: 
                    558:            if (destruction_fichier(nom_fichier) == d_erreur)
                    559:            {
                    560:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    561:                return;
                    562:            }
                    563: 
                    564:            /*
                    565:             * L'erreur retournée ne peut être qu'une erreur système
                    566:             */
                    567: 
                    568:            free(nom_fichier);
                    569:            return;
                    570:        }
                    571: 
                    572:        /*
                    573:         * Boucle de calcul des points de la fonction
                    574:         */
                    575: 
                    576:        if (borne_maximale_x < borne_minimale_x)
                    577:        {
                    578:            x = borne_maximale_x;
                    579:            borne_maximale_x = borne_minimale_x;
                    580:            borne_minimale_x = x;
                    581:        }
                    582: 
                    583:        for(x = borne_minimale_x; x <= borne_maximale_x;
                    584:                x += (*s_etat_processus).resolution)
                    585:        {
                    586:            if (recherche_variable(s_etat_processus, nom_x)
                    587:                    == d_vrai)
                    588:            {
                    589:                // La variable étant créée localement, elle n'est jamais
                    590:                // ni verrouillée ni partagée.
                    591: 
1.19      bertrand  592:                BUG((*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand  593:                        .objet == NULL);
                    594: 
1.19      bertrand  595:                if ((*(*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand  596:                        .objet).type != REL)
                    597:                {
                    598:                    liberation(s_etat_processus,
1.19      bertrand  599:                            (*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand  600:                            .objet);
                    601: 
1.19      bertrand  602:                    if (((*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand  603:                            .objet = allocation(s_etat_processus, REL))
                    604:                            == NULL)
                    605:                    {
                    606:                        (*s_etat_processus).erreur_systeme =
                    607:                                d_es_allocation_memoire;
                    608:                        return;
                    609:                    }
                    610:                }
                    611: 
1.19      bertrand  612:                (*((real8 *) (*(*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand  613:                        .objet).objet)) = x;
                    614:            }
                    615:            else
                    616:            {
                    617:                /*
                    618:                 * La variable créée étant locale, l'utilisateur ne peut
                    619:                 * pas l'effacer. On ne doit donc jamais passer par ici. Si
                    620:                 * c'est néanmoins le cas, une erreur système est générée
                    621:                 * provoquant l'arrêt du programme même dans une
                    622:                 * structure IFERR.
                    623:                 */
                    624: 
                    625:                if (fclose(fichier) != 0)
                    626:                {
                    627:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    628:                    return;
                    629:                }
                    630: 
                    631:                if (destruction_fichier(nom_fichier) == d_erreur)
                    632:                {
                    633:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    634:                    return;
                    635:                }
                    636: 
                    637:                if (last_valide == d_vrai)
                    638:                {
                    639:                    sf(s_etat_processus, 31);
                    640:                }
                    641: 
                    642:                free(nom_fichier);
                    643:                return;
                    644:            }
                    645: 
1.20      bertrand  646:            if (recherche_variable_globale(s_etat_processus, "EQ") == d_faux)
1.1       bertrand  647:            {
                    648:                /*
                    649:                 * Aucune variable "EQ" n'existe.
                    650:                 */
                    651: 
                    652:                (*s_etat_processus).erreur_execution =
                    653:                        d_ex_variable_non_definie;
                    654: 
                    655:                /*
                    656:                 * Retrait de la variable INDEP
                    657:                 */
                    658: 
                    659:                (*s_etat_processus).niveau_courant--;
                    660: 
                    661:                if (fclose(fichier) != 0)
                    662:                {
                    663:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    664:                    return;
                    665:                }
                    666: 
                    667:                if (destruction_fichier(nom_fichier) == d_erreur)
                    668:                {
                    669:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                    670:                    return;
                    671:                }
                    672: 
                    673:                if (retrait_variable(s_etat_processus, nom_x, 'L')
                    674:                        == d_erreur)
                    675:                {
                    676:                    if ((*s_etat_processus).erreur_systeme != d_es)
                    677:                    {
                    678:                        if ((*s_etat_processus).erreur_systeme ==
                    679:                                d_es_variable_introuvable)
                    680:                        {
                    681:                            (*s_etat_processus).erreur_systeme = d_es;
                    682:                        }
                    683:                        else
                    684:                        {
                    685: 
                    686:                        /*
                    687:                         * Erreur système
                    688:                         */
                    689: 
                    690:                            free(nom_fichier);
                    691:                            return;
                    692:                        }
                    693:                    }
                    694: 
                    695:                    free(nom_x);
                    696:                    free(nom_fichier);
                    697: 
                    698:                    if (last_valide == d_vrai)
                    699:                    {
                    700:                        sf(s_etat_processus, 31);
                    701:                    }
                    702: 
                    703:                    (*s_etat_processus).erreur_execution =
                    704:                            d_ex_variable_non_definie;
                    705:                    return;
                    706:                }
                    707: 
                    708:                if (last_valide == d_vrai)
                    709:                {
                    710:                    sf(s_etat_processus, 31);
                    711:                }
                    712: 
                    713:                free(nom_x);
                    714:                free(nom_fichier);
                    715:                return;
                    716:            }
                    717: 
                    718:            /*
                    719:             * Evaluation de la fonction
                    720:             */
                    721: 
                    722:            hauteur_pile = (*s_etat_processus).hauteur_pile_operationnelle;
                    723:            l_position_normale = (*s_etat_processus).l_base_pile_systeme;
                    724:            niveau_courant = (*s_etat_processus).niveau_courant;
                    725:            mode_evaluation_expression = (*s_etat_processus)
                    726:                    .mode_evaluation_expression;
                    727:            (*s_etat_processus).mode_evaluation_expression = 'Y';
                    728: 
                    729:            (*s_etat_processus).erreur_execution = d_ex;
                    730:            (*s_etat_processus).exception = d_ep;
                    731: 
1.19      bertrand  732:            if (evaluation(s_etat_processus, (*(*s_etat_processus)
                    733:                    .pointeur_variable_courante).objet, 'N') == d_erreur)
1.1       bertrand  734:            {
                    735:                (*s_etat_processus).mode_evaluation_expression =
                    736:                        mode_evaluation_expression;
                    737: 
                    738:                if ((*s_etat_processus).erreur_systeme != d_es)
                    739:                {
                    740:                    /*
                    741:                     * Erreur système
                    742:                     */
                    743: 
                    744:                    free(nom_fichier);
                    745:                    return;
                    746:                }
                    747:                else
                    748:                {
                    749:                    retour_suite_erreur = d_faux;
                    750:                    (*s_etat_processus).niveau_courant = niveau_courant;
                    751: 
                    752:                    /*
                    753:                     * Restauration de la pile initiale
                    754:                     */
                    755: 
                    756:                    while((*s_etat_processus).hauteur_pile_operationnelle >
                    757:                            (unsigned long) hauteur_pile)
                    758:                    {
                    759:                        if (depilement(s_etat_processus, &((*s_etat_processus)
                    760:                                .l_base_pile), &s_objet) == d_erreur)
                    761:                        {
                    762:                            (*s_etat_processus).erreur_execution =
                    763:                                    d_ex_manque_argument;
                    764:                            retour_suite_erreur = d_vrai;
                    765:                            break;
                    766:                        }
                    767: 
                    768:                        liberation(s_etat_processus, s_objet);
                    769:                    }
                    770: 
                    771:                    /*
                    772:                     * Restauration de la pile système
                    773:                     */
                    774: 
                    775:                    while((*s_etat_processus).l_base_pile_systeme !=
                    776:                            l_position_normale)
                    777:                    {
                    778:                        depilement_pile_systeme(s_etat_processus);
                    779: 
                    780:                        if ((*s_etat_processus).erreur_systeme != d_es)
                    781:                        {
                    782:                            /*
                    783:                             * Une pile vide provoque une erreur système
                    784:                             */
                    785: 
                    786:                            free(nom_fichier);
                    787:                            return;
                    788:                        }
                    789:                    }
                    790: 
                    791:                    if (retour_suite_erreur == d_vrai)
                    792:                    {
                    793:                        /*
                    794:                         * Retrait de la variable INDEP et retour
                    795:                         */
                    796: 
                    797:                        (*s_etat_processus).niveau_courant--;
                    798: 
                    799:                        if (fclose(fichier) != 0)
                    800:                        {
                    801:                            (*s_etat_processus).erreur_systeme =
                    802:                                    d_es_erreur_fichier;
                    803:                            return;
                    804:                        }
                    805: 
                    806:                        if (destruction_fichier(nom_fichier) == d_erreur)
                    807:                        {
                    808:                            (*s_etat_processus).erreur_systeme =
                    809:                                    d_es_erreur_fichier;
                    810:                            return;
                    811:                        }
                    812: 
                    813:                        if (retrait_variable(s_etat_processus,
                    814:                                nom_x, 'L') == d_erreur)
                    815:                        {
                    816:                            if ((*s_etat_processus).erreur_systeme != d_es)
                    817:                            {
                    818:                                if ((*s_etat_processus).erreur_systeme ==
                    819:                                        d_es_variable_introuvable)
                    820:                                {
                    821:                                    (*s_etat_processus).erreur_systeme =
                    822:                                            d_es;
                    823:                                }
                    824:                                else
                    825:                                {
                    826: 
                    827:                                /*
                    828:                                 * Erreur système
                    829:                                 */
                    830: 
                    831:                                    free(nom_fichier);
                    832:                                    return;
                    833:                                }
                    834:                            }
                    835: 
                    836:                            (*s_etat_processus).erreur_execution =
                    837:                                    d_ex_variable_non_definie;
                    838:                        }
                    839: 
                    840:                        free(nom_x);
                    841:                        free(nom_fichier);
                    842: 
                    843:                        if (last_valide == d_vrai)
                    844:                        {
                    845:                            sf(s_etat_processus, 31);
                    846:                        }
                    847: 
                    848:                        return;
                    849:                    }
                    850:                }
                    851: 
                    852:                (*s_etat_processus).erreur_execution = d_ex;
                    853:                (*s_etat_processus).exception = d_ep;
                    854:            }
                    855:            else
                    856:            {
                    857:                (*s_etat_processus).mode_evaluation_expression =
                    858:                        mode_evaluation_expression;
                    859: 
                    860:                /*
                    861:                 * Donnée valide à écrire dans le fichier
                    862:                 */
                    863: 
                    864:                if (depilement(s_etat_processus, &((*s_etat_processus)
                    865:                        .l_base_pile), &s_objet) == d_erreur)
                    866:                {
                    867: 
                    868:                    /*
                    869:                     * Retrait de la variable INDEP et retour
                    870:                     */
                    871: 
                    872:                    (*s_etat_processus).niveau_courant--;
                    873: 
                    874:                    if (fclose(fichier) != 0)
                    875:                    {
                    876:                        (*s_etat_processus).erreur_systeme =
                    877:                                d_es_erreur_fichier;
                    878:                        return;
                    879:                    }
                    880: 
                    881:                    if (destruction_fichier(nom_fichier) == d_erreur)
                    882:                    {
                    883:                        (*s_etat_processus).erreur_systeme =
                    884:                                d_es_erreur_fichier;
                    885:                        return;
                    886:                    }
                    887: 
                    888:                    if (retrait_variable(s_etat_processus, nom_x,
                    889:                            'L') == d_erreur)
                    890:                    {
                    891:                        if ((*s_etat_processus).erreur_systeme != d_es)
                    892:                        {
                    893:                            if ((*s_etat_processus).erreur_systeme ==
                    894:                                    d_es_variable_introuvable)
                    895:                            {
                    896:                                (*s_etat_processus).erreur_systeme = d_es;
                    897:                            }
                    898:                            else
                    899:                            {
                    900: 
                    901:                            /*
                    902:                             * Erreur système
                    903:                             */
                    904: 
                    905:                                free(nom_fichier);
                    906:                                return;
                    907:                            }
                    908:                        }
                    909: 
                    910:                        free(nom_x);
                    911:                        free(nom_fichier);
                    912: 
                    913:                        if (last_valide == d_vrai)
                    914:                        {
                    915:                            sf(s_etat_processus, 31);
                    916:                        }
                    917: 
                    918:                        (*s_etat_processus).erreur_execution =
                    919:                                d_ex_variable_non_definie;
                    920:                        return;
                    921:                    }
                    922: 
                    923:                    free(nom_x);
                    924:                    free(nom_fichier);
                    925: 
                    926:                    if (last_valide == d_vrai)
                    927:                    {
                    928:                        sf(s_etat_processus, 31);
                    929:                    }
                    930: 
                    931:                    (*s_etat_processus).erreur_execution =
                    932:                            d_ex_manque_argument;
                    933:                    return;
                    934:                }
                    935: 
                    936:                if ((*s_objet).type == INT)
                    937:                {
                    938:                    if (fprintf(fichier, "%f %f\n", x,
                    939:                            (double) (*((integer8 *)
                    940:                            (*s_objet).objet))) < 0)
                    941:                    {
                    942:                        (*s_etat_processus).erreur_systeme =
                    943:                                d_es_erreur_fichier;
                    944:                        return;
                    945:                    }
                    946:                }
                    947:                else if ((*s_objet).type == REL)
                    948:                {
                    949:                    if (fprintf(fichier, "%f %f\n", x, (*((real8 *)
                    950:                            (*s_objet).objet))) < 0)
                    951:                    {
                    952:                        (*s_etat_processus).erreur_systeme =
                    953:                                d_es_erreur_fichier;
                    954:                        return;
                    955:                    }
                    956:                }
                    957: 
                    958:                liberation(s_etat_processus, s_objet);
                    959:            }
                    960:        }
                    961: 
                    962:        /*
                    963:         * Retrait de la variable locale
                    964:         */
                    965: 
                    966:        (*s_etat_processus).niveau_courant--;
                    967: 
                    968:        if (retrait_variable(s_etat_processus, nom_x, 'L') == d_erreur)
                    969:        {
                    970:            if ((*s_etat_processus).erreur_systeme != d_es)
                    971:            {
                    972:                if ((*s_etat_processus).erreur_systeme ==
                    973:                        d_es_variable_introuvable)
                    974:                {
                    975:                    (*s_etat_processus).erreur_systeme = d_es;
                    976:                }
                    977:                else
                    978:                {
                    979:                    /*
                    980:                     * Erreur système
                    981:                     */
                    982: 
                    983:                    free(nom_fichier);
                    984:                    return;
                    985:                }
                    986:            }
                    987: 
                    988:            free(nom_x);
                    989:            free(nom_fichier);
                    990: 
                    991:            if (last_valide == d_vrai)
                    992:            {
                    993:                sf(s_etat_processus, 31);
                    994:            }
                    995: 
                    996:            (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
                    997:            return;
                    998:        }
                    999: 
                   1000:        free(nom_x);
                   1001:    }
                   1002: 
                   1003:    /*
                   1004:     * Tracé r=f(t)
                   1005:     * Les bornes de variation de T sont données par une
                   1006:     * liste "{ T T_min T_max } INDEP".
                   1007:     * INDEP et DEPND testent leurs arguments pour que les pointeurs
                   1008:     * indep et depend désignent des objets de type NOM ou LST à
                   1009:     * trois éléments.
                   1010:     */
                   1011: 
                   1012:    else if (strcmp((*s_etat_processus).type_trace_eq, "POLAIRE") == 0)
                   1013:    {
                   1014:        dimensions = 2;
                   1015: 
                   1016:        /*
                   1017:         * Vérification de la présence de la variable globale EQ
                   1018:         */
                   1019:        
1.19      bertrand 1020:        if (recherche_variable_globale(s_etat_processus, "EQ") == d_faux)
1.1       bertrand 1021:        {
                   1022:            /*
                   1023:             * Aucune variable "EQ" n'existe.
                   1024:             */
                   1025: 
                   1026:            if (last_valide == d_vrai)
                   1027:            {
                   1028:                sf(s_etat_processus, 31);
                   1029:            }
                   1030: 
1.19      bertrand 1031:            if ((*s_etat_processus).erreur_execution == d_ex)
1.1       bertrand 1032:            {
1.19      bertrand 1033:                (*s_etat_processus).erreur_execution = d_ex_absence_equation;
1.1       bertrand 1034:            }
                   1035: 
1.19      bertrand 1036:            (*s_etat_processus).erreur_systeme = d_es;
1.1       bertrand 1037: 
                   1038:            return;
                   1039:        }
                   1040: 
                   1041:        /*
                   1042:         * Création du fichier graphique temporaire
                   1043:         */
                   1044: 
                   1045:        if ((nom_fichier = creation_nom_fichier(s_etat_processus,
                   1046:                (*s_etat_processus).chemin_fichiers_temporaires)) == NULL)
                   1047:        {
                   1048:            (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1049:            return;
                   1050:        }
                   1051: 
                   1052:        if ((fichier = fopen(nom_fichier, "w+")) == NULL)
                   1053:        {
                   1054:            (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1055:            return;
                   1056:        }
                   1057: 
                   1058:        /*
                   1059:         * Récupération du domaine de variation de x
                   1060:         */
                   1061: 
                   1062:        if ((*(*s_etat_processus).indep).type == LST)
                   1063:        {
                   1064:            l_element_courant = (*(*s_etat_processus).indep).objet;
                   1065: 
                   1066:            if ((s_variable_x.nom = malloc((strlen((*((struct_nom *)
                   1067:                    (*(*l_element_courant).donnee).objet)).nom) + 1) *
                   1068:                    sizeof(unsigned char))) == NULL)
                   1069:            {
                   1070:                if (fclose(fichier) != 0)
                   1071:                {
                   1072:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1073:                    return;
                   1074:                }
                   1075: 
                   1076:                if (destruction_fichier(nom_fichier) == d_erreur)
                   1077:                {
                   1078:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1079:                    return;
                   1080:                }
                   1081: 
                   1082:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   1083:                return;
                   1084:            }
                   1085: 
                   1086:            strcpy(s_variable_x.nom, (*((struct_nom *) (*(*l_element_courant)
                   1087:                    .donnee).objet)).nom);
                   1088: 
                   1089:            if ((nom_x = malloc((strlen(s_variable_x.nom) + 1) *
                   1090:                    sizeof(unsigned char))) == NULL)
                   1091:            {
                   1092:                if (fclose(fichier) != 0)
                   1093:                {
                   1094:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1095:                    return;
                   1096:                }
                   1097: 
                   1098:                if (destruction_fichier(nom_fichier) == d_erreur)
                   1099:                {
                   1100:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1101:                    return;
                   1102:                }
                   1103: 
                   1104:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   1105:                return;
                   1106:            }
                   1107: 
                   1108:            strcpy(nom_x, s_variable_x.nom);
                   1109: 
                   1110:            l_element_courant = (*l_element_courant).suivant;
                   1111: 
                   1112:            if ((*(*l_element_courant).donnee).type == INT)
                   1113:            {
                   1114:                borne_minimale_x = (real8) (*((integer8 *)
                   1115:                        (*(*l_element_courant).donnee).objet));
                   1116:            }
                   1117:            else if ((*(*l_element_courant).donnee).type == REL)
                   1118:            {
                   1119:                borne_minimale_x = (*((real8 *) (*(*l_element_courant)
                   1120:                        .donnee).objet));
                   1121:            }
                   1122:            else
                   1123:            {
                   1124:                if (evaluation(s_etat_processus, (*l_element_courant).donnee,
                   1125:                        'N') == d_erreur)
                   1126:                {
                   1127:                    free(s_variable_x.nom);
                   1128:                    free(nom_x);
                   1129: 
                   1130:                    if (fclose(fichier) != 0)
                   1131:                    {
                   1132:                        (*s_etat_processus).erreur_systeme =
                   1133:                                d_es_erreur_fichier;
                   1134:                        return;
                   1135:                    }
                   1136: 
                   1137:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   1138:                    {
                   1139:                        (*s_etat_processus).erreur_systeme =
                   1140:                                d_es_erreur_fichier;
                   1141:                        return;
                   1142:                    }
                   1143: 
                   1144:                    if (last_valide == d_vrai)
                   1145:                    {
                   1146:                        sf(s_etat_processus, 31);
                   1147:                    }
                   1148: 
                   1149:                    free(nom_fichier);
                   1150:                    return;
                   1151:                }
                   1152: 
                   1153:                if (depilement(s_etat_processus, &((*s_etat_processus)
                   1154:                        .l_base_pile), &s_objet_evalue) == d_erreur)
                   1155:                {
                   1156:                    free(s_variable_x.nom);
                   1157:                    free(nom_x);
                   1158: 
                   1159:                    if (fclose(fichier) != 0)
                   1160:                    {
                   1161:                        (*s_etat_processus).erreur_systeme =
                   1162:                                d_es_erreur_fichier;
                   1163:                        return;
                   1164:                    }
                   1165: 
                   1166:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   1167:                    {
                   1168:                        (*s_etat_processus).erreur_systeme =
                   1169:                                d_es_erreur_fichier;
                   1170:                        return;
                   1171:                    }
                   1172: 
                   1173:                    (*s_etat_processus).erreur_execution =
                   1174:                            d_ex_manque_argument;
                   1175: 
                   1176:                    if (last_valide == d_vrai)
                   1177:                    {
                   1178:                        sf(s_etat_processus, 31);
                   1179:                    }
                   1180: 
                   1181:                    free(nom_fichier);
                   1182:                    return;
                   1183:                }
                   1184: 
                   1185:                if ((*s_objet_evalue).type == INT)
                   1186:                {
                   1187:                    borne_minimale_x = (real8) (*((integer8 *)
                   1188:                            (*s_objet_evalue).objet));
                   1189:                }
                   1190:                else if ((*s_objet_evalue).type == REL)
                   1191:                {
                   1192:                    borne_minimale_x = (*((real8 *) (*s_objet_evalue).objet));
                   1193:                }
                   1194:                else
                   1195:                {
                   1196:                    if (fclose(fichier) != 0)
                   1197:                    {
                   1198:                        (*s_etat_processus).erreur_systeme =
                   1199:                                d_es_erreur_fichier;
                   1200:                        return;
                   1201:                    }
                   1202: 
                   1203:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   1204:                    {
                   1205:                        (*s_etat_processus).erreur_systeme =
                   1206:                                d_es_erreur_fichier;
                   1207:                        return;
                   1208:                    }
                   1209: 
                   1210:                    free(s_variable_x.nom);
                   1211:                    free(nom_x);
                   1212:                    liberation(s_etat_processus, s_objet_evalue);
                   1213: 
                   1214:                    (*s_etat_processus).erreur_execution =
                   1215:                            d_ex_erreur_type_argument;
                   1216: 
                   1217:                    if (last_valide == d_vrai)
                   1218:                    {
                   1219:                        sf(s_etat_processus, 31);
                   1220:                    }
                   1221: 
                   1222:                    free(nom_fichier);
                   1223:                    return;
                   1224:                }
                   1225: 
                   1226:                liberation(s_etat_processus, s_objet_evalue);
                   1227:            }
                   1228: 
                   1229:            l_element_courant = (*l_element_courant).suivant;
                   1230: 
                   1231:            if ((*(*l_element_courant).donnee).type == INT)
                   1232:            {
                   1233:                borne_maximale_x = (real8) (*((integer8 *)
                   1234:                        (*(*l_element_courant).donnee).objet));
                   1235:            }
                   1236:            else if ((*(*l_element_courant).donnee).type == REL)
                   1237:            {
                   1238:                borne_maximale_x = (*((real8 *) (*(*l_element_courant)
                   1239:                        .donnee).objet));
                   1240:            }
                   1241:            else
                   1242:            {
                   1243:                if (evaluation(s_etat_processus, (*l_element_courant).donnee,
                   1244:                        'N') == d_erreur)
                   1245:                {
                   1246:                    free(s_variable_x.nom);
                   1247:                    free(nom_x);
                   1248: 
                   1249:                    if (fclose(fichier) != 0)
                   1250:                    {
                   1251:                        (*s_etat_processus).erreur_systeme =
                   1252:                                d_es_erreur_fichier;
                   1253:                        return;
                   1254:                    }
                   1255: 
                   1256:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   1257:                    {
                   1258:                        (*s_etat_processus).erreur_systeme =
                   1259:                                d_es_erreur_fichier;
                   1260:                        return;
                   1261:                    }
                   1262: 
                   1263:                    if (last_valide == d_vrai)
                   1264:                    {
                   1265:                        sf(s_etat_processus, 31);
                   1266:                    }
                   1267: 
                   1268:                    free(nom_fichier);
                   1269:                    return;
                   1270:                }
                   1271: 
                   1272:                if (depilement(s_etat_processus, &((*s_etat_processus)
                   1273:                        .l_base_pile), &s_objet_evalue) == d_erreur)
                   1274:                {
                   1275:                    free(s_variable_x.nom);
                   1276:                    free(nom_x);
                   1277: 
                   1278:                    if (fclose(fichier) != 0)
                   1279:                    {
                   1280:                        (*s_etat_processus).erreur_systeme =
                   1281:                                d_es_erreur_fichier;
                   1282:                        return;
                   1283:                    }
                   1284: 
                   1285:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   1286:                    {
                   1287:                        (*s_etat_processus).erreur_systeme =
                   1288:                                d_es_erreur_fichier;
                   1289:                        return;
                   1290:                    }
                   1291: 
                   1292:                    (*s_etat_processus).erreur_execution =
                   1293:                            d_ex_manque_argument;
                   1294: 
                   1295:                    if (last_valide == d_vrai)
                   1296:                    {
                   1297:                        sf(s_etat_processus, 31);
                   1298:                    }
                   1299: 
                   1300:                    free(nom_fichier);
                   1301:                    return;
                   1302:                }
                   1303: 
                   1304:                if ((*s_objet_evalue).type == INT)
                   1305:                {
                   1306:                    borne_maximale_x = (real8) (*((integer8 *)
                   1307:                            (*s_objet_evalue).objet));
                   1308:                }
                   1309:                else if ((*s_objet_evalue).type == REL)
                   1310:                {
                   1311:                    borne_maximale_x = (*((real8 *) (*s_objet_evalue).objet));
                   1312:                }
                   1313:                else
                   1314:                {
                   1315:                    free(s_variable_x.nom);
                   1316:                    free(nom_x);
                   1317: 
                   1318:                    if (fclose(fichier) != 0)
                   1319:                    {
                   1320:                        (*s_etat_processus).erreur_systeme =
                   1321:                                d_es_erreur_fichier;
                   1322:                        return;
                   1323:                    }
                   1324: 
                   1325:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   1326:                    {
                   1327:                        (*s_etat_processus).erreur_systeme =
                   1328:                                d_es_erreur_fichier;
                   1329:                        return;
                   1330:                    }
                   1331: 
                   1332:                    liberation(s_etat_processus, s_objet_evalue);
                   1333: 
                   1334:                    (*s_etat_processus).erreur_execution =
                   1335:                            d_ex_erreur_type_argument;
                   1336: 
                   1337:                    if (last_valide == d_vrai)
                   1338:                    {
                   1339:                        sf(s_etat_processus, 31);
                   1340:                    }
                   1341: 
                   1342:                    free(nom_fichier);
                   1343:                    return;
                   1344:                }
                   1345: 
                   1346:                liberation(s_etat_processus, s_objet_evalue);
                   1347:            }
                   1348:        }
                   1349:        else
                   1350:        {
                   1351:            if (fclose(fichier) != 0)
                   1352:            {
                   1353:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1354:                return;
                   1355:            }
                   1356: 
                   1357:            if (destruction_fichier(nom_fichier) == d_erreur)
                   1358:            {
                   1359:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1360:                return;
                   1361:            }
                   1362: 
                   1363:            (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
                   1364: 
                   1365:            if (last_valide == d_vrai)
                   1366:            {
                   1367:                sf(s_etat_processus, 31);
                   1368:            }
                   1369: 
                   1370:            free(nom_fichier);
                   1371:            return;
                   1372:        }
                   1373: 
                   1374:        /*
                   1375:         * Création d'une variable locale du nom pointé par INDEP
                   1376:         */
                   1377: 
                   1378:        (*s_etat_processus).niveau_courant++;
                   1379:        s_variable_x.niveau = (*s_etat_processus).niveau_courant;
                   1380: 
                   1381:        if ((s_variable_x.objet = allocation(s_etat_processus, REL)) == NULL)
                   1382:        {
                   1383:            if (fclose(fichier) != 0)
                   1384:            {
                   1385:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1386:                return;
                   1387:            }
                   1388: 
                   1389:            if (destruction_fichier(nom_fichier) == d_erreur)
                   1390:            {
                   1391:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1392:                return;
                   1393:            }
                   1394: 
                   1395:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   1396:            return;
                   1397:        }
                   1398: 
                   1399:        if (creation_variable(s_etat_processus, &s_variable_x, 'V', 'P')
                   1400:                == d_erreur)
                   1401:        {
                   1402:            if (fclose(fichier) != 0)
                   1403:            {
                   1404:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1405:                return;
                   1406:            }
                   1407: 
                   1408:            if (destruction_fichier(nom_fichier) == d_erreur)
                   1409:            {
                   1410:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1411:                return;
                   1412:            }
                   1413: 
                   1414:            /*
                   1415:             * L'erreur retournée ne peut être qu'une erreur système
                   1416:             */
                   1417: 
                   1418:            free(nom_fichier);
                   1419:            return;
                   1420:        }
                   1421: 
                   1422:        /*
                   1423:         * Boucle de calcul des points de la fonction
                   1424:         */
                   1425: 
                   1426:        if (borne_maximale_x < borne_minimale_x)
                   1427:        {
                   1428:            t = borne_maximale_x;
                   1429:            borne_maximale_x = borne_minimale_x;
                   1430:            borne_minimale_x = t;
                   1431:        }
                   1432: 
                   1433:        for(t = borne_minimale_x; t <= borne_maximale_x;
                   1434:                t += (*s_etat_processus).resolution)
                   1435:        {
                   1436:            if (recherche_variable(s_etat_processus, nom_x) == d_vrai)
                   1437:            {
                   1438:                // La variable étant créée localement, elle n'est jamais
                   1439:                // ni verrouillée ni partagée.
                   1440: 
1.19      bertrand 1441:                BUG((*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand 1442:                        .objet == NULL);
                   1443: 
1.19      bertrand 1444:                if ((*(*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand 1445:                        .objet).type != REL)
                   1446:                {
                   1447:                    liberation(s_etat_processus,
1.19      bertrand 1448:                            (*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand 1449:                            .objet);
                   1450: 
1.19      bertrand 1451:                    if (((*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand 1452:                            .objet = allocation(s_etat_processus, REL))
                   1453:                            == NULL)
                   1454:                    {
                   1455:                        (*s_etat_processus).erreur_systeme =
                   1456:                                d_es_allocation_memoire;
                   1457:                        return;
                   1458:                    }
                   1459:                }
                   1460: 
1.19      bertrand 1461:                (*((real8 *) (*(*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand 1462:                        .objet).objet)) = t;
                   1463:            }
                   1464:            else
                   1465:            {
                   1466:                /*
                   1467:                 * La variable créée étant locale, l'utilisateur ne peut
                   1468:                 * pas l'effacer. On ne doit donc jamais passer par ici. Si
                   1469:                 * c'est néanmoins le cas, une erreur système est générée
                   1470:                 * provoquant l'arrêt du programme même dans une
                   1471:                 * structure IFERR.
                   1472:                 */
                   1473: 
                   1474:                if (fclose(fichier) != 0)
                   1475:                {
                   1476:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1477:                    return;
                   1478:                }
                   1479: 
                   1480:                if (destruction_fichier(nom_fichier) == d_erreur)
                   1481:                {
                   1482:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1483:                    return;
                   1484:                }
                   1485: 
                   1486:                if (last_valide == d_vrai)
                   1487:                {
                   1488:                    sf(s_etat_processus, 31);
                   1489:                }
                   1490: 
                   1491:                free(nom_fichier);
                   1492:                return;
                   1493:            }
                   1494: 
1.20      bertrand 1495:            if (recherche_variable_globale(s_etat_processus, "EQ") == d_faux)
1.1       bertrand 1496:            {
                   1497:                /*
                   1498:                 * Aucune variable "EQ" n'existe.
                   1499:                 */
                   1500: 
                   1501:                (*s_etat_processus).erreur_execution =
                   1502:                        d_ex_variable_non_definie;
                   1503: 
                   1504:                /*
                   1505:                 * Retrait de la variable INDEP
                   1506:                 */
                   1507: 
                   1508:                (*s_etat_processus).niveau_courant--;
                   1509: 
                   1510:                if (fclose(fichier) != 0)
                   1511:                {
                   1512:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1513:                    return;
                   1514:                }
                   1515: 
                   1516:                if (destruction_fichier(nom_fichier) == d_erreur)
                   1517:                {
                   1518:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1519:                    return;
                   1520:                }
                   1521: 
                   1522:                if (retrait_variable(s_etat_processus, nom_x, 'L') == d_erreur)
                   1523:                {
                   1524:                    if ((*s_etat_processus).erreur_systeme != d_es)
                   1525:                    {
                   1526:                        if ((*s_etat_processus).erreur_systeme ==
                   1527:                                d_es_variable_introuvable)
                   1528:                        {
                   1529:                            (*s_etat_processus).erreur_systeme = d_es;
                   1530:                        }
                   1531:                        else
                   1532:                        {
                   1533: 
                   1534:                        /*
                   1535:                         * Erreur système
                   1536:                         */
                   1537: 
                   1538:                            free(nom_fichier);
                   1539:                            return;
                   1540:                        }
                   1541:                    }
                   1542: 
                   1543:                    free(nom_x);
                   1544:                    free(nom_fichier);
                   1545: 
                   1546:                    if (last_valide == d_vrai)
                   1547:                    {
                   1548:                        sf(s_etat_processus, 31);
                   1549:                    }
                   1550: 
                   1551:                    (*s_etat_processus).erreur_execution =
                   1552:                            d_ex_variable_non_definie;
                   1553:                    return;
                   1554:                }
                   1555: 
                   1556:                if (last_valide == d_vrai)
                   1557:                {
                   1558:                    sf(s_etat_processus, 31);
                   1559:                }
                   1560: 
                   1561:                free(nom_x);
                   1562:                free(nom_fichier);
                   1563:                return;
                   1564:            }
                   1565: 
                   1566:            /*
                   1567:             * Evaluation de la fonction
                   1568:             */
                   1569: 
                   1570:            hauteur_pile = (*s_etat_processus).hauteur_pile_operationnelle;
                   1571:            l_position_normale = (*s_etat_processus).l_base_pile_systeme;
                   1572:            niveau_courant = (*s_etat_processus).niveau_courant;
                   1573: 
                   1574:            (*s_etat_processus).erreur_execution = d_ex;
                   1575:            (*s_etat_processus).exception = d_ep;
                   1576: 
1.19      bertrand 1577:            if (evaluation(s_etat_processus, (*(*s_etat_processus)
                   1578:                    .pointeur_variable_courante).objet, 'N') == d_erreur)
1.1       bertrand 1579:            {
                   1580:                if ((*s_etat_processus).erreur_systeme != d_es)
                   1581:                {
                   1582:                    /*
                   1583:                     * Erreur système
                   1584:                     */
                   1585: 
                   1586:                    free(nom_fichier);
                   1587:                    return;
                   1588:                }
                   1589:                else
                   1590:                {
                   1591:                    retour_suite_erreur = d_faux;
                   1592:                    (*s_etat_processus).niveau_courant = niveau_courant;
                   1593: 
                   1594:                    /*
                   1595:                     * Restauration de la pile initiale
                   1596:                     */
                   1597: 
                   1598:                    while((*s_etat_processus).hauteur_pile_operationnelle >
                   1599:                            (unsigned long) hauteur_pile)
                   1600:                    {
                   1601:                        if (depilement(s_etat_processus, &((*s_etat_processus)
                   1602:                                .l_base_pile), &s_objet) == d_erreur)
                   1603:                        {
                   1604:                            (*s_etat_processus).erreur_execution =
                   1605:                                    d_ex_manque_argument;
                   1606:                            retour_suite_erreur = d_vrai;
                   1607:                            break;
                   1608:                        }
                   1609: 
                   1610:                        liberation(s_etat_processus, s_objet);
                   1611:                    }
                   1612: 
                   1613:                    /*
                   1614:                     * Restauration de la pile système
                   1615:                     */
                   1616: 
                   1617:                    while((*s_etat_processus).l_base_pile_systeme !=
                   1618:                            l_position_normale)
                   1619:                    {
                   1620:                        depilement_pile_systeme(s_etat_processus);
                   1621: 
                   1622:                        if ((*s_etat_processus).erreur_systeme != d_es)
                   1623:                        {
                   1624:                            /*
                   1625:                             * Une pile vide provoque une erreur système
                   1626:                             */
                   1627: 
                   1628:                            free(nom_fichier);
                   1629:                            return;
                   1630:                        }
                   1631:                    }
                   1632: 
                   1633:                    if (retour_suite_erreur == d_vrai)
                   1634:                    {
                   1635:                        /*
                   1636:                         * Retrait de la variable INDEP et retour
                   1637:                         */
                   1638: 
                   1639:                        (*s_etat_processus).niveau_courant--;
                   1640: 
                   1641:                        if (fclose(fichier) != 0)
                   1642:                        {
                   1643:                            (*s_etat_processus).erreur_systeme =
                   1644:                                    d_es_erreur_fichier;
                   1645:                            return;
                   1646:                        }
                   1647: 
                   1648:                        if (destruction_fichier(nom_fichier) == d_erreur)
                   1649:                        {
                   1650:                            (*s_etat_processus).erreur_systeme =
                   1651:                                    d_es_erreur_fichier;
                   1652:                            return;
                   1653:                        }
                   1654: 
                   1655:                        if (retrait_variable(s_etat_processus,
                   1656:                                nom_x, 'L') == d_erreur)
                   1657:                        {
                   1658:                            if ((*s_etat_processus).erreur_systeme != d_es)
                   1659:                            {
                   1660:                                if ((*s_etat_processus).erreur_systeme ==
                   1661:                                        d_es_variable_introuvable)
                   1662:                                {
                   1663:                                    (*s_etat_processus).erreur_systeme =
                   1664:                                            d_es;
                   1665:                                }
                   1666:                                else
                   1667:                                {
                   1668: 
                   1669:                                /*
                   1670:                                 * Erreur système
                   1671:                                 */
                   1672: 
                   1673:                                    free(nom_fichier);
                   1674:                                    return;
                   1675:                                }
                   1676:                            }
                   1677: 
                   1678:                            (*s_etat_processus).erreur_execution =
                   1679:                                    d_ex_variable_non_definie;
                   1680:                        }
                   1681: 
                   1682:                        if (last_valide == d_vrai)
                   1683:                        {
                   1684:                            sf(s_etat_processus, 31);
                   1685:                        }
                   1686: 
                   1687:                        free(nom_x);
                   1688:                        free(nom_fichier);
                   1689: 
                   1690:                        return;
                   1691:                    }
                   1692:                }
                   1693: 
                   1694:                (*s_etat_processus).erreur_execution = d_ex;
                   1695:                (*s_etat_processus).exception = d_ep;
                   1696:            }
                   1697:            else
                   1698:            {
                   1699:                /*
                   1700:                 * Donnée valide à écrire dans le fichier
                   1701:                 */
                   1702: 
                   1703:                if (depilement(s_etat_processus, &((*s_etat_processus)
                   1704:                        .l_base_pile), &s_objet) == d_erreur)
                   1705:                {
                   1706: 
                   1707:                    /*
                   1708:                     * Retrait de la variable INDEP et retour
                   1709:                     */
                   1710: 
                   1711:                    (*s_etat_processus).niveau_courant--;
                   1712: 
                   1713:                    if (fclose(fichier) != 0)
                   1714:                    {
                   1715:                        (*s_etat_processus).erreur_systeme =
                   1716:                                d_es_erreur_fichier;
                   1717:                        return;
                   1718:                    }
                   1719: 
                   1720:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   1721:                    {
                   1722:                        (*s_etat_processus).erreur_systeme =
                   1723:                                d_es_erreur_fichier;
                   1724:                        return;
                   1725:                    }
                   1726: 
                   1727:                    if (retrait_variable(s_etat_processus, nom_x,
                   1728:                            'L') == d_erreur)
                   1729:                    {
                   1730:                        if ((*s_etat_processus).erreur_systeme != d_es)
                   1731:                        {
                   1732:                            if ((*s_etat_processus).erreur_systeme ==
                   1733:                                    d_es_variable_introuvable)
                   1734:                            {
                   1735:                                (*s_etat_processus).erreur_systeme = d_es;
                   1736:                            }
                   1737:                            else
                   1738:                            {
                   1739: 
                   1740:                            /*
                   1741:                             * Erreur système
                   1742:                             */
                   1743: 
                   1744:                                free(nom_fichier);
                   1745:                                return;
                   1746:                            }
                   1747:                        }
                   1748: 
                   1749:                        free(nom_x);
                   1750:                        free(nom_fichier);
                   1751: 
                   1752:                        if (last_valide == d_vrai)
                   1753:                        {
                   1754:                            sf(s_etat_processus, 31);
                   1755:                        }
                   1756: 
                   1757:                        (*s_etat_processus).erreur_execution =
                   1758:                                d_ex_variable_non_definie;
                   1759:                        return;
                   1760:                    }
                   1761: 
                   1762:                    free(nom_x);
                   1763:                    free(nom_fichier);
                   1764: 
                   1765:                    if (last_valide == d_vrai)
                   1766:                    {
                   1767:                        sf(s_etat_processus, 31);
                   1768:                    }
                   1769: 
                   1770:                    (*s_etat_processus).erreur_execution = d_ex_manque_argument;
                   1771:                    return;
                   1772:                }
                   1773: 
                   1774:                if ((*s_objet).type == INT)
                   1775:                {
                   1776:                    r = (double) (*((integer8 *) (*s_objet).objet));
                   1777: 
                   1778:                    if (fprintf(fichier, "%f %f\n", r * cos(t), r * sin(t)) < 0)
                   1779:                    {
                   1780:                        (*s_etat_processus).erreur_systeme =
                   1781:                                d_es_erreur_fichier;
                   1782:                        return;
                   1783:                    }
                   1784:                }
                   1785:                else if ((*s_objet).type == REL)
                   1786:                {
                   1787:                    r = (double) (*((real8 *) (*s_objet).objet));
                   1788: 
                   1789:                    if (fprintf(fichier, "%f %f\n", r * cos(t), r * sin(t)) < 0)
                   1790:                    {
                   1791:                        (*s_etat_processus).erreur_systeme =
                   1792:                                d_es_erreur_fichier;
                   1793:                        return;
                   1794:                    }
                   1795:                }
                   1796: 
                   1797:                liberation(s_etat_processus, s_objet);
                   1798:            }
                   1799:        }
                   1800: 
                   1801:        /*
                   1802:         * Retrait de la variable locale
                   1803:         */
                   1804: 
                   1805:        (*s_etat_processus).niveau_courant--;
                   1806: 
                   1807:        if (retrait_variable(s_etat_processus, nom_x, 'L') == d_erreur)
                   1808:        {
                   1809:            if ((*s_etat_processus).erreur_systeme != d_es)
                   1810:            {
                   1811:                if ((*s_etat_processus).erreur_systeme ==
                   1812:                        d_es_variable_introuvable)
                   1813:                {
                   1814:                    (*s_etat_processus).erreur_systeme = d_es;
                   1815:                }
                   1816:                else
                   1817:                {
                   1818:                    /*
                   1819:                     * Erreur système
                   1820:                     */
                   1821: 
                   1822:                    free(nom_fichier);
                   1823:                    return;
                   1824:                }
                   1825:            }
                   1826: 
                   1827:            free(nom_x);
                   1828:            free(nom_fichier);
                   1829: 
                   1830:            if (last_valide == d_vrai)
                   1831:            {
                   1832:                sf(s_etat_processus, 31);
                   1833:            }
                   1834: 
                   1835:            (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
                   1836:            return;
                   1837:        }
                   1838: 
                   1839:        free(nom_x);
                   1840:    }
                   1841: 
                   1842:    /*
                   1843:     * Tracé { x=RE(f(t)), y=IM(f(t)) }
                   1844:     * Les bornes de variation de T sont données par une
                   1845:     * liste "{ T T_min T_max } INDEP".
                   1846:     * INDEP et DEPND testent leurs arguments pour que les pointeurs
                   1847:     * indep et depend désignent des objets de type NOM ou LST à
                   1848:     * trois éléments.
                   1849:     */
                   1850: 
                   1851:    else if (strcmp((*s_etat_processus).type_trace_eq, "PARAMETRIQUE") == 0)
                   1852:    {
                   1853:        dimensions = 2;
                   1854: 
                   1855:        /*
                   1856:         * Vérification de la présence de la variable globale EQ
                   1857:         */
                   1858:        
1.19      bertrand 1859:        if (recherche_variable_globale(s_etat_processus, "EQ") == d_faux)
1.1       bertrand 1860:        {
                   1861:            /*
                   1862:             * Aucune variable "EQ" n'existe.
                   1863:             */
                   1864: 
1.19      bertrand 1865:            if ((*s_etat_processus).erreur_execution == d_ex)
1.1       bertrand 1866:            {
1.19      bertrand 1867:                (*s_etat_processus).erreur_execution = d_ex_absence_equation;
1.1       bertrand 1868:            }
                   1869: 
1.19      bertrand 1870:            (*s_etat_processus).erreur_systeme = d_es;
1.1       bertrand 1871: 
                   1872:            if (last_valide == d_vrai)
                   1873:            {
                   1874:                sf(s_etat_processus, 31);
                   1875:            }
                   1876: 
                   1877:            return;
                   1878:        }
                   1879: 
                   1880:        /*
                   1881:         * Création du fichier graphique temporaire
                   1882:         */
                   1883: 
                   1884:        if ((nom_fichier = creation_nom_fichier(s_etat_processus,
                   1885:                (*s_etat_processus).chemin_fichiers_temporaires)) == NULL)
                   1886:        {
                   1887:            (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1888:            return;
                   1889:        }
                   1890: 
                   1891:        if ((fichier = fopen(nom_fichier, "w+")) == NULL)
                   1892:        {
                   1893:            (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   1894:            return;
                   1895:        }
                   1896: 
                   1897:        /*
                   1898:         * Récupération du domaine de variation de x
                   1899:         */
                   1900: 
                   1901:        if ((*(*s_etat_processus).indep).type == LST)
                   1902:        {
                   1903:            l_element_courant = (*(*s_etat_processus).indep).objet;
                   1904: 
                   1905:            if ((s_variable_x.nom = malloc((strlen((*((struct_nom *)
                   1906:                    (*(*l_element_courant).donnee).objet)).nom) + 1) *
                   1907:                    sizeof(unsigned char))) == NULL)
                   1908:            {
                   1909:                if (fclose(fichier) != 0)
                   1910:                {
                   1911:                    (*s_etat_processus).erreur_systeme =
                   1912:                            d_es_erreur_fichier;
                   1913:                    return;
                   1914:                }
                   1915: 
                   1916:                if (destruction_fichier(nom_fichier) == d_erreur)
                   1917:                {
                   1918:                    (*s_etat_processus).erreur_systeme =
                   1919:                            d_es_erreur_fichier;
                   1920:                    return;
                   1921:                }
                   1922: 
                   1923:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   1924:                return;
                   1925:            }
                   1926: 
                   1927:            strcpy(s_variable_x.nom, (*((struct_nom *) (*(*l_element_courant)
                   1928:                    .donnee).objet)).nom);
                   1929: 
                   1930:            if ((nom_x = malloc((strlen(s_variable_x.nom) + 1) *
                   1931:                    sizeof(unsigned char))) == NULL)
                   1932:            {
                   1933:                if (fclose(fichier) != 0)
                   1934:                {
                   1935:                    (*s_etat_processus).erreur_systeme =
                   1936:                            d_es_erreur_fichier;
                   1937:                    return;
                   1938:                }
                   1939: 
                   1940:                if (destruction_fichier(nom_fichier) == d_erreur)
                   1941:                {
                   1942:                    (*s_etat_processus).erreur_systeme =
                   1943:                            d_es_erreur_fichier;
                   1944:                    return;
                   1945:                }
                   1946: 
                   1947:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   1948:                return;
                   1949:            }
                   1950: 
                   1951:            strcpy(nom_x, s_variable_x.nom);
                   1952: 
                   1953:            l_element_courant = (*l_element_courant).suivant;
                   1954: 
                   1955:            if ((*(*l_element_courant).donnee).type == INT)
                   1956:            {
                   1957:                borne_minimale_x = (real8) (*((integer8 *)
                   1958:                        (*(*l_element_courant).donnee).objet));
                   1959:            }
                   1960:            else if ((*(*l_element_courant).donnee).type == INT)
                   1961:            {
                   1962:                borne_minimale_x = (*((real8 *) (*(*l_element_courant)
                   1963:                        .donnee).objet));
                   1964:            }
                   1965:            else
                   1966:            {
                   1967:                if (evaluation(s_etat_processus, (*l_element_courant).donnee,
                   1968:                        'N') == d_erreur)
                   1969:                {
                   1970:                    free(s_variable_x.nom);
                   1971:                    free(nom_x);
                   1972: 
                   1973:                    if (fclose(fichier) != 0)
                   1974:                    {
                   1975:                        (*s_etat_processus).erreur_systeme =
                   1976:                                d_es_erreur_fichier;
                   1977:                        return;
                   1978:                    }
                   1979: 
                   1980:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   1981:                    {
                   1982:                        (*s_etat_processus).erreur_systeme =
                   1983:                                d_es_erreur_fichier;
                   1984:                        return;
                   1985:                    }
                   1986: 
                   1987:                    if (last_valide == d_vrai)
                   1988:                    {
                   1989:                        sf(s_etat_processus, 31);
                   1990:                    }
                   1991: 
                   1992:                    free(nom_fichier);
                   1993:                    return;
                   1994:                }
                   1995: 
                   1996:                if (depilement(s_etat_processus, &((*s_etat_processus)
                   1997:                        .l_base_pile), &s_objet_evalue) == d_erreur)
                   1998:                {
                   1999:                    free(s_variable_x.nom);
                   2000:                    free(nom_x);
                   2001: 
                   2002:                    if (fclose(fichier) != 0)
                   2003:                    {
                   2004:                        (*s_etat_processus).erreur_systeme =
                   2005:                                d_es_erreur_fichier;
                   2006:                        return;
                   2007:                    }
                   2008: 
                   2009:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   2010:                    {
                   2011:                        (*s_etat_processus).erreur_systeme =
                   2012:                                d_es_erreur_fichier;
                   2013:                        return;
                   2014:                    }
                   2015: 
                   2016:                    (*s_etat_processus).erreur_execution =
                   2017:                            d_ex_manque_argument;
                   2018: 
                   2019:                    if (last_valide == d_vrai)
                   2020:                    {
                   2021:                        sf(s_etat_processus, 31);
                   2022:                    }
                   2023: 
                   2024:                    free(nom_fichier);
                   2025:                    return;
                   2026:                }
                   2027: 
                   2028:                if ((*s_objet_evalue).type == INT)
                   2029:                {
                   2030:                    borne_minimale_x = (real8) (*((integer8 *)
                   2031:                            (*s_objet_evalue).objet));
                   2032:                }
                   2033:                else if ((*s_objet_evalue).type == REL)
                   2034:                {
                   2035:                    borne_minimale_x = (*((real8 *) (*s_objet_evalue).objet));
                   2036:                }
                   2037:                else
                   2038:                {
                   2039:                    if (fclose(fichier) != 0)
                   2040:                    {
                   2041:                        (*s_etat_processus).erreur_systeme =
                   2042:                                d_es_erreur_fichier;
                   2043:                        return;
                   2044:                    }
                   2045: 
                   2046:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   2047:                    {
                   2048:                        (*s_etat_processus).erreur_systeme =
                   2049:                                d_es_erreur_fichier;
                   2050:                        return;
                   2051:                    }
                   2052: 
                   2053:                    free(s_variable_x.nom);
                   2054:                    free(nom_x);
                   2055:                    liberation(s_etat_processus, s_objet_evalue);
                   2056: 
                   2057:                    (*s_etat_processus).erreur_execution =
                   2058:                            d_ex_erreur_type_argument;
                   2059: 
                   2060:                    if (last_valide == d_vrai)
                   2061:                    {
                   2062:                        sf(s_etat_processus, 31);
                   2063:                    }
                   2064: 
                   2065:                    free(nom_fichier);
                   2066:                    return;
                   2067:                }
                   2068: 
                   2069:                liberation(s_etat_processus, s_objet_evalue);
                   2070:            }
                   2071: 
                   2072:            l_element_courant = (*l_element_courant).suivant;
                   2073: 
                   2074:            if ((*(*l_element_courant).donnee).type == INT)
                   2075:            {
                   2076:                borne_maximale_x = (real8) (*((integer8 *)
                   2077:                        (*(*l_element_courant).donnee).objet));
                   2078:            }
                   2079:            else if ((*(*l_element_courant).donnee).type == REL)
                   2080:            {
                   2081:                borne_maximale_x = (*((real8 *) (*(*l_element_courant)
                   2082:                        .donnee).objet));
                   2083:            }
                   2084:            else
                   2085:            {
                   2086:                if (evaluation(s_etat_processus, (*l_element_courant).donnee,
                   2087:                        'N') == d_erreur)
                   2088:                {
                   2089:                    free(s_variable_x.nom);
                   2090:                    free(nom_x);
                   2091: 
                   2092:                    if (fclose(fichier) != 0)
                   2093:                    {
                   2094:                        (*s_etat_processus).erreur_systeme =
                   2095:                                d_es_erreur_fichier;
                   2096:                        return;
                   2097:                    }
                   2098: 
                   2099:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   2100:                    {
                   2101:                        (*s_etat_processus).erreur_systeme =
                   2102:                                d_es_erreur_fichier;
                   2103:                        return;
                   2104:                    }
                   2105: 
                   2106:                    if (last_valide == d_vrai)
                   2107:                    {
                   2108:                        sf(s_etat_processus, 31);
                   2109:                    }
                   2110: 
                   2111:                    free(nom_fichier);
                   2112:                    return;
                   2113:                }
                   2114: 
                   2115:                if (depilement(s_etat_processus, &((*s_etat_processus)
                   2116:                        .l_base_pile), &s_objet_evalue) == d_erreur)
                   2117:                {
                   2118:                    free(s_variable_x.nom);
                   2119:                    free(nom_x);
                   2120: 
                   2121:                    if (fclose(fichier) != 0)
                   2122:                    {
                   2123:                        (*s_etat_processus).erreur_systeme =
                   2124:                                d_es_erreur_fichier;
                   2125:                        return;
                   2126:                    }
                   2127: 
                   2128:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   2129:                    {
                   2130:                        (*s_etat_processus).erreur_systeme =
                   2131:                                d_es_erreur_fichier;
                   2132:                        return;
                   2133:                    }
                   2134: 
                   2135:                    (*s_etat_processus).erreur_execution =
                   2136:                            d_ex_manque_argument;
                   2137: 
                   2138:                    if (last_valide == d_vrai)
                   2139:                    {
                   2140:                        sf(s_etat_processus, 31);
                   2141:                    }
                   2142: 
                   2143:                    free(nom_fichier);
                   2144:                    return;
                   2145:                }
                   2146: 
                   2147:                if ((*s_objet_evalue).type == INT)
                   2148:                {
                   2149:                    borne_maximale_x = (real8) (*((integer8 *)
                   2150:                            (*s_objet_evalue).objet));
                   2151:                }
                   2152:                else if ((*s_objet_evalue).type == REL)
                   2153:                {
                   2154:                    borne_maximale_x = (*((real8 *) (*s_objet_evalue).objet));
                   2155:                }
                   2156:                else
                   2157:                {
                   2158:                    free(s_variable_x.nom);
                   2159:                    free(nom_x);
                   2160: 
                   2161:                    if (fclose(fichier) != 0)
                   2162:                    {
                   2163:                        (*s_etat_processus).erreur_systeme =
                   2164:                                d_es_erreur_fichier;
                   2165:                        return;
                   2166:                    }
                   2167: 
                   2168:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   2169:                    {
                   2170:                        (*s_etat_processus).erreur_systeme =
                   2171:                                d_es_erreur_fichier;
                   2172:                        return;
                   2173:                    }
                   2174: 
                   2175:                    liberation(s_etat_processus, s_objet_evalue);
                   2176: 
                   2177:                    (*s_etat_processus).erreur_execution =
                   2178:                            d_ex_erreur_type_argument;
                   2179: 
                   2180:                    if (last_valide == d_vrai)
                   2181:                    {
                   2182:                        sf(s_etat_processus, 31);
                   2183:                    }
                   2184: 
                   2185:                    free(nom_fichier);
                   2186:                    return;
                   2187:                }
                   2188: 
                   2189:                liberation(s_etat_processus, s_objet_evalue);
                   2190:            }
                   2191:        }
                   2192:        else
                   2193:        {
                   2194:            if (fclose(fichier) != 0)
                   2195:            {
                   2196:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2197:                return;
                   2198:            }
                   2199: 
                   2200:            if (destruction_fichier(nom_fichier) == d_erreur)
                   2201:            {
                   2202:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2203:                return;
                   2204:            }
                   2205: 
                   2206:            if (last_valide == d_vrai)
                   2207:            {
                   2208:                sf(s_etat_processus, 31);
                   2209:            }
                   2210: 
                   2211:            (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
                   2212: 
                   2213:            free(nom_fichier);
                   2214:            return;
                   2215:        }
                   2216: 
                   2217:        /*
                   2218:         * Création d'une variable locale du nom pointé par INDEP
                   2219:         */
                   2220: 
                   2221:        (*s_etat_processus).niveau_courant++;
                   2222:        s_variable_x.niveau = (*s_etat_processus).niveau_courant;
                   2223: 
                   2224:        if ((s_variable_x.objet = allocation(s_etat_processus, REL)) == NULL)
                   2225:        {
                   2226:            if (fclose(fichier) != 0)
                   2227:            {
                   2228:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2229:                return;
                   2230:            }
                   2231: 
                   2232:            if (destruction_fichier(nom_fichier) == d_erreur)
                   2233:            {
                   2234:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2235:                return;
                   2236:            }
                   2237: 
                   2238:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2239:            return;
                   2240:        }
                   2241: 
                   2242:        if (creation_variable(s_etat_processus, &s_variable_x, 'V', 'P')
                   2243:                == d_erreur)
                   2244:        {
                   2245:            if (fclose(fichier) != 0)
                   2246:            {
                   2247:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2248:                return;
                   2249:            }
                   2250: 
                   2251:            if (destruction_fichier(nom_fichier) == d_erreur)
                   2252:            {
                   2253:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2254:                return;
                   2255:            }
                   2256: 
                   2257:            /*
1.19      bertrand 2258:             * L'erreur retournée ne peut être qu'une erreur système.
1.1       bertrand 2259:             */
                   2260: 
                   2261:            free(nom_fichier);
                   2262:            return;
                   2263:        }
                   2264: 
                   2265:        /*
                   2266:         * Boucle de calcul des points de la fonction
                   2267:         */
                   2268: 
                   2269:        if (borne_maximale_x < borne_minimale_x)
                   2270:        {
                   2271:            t = borne_maximale_x;
                   2272:            borne_maximale_x = borne_minimale_x;
                   2273:            borne_minimale_x = t;
                   2274:        }
                   2275: 
                   2276:        for(t = borne_minimale_x; t <= borne_maximale_x;
                   2277:                t += (*s_etat_processus).resolution)
                   2278:        {
                   2279:            if (recherche_variable(s_etat_processus, nom_x) == d_vrai)
                   2280:            {
                   2281:                // La variable étant créée localement, elle n'est jamais
                   2282:                // ni verrouillée ni partagée.
                   2283: 
1.19      bertrand 2284:                BUG((*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand 2285:                        .objet == NULL);
                   2286: 
1.19      bertrand 2287:                if ((*(*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand 2288:                        .objet).type != REL)
                   2289:                {
                   2290:                    liberation(s_etat_processus,
1.19      bertrand 2291:                            (*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand 2292:                            .objet);
                   2293: 
1.19      bertrand 2294:                    if (((*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand 2295:                            .objet = allocation(s_etat_processus, REL))
                   2296:                            == NULL)
                   2297:                    {
                   2298:                        (*s_etat_processus).erreur_systeme =
                   2299:                                d_es_allocation_memoire;
                   2300:                        return;
                   2301:                    }
                   2302:                }
                   2303: 
1.19      bertrand 2304:                (*((real8 *) (*(*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand 2305:                        .objet).objet)) = t;
                   2306:            }
                   2307:            else
                   2308:            {
                   2309:                /*
                   2310:                 * La variable créée étant locale, l'utilisateur ne peut
                   2311:                 * pas l'effacer. On ne doit donc jamais passer par ici. Si
                   2312:                 * c'est néanmoins le cas, une erreur système est générée
                   2313:                 * provoquant l'arrêt du programme même dans une
                   2314:                 * structure IFERR.
                   2315:                 */
                   2316: 
                   2317:                if (fclose(fichier) != 0)
                   2318:                {
                   2319:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2320:                    return;
                   2321:                }
                   2322: 
                   2323:                if (destruction_fichier(nom_fichier) == d_erreur)
                   2324:                {
                   2325:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2326:                    return;
                   2327:                }
                   2328: 
                   2329:                if (last_valide == d_vrai)
                   2330:                {
                   2331:                    sf(s_etat_processus, 31);
                   2332:                }
                   2333: 
                   2334:                free(nom_fichier);
                   2335:                return;
                   2336:            }
                   2337: 
1.20      bertrand 2338:            if (recherche_variable_globale(s_etat_processus, "EQ") == d_faux)
1.1       bertrand 2339:            {
                   2340:                /*
                   2341:                 * Aucune variable "EQ" n'existe.
                   2342:                 */
                   2343: 
                   2344:                (*s_etat_processus).erreur_execution =
                   2345:                        d_ex_variable_non_definie;
                   2346: 
                   2347:                /*
                   2348:                 * Retrait de la variable INDEP
                   2349:                 */
                   2350: 
                   2351:                (*s_etat_processus).niveau_courant--;
                   2352: 
                   2353:                if (fclose(fichier) != 0)
                   2354:                {
                   2355:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2356:                    return;
                   2357:                }
                   2358: 
                   2359:                if (destruction_fichier(nom_fichier) == d_erreur)
                   2360:                {
                   2361:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2362:                    return;
                   2363:                }
                   2364: 
                   2365:                if (retrait_variable(s_etat_processus, nom_x, 'L')
                   2366:                        == d_erreur)
                   2367:                {
                   2368:                    if ((*s_etat_processus).erreur_systeme != d_es)
                   2369:                    {
                   2370:                        if ((*s_etat_processus).erreur_systeme ==
                   2371:                                d_es_variable_introuvable)
                   2372:                        {
                   2373:                            (*s_etat_processus).erreur_systeme = d_es;
                   2374:                        }
                   2375:                        else
                   2376:                        {
                   2377: 
                   2378:                        /*
                   2379:                         * Erreur système
                   2380:                         */
                   2381: 
                   2382:                            free(nom_fichier);
                   2383:                            return;
                   2384:                        }
                   2385:                    }
                   2386: 
                   2387:                    free(nom_x);
                   2388:                    free(nom_fichier);
                   2389: 
                   2390:                    if (last_valide == d_vrai)
                   2391:                    {
                   2392:                        sf(s_etat_processus, 31);
                   2393:                    }
                   2394: 
                   2395:                    (*s_etat_processus).erreur_execution =
                   2396:                            d_ex_variable_non_definie;
                   2397:                    return;
                   2398:                }
                   2399: 
                   2400:                if (last_valide == d_vrai)
                   2401:                {
                   2402:                    sf(s_etat_processus, 31);
                   2403:                }
                   2404: 
                   2405:                free(nom_x);
                   2406:                free(nom_fichier);
                   2407:                return;
                   2408:            }
                   2409: 
                   2410:            /*
                   2411:             * Evaluation de la fonction
                   2412:             */
                   2413: 
                   2414:            hauteur_pile = (*s_etat_processus).hauteur_pile_operationnelle;
                   2415:            l_position_normale = (*s_etat_processus).l_base_pile_systeme;
                   2416:            niveau_courant = (*s_etat_processus).niveau_courant;
                   2417: 
                   2418:            (*s_etat_processus).erreur_execution = d_ex;
                   2419:            (*s_etat_processus).exception = d_ep;
                   2420: 
1.19      bertrand 2421:            if (evaluation(s_etat_processus, (*(*s_etat_processus)
                   2422:                    .pointeur_variable_courante).objet, 'N') == d_erreur)
1.1       bertrand 2423:            {
                   2424:                if ((*s_etat_processus).erreur_systeme != d_es)
                   2425:                {
                   2426:                    /*
                   2427:                     * Erreur système
                   2428:                     */
                   2429: 
                   2430:                    free(nom_fichier);
                   2431:                    return;
                   2432:                }
                   2433:                else
                   2434:                {
                   2435:                    retour_suite_erreur = d_faux;
                   2436:                    (*s_etat_processus).niveau_courant = niveau_courant;
                   2437: 
                   2438:                    /*
                   2439:                     * Restauration de la pile initiale
                   2440:                     */
                   2441: 
                   2442:                    while((*s_etat_processus).hauteur_pile_operationnelle >
                   2443:                            (unsigned long) hauteur_pile)
                   2444:                    {
                   2445:                        if (depilement(s_etat_processus, &((*s_etat_processus)
                   2446:                                .l_base_pile), &s_objet) == d_erreur)
                   2447:                        {
                   2448:                            (*s_etat_processus).erreur_execution =
                   2449:                                    d_ex_manque_argument;
                   2450:                            retour_suite_erreur = d_vrai;
                   2451:                            break;
                   2452:                        }
                   2453: 
                   2454:                        liberation(s_etat_processus, s_objet);
                   2455:                    }
                   2456: 
                   2457:                    /*
                   2458:                     * Restauration de la pile système
                   2459:                     */
                   2460: 
                   2461:                    while((*s_etat_processus).l_base_pile_systeme !=
                   2462:                            l_position_normale)
                   2463:                    {
                   2464:                        depilement_pile_systeme(s_etat_processus);
                   2465: 
                   2466:                        if ((*s_etat_processus).erreur_systeme != d_es)
                   2467:                        {
                   2468:                            /*
                   2469:                             * Une pile vide provoque une erreur système
                   2470:                             */
                   2471: 
                   2472:                            free(nom_fichier);
                   2473:                            return;
                   2474:                        }
                   2475:                    }
                   2476: 
                   2477:                    if (retour_suite_erreur == d_vrai)
                   2478:                    {
                   2479:                        /*
                   2480:                         * Retrait de la variable INDEP et retour
                   2481:                         */
                   2482: 
                   2483:                        (*s_etat_processus).niveau_courant--;
                   2484: 
                   2485:                        if (fclose(fichier) != 0)
                   2486:                        {
                   2487:                            (*s_etat_processus).erreur_systeme =
                   2488:                                    d_es_erreur_fichier;
                   2489:                            return;
                   2490:                        }
                   2491: 
                   2492:                        if (destruction_fichier(nom_fichier) == d_erreur)
                   2493:                        {
                   2494:                            (*s_etat_processus).erreur_systeme =
                   2495:                                    d_es_erreur_fichier;
                   2496:                            return;
                   2497:                        }
                   2498: 
                   2499:                        if (retrait_variable(s_etat_processus,
                   2500:                                nom_x, 'L') == d_erreur)
                   2501:                        {
                   2502:                            if ((*s_etat_processus).erreur_systeme != d_es)
                   2503:                            {
                   2504:                                if ((*s_etat_processus).erreur_systeme ==
                   2505:                                        d_es_variable_introuvable)
                   2506:                                {
                   2507:                                    (*s_etat_processus).erreur_systeme =
                   2508:                                            d_es;
                   2509:                                }
                   2510:                                else
                   2511:                                {
                   2512: 
                   2513:                                /*
                   2514:                                 * Erreur système
                   2515:                                 */
                   2516: 
                   2517:                                    free(nom_fichier);
                   2518:                                    return;
                   2519:                                }
                   2520:                            }
                   2521: 
                   2522:                            (*s_etat_processus).erreur_execution =
                   2523:                                    d_ex_variable_non_definie;
                   2524:                        }
                   2525: 
                   2526:                        if (last_valide == d_vrai)
                   2527:                        {
                   2528:                            sf(s_etat_processus, 31);
                   2529:                        }
                   2530: 
                   2531:                        free(nom_x);
                   2532:                        free(nom_fichier);
                   2533:                        return;
                   2534:                    }
                   2535:                }
                   2536: 
                   2537:                (*s_etat_processus).erreur_execution = d_ex;
                   2538:                (*s_etat_processus).exception = d_ep;
                   2539:            }
                   2540:            else
                   2541:            {
                   2542:                /*
                   2543:                 * Donnée valide à écrire dans le fichier
                   2544:                 */
                   2545: 
                   2546:                if (depilement(s_etat_processus, &((*s_etat_processus)
                   2547:                        .l_base_pile), &s_objet) == d_erreur)
                   2548:                {
                   2549: 
                   2550:                    /*
                   2551:                     * Retrait de la variable INDEP et retour
                   2552:                     */
                   2553: 
                   2554:                    (*s_etat_processus).niveau_courant--;
                   2555: 
                   2556:                    if (fclose(fichier) != 0)
                   2557:                    {
                   2558:                        (*s_etat_processus).erreur_systeme =
                   2559:                                d_es_erreur_fichier;
                   2560:                        return;
                   2561:                    }
                   2562: 
                   2563:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   2564:                    {
                   2565:                        (*s_etat_processus).erreur_systeme =
                   2566:                                d_es_erreur_fichier;
                   2567:                        return;
                   2568:                    }
                   2569: 
                   2570:                    if (retrait_variable(s_etat_processus, nom_x,
                   2571:                            'L') == d_erreur)
                   2572:                    {
                   2573:                        if ((*s_etat_processus).erreur_systeme != d_es)
                   2574:                        {
                   2575:                            if ((*s_etat_processus).erreur_systeme ==
                   2576:                                    d_es_variable_introuvable)
                   2577:                            {
                   2578:                                (*s_etat_processus).erreur_systeme = d_es;
                   2579:                            }
                   2580:                            else
                   2581:                            {
                   2582: 
                   2583:                            /*
                   2584:                             * Erreur système
                   2585:                             */
                   2586: 
                   2587:                                free(nom_fichier);
                   2588:                                return;
                   2589:                            }
                   2590:                        }
                   2591: 
                   2592:                        free(nom_x);
                   2593:                        free(nom_fichier);
                   2594: 
                   2595:                        if (last_valide == d_vrai)
                   2596:                        {
                   2597:                            sf(s_etat_processus, 31);
                   2598:                        }
                   2599: 
                   2600:                        (*s_etat_processus).erreur_execution =
                   2601:                                d_ex_variable_non_definie;
                   2602:                        return;
                   2603:                    }
                   2604: 
                   2605:                    free(nom_x);
                   2606:                    free(nom_fichier);
                   2607: 
                   2608:                    if (last_valide == d_vrai)
                   2609:                    {
                   2610:                        sf(s_etat_processus, 31);
                   2611:                    }
                   2612: 
                   2613:                    (*s_etat_processus).erreur_execution = d_ex_manque_argument;
                   2614:                    return;
                   2615:                }
                   2616: 
                   2617:                if ((*s_objet).type == INT)
                   2618:                {
                   2619:                    x = (double) (*((integer8 *) (*s_objet).objet));
                   2620:                    y = 0;
                   2621: 
                   2622:                    if (fprintf(fichier, "%f %f\n", x, y) < 0)
                   2623:                    {
                   2624:                        (*s_etat_processus).erreur_systeme =
                   2625:                                d_es_erreur_fichier;
                   2626:                        return;
                   2627:                    }
                   2628:                }
                   2629:                else if ((*s_objet).type == REL)
                   2630:                {
                   2631:                    x = (double) (*((real8 *) (*s_objet).objet));
                   2632:                    y = 0;
                   2633: 
                   2634:                    if (fprintf(fichier, "%f %f\n", x, y) < 0)
                   2635:                    {
                   2636:                        (*s_etat_processus).erreur_systeme =
                   2637:                                d_es_erreur_fichier;
                   2638:                        return;
                   2639:                    }
                   2640:                }
                   2641:                else if ((*s_objet).type == CPL)
                   2642:                {
                   2643:                    x = (*((complex16 *) (*s_objet).objet)).partie_reelle;
                   2644:                    y = (*((complex16 *) (*s_objet).objet)).partie_imaginaire;
                   2645: 
                   2646:                    if (fprintf(fichier, "%f %f\n", x, y) < 0)
                   2647:                    {
                   2648:                        (*s_etat_processus).erreur_systeme =
                   2649:                                d_es_erreur_fichier;
                   2650:                        return;
                   2651:                    }
                   2652:                }
                   2653: 
                   2654:                liberation(s_etat_processus, s_objet);
                   2655:            }
                   2656:        }
                   2657: 
                   2658:        /*
                   2659:         * Retrait de la variable locale
                   2660:         */
                   2661: 
                   2662:        (*s_etat_processus).niveau_courant--;
                   2663: 
                   2664:        if (retrait_variable(s_etat_processus, nom_x, 'L') == d_erreur)
                   2665:        {
                   2666:            if ((*s_etat_processus).erreur_systeme != d_es)
                   2667:            {
                   2668:                if ((*s_etat_processus).erreur_systeme ==
                   2669:                        d_es_variable_introuvable)
                   2670:                {
                   2671:                    (*s_etat_processus).erreur_systeme = d_es;
                   2672:                }
                   2673:                else
                   2674:                {
                   2675:                    /*
                   2676:                     * Erreur système
                   2677:                     */
                   2678: 
                   2679:                    free(nom_fichier);
                   2680:                    return;
                   2681:                }
                   2682:            }
                   2683: 
                   2684:            free(nom_x);
                   2685:            free(nom_fichier);
                   2686: 
                   2687:            if (last_valide == d_vrai)
                   2688:            {
                   2689:                sf(s_etat_processus, 31);
                   2690:            }
                   2691: 
                   2692:            (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
                   2693:            return;
                   2694:        }
                   2695: 
                   2696:        free(nom_x);
                   2697:    }
                   2698: 
                   2699:    /*
                   2700:     * Tracé z=f(x,y)
                   2701:     * Les bornes de variation de X sont données dans l'ordre
                   2702:     * - soit sous la forme "{ X X_min X_max } INDEP" ;
                   2703:     * - soit par les parties réelles de PMIN et PMAX.
                   2704:     * Les bornes de variation de Y sont données dans l'ordre
                   2705:     * - soit sous la forme "{ Y Y_min Y_max } DEPND" ;
                   2706:     * - soit par les parties imaginaires de PMIN et PMAX.
                   2707:     * INDEP et DEPND testent leurs arguments pour que les pointeurs
                   2708:     * indep et depend désignent des objets de type NOM ou LST à
                   2709:     * trois éléments.
                   2710:     */
                   2711: 
                   2712:    else if ((strcmp((*s_etat_processus).type_trace_eq, "GRILLE 3D") == 0) ||
                   2713:            (strcmp((*s_etat_processus).type_trace_eq, "COURBES DE NIVEAU")
                   2714:            == 0))
                   2715:    {
                   2716:        premiere_iteration = d_vrai;
                   2717: 
                   2718:        /*
                   2719:         * Vérification de la présence de la variable globale EQ
                   2720:         */
                   2721:        
1.19      bertrand 2722:        if (recherche_variable_globale(s_etat_processus, "EQ") == d_faux)
1.1       bertrand 2723:        {
                   2724:            /*
                   2725:             * Aucune variable "EQ" n'existe.
                   2726:             */
                   2727: 
1.19      bertrand 2728:            if ((*s_etat_processus).erreur_execution == d_ex)
1.1       bertrand 2729:            {
1.19      bertrand 2730:                (*s_etat_processus).erreur_execution = d_ex_absence_equation;
1.1       bertrand 2731:            }
                   2732: 
1.19      bertrand 2733:            (*s_etat_processus).erreur_systeme = d_es;
1.1       bertrand 2734: 
                   2735:            return;
                   2736:        }
                   2737: 
                   2738:        /*
                   2739:         * Création du fichier graphique temporaire
                   2740:         */
                   2741: 
                   2742:        if ((nom_fichier = creation_nom_fichier(s_etat_processus,
                   2743:                (*s_etat_processus).chemin_fichiers_temporaires)) == NULL)
                   2744:        {
                   2745:            (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2746:            return;
                   2747:        }
                   2748: 
                   2749:        if ((fichier = fopen(nom_fichier, "w+")) == NULL)
                   2750:        {
                   2751:            (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2752:            return;
                   2753:        }
                   2754: 
                   2755:        /*
                   2756:         * Récupération du domaine de variation de x
                   2757:         */
                   2758: 
                   2759:        if ((*(*s_etat_processus).indep).type == LST)
                   2760:        {
                   2761:            l_element_courant = (*(*s_etat_processus).indep).objet;
                   2762: 
                   2763:            if ((s_variable_x.nom = malloc((strlen((*((struct_nom *)
                   2764:                    (*(*l_element_courant).donnee).objet)).nom) + 1) *
                   2765:                    sizeof(unsigned char))) == NULL)
                   2766:            {
                   2767:                if (fclose(fichier) != 0)
                   2768:                {
                   2769:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2770:                    return;
                   2771:                }
                   2772: 
                   2773:                if (destruction_fichier(nom_fichier) == d_erreur)
                   2774:                {
                   2775:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2776:                    return;
                   2777:                }
                   2778: 
                   2779:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2780:                return;
                   2781:            }
                   2782: 
                   2783:            strcpy(s_variable_x.nom, (*((struct_nom *) (*(*l_element_courant)
                   2784:                    .donnee).objet)).nom);
                   2785: 
                   2786:            if ((nom_x = malloc((strlen(s_variable_x.nom) + 1) *
                   2787:                    sizeof(unsigned char))) == NULL)
                   2788:            {
                   2789:                if (fclose(fichier) != 0)
                   2790:                {
                   2791:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2792:                    return;
                   2793:                }
                   2794: 
                   2795:                if (destruction_fichier(nom_fichier) == d_erreur)
                   2796:                {
                   2797:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   2798:                    return;
                   2799:                }
                   2800: 
                   2801:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   2802:                return;
                   2803:            }
                   2804: 
                   2805:            strcpy(nom_x, s_variable_x.nom);
                   2806: 
                   2807:            l_element_courant = (*l_element_courant).suivant;
                   2808: 
                   2809:            if ((*(*l_element_courant).donnee).type == INT)
                   2810:            {
                   2811:                borne_minimale_x = (real8) (*((integer8 *)
                   2812:                        (*(*l_element_courant).donnee).objet));
                   2813:            }
                   2814:            else if ((*(*l_element_courant).donnee).type == REL)
                   2815:            {
                   2816:                borne_minimale_x = (*((real8 *) (*(*l_element_courant)
                   2817:                        .donnee).objet));
                   2818:            }
                   2819:            else
                   2820:            {
                   2821:                if (evaluation(s_etat_processus, (*l_element_courant).donnee,
                   2822:                        'N') == d_erreur)
                   2823:                {
                   2824:                    free(s_variable_x.nom);
                   2825:                    free(nom_x);
                   2826: 
                   2827:                    if (fclose(fichier) != 0)
                   2828:                    {
                   2829:                        (*s_etat_processus).erreur_systeme =
                   2830:                                d_es_erreur_fichier;
                   2831:                        return;
                   2832:                    }
                   2833: 
                   2834:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   2835:                    {
                   2836:                        (*s_etat_processus).erreur_systeme =
                   2837:                                d_es_erreur_fichier;
                   2838:                        return;
                   2839:                    }
                   2840: 
                   2841:                    if (last_valide == d_vrai)
                   2842:                    {
                   2843:                        sf(s_etat_processus, 31);
                   2844:                    }
                   2845: 
                   2846:                    free(nom_fichier);
                   2847:                    return;
                   2848:                }
                   2849: 
                   2850:                if (depilement(s_etat_processus, &((*s_etat_processus)
                   2851:                        .l_base_pile), &s_objet_evalue) == d_erreur)
                   2852:                {
                   2853:                    free(s_variable_x.nom);
                   2854:                    free(nom_x);
                   2855: 
                   2856:                    if (fclose(fichier) != 0)
                   2857:                    {
                   2858:                        (*s_etat_processus).erreur_systeme =
                   2859:                                d_es_erreur_fichier;
                   2860:                        return;
                   2861:                    }
                   2862: 
                   2863:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   2864:                    {
                   2865:                        (*s_etat_processus).erreur_systeme =
                   2866:                                d_es_erreur_fichier;
                   2867:                        return;
                   2868:                    }
                   2869: 
                   2870:                    (*s_etat_processus).erreur_execution =
                   2871:                            d_ex_manque_argument;
                   2872: 
                   2873:                    if (last_valide == d_vrai)
                   2874:                    {
                   2875:                        sf(s_etat_processus, 31);
                   2876:                    }
                   2877: 
                   2878:                    free(nom_fichier);
                   2879:                    return;
                   2880:                }
                   2881: 
                   2882:                if ((*s_objet_evalue).type == INT)
                   2883:                {
                   2884:                    borne_minimale_x = (real8) (*((integer8 *)
                   2885:                            (*s_objet_evalue).objet));
                   2886:                }
                   2887:                else if ((*s_objet_evalue).type == REL)
                   2888:                {
                   2889:                    borne_minimale_x = (*((real8 *) (*s_objet_evalue).objet));
                   2890:                }
                   2891:                else
                   2892:                {
                   2893:                    if (fclose(fichier) != 0)
                   2894:                    {
                   2895:                        (*s_etat_processus).erreur_systeme =
                   2896:                                d_es_erreur_fichier;
                   2897:                        return;
                   2898:                    }
                   2899: 
                   2900:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   2901:                    {
                   2902:                        (*s_etat_processus).erreur_systeme =
                   2903:                                d_es_erreur_fichier;
                   2904:                        return;
                   2905:                    }
                   2906: 
                   2907:                    free(s_variable_x.nom);
                   2908:                    free(nom_x);
                   2909:                    free(nom_fichier);
                   2910:                    liberation(s_etat_processus, s_objet_evalue);
                   2911: 
                   2912:                    if (last_valide == d_vrai)
                   2913:                    {
                   2914:                        sf(s_etat_processus, 31);
                   2915:                    }
                   2916: 
                   2917:                    (*s_etat_processus).erreur_execution =
                   2918:                            d_ex_erreur_type_argument;
                   2919:                    return;
                   2920:                }
                   2921: 
                   2922:                liberation(s_etat_processus, s_objet_evalue);
                   2923:            }
                   2924: 
                   2925:            l_element_courant = (*l_element_courant).suivant;
                   2926: 
                   2927:            if ((*(*l_element_courant).donnee).type == INT)
                   2928:            {
                   2929:                borne_maximale_x = (real8) (*((integer8 *)
                   2930:                        (*(*l_element_courant).donnee).objet));
                   2931:            }
                   2932:            else if ((*(*l_element_courant).donnee).type == REL)
                   2933:            {
                   2934:                borne_maximale_x = (*((real8 *) (*(*l_element_courant)
                   2935:                        .donnee).objet));
                   2936:            }
                   2937:            else
                   2938:            {
                   2939:                if (evaluation(s_etat_processus, (*l_element_courant).donnee,
                   2940:                        'N') == d_erreur)
                   2941:                {
                   2942:                    free(s_variable_x.nom);
                   2943:                    free(nom_x);
                   2944: 
                   2945:                    if (fclose(fichier) != 0)
                   2946:                    {
                   2947:                        (*s_etat_processus).erreur_systeme =
                   2948:                                d_es_erreur_fichier;
                   2949:                        return;
                   2950:                    }
                   2951: 
                   2952:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   2953:                    {
                   2954:                        (*s_etat_processus).erreur_systeme =
                   2955:                                d_es_erreur_fichier;
                   2956:                        return;
                   2957:                    }
                   2958: 
                   2959:                    if (last_valide == d_vrai)
                   2960:                    {
                   2961:                        sf(s_etat_processus, 31);
                   2962:                    }
                   2963: 
                   2964:                    free(nom_fichier);
                   2965:                    return;
                   2966:                }
                   2967: 
                   2968:                if (depilement(s_etat_processus, &((*s_etat_processus)
                   2969:                        .l_base_pile), &s_objet_evalue) == d_erreur)
                   2970:                {
                   2971:                    free(s_variable_x.nom);
                   2972:                    free(nom_x);
                   2973: 
                   2974:                    if (fclose(fichier) != 0)
                   2975:                    {
                   2976:                        (*s_etat_processus).erreur_systeme =
                   2977:                                d_es_erreur_fichier;
                   2978:                        return;
                   2979:                    }
                   2980: 
                   2981:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   2982:                    {
                   2983:                        (*s_etat_processus).erreur_systeme =
                   2984:                                d_es_erreur_fichier;
                   2985:                        return;
                   2986:                    }
                   2987: 
                   2988:                    (*s_etat_processus).erreur_execution =
                   2989:                            d_ex_manque_argument;
                   2990: 
                   2991:                    if (last_valide == d_vrai)
                   2992:                    {
                   2993:                        sf(s_etat_processus, 31);
                   2994:                    }
                   2995: 
                   2996:                    free(nom_fichier);
                   2997:                    return;
                   2998:                }
                   2999: 
                   3000:                if ((*s_objet_evalue).type == INT)
                   3001:                {
                   3002:                    borne_maximale_x = (real8) (*((integer8 *)
                   3003:                            (*s_objet_evalue).objet));
                   3004:                }
                   3005:                else if ((*s_objet_evalue).type == REL)
                   3006:                {
                   3007:                    borne_maximale_x = (*((real8 *) (*s_objet_evalue).objet));
                   3008:                }
                   3009:                else
                   3010:                {
                   3011:                    free(s_variable_x.nom);
                   3012:                    free(nom_x);
                   3013: 
                   3014:                    if (fclose(fichier) != 0)
                   3015:                    {
                   3016:                        (*s_etat_processus).erreur_systeme =
                   3017:                                d_es_erreur_fichier;
                   3018:                        return;
                   3019:                    }
                   3020: 
                   3021:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   3022:                    {
                   3023:                        (*s_etat_processus).erreur_systeme =
                   3024:                                d_es_erreur_fichier;
                   3025:                        return;
                   3026:                    }
                   3027: 
                   3028:                    liberation(s_etat_processus, s_objet_evalue);
                   3029: 
                   3030:                    (*s_etat_processus).erreur_execution =
                   3031:                            d_ex_erreur_type_argument;
                   3032: 
                   3033:                    if (last_valide == d_vrai)
                   3034:                    {
                   3035:                        sf(s_etat_processus, 31);
                   3036:                    }
                   3037: 
                   3038:                    free(nom_fichier);
                   3039:                    return;
                   3040:                }
                   3041: 
                   3042:                liberation(s_etat_processus, s_objet_evalue);
                   3043:            }
                   3044:        }
                   3045:        else
                   3046:        {
                   3047:            if ((s_variable_x.nom =
                   3048:                    malloc((strlen((*((struct_nom *) (*(*s_etat_processus)
                   3049:                    .indep).objet)).nom) + 1) * sizeof(unsigned char))) == NULL)
                   3050:            {
                   3051:                if (fclose(fichier) != 0)
                   3052:                {
                   3053:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   3054:                    return;
                   3055:                }
                   3056: 
                   3057:                if (destruction_fichier(nom_fichier) == d_erreur)
                   3058:                {
                   3059:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   3060:                    return;
                   3061:                }
                   3062: 
                   3063:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3064:                return;
                   3065:            }
                   3066: 
                   3067:            strcpy(s_variable_x.nom, (*((struct_nom *) (*(*s_etat_processus)
                   3068:                    .indep).objet)).nom);
                   3069: 
                   3070:            if ((nom_x = malloc((strlen(s_variable_x.nom) + 1) *
                   3071:                    sizeof(unsigned char))) == NULL)
                   3072:            {
                   3073:                if (fclose(fichier) != 0)
                   3074:                {
                   3075:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   3076:                    return;
                   3077:                }
                   3078: 
                   3079:                if (destruction_fichier(nom_fichier) == d_erreur)
                   3080:                {
                   3081:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   3082:                    return;
                   3083:                }
                   3084: 
                   3085:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3086:                return;
                   3087:            }
                   3088: 
                   3089:            strcpy(nom_x, s_variable_x.nom);
                   3090: 
                   3091:            if ((*s_etat_processus).systeme_axes == 0)
                   3092:            {
                   3093:                borne_minimale_x = (*s_etat_processus).x_min;
                   3094:                borne_maximale_x = (*s_etat_processus).x_max;
                   3095:            }
                   3096:            else
                   3097:            {
                   3098:                borne_minimale_x = (*s_etat_processus).x2_min;
                   3099:                borne_maximale_x = (*s_etat_processus).x2_max;
                   3100:            }
                   3101:        }
                   3102: 
                   3103:        /*
                   3104:         * Création d'une variable locale du nom pointé par INDEP
                   3105:         */
                   3106: 
                   3107:        (*s_etat_processus).niveau_courant++;
                   3108:        s_variable_x.niveau = (*s_etat_processus).niveau_courant;
                   3109: 
                   3110:        if ((s_variable_x.objet = allocation(s_etat_processus, REL)) == NULL)
                   3111:        {
                   3112:            if (fclose(fichier) != 0)
                   3113:            {
                   3114:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   3115:                return;
                   3116:            }
                   3117: 
                   3118:            if (destruction_fichier(nom_fichier) == d_erreur)
                   3119:            {
                   3120:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   3121:                return;
                   3122:            }
                   3123: 
                   3124:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3125:            return;
                   3126:        }
                   3127: 
                   3128:        if (creation_variable(s_etat_processus, &s_variable_x, 'V', 'P')
                   3129:                == d_erreur)
                   3130:        {
                   3131:            if (fclose(fichier) != 0)
                   3132:            {
                   3133:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   3134:                return;
                   3135:            }
                   3136: 
                   3137:            if (destruction_fichier(nom_fichier) == d_erreur)
                   3138:            {
                   3139:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   3140:                return;
                   3141:            }
                   3142: 
                   3143:            /*
                   3144:             * L'erreur retournée ne peut être qu'une erreur système
                   3145:             */
                   3146: 
                   3147:            free(nom_fichier);
                   3148:            return;
                   3149:        }
                   3150: 
                   3151:        /*
                   3152:         * Boucle de calcul des points de la fonction
                   3153:         */
                   3154: 
                   3155:        if (borne_maximale_x < borne_minimale_x)
                   3156:        {
                   3157:            x = borne_maximale_x;
                   3158:            borne_maximale_x = borne_minimale_x;
                   3159:            borne_minimale_x = x;
                   3160:        }
                   3161: 
                   3162:        dernier_point_valide[0] = 0;
                   3163:        dernier_point_valide[1] = 0;
                   3164:        dernier_point_valide[2] = 0;
                   3165: 
                   3166:        for(x = borne_minimale_x; x <= borne_maximale_x;
                   3167:                x += (*s_etat_processus).resolution)
                   3168:        {
                   3169:            /*
                   3170:             * Récupération du domaine de variation de y, celui-ci peut dépendre
                   3171:             * du domaine de variation de x.
                   3172:             */
                   3173: 
                   3174:            if ((*(*s_etat_processus).depend).type == LST)
                   3175:            {
                   3176:                l_element_courant = (*(*s_etat_processus).depend).objet;
                   3177: 
                   3178:                if ((s_variable_y.nom = malloc((strlen((*((struct_nom *)
                   3179:                        (*(*l_element_courant).donnee).objet)).nom) + 1) *
                   3180:                        sizeof(unsigned char))) == NULL)
                   3181:                {
                   3182:                    if (fclose(fichier) != 0)
                   3183:                    {
                   3184:                        (*s_etat_processus).erreur_systeme =
                   3185:                                d_es_erreur_fichier;
                   3186:                        return;
                   3187:                    }
                   3188: 
                   3189:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   3190:                    {
                   3191:                        (*s_etat_processus).erreur_systeme =
                   3192:                                d_es_erreur_fichier;
                   3193:                        return;
                   3194:                    }
                   3195: 
                   3196:                    (*s_etat_processus).erreur_systeme =
                   3197:                            d_es_allocation_memoire;
                   3198:                    return;
                   3199:                }
                   3200: 
                   3201:                strcpy(s_variable_y.nom, (*((struct_nom *)
                   3202:                        (*(*l_element_courant).donnee).objet)).nom);
                   3203: 
                   3204:                if ((nom_y = malloc((strlen(s_variable_y.nom) + 1) *
                   3205:                        sizeof(unsigned char))) == NULL)
                   3206:                {
                   3207:                    if (fclose(fichier) != 0)
                   3208:                    {
                   3209:                        (*s_etat_processus).erreur_systeme =
                   3210:                                d_es_erreur_fichier;
                   3211:                        return;
                   3212:                    }
                   3213: 
                   3214:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   3215:                    {
                   3216:                        (*s_etat_processus).erreur_systeme =
                   3217:                                d_es_erreur_fichier;
                   3218:                        return;
                   3219:                    }
                   3220: 
                   3221:                    (*s_etat_processus).erreur_systeme =
                   3222:                            d_es_allocation_memoire;
                   3223:                    return;
                   3224:                }
                   3225: 
                   3226:                strcpy(nom_y, s_variable_y.nom);
                   3227: 
                   3228:                l_element_courant = (*l_element_courant).suivant;
                   3229: 
                   3230:                if ((*(*l_element_courant).donnee).type == INT)
                   3231:                {
                   3232:                    borne_minimale_y = (real8) (*((integer8 *)
                   3233:                            (*(*l_element_courant).donnee).objet));
                   3234:                }
                   3235:                else if ((*(*l_element_courant).donnee).type == REL)
                   3236:                {
                   3237:                    borne_minimale_y = (*((real8 *) (*(*l_element_courant)
                   3238:                            .donnee).objet));
                   3239:                }
                   3240:                else
                   3241:                {
                   3242:                    if (evaluation(s_etat_processus,
                   3243:                            (*l_element_courant).donnee, 'N') == d_erreur)
                   3244:                    {
                   3245:                        free(s_variable_y.nom);
                   3246:                        free(nom_y);
                   3247: 
                   3248:                        free(s_variable_x.nom);
                   3249:                        free(nom_x);
                   3250: 
                   3251:                        if (fclose(fichier) != 0)
                   3252:                        {
                   3253:                            (*s_etat_processus).erreur_systeme =
                   3254:                                    d_es_erreur_fichier;
                   3255:                            return;
                   3256:                        }
                   3257: 
                   3258:                        if (destruction_fichier(nom_fichier) == d_erreur)
                   3259:                        {
                   3260:                            (*s_etat_processus).erreur_systeme =
                   3261:                                    d_es_erreur_fichier;
                   3262:                            return;
                   3263:                        }
                   3264: 
                   3265:                        if (last_valide == d_vrai)
                   3266:                        {
                   3267:                            sf(s_etat_processus, 31);
                   3268:                        }
                   3269: 
                   3270:                        free(nom_fichier);
                   3271:                        return;
                   3272:                    }
                   3273: 
                   3274:                    if (depilement(s_etat_processus, &((*s_etat_processus)
                   3275:                            .l_base_pile), &s_objet_evalue) == d_erreur)
                   3276:                    {
                   3277:                        free(s_variable_y.nom);
                   3278:                        free(nom_y);
                   3279: 
                   3280:                        free(s_variable_x.nom);
                   3281:                        free(nom_x);
                   3282: 
                   3283:                        if (fclose(fichier) != 0)
                   3284:                        {
                   3285:                            (*s_etat_processus).erreur_systeme =
                   3286:                                    d_es_erreur_fichier;
                   3287:                            return;
                   3288:                        }
                   3289: 
                   3290:                        if (destruction_fichier(nom_fichier) == d_erreur)
                   3291:                        {
                   3292:                            (*s_etat_processus).erreur_systeme =
                   3293:                                    d_es_erreur_fichier;
                   3294:                            return;
                   3295:                        }
                   3296: 
                   3297:                        (*s_etat_processus).erreur_execution =
                   3298:                                d_ex_manque_argument;
                   3299: 
                   3300:                        if (last_valide == d_vrai)
                   3301:                        {
                   3302:                            sf(s_etat_processus, 31);
                   3303:                        }
                   3304: 
                   3305:                        free(nom_fichier);
                   3306:                        return;
                   3307:                    }
                   3308: 
                   3309:                    if ((*s_objet_evalue).type == INT)
                   3310:                    {
                   3311:                        borne_minimale_y = (real8) (*((integer8 *)
                   3312:                                (*s_objet_evalue).objet));
                   3313:                    }
                   3314:                    else if ((*s_objet_evalue).type == REL)
                   3315:                    {
                   3316:                        borne_minimale_y = (*((real8 *)
                   3317:                                (*s_objet_evalue).objet));
                   3318:                    }
                   3319:                    else
                   3320:                    {
                   3321:                        if (fclose(fichier) != 0)
                   3322:                        {
                   3323:                            (*s_etat_processus).erreur_systeme =
                   3324:                                    d_es_erreur_fichier;
                   3325:                            return;
                   3326:                        }
                   3327: 
                   3328:                        if (destruction_fichier(nom_fichier) == d_erreur)
                   3329:                        {
                   3330:                            (*s_etat_processus).erreur_systeme =
                   3331:                                    d_es_erreur_fichier;
                   3332:                            return;
                   3333:                        }
                   3334: 
                   3335:                        free(s_variable_y.nom);
                   3336:                        free(nom_y);
                   3337:                        free(s_variable_x.nom);
                   3338:                        free(nom_x);
                   3339:                        free(nom_fichier);
                   3340:                        liberation(s_etat_processus, s_objet_evalue);
                   3341: 
                   3342:                        if (last_valide == d_vrai)
                   3343:                        {
                   3344:                            sf(s_etat_processus, 31);
                   3345:                        }
                   3346: 
                   3347:                        (*s_etat_processus).erreur_execution =
                   3348:                                d_ex_erreur_type_argument;
                   3349:                        return;
                   3350:                    }
                   3351: 
                   3352:                    liberation(s_etat_processus, s_objet_evalue);
                   3353:                }
                   3354: 
                   3355:                l_element_courant = (*l_element_courant).suivant;
                   3356: 
                   3357:                if ((*(*l_element_courant).donnee).type == INT)
                   3358:                {
                   3359:                    borne_maximale_y = (real8) (*((integer8 *)
                   3360:                            (*(*l_element_courant).donnee).objet));
                   3361:                }
                   3362:                else if ((*(*l_element_courant).donnee).type == REL)
                   3363:                {
                   3364:                    borne_maximale_y = (*((real8 *) (*(*l_element_courant)
                   3365:                            .donnee).objet));
                   3366:                }
                   3367:                else
                   3368:                {
                   3369:                    if (evaluation(s_etat_processus,
                   3370:                            (*l_element_courant).donnee, 'N') == d_erreur)
                   3371:                    {
                   3372:                        free(s_variable_y.nom);
                   3373:                        free(nom_y);
                   3374:                        free(s_variable_x.nom);
                   3375:                        free(nom_x);
                   3376: 
                   3377:                        if (fclose(fichier) != 0)
                   3378:                        {
                   3379:                            (*s_etat_processus).erreur_systeme =
                   3380:                                    d_es_erreur_fichier;
                   3381:                            return;
                   3382:                        }
                   3383: 
                   3384:                        if (destruction_fichier(nom_fichier) == d_erreur)
                   3385:                        {
                   3386:                            (*s_etat_processus).erreur_systeme =
                   3387:                                    d_es_erreur_fichier;
                   3388:                            return;
                   3389:                        }
                   3390: 
                   3391:                        if (last_valide == d_vrai)
                   3392:                        {
                   3393:                            sf(s_etat_processus, 31);
                   3394:                        }
                   3395: 
                   3396:                        free(nom_fichier);
                   3397:                        return;
                   3398:                    }
                   3399: 
                   3400:                    if (depilement(s_etat_processus, &((*s_etat_processus)
                   3401:                            .l_base_pile), &s_objet_evalue) == d_erreur)
                   3402:                    {
                   3403:                        free(s_variable_y.nom);
                   3404:                        free(nom_y);
                   3405:                        free(s_variable_x.nom);
                   3406:                        free(nom_x);
                   3407: 
                   3408:                        if (fclose(fichier) != 0)
                   3409:                        {
                   3410:                            (*s_etat_processus).erreur_systeme =
                   3411:                                    d_es_erreur_fichier;
                   3412:                            return;
                   3413:                        }
                   3414: 
                   3415:                        if (destruction_fichier(nom_fichier) == d_erreur)
                   3416:                        {
                   3417:                            (*s_etat_processus).erreur_systeme =
                   3418:                                    d_es_erreur_fichier;
                   3419:                            return;
                   3420:                        }
                   3421: 
                   3422:                        (*s_etat_processus).erreur_execution =
                   3423:                                d_ex_manque_argument;
                   3424: 
                   3425:                        if (last_valide == d_vrai)
                   3426:                        {
                   3427:                            sf(s_etat_processus, 31);
                   3428:                        }
                   3429: 
                   3430:                        free(nom_fichier);
                   3431:                        return;
                   3432:                    }
                   3433: 
                   3434:                    if ((*s_objet_evalue).type == INT)
                   3435:                    {
                   3436:                        borne_maximale_y = (real8) (*((integer8 *)
                   3437:                                (*s_objet_evalue).objet));
                   3438:                    }
                   3439:                    else if ((*s_objet_evalue).type == REL)
                   3440:                    {
                   3441:                        borne_maximale_y = (*((real8 *)
                   3442:                                (*s_objet_evalue).objet));
                   3443:                    }
                   3444:                    else
                   3445:                    {
                   3446:                        free(s_variable_y.nom);
                   3447:                        free(nom_y);
                   3448:                        free(s_variable_x.nom);
                   3449:                        free(nom_x);
                   3450: 
                   3451:                        if (fclose(fichier) != 0)
                   3452:                        {
                   3453:                            (*s_etat_processus).erreur_systeme =
                   3454:                                    d_es_erreur_fichier;
                   3455:                            return;
                   3456:                        }
                   3457: 
                   3458:                        if (destruction_fichier(nom_fichier) == d_erreur)
                   3459:                        {
                   3460:                            (*s_etat_processus).erreur_systeme =
                   3461:                                    d_es_erreur_fichier;
                   3462:                            return;
                   3463:                        }
                   3464: 
                   3465:                        liberation(s_etat_processus, s_objet_evalue);
                   3466: 
                   3467:                        (*s_etat_processus).erreur_execution =
                   3468:                                d_ex_erreur_type_argument;
                   3469: 
                   3470:                        if (last_valide == d_vrai)
                   3471:                        {
                   3472:                            sf(s_etat_processus, 31);
                   3473:                        }
                   3474: 
                   3475:                        free(nom_fichier);
                   3476:                        return;
                   3477:                    }
                   3478: 
                   3479:                    liberation(s_etat_processus, s_objet_evalue);
                   3480:                }
                   3481:            }
                   3482:            else
                   3483:            {
                   3484:                if ((s_variable_y.nom =
                   3485:                        malloc((strlen((*((struct_nom *) (*(*s_etat_processus)
                   3486:                        .depend).objet)).nom) + 1) * sizeof(unsigned char)))
                   3487:                        == NULL)
                   3488:                {
                   3489:                    if (fclose(fichier) != 0)
                   3490:                    {
                   3491:                        (*s_etat_processus).erreur_systeme =
                   3492:                                d_es_erreur_fichier;
                   3493:                        return;
                   3494:                    }
                   3495: 
                   3496:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   3497:                    {
                   3498:                        (*s_etat_processus).erreur_systeme =
                   3499:                                d_es_erreur_fichier;
                   3500:                        return;
                   3501:                    }
                   3502: 
                   3503:                    (*s_etat_processus).erreur_systeme =
                   3504:                            d_es_allocation_memoire;
                   3505:                    return;
                   3506:                }
                   3507: 
                   3508:                strcpy(s_variable_y.nom, (*((struct_nom *) (*(*s_etat_processus)
                   3509:                        .depend).objet)).nom);
                   3510: 
                   3511:                if ((nom_y = malloc((strlen(s_variable_y.nom) + 1) *
                   3512:                        sizeof(unsigned char))) == NULL)
                   3513:                {
                   3514:                    if (fclose(fichier) != 0)
                   3515:                    {
                   3516:                        (*s_etat_processus).erreur_systeme =
                   3517:                                d_es_erreur_fichier;
                   3518:                        return;
                   3519:                    }
                   3520: 
                   3521:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   3522:                    {
                   3523:                        (*s_etat_processus).erreur_systeme =
                   3524:                                d_es_erreur_fichier;
                   3525:                        return;
                   3526:                    }
                   3527: 
                   3528:                    (*s_etat_processus).erreur_systeme =
                   3529:                            d_es_allocation_memoire;
                   3530:                    return;
                   3531:                }
                   3532: 
                   3533:                strcpy(nom_y, s_variable_y.nom);
                   3534: 
                   3535:                if ((*s_etat_processus).systeme_axes == 0)
                   3536:                {
                   3537:                    borne_minimale_y = (*s_etat_processus).y_min;
                   3538:                    borne_maximale_y = (*s_etat_processus).y_max;
                   3539:                }
                   3540:                else
                   3541:                {
                   3542:                    borne_minimale_y = (*s_etat_processus).y2_min;
                   3543:                    borne_maximale_y = (*s_etat_processus).y2_max;
                   3544:                }
                   3545:            }
                   3546: 
                   3547:            /*
                   3548:             * Création d'une variable locale du nom pointé par DEPEND
                   3549:             */
                   3550: 
                   3551:            s_variable_y.niveau = (*s_etat_processus).niveau_courant;
                   3552: 
                   3553:            if ((s_variable_y.objet = allocation(s_etat_processus, REL))
                   3554:                    == NULL)
                   3555:            {
                   3556:                if (fclose(fichier) != 0)
                   3557:                {
                   3558:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   3559:                    return;
                   3560:                }
                   3561: 
                   3562:                if (destruction_fichier(nom_fichier) == d_erreur)
                   3563:                {
                   3564:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   3565:                    return;
                   3566:                }
                   3567: 
                   3568:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   3569:                return;
                   3570:            }
                   3571: 
                   3572:            if (creation_variable(s_etat_processus, &s_variable_y, 'V', 'P')
                   3573:                    == d_erreur)
                   3574:            {
                   3575:                if (fclose(fichier) != 0)
                   3576:                {
                   3577:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   3578:                    return;
                   3579:                }
                   3580: 
                   3581:                if (destruction_fichier(nom_fichier) == d_erreur)
                   3582:                {
                   3583:                    (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   3584:                    return;
                   3585:                }
                   3586: 
                   3587:                /*
                   3588:                 * L'erreur retournée ne peut être qu'une erreur système
                   3589:                 */
                   3590: 
                   3591:                free(nom_fichier);
                   3592:                return;
                   3593:            }
                   3594: 
                   3595:            if (borne_maximale_y < borne_minimale_y)
                   3596:            {
                   3597:                y = borne_maximale_y;
                   3598:                borne_maximale_y = borne_minimale_y;
                   3599:                borne_minimale_y = y;
                   3600:            }
                   3601: 
                   3602:            if (premiere_iteration == d_vrai)
                   3603:            {
                   3604:                dernier_point_valide[0] = borne_minimale_x;
                   3605:                dernier_point_valide[1] = borne_minimale_y;
                   3606:                dernier_point_valide[2] = 0;
                   3607: 
                   3608:                premiere_iteration = d_faux;
                   3609:            }
                   3610: 
                   3611:            for(y = borne_minimale_y; y <= borne_maximale_y;
                   3612:                    y += (*s_etat_processus).resolution)
                   3613:            {
                   3614:                if (recherche_variable(s_etat_processus, nom_x) == d_vrai)
                   3615:                {
                   3616:                    // La variable étant créée localement, elle n'est jamais
                   3617:                    // ni verrouillée ni partagee.
                   3618: 
1.19      bertrand 3619:                    BUG((*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand 3620:                            .objet == NULL);
                   3621: 
1.19      bertrand 3622:                    if ((*(*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand 3623:                            .objet).type != REL)
                   3624:                    {
                   3625:                        liberation(s_etat_processus,
1.19      bertrand 3626:                                (*(*s_etat_processus)
                   3627:                                .pointeur_variable_courante).objet);
                   3628: 
                   3629:                        if (((*(*s_etat_processus).pointeur_variable_courante)
                   3630:                                .objet = allocation(s_etat_processus, REL))
                   3631:                                == NULL)
1.1       bertrand 3632:                        {
                   3633:                            (*s_etat_processus).erreur_systeme =
                   3634:                                    d_es_allocation_memoire;
                   3635:                            return;
                   3636:                        }
                   3637:                    }
                   3638: 
1.19      bertrand 3639:                    (*((real8 *) (*(*(*s_etat_processus)
                   3640:                            .pointeur_variable_courante).objet).objet)) = x;
1.1       bertrand 3641:                }
                   3642:                else
                   3643:                {
                   3644:                    /*
                   3645:                     * La variable créée étant locale, l'utilisateur ne peut
                   3646:                     * pas l'effacer. On ne doit donc jamais passer par ici. Si
                   3647:                     * c'est néanmoins le cas, une erreur système est générée
                   3648:                     * provoquant l'arrêt du programme même dans une
                   3649:                     * structure IFERR.
                   3650:                     */
                   3651: 
                   3652:                    if (fclose(fichier) != 0)
                   3653:                    {
                   3654:                        (*s_etat_processus).erreur_systeme =
                   3655:                                d_es_erreur_fichier;
                   3656:                        return;
                   3657:                    }
                   3658: 
                   3659:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   3660:                    {
                   3661:                        (*s_etat_processus).erreur_systeme =
                   3662:                                d_es_erreur_fichier;
                   3663:                        return;
                   3664:                    }
                   3665: 
                   3666:                    if (last_valide == d_vrai)
                   3667:                    {
                   3668:                        sf(s_etat_processus, 31);
                   3669:                    }
                   3670: 
                   3671:                    free(nom_fichier);
                   3672:                    return;
                   3673:                }
                   3674: 
                   3675:                if (recherche_variable(s_etat_processus, nom_y) == d_vrai)
                   3676:                {
                   3677:                    // La variable étant créée localement, elle n'est jamais
                   3678:                    // ni verrouillée ni partagée.
                   3679: 
1.19      bertrand 3680:                    BUG((*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand 3681:                            .objet == NULL);
                   3682: 
1.19      bertrand 3683:                    if ((*(*(*s_etat_processus).pointeur_variable_courante)
1.1       bertrand 3684:                            .objet).type != REL)
                   3685:                    {
1.19      bertrand 3686:                        liberation(s_etat_processus, (*(*s_etat_processus)
                   3687:                                .pointeur_variable_courante).objet);
                   3688: 
                   3689:                        if (((*(*s_etat_processus).pointeur_variable_courante)
                   3690:                                .objet = allocation(s_etat_processus, REL))
                   3691:                                == NULL)
1.1       bertrand 3692:                        {
                   3693:                            (*s_etat_processus).erreur_systeme =
                   3694:                                    d_es_allocation_memoire;
                   3695:                            return;
                   3696:                        }
                   3697:                    }
                   3698: 
1.19      bertrand 3699:                    (*((real8 *) (*(*(*s_etat_processus)
                   3700:                            .pointeur_variable_courante).objet).objet)) = y;
1.1       bertrand 3701:                }
                   3702:                else
                   3703:                {
                   3704:                    /*
                   3705:                     * La variable créée étant locale, l'utilisateur ne peut
                   3706:                     * pas l'effacer. On ne doit donc jamais passer par ici. Si
                   3707:                     * c'est néanmoins le cas, une erreur système est générée
                   3708:                     * provoquant l'arrêt du programme même dans une
                   3709:                     * structure IFERR.
                   3710:                     */
                   3711: 
                   3712:                    if (fclose(fichier) != 0)
                   3713:                    {
                   3714:                        (*s_etat_processus).erreur_systeme =
                   3715:                                d_es_erreur_fichier;
                   3716:                        return;
                   3717:                    }
                   3718: 
                   3719:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   3720:                    {
                   3721:                        (*s_etat_processus).erreur_systeme =
                   3722:                                d_es_erreur_fichier;
                   3723:                        return;
                   3724:                    }
                   3725: 
                   3726:                    if (last_valide == d_vrai)
                   3727:                    {
                   3728:                        sf(s_etat_processus, 31);
                   3729:                    }
                   3730: 
                   3731:                    free(nom_fichier);
                   3732:                    return;
                   3733:                }
                   3734: 
1.19      bertrand 3735:                if (recherche_variable_globale(s_etat_processus, "EQ")
1.1       bertrand 3736:                        == d_faux)
                   3737:                {
                   3738:                    /*
                   3739:                     * Aucune variable "EQ" n'existe.
                   3740:                     */
                   3741: 
                   3742:                    (*s_etat_processus).erreur_execution =
                   3743:                            d_ex_variable_non_definie;
                   3744: 
                   3745:                    /*
                   3746:                     * Retrait des variables INDEP et DEPND
                   3747:                     */
                   3748: 
                   3749:                    (*s_etat_processus).niveau_courant--;
                   3750: 
                   3751:                    if (fclose(fichier) != 0)
                   3752:                    {
                   3753:                        (*s_etat_processus).erreur_systeme =
                   3754:                                d_es_erreur_fichier;
                   3755:                        return;
                   3756:                    }
                   3757: 
                   3758:                    if (destruction_fichier(nom_fichier) == d_erreur)
                   3759:                    {
                   3760:                        (*s_etat_processus).erreur_systeme =
                   3761:                                d_es_erreur_fichier;
                   3762:                        return;
                   3763:                    }
                   3764: 
                   3765:                    if (retrait_variable(s_etat_processus, nom_x, 'L')
                   3766:                            == d_erreur)
                   3767:                    {
                   3768:                        if ((*s_etat_processus).erreur_systeme != d_es)
                   3769:                        {
                   3770:                            if ((*s_etat_processus).erreur_systeme ==
                   3771:                                    d_es_variable_introuvable)
                   3772:                            {
                   3773:                                (*s_etat_processus).erreur_systeme = d_es;
                   3774:                            }
                   3775:                            else
                   3776:                            {
                   3777: 
                   3778:                            /*
                   3779:                             * Erreur système
                   3780:                             */
                   3781: 
                   3782:                                free(nom_fichier);
                   3783:                                return;
                   3784:                            }
                   3785:                        }
                   3786: 
                   3787:                        free(nom_x);
                   3788:                        free(nom_y);
                   3789:                        free(nom_fichier);
                   3790: 
                   3791:                        if (last_valide == d_vrai)
                   3792:                        {
                   3793:                            sf(s_etat_processus, 31);
                   3794:                        }
                   3795: 
                   3796:                        (*s_etat_processus).erreur_execution =
                   3797:                                d_ex_variable_non_definie;
                   3798:                        return;
                   3799:                    }
                   3800: 
                   3801:                    if (retrait_variable(s_etat_processus, nom_y, 'L')
                   3802:                            == d_erreur)
                   3803:                    {
                   3804:                        if ((*s_etat_processus).erreur_systeme != d_es)
                   3805:                        {
                   3806:                            if ((*s_etat_processus).erreur_systeme ==
                   3807:                                    d_es_variable_introuvable)
                   3808:                            {
                   3809:                                (*s_etat_processus).erreur_systeme = d_es;
                   3810:                            }
                   3811:                            else
                   3812:                            {
                   3813: 
                   3814:                            /*
                   3815:                             * Erreur système
                   3816:                             */
                   3817: 
                   3818:                                free(nom_fichier);
                   3819:                                return;
                   3820:                            }
                   3821:                        }
                   3822: 
                   3823:                        free(nom_x);
                   3824:                        free(nom_y);
                   3825:                        free(nom_fichier);
                   3826: 
                   3827:                        if (last_valide == d_vrai)
                   3828:                        {
                   3829:                            sf(s_etat_processus, 31);
                   3830:                        }
                   3831: 
                   3832:                        (*s_etat_processus).erreur_execution =
                   3833:                                d_ex_variable_non_definie;
                   3834:                        return;
                   3835:                    }
                   3836: 
                   3837:                    if (last_valide == d_vrai)
                   3838:                    {
                   3839:                        sf(s_etat_processus, 31);
                   3840:                    }
                   3841: 
                   3842:                    free(nom_x);
                   3843:                    free(nom_y);
                   3844:                    free(nom_fichier);
                   3845:                    return;
                   3846:                }
                   3847: 
                   3848:                /*
                   3849:                 * Evaluation de la fonction
                   3850:                 */
                   3851: 
                   3852:                hauteur_pile = (*s_etat_processus).hauteur_pile_operationnelle;
                   3853:                l_position_normale = (*s_etat_processus).l_base_pile_systeme;
                   3854:                niveau_courant = (*s_etat_processus).niveau_courant;
                   3855: 
                   3856:                (*s_etat_processus).erreur_execution = d_ex;
                   3857:                (*s_etat_processus).exception = d_ep;
                   3858: 
1.19      bertrand 3859:                if (evaluation(s_etat_processus, (*(*s_etat_processus)
                   3860:                        .pointeur_variable_courante).objet, 'N') == d_erreur)
1.1       bertrand 3861:                {
                   3862:                    if ((*s_etat_processus).erreur_systeme != d_es)
                   3863:                    {
                   3864:                        /*
                   3865:                         * Erreur système
                   3866:                         */
                   3867: 
                   3868:                        free(nom_fichier);
                   3869:                        return;
                   3870:                    }
                   3871:                    else
                   3872:                    {
                   3873:                        retour_suite_erreur = d_faux;
                   3874:                        (*s_etat_processus).niveau_courant = niveau_courant;
                   3875: 
                   3876:                        /*
                   3877:                         * Restauration de la pile initiale
                   3878:                         */
                   3879: 
                   3880:                        while((*s_etat_processus).hauteur_pile_operationnelle >
                   3881:                                (unsigned long) hauteur_pile)
                   3882:                        {
                   3883:                            if (depilement(s_etat_processus,
                   3884:                                    &((*s_etat_processus)
                   3885:                                    .l_base_pile), &s_objet) == d_erreur)
                   3886:                            {
                   3887:                                (*s_etat_processus).erreur_execution =
                   3888:                                        d_ex_manque_argument;
                   3889:                                retour_suite_erreur = d_vrai;
                   3890:                                break;
                   3891:                            }
                   3892: 
                   3893:                            liberation(s_etat_processus, s_objet);
                   3894:                        }
                   3895: 
                   3896:                        /*
                   3897:                         * Restauration de la pile système
                   3898:                         */
                   3899: 
                   3900:                        while((*s_etat_processus).l_base_pile_systeme !=
                   3901:                                l_position_normale)
                   3902:                        {
                   3903:                            depilement_pile_systeme(s_etat_processus);
                   3904: 
                   3905:                            if ((*s_etat_processus).erreur_systeme != d_es)
                   3906:                            {
                   3907:                                /*
                   3908:                                 * Une pile vide provoque une erreur système
                   3909:                                 */
                   3910: 
                   3911:                                free(nom_fichier);
                   3912:                                return;
                   3913:                            }
                   3914:                        }
                   3915: 
                   3916:                        if (retour_suite_erreur == d_vrai)
                   3917:                        {
                   3918:                            /*
                   3919:                             * Retrait des variables INDEP, DEPND et retour
                   3920:                             */
                   3921: 
                   3922:                            (*s_etat_processus).niveau_courant--;
                   3923: 
                   3924:                            if (fclose(fichier) != 0)
                   3925:                            {
                   3926:                                (*s_etat_processus).erreur_systeme =
                   3927:                                        d_es_erreur_fichier;
                   3928:                                return;
                   3929:                            }
                   3930: 
                   3931:                            if (destruction_fichier(nom_fichier) == d_erreur)
                   3932:                            {
                   3933:                                (*s_etat_processus).erreur_systeme =
                   3934:                                        d_es_erreur_fichier;
                   3935:                                return;
                   3936:                            }
                   3937: 
                   3938:                            if (retrait_variable(s_etat_processus,
                   3939:                                    nom_x, 'L') == d_erreur)
                   3940:                            {
                   3941:                                if ((*s_etat_processus).erreur_systeme != d_es)
                   3942:                                {
                   3943:                                    if ((*s_etat_processus).erreur_systeme ==
                   3944:                                            d_es_variable_introuvable)
                   3945:                                    {
                   3946:                                        (*s_etat_processus).erreur_systeme =
                   3947:                                                d_es;
                   3948:                                    }
                   3949:                                    else
                   3950:                                    {
                   3951: 
                   3952:                                    /*
                   3953:                                     * Erreur système
                   3954:                                     */
                   3955: 
                   3956:                                        free(nom_fichier);
                   3957:                                        return;
                   3958:                                    }
                   3959:                                }
                   3960: 
                   3961:                                (*s_etat_processus).erreur_execution =
                   3962:                                        d_ex_variable_non_definie;
                   3963:                            }
                   3964: 
                   3965:                            if (retrait_variable(s_etat_processus,
                   3966:                                    nom_y, 'L') == d_erreur)
                   3967:                            {
                   3968:                                if ((*s_etat_processus).erreur_systeme != d_es)
                   3969:                                {
                   3970:                                    if ((*s_etat_processus).erreur_systeme ==
                   3971:                                            d_es_variable_introuvable)
                   3972:                                    {
                   3973:                                        (*s_etat_processus).erreur_systeme =
                   3974:                                                d_es;
                   3975:                                    }
                   3976:                                    else
                   3977:                                    {
                   3978: 
                   3979:                                    /*
                   3980:                                     * Erreur système
                   3981:                                     */
                   3982: 
                   3983:                                        free(nom_fichier);
                   3984:                                        return;
                   3985:                                    }
                   3986:                                }
                   3987: 
                   3988:                                (*s_etat_processus).erreur_execution =
                   3989:                                        d_ex_variable_non_definie;
                   3990:                            }
                   3991: 
                   3992:                            free(nom_x);
                   3993:                            free(nom_y);
                   3994:                            free(nom_fichier);
                   3995: 
                   3996:                            if (last_valide == d_vrai)
                   3997:                            {
                   3998:                                sf(s_etat_processus, 31);
                   3999:                            }
                   4000: 
                   4001:                            return;
                   4002:                        }
                   4003:                    }
                   4004: 
                   4005:                    (*s_etat_processus).erreur_execution = d_ex;
                   4006:                    (*s_etat_processus).exception = d_ep;
                   4007: 
                   4008:                    if (fprintf(fichier, "%f %f %f\n",
                   4009:                            dernier_point_valide[0],
                   4010:                            dernier_point_valide[1],
                   4011:                            dernier_point_valide[2]) < 0)
                   4012:                    {
                   4013:                        (*s_etat_processus).erreur_systeme =
                   4014:                                d_es_erreur_fichier;
                   4015:                        return;
                   4016:                    }
                   4017:                }
                   4018:                else
                   4019:                {
                   4020:                    /*
                   4021:                     * Donnée valide à écrire dans le fichier
                   4022:                     */
                   4023: 
                   4024:                    if (depilement(s_etat_processus, &((*s_etat_processus)
                   4025:                            .l_base_pile), &s_objet) == d_erreur)
                   4026:                    {
                   4027: 
                   4028:                    /*
                   4029:                     * Retrait des variables INDEP et DEPND et retour
                   4030:                     */
                   4031: 
                   4032:                        (*s_etat_processus).niveau_courant--;
                   4033: 
                   4034:                        if (fclose(fichier) != 0)
                   4035:                        {
                   4036:                            (*s_etat_processus).erreur_systeme =
                   4037:                                    d_es_erreur_fichier;
                   4038:                            return;
                   4039:                        }
                   4040: 
                   4041:                        if (destruction_fichier(nom_fichier) == d_erreur)
                   4042:                        {
                   4043:                            (*s_etat_processus).erreur_systeme =
                   4044:                                    d_es_erreur_fichier;
                   4045:                            return;
                   4046:                        }
                   4047: 
                   4048:                        if (retrait_variable(s_etat_processus, nom_x,
                   4049:                                'L') == d_erreur)
                   4050:                        {
                   4051:                            if ((*s_etat_processus).erreur_systeme != d_es)
                   4052:                            {
                   4053:                                if ((*s_etat_processus).erreur_systeme ==
                   4054:                                        d_es_variable_introuvable)
                   4055:                                {
                   4056:                                    (*s_etat_processus).erreur_systeme = d_es;
                   4057:                                }
                   4058:                                else
                   4059:                                {
                   4060: 
                   4061:                                /*
                   4062:                                 * Erreur système
                   4063:                                 */
                   4064: 
                   4065:                                    free(nom_fichier);
                   4066:                                    return;
                   4067:                                }
                   4068:                            }
                   4069: 
                   4070:                            free(nom_x);
                   4071:                            free(nom_y);
                   4072:                            free(nom_fichier);
                   4073: 
                   4074:                            if (last_valide == d_vrai)
                   4075:                            {
                   4076:                                sf(s_etat_processus, 31);
                   4077:                            }
                   4078: 
                   4079:                            (*s_etat_processus).erreur_execution =
                   4080:                                    d_ex_variable_non_definie;
                   4081:                            return;
                   4082:                        }
                   4083: 
                   4084:                        if (retrait_variable(s_etat_processus, nom_y,
                   4085:                                'L') == d_erreur)
                   4086:                        {
                   4087:                            if ((*s_etat_processus).erreur_systeme != d_es)
                   4088:                            {
                   4089:                                if ((*s_etat_processus).erreur_systeme ==
                   4090:                                        d_es_variable_introuvable)
                   4091:                                {
                   4092:                                    (*s_etat_processus).erreur_systeme = d_es;
                   4093:                                }
                   4094:                                else
                   4095:                                {
                   4096: 
                   4097:                                /*
                   4098:                                 * Erreur système
                   4099:                                 */
                   4100: 
                   4101:                                    free(nom_fichier);
                   4102:                                    return;
                   4103:                                }
                   4104:                            }
                   4105: 
                   4106:                            free(nom_x);
                   4107:                            free(nom_y);
                   4108:                            free(nom_fichier);
                   4109: 
                   4110:                            if (last_valide == d_vrai)
                   4111:                            {
                   4112:                                sf(s_etat_processus, 31);
                   4113:                            }
                   4114: 
                   4115:                            (*s_etat_processus).erreur_execution =
                   4116:                                    d_ex_variable_non_definie;
                   4117:                            return;
                   4118:                        }
                   4119: 
                   4120:                        free(nom_x);
                   4121:                        free(nom_y);
                   4122:                        free(nom_fichier);
                   4123: 
                   4124:                        if (last_valide == d_vrai)
                   4125:                        {
                   4126:                            sf(s_etat_processus, 31);
                   4127:                        }
                   4128: 
                   4129:                        (*s_etat_processus).erreur_execution =
                   4130:                                d_ex_manque_argument;
                   4131:                        return;
                   4132:                    }
                   4133: 
                   4134:                    if ((*s_objet).type == INT)
                   4135:                    {
                   4136:                        dernier_point_valide[0] = x;
                   4137:                        dernier_point_valide[1] = y;
                   4138:                        dernier_point_valide[2] = (real8) (*((integer8 *)
                   4139:                                (*s_objet).objet));
                   4140: 
                   4141:                        if (fprintf(fichier, "%f %f %f\n", x, y,
                   4142:                                (double) (*((integer8 *)
                   4143:                                (*s_objet).objet))) < 0)
                   4144:                        {
                   4145:                            (*s_etat_processus).erreur_systeme =
                   4146:                                    d_es_erreur_fichier;
                   4147:                            return;
                   4148:                        }
                   4149:                    }
                   4150:                    else if ((*s_objet).type == REL)
                   4151:                    {
                   4152:                        dernier_point_valide[0] = x;
                   4153:                        dernier_point_valide[1] = y;
                   4154:                        dernier_point_valide[2] = (*((real8 *)
                   4155:                                (*s_objet).objet));
                   4156: 
                   4157:                        if (fprintf(fichier, "%f %f %f\n", x, y,
                   4158:                                (*((real8 *) (*s_objet).objet))) < 0)
                   4159:                        {
                   4160:                            (*s_etat_processus).erreur_systeme =
                   4161:                                    d_es_erreur_fichier;
                   4162:                            return;
                   4163:                        }
                   4164:                    }
                   4165: 
                   4166:                    liberation(s_etat_processus, s_objet);
                   4167:                }
                   4168:            }
                   4169: 
                   4170:            /*
                   4171:             * Retrait de la variable locale DEPND
                   4172:             */
                   4173: 
                   4174:            if (retrait_variable(s_etat_processus, nom_y, 'L') == d_erreur)
                   4175:            {
                   4176:                if ((*s_etat_processus).erreur_systeme != d_es)
                   4177:                {
                   4178:                    if ((*s_etat_processus).erreur_systeme ==
                   4179:                            d_es_variable_introuvable)
                   4180:                    {
                   4181:                        (*s_etat_processus).erreur_systeme = d_es;
                   4182:                    }
                   4183:                    else
                   4184:                    {
                   4185:                        /*
                   4186:                         * Erreur système
                   4187:                         */
                   4188: 
                   4189:                        free(nom_fichier);
                   4190:                        return;
                   4191:                    }
                   4192:                }
                   4193: 
                   4194:                free(nom_x);
                   4195:                free(nom_y);
                   4196:                free(nom_fichier);
                   4197: 
                   4198:                if (last_valide == d_vrai)
                   4199:                {
                   4200:                    sf(s_etat_processus, 31);
                   4201:                }
                   4202: 
                   4203:                (*s_etat_processus).erreur_execution =
                   4204:                        d_ex_variable_non_definie;
                   4205:                return;
                   4206:            }
                   4207: 
                   4208:            free(nom_y);
                   4209: 
                   4210:            /*
                   4211:             * Saut de ligne dans le fichier pour commencer une nouvelle
                   4212:             * trace.
                   4213:             */
                   4214: 
                   4215:            if (fprintf(fichier, "\n") < 0)
                   4216:            {
                   4217:                (*s_etat_processus).erreur_systeme =
                   4218:                        d_es_erreur_fichier;
                   4219:                return;
                   4220:            }
                   4221:        }
                   4222: 
                   4223:        /*
                   4224:         * Retrait de la variable locale INDEP
                   4225:         */
                   4226: 
                   4227:        (*s_etat_processus).niveau_courant--;
                   4228: 
                   4229:        if (retrait_variable(s_etat_processus, nom_x, 'L') == d_erreur)
                   4230:        {
                   4231:            if ((*s_etat_processus).erreur_systeme != d_es)
                   4232:            {
                   4233:                if ((*s_etat_processus).erreur_systeme ==
                   4234:                        d_es_variable_introuvable)
                   4235:                {
                   4236:                    (*s_etat_processus).erreur_systeme = d_es;
                   4237:                }
                   4238:                else
                   4239:                {
                   4240:                    /*
                   4241:                     * Erreur système
                   4242:                     */
                   4243: 
                   4244:                    free(nom_fichier);
                   4245:                    return;
                   4246:                }
                   4247:            }
                   4248: 
                   4249:            free(nom_x);
                   4250:            free(nom_fichier);
                   4251: 
                   4252:            if (last_valide == d_vrai)
                   4253:            {
                   4254:                sf(s_etat_processus, 31);
                   4255:            }
                   4256: 
                   4257:            (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
                   4258:            return;
                   4259:        }
                   4260: 
                   4261:        free(nom_x);
                   4262: 
                   4263:        if (strcmp((*s_etat_processus).type_trace_eq, "COURBES DE NIVEAU") == 0)
                   4264:        {
                   4265:            // Conversion du graphe
                   4266:            dimensions = 2;
                   4267: 
                   4268:            if (fclose(fichier) != 0)
                   4269:            {
                   4270:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   4271:                return;
                   4272:            }
                   4273: 
                   4274:            if ((entree_standard =  popen("gnuplot", "w")) == NULL)
                   4275:            {
                   4276:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   4277:                return;
                   4278:            }
                   4279: 
                   4280:            if (fprintf(entree_standard, "set nosurface\n") < 0)
                   4281:            {
                   4282:                (*s_etat_processus).erreur_systeme = d_es_processus;
                   4283:                return;
                   4284:            }
                   4285: 
                   4286:            if (fprintf(entree_standard, "set contour\n") < 0)
                   4287:            {
                   4288:                (*s_etat_processus).erreur_systeme = d_es_processus;
                   4289:                return;
                   4290:            }
                   4291: 
                   4292:            if (fprintf(entree_standard, "set cntrparam level ") < 0)
                   4293:            {
                   4294:                (*s_etat_processus).erreur_systeme = d_es_processus;
                   4295:                return;
                   4296:            }
                   4297: 
                   4298:            l_element_courant = (struct_liste_chainee *) (*(*s_etat_processus)
                   4299:                    .parametres_courbes_de_niveau).objet;
                   4300: 
                   4301:            if (l_element_courant != NULL)
                   4302:            {
                   4303:                if ((*(*l_element_courant).donnee).type == CHN)
                   4304:                {
                   4305:                    if (strcmp((unsigned char *) (*(*l_element_courant).donnee)
                   4306:                            .objet, "AUTOMATIC") == 0)
                   4307:                    {
                   4308:                        if (fprintf(entree_standard, "auto") < 0)
                   4309:                        {
                   4310:                            (*s_etat_processus).erreur_systeme = d_es_processus;
                   4311:                            return;
                   4312:                        }
                   4313:                    }
                   4314:                    else if (strcmp((unsigned char *) (*(*l_element_courant)
                   4315:                            .donnee).objet, "DISCRETE") == 0)
                   4316:                    {
                   4317:                        if (fprintf(entree_standard, "discrete") < 0)
                   4318:                        {
                   4319:                            (*s_etat_processus).erreur_systeme = d_es_processus;
                   4320:                            return;
                   4321:                        }
                   4322:                    }
                   4323:                    else
                   4324:                    {
                   4325:                        if (fprintf(entree_standard, "incremental") < 0)
                   4326:                        {
                   4327:                            (*s_etat_processus).erreur_systeme = d_es_processus;
                   4328:                            return;
                   4329:                        }
                   4330:                    }
                   4331:                }
                   4332: 
                   4333:                l_element_courant = (*l_element_courant).suivant;
                   4334: 
                   4335:                if (l_element_courant != NULL)
                   4336:                {
                   4337:                    if (fprintf(entree_standard, " ") < 0)
                   4338:                    {
                   4339:                        (*s_etat_processus).erreur_systeme = d_es_processus;
                   4340:                        return;
                   4341:                    }
                   4342:                }
                   4343: 
                   4344:                while(l_element_courant != NULL)
                   4345:                {
                   4346:                    if ((*(*l_element_courant).donnee).type == INT)
                   4347:                    {
                   4348:                        if (fprintf(entree_standard, "%f", (double)
                   4349:                                (*((integer8 *) (*(*l_element_courant).donnee)
                   4350:                                .objet))) < 0)
                   4351:                        {
                   4352:                            (*s_etat_processus).erreur_systeme = d_es_processus;
                   4353:                            return;
                   4354:                        }
                   4355:                    }
                   4356:                    else
                   4357:                    {
                   4358:                        if (fprintf(entree_standard, "%f", (double)
                   4359:                                (*((real8 *) (*(*l_element_courant).donnee)
                   4360:                                .objet))) < 0)
                   4361:                        {
                   4362:                            (*s_etat_processus).erreur_systeme = d_es_processus;
                   4363:                            return;
                   4364:                        }
                   4365:                    }
                   4366: 
                   4367:                    l_element_courant = (*l_element_courant).suivant;
                   4368: 
                   4369:                    if (l_element_courant != NULL)
                   4370:                    {
                   4371:                        if (fprintf(entree_standard, ",") < 0)
                   4372:                        {
                   4373:                            (*s_etat_processus).erreur_systeme = d_es_processus;
                   4374:                            return;
                   4375:                        }
                   4376:                    }
                   4377:                }
                   4378: 
                   4379:                if (fprintf(entree_standard, "\n") < 0)
                   4380:                {
                   4381:                    (*s_etat_processus).erreur_systeme = d_es_processus;
                   4382:                    return;
                   4383:                }
                   4384:            }
                   4385: 
                   4386:            if (fprintf(entree_standard, "set terminal table\n") < 0)
                   4387:            {
                   4388:                (*s_etat_processus).erreur_systeme = d_es_processus;
                   4389:                return;
                   4390:            }
                   4391: 
                   4392:            if ((nom_fichier_converti = creation_nom_fichier(
                   4393:                    s_etat_processus, (*s_etat_processus)
                   4394:                    .chemin_fichiers_temporaires)) == NULL)
                   4395:            {
                   4396:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   4397:                return;
                   4398:            }
                   4399: 
                   4400:            if (fprintf(entree_standard, "set output '%s'\n",
                   4401:                    nom_fichier_converti) < 0)
                   4402:            {
                   4403:                (*s_etat_processus).erreur_systeme = d_es_processus;
                   4404:                return;
                   4405:            }
                   4406: 
                   4407:            if (fprintf(entree_standard, "splot '%s'\n", nom_fichier) < 0)
                   4408:            {
                   4409:                (*s_etat_processus).erreur_systeme = d_es_processus;
                   4410:                return;
                   4411:            }
                   4412: 
                   4413:            if (fprintf(entree_standard, "set output\n") < 0)
                   4414:            {
                   4415:                (*s_etat_processus).erreur_systeme = d_es_processus;
                   4416:                return;
                   4417:            }
                   4418: 
                   4419:            if (fprintf(entree_standard, "quit\n") < 0)
                   4420:            {
                   4421:                (*s_etat_processus).erreur_systeme = d_es_processus;
                   4422:                return;
                   4423:            }
                   4424: 
                   4425:            if (pclose(entree_standard) != 0)
                   4426:            {
                   4427:                (*s_etat_processus).erreur_systeme = d_es_processus;
                   4428:                return;
                   4429:            }
                   4430: 
                   4431:            if (destruction_fichier(nom_fichier) == d_erreur)
                   4432:            {
                   4433:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   4434:                return;
                   4435:            }
                   4436: 
                   4437:            if ((fichier = fopen(nom_fichier_converti, "r")) == NULL)
                   4438:            {
                   4439:                (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   4440:                return;
                   4441:            }
                   4442: 
                   4443:            free(nom_fichier);
                   4444:            nom_fichier = nom_fichier_converti;
                   4445:        }
                   4446:        else
                   4447:        {
                   4448:            dimensions = 3;
                   4449:        }
                   4450: 
                   4451:    }
                   4452: 
                   4453:    /*
                   4454:     * Type de tracé invalide
                   4455:     */
                   4456: 
                   4457:    else
                   4458:    {
                   4459:        if (last_valide == d_vrai)
                   4460:        {
                   4461:            sf(s_etat_processus, 31);
                   4462:        }
                   4463: 
                   4464:        (*s_etat_processus).erreur_execution = d_ex_type_trace_invalide;
                   4465:        return;
                   4466:    }
                   4467: 
                   4468:    /*
                   4469:     * Fermeture du fichier graphique
                   4470:     */
                   4471: 
                   4472:    if (fclose(fichier) != 0)
                   4473:    {
                   4474:        (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   4475:        return;
                   4476:    }
                   4477: 
                   4478:    /*
                   4479:     * Chaînage du fichier temporaire à la liste des fichiers graphiques
                   4480:     */
                   4481: 
                   4482:    l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
                   4483: 
                   4484:    if (l_fichier_courant == NULL)
                   4485:    {
                   4486:        if (((*s_etat_processus).fichiers_graphiques = malloc(
                   4487:                sizeof(struct_fichier_graphique))) == NULL)
                   4488:        {
                   4489:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   4490:            return;
                   4491:        }
                   4492: 
                   4493:        (*(*s_etat_processus).fichiers_graphiques).suivant = NULL;
                   4494:        (*(*s_etat_processus).fichiers_graphiques).nom = nom_fichier;
                   4495:        (*(*s_etat_processus).fichiers_graphiques).legende = NULL;
                   4496:        (*(*s_etat_processus).fichiers_graphiques).dimensions = dimensions;
                   4497:        (*(*s_etat_processus).fichiers_graphiques).presence_axes = d_faux;
                   4498:        (*(*s_etat_processus).fichiers_graphiques).systeme_axes =
                   4499:                (*s_etat_processus).systeme_axes;
                   4500:        strcpy((*(*s_etat_processus).fichiers_graphiques).type,
                   4501:                (*s_etat_processus).type_trace_eq);
                   4502:    }
                   4503:    else
                   4504:    {
                   4505:        while(l_fichier_courant != NULL)
                   4506:        {
                   4507:            if ((*l_fichier_courant).dimensions != dimensions)
                   4508:            {
                   4509:                if (last_valide == d_vrai)
                   4510:                {
                   4511:                    sf(s_etat_processus, 31);
                   4512:                }
                   4513: 
                   4514:                (*s_etat_processus).erreur_execution =
                   4515:                        d_ex_dimensions_differentes;
                   4516:                return;
                   4517:            }
                   4518: 
                   4519:            l_fichier_precedent = l_fichier_courant;
                   4520:            l_fichier_courant = (*l_fichier_courant).suivant;
                   4521:        }
                   4522: 
                   4523:        l_fichier_courant = l_fichier_precedent;
                   4524: 
                   4525:        if (((*l_fichier_courant).suivant = malloc(
                   4526:                sizeof(struct_fichier_graphique))) == NULL)
                   4527:        {
                   4528:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   4529:            return;
                   4530:        }
                   4531: 
                   4532:        l_fichier_courant = (*l_fichier_courant).suivant;
                   4533: 
                   4534:        (*l_fichier_courant).suivant = NULL;
                   4535:        (*l_fichier_courant).nom = nom_fichier;
                   4536:        (*l_fichier_courant).legende = NULL;
                   4537:        (*l_fichier_courant).dimensions = dimensions;
                   4538:        (*l_fichier_courant).presence_axes = d_faux;
                   4539:        (*l_fichier_courant).systeme_axes = (*s_etat_processus).systeme_axes;
                   4540:        strcpy((*l_fichier_courant).type, (*s_etat_processus).type_trace_eq);
                   4541:    }
                   4542: 
                   4543:    /*
                   4544:     * Affichage du graphique
                   4545:     */
                   4546: 
                   4547:    appel_gnuplot(s_etat_processus, 'N');
                   4548:    (*s_etat_processus).erreur_execution = d_ex;
                   4549:    (*s_etat_processus).exception = d_ep;
                   4550: 
                   4551:    if (last_valide == d_vrai)
                   4552:    {
                   4553:        sf(s_etat_processus, 31);
                   4554:    }
                   4555: 
                   4556:    return;
                   4557: }
                   4558: 
                   4559: 
                   4560: /*
                   4561: ================================================================================
                   4562:   Fonction 'drax'
                   4563: ================================================================================
                   4564:   Entrées : pointeur sur une structure struct_processus
                   4565: --------------------------------------------------------------------------------
                   4566:   Sorties :
                   4567: --------------------------------------------------------------------------------
                   4568:   Effets de bord : néant
                   4569: ================================================================================
                   4570: */
                   4571: 
                   4572: void
                   4573: instruction_drax(struct_processus *s_etat_processus)
                   4574: {
                   4575:    struct_fichier_graphique        *l_fichier_courant;
                   4576: 
                   4577:    (*s_etat_processus).erreur_execution = d_ex;
                   4578: 
                   4579:    if ((*s_etat_processus).affichage_arguments == 'Y')
                   4580:    {
                   4581:        printf("\n  DRAX ");
                   4582: 
                   4583:        if ((*s_etat_processus).langue == 'F')
                   4584:        {
                   4585:            printf("(trace les axes)\n\n");
                   4586:            printf("  Aucun argument\n");
                   4587:        }
                   4588:        else
                   4589:        {
                   4590:            printf("(plot axes)\n\n");
                   4591:            printf("  No argument\n");
                   4592:        }
                   4593: 
                   4594:        return;
                   4595:    }
                   4596:    else if ((*s_etat_processus).test_instruction == 'Y')
                   4597:    {
                   4598:        (*s_etat_processus).nombre_arguments = -1;
                   4599:        return;
                   4600:    }
                   4601: 
                   4602:    if (test_cfsf(s_etat_processus, 31) == d_vrai)
                   4603:    {
                   4604:        if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
                   4605:        {
                   4606:            return;
                   4607:        }
                   4608:    }
                   4609: 
                   4610:    if ((*s_etat_processus).fichiers_graphiques != NULL)
                   4611:    {
                   4612:        l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
                   4613: 
                   4614:        if (l_fichier_courant != NULL)
                   4615:        {
                   4616:            while((*l_fichier_courant).suivant != NULL)
                   4617:            {
                   4618:                l_fichier_courant = (*l_fichier_courant).suivant;
                   4619:            }
                   4620: 
                   4621:            (*l_fichier_courant).presence_axes = d_vrai;
                   4622:        }
                   4623:    }
                   4624: 
                   4625:    if (test_cfsf(s_etat_processus, 52) == d_faux)
                   4626:    {
                   4627:        if ((*s_etat_processus).fichiers_graphiques != NULL)
                   4628:        {
                   4629:            appel_gnuplot(s_etat_processus, 'N');
                   4630:        }
                   4631:    }
                   4632: 
                   4633:    return;
                   4634: }
                   4635: 
                   4636: 
                   4637: /*
                   4638: ================================================================================
                   4639:   Fonction 'depnd'
                   4640: ================================================================================
                   4641:   Entrées : pointeur sur une structure struct_processus
                   4642: --------------------------------------------------------------------------------
                   4643:   Sorties :
                   4644: --------------------------------------------------------------------------------
                   4645:   Effets de bord : néant
                   4646: ================================================================================
                   4647: */
                   4648: 
                   4649: void
                   4650: instruction_depnd(struct_processus *s_etat_processus)
                   4651: {
                   4652:    struct_liste_chainee            *l_element_courant;
                   4653: 
                   4654:    struct_objet                    *s_objet;
                   4655: 
                   4656:    (*s_etat_processus).erreur_execution = d_ex;
                   4657: 
                   4658:    if ((*s_etat_processus).affichage_arguments == 'Y')
                   4659:    {
                   4660:        printf("\n  DEPND ");
                   4661: 
                   4662:        if ((*s_etat_processus).langue == 'F')
                   4663:        {
                   4664:            printf("(indication de la variable dépendante)\n\n");
                   4665:        }
                   4666:        else
                   4667:        {
                   4668:            printf("(set dependant variable)\n\n");
                   4669:        }
                   4670: 
                   4671:        printf("    1: %s, %s\n", d_NOM, d_LST);
                   4672: 
                   4673:        return;
                   4674:    }
                   4675:    else if ((*s_etat_processus).test_instruction == 'Y')
                   4676:    {
                   4677:        (*s_etat_processus).nombre_arguments = -1;
                   4678:        return;
                   4679:    }
                   4680: 
                   4681:    if (test_cfsf(s_etat_processus, 31) == d_vrai)
                   4682:    {
                   4683:        if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
                   4684:        {
                   4685:            return;
                   4686:        }
                   4687:    }
                   4688: 
                   4689:    if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                   4690:            &s_objet) == d_erreur)
                   4691:    {
                   4692:        (*s_etat_processus).erreur_execution = d_ex_manque_argument;
                   4693:        return;
                   4694:    }
                   4695: 
                   4696:    if ((*s_objet).type == NOM)
                   4697:    {
                   4698:        liberation(s_etat_processus, (*s_etat_processus).depend);
                   4699:        (*s_etat_processus).depend = s_objet;
                   4700:    }
                   4701:    else if ((*s_objet).type == LST)
                   4702:    {
                   4703:        l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
                   4704: 
                   4705:        if ((*(*l_element_courant).donnee).type != NOM)
                   4706:        {
                   4707:            liberation(s_etat_processus, s_objet);
                   4708: 
                   4709:            (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
                   4710:            return;
                   4711:        }
                   4712: 
                   4713:        (*((struct_nom *) (*(*l_element_courant).donnee).objet)).symbole =
                   4714:                d_vrai;
                   4715: 
                   4716:        l_element_courant = (*l_element_courant).suivant;
                   4717: 
                   4718:        if (!(((*(*l_element_courant).donnee).type == INT) ||
                   4719:                ((*(*l_element_courant).donnee).type == REL) ||
                   4720:                ((*(*l_element_courant).donnee).type == NOM) ||
                   4721:                ((*(*l_element_courant).donnee).type == ALG) ||
                   4722:                ((*(*l_element_courant).donnee).type == RPN)))
                   4723:        {
                   4724:            liberation(s_etat_processus, s_objet);
                   4725: 
                   4726:            (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
                   4727:            return;
                   4728:        }
                   4729: 
                   4730:        l_element_courant = (*l_element_courant).suivant;
                   4731: 
                   4732:        if (!(((*(*l_element_courant).donnee).type == INT) ||
                   4733:                ((*(*l_element_courant).donnee).type == REL) ||
                   4734:                ((*(*l_element_courant).donnee).type == NOM) ||
                   4735:                ((*(*l_element_courant).donnee).type == ALG) ||
                   4736:                ((*(*l_element_courant).donnee).type == RPN)))
                   4737:        {
                   4738:            liberation(s_etat_processus, s_objet);
                   4739: 
                   4740:            (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
                   4741:            return;
                   4742:        }
                   4743: 
                   4744:        l_element_courant = (*l_element_courant).suivant;
                   4745: 
                   4746:        if (l_element_courant != NULL)
                   4747:        {
                   4748:            liberation(s_etat_processus, s_objet);
                   4749: 
                   4750:            (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
                   4751:            return;
                   4752:        }
                   4753: 
                   4754:        liberation(s_etat_processus, (*s_etat_processus).depend);
                   4755:        (*s_etat_processus).depend = s_objet;
                   4756:    }
                   4757:    else
                   4758:    {
                   4759:        liberation(s_etat_processus, s_objet);
                   4760: 
                   4761:        (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
                   4762:        return;
                   4763:    }
                   4764: 
                   4765:    return;
                   4766: }
                   4767: 
                   4768: // vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>