Annotation of rpl/src/instructions_x2.c, revision 1.47

1.1       bertrand    1: /*
                      2: ================================================================================
1.47    ! bertrand    3:   RPL/2 (R) version 4.1.18
1.46      bertrand    4:   Copyright (C) 1989-2014 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 'xroot'
                     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_xroot(struct_processus *s_etat_processus)
                     40: {
                     41:    real8                       argument;
                     42:    real8                       module;
                     43: 
                     44:    struct_liste_chainee        *l_element_courant;
                     45:    struct_liste_chainee        *l_element_precedent;
                     46: 
                     47:    struct_objet                *s_copie_argument_1;
                     48:    struct_objet                *s_copie_argument_2;
                     49:    struct_objet                *s_objet_argument_1;
                     50:    struct_objet                *s_objet_argument_2;
                     51:    struct_objet                *s_objet_resultat;
                     52: 
                     53:    unsigned long               nombre_elements;
                     54: 
                     55:    (*s_etat_processus).erreur_execution = d_ex;
                     56: 
                     57:    if ((*s_etat_processus).affichage_arguments == 'Y')
                     58:    {
                     59:        printf("\n  XROOT ");
                     60: 
                     61:        if ((*s_etat_processus).langue == 'F')
                     62:        {
                     63:            printf("(racine n-ième)\n\n");
                     64:        }
                     65:        else
                     66:        {
                     67:            printf("(Nth root)\n\n");
                     68:        }
                     69: 
                     70:        printf("    2: %s, %s, %s\n", d_INT, d_REL, d_CPL);
                     71:        printf("    1: %s\n", d_INT);
                     72:        printf("->  1: %s, %s\n\n", d_REL, d_CPL);
                     73: 
                     74:        printf("    2: %s, %s, %s, %s, %s, %s\n",
                     75:                d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN);
                     76:        printf("    1: %s, %s, %s, %s, %s, %s\n",
                     77:                d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN);
                     78:        printf("->  1: %s, %s\n", d_ALG, d_RPN);
                     79: 
                     80:        return;
                     81:    }
                     82:    else if ((*s_etat_processus).test_instruction == 'Y')
                     83:    {
                     84:        (*s_etat_processus).nombre_arguments = 2;
                     85:        return;
                     86:    }
                     87: 
                     88:    if (test_cfsf(s_etat_processus, 31) == d_vrai)
                     89:    {
                     90:        if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
                     91:        {
                     92:            return;
                     93:        }
                     94:    }
                     95: 
                     96:    if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                     97:            &s_objet_argument_1) == d_erreur)
                     98:    {
                     99:        (*s_etat_processus).erreur_execution = d_ex_manque_argument;
                    100:        return;
                    101:    }
                    102: 
                    103:    if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                    104:            &s_objet_argument_2) == d_erreur)
                    105:    {
                    106:        liberation(s_etat_processus, s_objet_argument_1);
                    107: 
                    108:        (*s_etat_processus).erreur_execution = d_ex_manque_argument;
                    109:        return;
                    110:    }
                    111: 
                    112: /*
                    113: --------------------------------------------------------------------------------
                    114:   Racines n-ièmes de scalaires
                    115: --------------------------------------------------------------------------------
                    116: */
                    117: 
                    118:    if (((*s_objet_argument_1).type == INT) &&
                    119:            ((*s_objet_argument_2).type == INT))
                    120:    {
                    121:        if ((*((integer8 *) (*s_objet_argument_1).objet)) <= 0)
                    122:        {
                    123:            liberation(s_etat_processus, s_objet_argument_1);
                    124:            liberation(s_etat_processus, s_objet_argument_2);
                    125: 
                    126:            (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
                    127:            return;
                    128:        }
                    129: 
                    130:        if (((*((integer8 *) (*s_objet_argument_2).objet)) < 0) &&
                    131:                (((*((integer8 *) (*s_objet_argument_1).objet)) % 2) == 0))
                    132:        {
                    133:            /*
                    134:             * Résultat Y^(1/X) complexe si X impair et Y négatif
                    135:             */
                    136: 
                    137:            if ((s_objet_resultat = allocation(s_etat_processus, CPL))
                    138:                    == NULL)
                    139:            {
                    140:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    141:                return;
                    142:            }
                    143: 
1.41      bertrand  144:            module = abs((real8) (*((integer8 *) (*s_objet_argument_2).objet)));
1.1       bertrand  145:            argument = ((*((integer8 *) (*s_objet_argument_2).objet)) >= 0)
                    146:                    ? 0 : (4 * atan((double) 1));
                    147: 
                    148:            argument /= ((double) (*((integer8 *) (*s_objet_argument_1)
                    149:                    .objet)));
                    150:            module = pow(module, ((double) 1) / ((double) (*((integer8 *)
                    151:                    (*s_objet_argument_1).objet))));
                    152: 
                    153:            (*((complex16 *) (*s_objet_resultat).objet)).partie_reelle =
                    154:                    module * cos(argument);
                    155:            (*((complex16 *) (*s_objet_resultat).objet)).partie_imaginaire =
                    156:                    module * sin(argument);
                    157:        }
                    158:        else
                    159:        {
                    160:            /*
                    161:             * Résultat réel
                    162:             */
                    163: 
                    164:            if ((s_objet_resultat = allocation(s_etat_processus, REL))
                    165:                    == NULL)
                    166:            {
                    167:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    168:                return;
                    169:            }
                    170: 
                    171:            if ((*((integer8 *) (*s_objet_argument_2).objet)) >= 0)
                    172:            {
                    173:                (*((real8 *) (*s_objet_resultat).objet)) = pow(((double)
                    174:                        (*((integer8 *) (*s_objet_argument_2).objet))),
                    175:                        ((double) 1) / ((double) (*((integer8 *)
                    176:                        (*s_objet_argument_1).objet))));
                    177:            }
                    178:            else
                    179:            {
                    180:                (*((real8 *) (*s_objet_resultat).objet)) = -pow(((double)
                    181:                        -(*((integer8 *) (*s_objet_argument_2).objet))),
                    182:                        ((double) 1) / ((double) (*((integer8 *)
                    183:                        (*s_objet_argument_1).objet))));
                    184:            }
                    185:        }
                    186:    }
                    187:    else if (((*s_objet_argument_1).type == INT) &&
                    188:            ((*s_objet_argument_2).type == REL))
                    189:    {
                    190:        if ((*((integer8 *) (*s_objet_argument_1).objet)) <= 0)
                    191:        {
                    192:            liberation(s_etat_processus, s_objet_argument_1);
                    193:            liberation(s_etat_processus, s_objet_argument_2);
                    194: 
                    195:            (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
                    196:            return;
                    197:        }
                    198: 
                    199:        if (((*((real8 *) (*s_objet_argument_2).objet)) < 0) &&
                    200:                (((*((integer8 *) (*s_objet_argument_1).objet)) % 2) == 0))
                    201:        {
                    202:            /*
                    203:             * Résultat Y^(1/X) complexe si X impair et Y négatif
                    204:             */
                    205: 
                    206:            if ((s_objet_resultat = allocation(s_etat_processus, CPL))
                    207:                    == NULL)
                    208:            {
                    209:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    210:                return;
                    211:            }
                    212: 
                    213:            module = abs((*((real8 *) (*s_objet_argument_2).objet)));
                    214:            argument = ((*((real8 *) (*s_objet_argument_2).objet)) >= 0)
                    215:                    ? 0 : (4 * atan((double) 1));
                    216: 
                    217:            argument /= ((double) (*((integer8 *) (*s_objet_argument_1)
                    218:                    .objet)));
                    219:            module = pow(module, ((double) 1) / ((double) (*((integer8 *)
                    220:                    (*s_objet_argument_1).objet))));
                    221: 
                    222:            (*((complex16 *) (*s_objet_resultat).objet)).partie_reelle =
                    223:                    module * cos(argument);
                    224:            (*((complex16 *) (*s_objet_resultat).objet)).partie_imaginaire =
                    225:                    module * sin(argument);
                    226:        }
                    227:        else
                    228:        {
                    229:            /*
                    230:             * Résultat réel
                    231:             */
                    232: 
                    233:            if ((s_objet_resultat = allocation(s_etat_processus, REL))
                    234:                    == NULL)
                    235:            {
                    236:                (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    237:                return;
                    238:            }
                    239: 
                    240:            if ((*((real8 *) (*s_objet_argument_2).objet)) >= 0)
                    241:            {
                    242:                (*((real8 *) (*s_objet_resultat).objet)) = pow(
                    243:                        (*((real8 *) (*s_objet_argument_2).objet)),
                    244:                        ((double) 1) / ((double) (*((integer8 *)
                    245:                        (*s_objet_argument_1).objet))));
                    246:            }
                    247:            else
                    248:            {
                    249:                (*((real8 *) (*s_objet_resultat).objet)) = -pow(
                    250:                        -(*((real8 *) (*s_objet_argument_2).objet)),
                    251:                        ((double) 1) / ((double) (*((integer8 *)
                    252:                        (*s_objet_argument_1).objet))));
                    253:            }
                    254:        }
                    255:    }
                    256:    else if (((*s_objet_argument_1).type == INT) &&
                    257:            ((*s_objet_argument_2).type == CPL))
                    258:    {
                    259:        if ((*((integer8 *) (*s_objet_argument_1).objet)) <= 0)
                    260:        {
                    261:            liberation(s_etat_processus, s_objet_argument_1);
                    262:            liberation(s_etat_processus, s_objet_argument_2);
                    263: 
                    264:            (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
                    265:            return;
                    266:        }
                    267: 
                    268:        if ((s_objet_resultat = allocation(s_etat_processus, CPL))
                    269:                == NULL)
                    270:        {
                    271:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    272:            return;
                    273:        }
                    274: 
                    275:        f77absc_(((struct_complexe16 *) (*s_objet_argument_2).objet), &module);
                    276: 
                    277:        argument = atan2((*((struct_complexe16 *) (*s_objet_argument_2).objet))
                    278:                .partie_imaginaire, (*((struct_complexe16 *)
                    279:                (*s_objet_argument_2).objet)).partie_reelle);
                    280: 
                    281:        argument /= ((double) (*((integer8 *) (*s_objet_argument_1).objet)));
                    282:        module = pow(module, ((double) 1) / ((double) (*((integer8 *)
                    283:                (*s_objet_argument_1).objet))));
                    284: 
                    285:        (*((complex16 *) (*s_objet_resultat).objet)).partie_reelle =
                    286:                module * cos(argument);
                    287:        (*((complex16 *) (*s_objet_resultat).objet)).partie_imaginaire =
                    288:                module * sin(argument);
                    289:    }
                    290: 
                    291: /*
                    292: --------------------------------------------------------------------------------
                    293:   Résultat sous forme d'expression algébrique
                    294: --------------------------------------------------------------------------------
                    295: */
                    296: 
                    297:    else if ((((*s_objet_argument_2).type == NOM) &&
                    298:            (((*s_objet_argument_1).type == NOM) ||
                    299:            ((*s_objet_argument_1).type == INT))) ||
                    300:            ((((*s_objet_argument_2).type == INT) ||
                    301:            ((*s_objet_argument_2).type == REL) ||
                    302:            ((*s_objet_argument_2).type == CPL)) &&
                    303:            ((*s_objet_argument_1).type == NOM)))
                    304:    {
                    305:        if ((s_objet_resultat = allocation(s_etat_processus, ALG))
                    306:                == NULL)
                    307:        {
                    308:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    309:            return;
                    310:        }
                    311: 
                    312:        if (((*s_objet_resultat).objet =
                    313:                allocation_maillon(s_etat_processus)) == NULL)
                    314:        {
                    315:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    316:            return;
                    317:        }
                    318: 
                    319:        l_element_courant = (*s_objet_resultat).objet;
                    320: 
                    321:        if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
                    322:                == NULL)
                    323:        {
                    324:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    325:            return;
                    326:        }
                    327: 
                    328:        (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    329:                .nombre_arguments = 2;
                    330:        (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    331:                .fonction = instruction_vers_niveau_superieur;
                    332: 
                    333:        if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    334:                .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
                    335:        {
                    336:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    337:            return;
                    338:        }
                    339: 
                    340:        strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    341:                .nom_fonction, "<<");
                    342: 
                    343:        if (((*l_element_courant).suivant =
                    344:                allocation_maillon(s_etat_processus)) == NULL)
                    345:        {
                    346:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    347:            return;
                    348:        }
                    349: 
                    350:        l_element_courant = (*l_element_courant).suivant;
                    351:        (*l_element_courant).donnee = s_objet_argument_2;
                    352: 
                    353:        if (((*l_element_courant).suivant =
                    354:                allocation_maillon(s_etat_processus)) == NULL)
                    355:        {
                    356:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    357:            return;
                    358:        }
                    359: 
                    360:        l_element_courant = (*l_element_courant).suivant;
                    361:        (*l_element_courant).donnee = s_objet_argument_1;
                    362: 
                    363:        if (((*l_element_courant).suivant =
                    364:                allocation_maillon(s_etat_processus)) == NULL)
                    365:        {
                    366:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    367:            return;
                    368:        }
                    369: 
                    370:        l_element_courant = (*l_element_courant).suivant;
                    371: 
                    372:        if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
                    373:                == NULL)
                    374:        {
                    375:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    376:            return;
                    377:        }
                    378: 
                    379:        (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    380:                .nombre_arguments = 2;
                    381:        (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    382:                .fonction = instruction_xroot;
                    383: 
                    384:        if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    385:                .nom_fonction = malloc(6 * sizeof(unsigned char))) == NULL)
                    386:        {
                    387:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    388:            return;
                    389:        }
                    390: 
                    391:        strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    392:                .nom_fonction, "XROOT");
                    393: 
                    394:        if (((*l_element_courant).suivant =
                    395:                allocation_maillon(s_etat_processus)) == NULL)
                    396:        {
                    397:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    398:            return;
                    399:        }
                    400: 
                    401:        l_element_courant = (*l_element_courant).suivant;
                    402: 
                    403:        if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
                    404:                == NULL)
                    405:        {
                    406:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    407:            return;
                    408:        }
                    409: 
                    410:        (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    411:                .nombre_arguments = 2;
                    412:        (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    413:                .fonction = instruction_vers_niveau_inferieur;
                    414: 
                    415:        if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    416:                .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
                    417:        {
                    418:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    419:            return;
                    420:        }
                    421: 
                    422:        strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    423:                .nom_fonction, ">>");
                    424: 
                    425:        (*l_element_courant).suivant = NULL;
                    426: 
                    427:        s_objet_argument_1 = NULL;
                    428:        s_objet_argument_2 = NULL;
                    429:    }
                    430: 
                    431:    /*
                    432:     * Expression / Nom ou valeur numérique
                    433:     */
                    434: 
                    435:    else if ((((*s_objet_argument_1).type == ALG) ||
                    436:            ((*s_objet_argument_1).type == RPN)) &&
                    437:            (((*s_objet_argument_2).type == NOM) ||
                    438:            ((*s_objet_argument_2).type == INT) ||
                    439:            ((*s_objet_argument_2).type == REL) ||
                    440:            ((*s_objet_argument_2).type == CPL)))
                    441:    {
                    442:        nombre_elements = 0;
                    443:        l_element_courant = (struct_liste_chainee *)
                    444:                (*s_objet_argument_1).objet;
                    445: 
                    446:        while(l_element_courant != NULL)
                    447:        {
                    448:            nombre_elements++;
                    449:            l_element_courant = (*l_element_courant).suivant;
                    450:        }
                    451: 
                    452:        if (nombre_elements == 2)
                    453:        {
                    454:            liberation(s_etat_processus, s_objet_argument_1);
                    455:            liberation(s_etat_processus, s_objet_argument_2);
                    456: 
                    457:            (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
                    458:            return;
                    459:        }
                    460: 
                    461:        if ((s_objet_resultat = copie_objet(s_etat_processus,
                    462:                s_objet_argument_1, 'N')) == NULL)
                    463:        {
                    464:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    465:            return;
                    466:        }
                    467: 
                    468:        l_element_courant = (struct_liste_chainee *)
                    469:                (*s_objet_resultat).objet;
                    470:        l_element_precedent = l_element_courant;
                    471:        l_element_courant = (*l_element_courant).suivant;
                    472: 
                    473:        if (((*l_element_precedent).suivant =
                    474:                allocation_maillon(s_etat_processus)) == NULL)
                    475:        {
                    476:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    477:            return;
                    478:        }
                    479: 
                    480:        (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
                    481:        (*(*l_element_precedent).suivant).suivant = l_element_courant;
                    482: 
                    483:        while((*l_element_courant).suivant != NULL)
                    484:        {
                    485:            l_element_precedent = l_element_courant;
                    486:            l_element_courant = (*l_element_courant).suivant;
                    487:        }
                    488: 
                    489:        if (((*l_element_precedent).suivant =
                    490:                allocation_maillon(s_etat_processus)) == NULL)
                    491:        {
                    492:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    493:            return;
                    494:        }
                    495: 
                    496:        if (((*(*l_element_precedent).suivant).donnee =
                    497:                allocation(s_etat_processus, FCT)) == NULL)
                    498:        {
                    499:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    500:            return;
                    501:        }
                    502: 
                    503:        (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
                    504:                .donnee).objet)).nombre_arguments = 2;
                    505:        (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
                    506:                .donnee).objet)).fonction = instruction_xroot;
                    507: 
                    508:        if (((*((struct_fonction *) (*(*(*l_element_precedent)
                    509:                .suivant).donnee).objet)).nom_fonction =
                    510:                malloc(6 * sizeof(unsigned char))) == NULL)
                    511:        {
                    512:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    513:            return;
                    514:        }
                    515: 
                    516:        strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
                    517:                .suivant).donnee).objet)).nom_fonction, "XROOT");
                    518: 
                    519:        (*(*l_element_precedent).suivant).suivant = l_element_courant;
                    520: 
                    521:        s_objet_argument_2 = NULL;
                    522:    }
                    523: 
                    524:    /*
                    525:     * Expression / Nom ou valeur numérique
                    526:     */
                    527: 
                    528:    else if ((((*s_objet_argument_1).type == NOM) ||
                    529:            ((*s_objet_argument_1).type == INT)) &&
                    530:            (((*s_objet_argument_2).type == ALG) ||
                    531:            ((*s_objet_argument_2).type == RPN)))
                    532:    {
                    533:        nombre_elements = 0;
                    534:        l_element_courant = (struct_liste_chainee *)
                    535:                (*s_objet_argument_2).objet;
                    536: 
                    537:        while(l_element_courant != NULL)
                    538:        {
                    539:            nombre_elements++;
                    540:            l_element_courant = (*l_element_courant).suivant;
                    541:        }
                    542: 
                    543:        if (nombre_elements == 2)
                    544:        {
                    545:            liberation(s_etat_processus, s_objet_argument_1);
                    546:            liberation(s_etat_processus, s_objet_argument_2);
                    547: 
                    548:            (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
                    549:            return;
                    550:        }
                    551: 
                    552:        if ((s_objet_resultat = copie_objet(s_etat_processus,
                    553:                s_objet_argument_2, 'N')) == NULL)
                    554:        {
                    555:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    556:            return;
                    557:        }
                    558: 
                    559:        l_element_courant = (struct_liste_chainee *)
                    560:                (*s_objet_resultat).objet;
                    561:        l_element_precedent = l_element_courant;
                    562: 
                    563:        while((*l_element_courant).suivant != NULL)
                    564:        {
                    565:            l_element_precedent = l_element_courant;
                    566:            l_element_courant = (*l_element_courant).suivant;
                    567:        }
                    568: 
                    569:        if (((*l_element_precedent).suivant =
                    570:                allocation_maillon(s_etat_processus)) == NULL)
                    571:        {
                    572:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    573:            return;
                    574:        }
                    575: 
                    576:        (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
                    577:        l_element_precedent = (*l_element_precedent).suivant;
                    578: 
                    579:        if (((*l_element_precedent).suivant =
                    580:                allocation_maillon(s_etat_processus)) == NULL)
                    581:        {
                    582:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    583:            return;
                    584:        }
                    585: 
                    586:        if (((*(*l_element_precedent).suivant).donnee =
                    587:                allocation(s_etat_processus, FCT)) == NULL)
                    588:        {
                    589:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    590:            return;
                    591:        }
                    592: 
                    593:        (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
                    594:                .donnee).objet)).nombre_arguments = 2;
                    595:        (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
                    596:                .donnee).objet)).fonction = instruction_xroot;
                    597: 
                    598:        if (((*((struct_fonction *) (*(*(*l_element_precedent)
                    599:                .suivant).donnee).objet)).nom_fonction =
                    600:                malloc(6 * sizeof(unsigned char))) == NULL)
                    601:        {
                    602:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    603:            return;
                    604:        }
                    605: 
                    606:        strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
                    607:                .suivant).donnee).objet)).nom_fonction, "XROOT");
                    608: 
                    609:        (*(*l_element_precedent).suivant).suivant = l_element_courant;
                    610: 
                    611:        s_objet_argument_1 = NULL;
                    612:    }
                    613: 
                    614:    /*
                    615:     * Expression / Expression
                    616:     */
                    617: 
                    618:    else if ((((*s_objet_argument_1).type == ALG) &&
                    619:            ((*s_objet_argument_2).type == ALG)) ||
                    620:            (((*s_objet_argument_1).type == RPN) &&
                    621:            ((*s_objet_argument_2).type == RPN)))
                    622:    {
                    623:        nombre_elements = 0;
                    624:        l_element_courant = (struct_liste_chainee *)
                    625:                (*s_objet_argument_1).objet;
                    626: 
                    627:        while(l_element_courant != NULL)
                    628:        {
                    629:            nombre_elements++;
                    630:            l_element_courant = (*l_element_courant).suivant;
                    631:        }
                    632: 
                    633:        if (nombre_elements == 2)
                    634:        {
                    635:            liberation(s_etat_processus, s_objet_argument_1);
                    636:            liberation(s_etat_processus, s_objet_argument_2);
                    637: 
                    638:            (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
                    639:            return;
                    640:        }
                    641: 
                    642:        nombre_elements = 0;
                    643:        l_element_courant = (struct_liste_chainee *)
                    644:                (*s_objet_argument_2).objet;
                    645: 
                    646:        while(l_element_courant != NULL)
                    647:        {
                    648:            nombre_elements++;
                    649:            l_element_courant = (*l_element_courant).suivant;
                    650:        }
                    651: 
                    652:        if (nombre_elements == 2)
                    653:        {
                    654:            liberation(s_etat_processus, s_objet_argument_1);
                    655:            liberation(s_etat_processus, s_objet_argument_2);
                    656: 
                    657:            (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
                    658:            return;
                    659:        }
                    660: 
                    661:        if ((s_copie_argument_1 = copie_objet(s_etat_processus,
                    662:                s_objet_argument_1, 'N')) == NULL)
                    663:        {
                    664:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    665:            return;
                    666:        }
                    667: 
                    668:        if ((s_copie_argument_2 = copie_objet(s_etat_processus,
                    669:                s_objet_argument_2, 'N')) == NULL)
                    670:        {
                    671:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    672:            return;
                    673:        }
                    674: 
                    675:        l_element_courant = (struct_liste_chainee *)
                    676:                (*s_copie_argument_1).objet;
                    677:        (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
                    678:                (*s_copie_argument_1).objet)).suivant;
                    679: 
                    680:        liberation(s_etat_processus, (*l_element_courant).donnee);
                    681:        free(l_element_courant);
                    682: 
                    683:        l_element_courant = (struct_liste_chainee *)
                    684:                (*s_copie_argument_2).objet;
                    685:        l_element_precedent = l_element_courant;
                    686:        s_objet_resultat = s_copie_argument_2;
                    687: 
                    688:        while((*l_element_courant).suivant != NULL)
                    689:        {
                    690:            l_element_precedent = l_element_courant;
                    691:            l_element_courant = (*l_element_courant).suivant;
                    692:        }
                    693: 
                    694:        liberation(s_etat_processus, (*l_element_courant).donnee);
                    695:        free(l_element_courant);
                    696: 
                    697:        (*l_element_precedent).suivant = (struct_liste_chainee *)
                    698:                (*s_copie_argument_1).objet;
                    699:        free(s_copie_argument_1);
                    700: 
                    701:        l_element_courant = (*l_element_precedent).suivant;
                    702:        while((*l_element_courant).suivant != NULL)
                    703:        {
                    704:            l_element_precedent = l_element_courant;
                    705:            l_element_courant = (*l_element_courant).suivant;
                    706:        }
                    707: 
                    708:        if (((*l_element_precedent).suivant =
                    709:                allocation_maillon(s_etat_processus)) == NULL)
                    710:        {
                    711:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    712:            return;
                    713:        }
                    714: 
                    715:        (*(*l_element_precedent).suivant).suivant = l_element_courant;
                    716:        l_element_courant = (*l_element_precedent).suivant;
                    717: 
                    718:        if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
                    719:                == NULL)
                    720:        {
                    721:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    722:            return;
                    723:        }
                    724: 
                    725:        (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    726:                .nombre_arguments = 2;
                    727:        (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    728:                .fonction = instruction_xroot;
                    729: 
                    730:        if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    731:                .nom_fonction = malloc(6 * sizeof(unsigned char))) == NULL)
                    732:        {
                    733:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    734:            return;
                    735:        }
                    736: 
                    737:        strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                    738:                .nom_fonction, "XROOT");
                    739:    }
                    740:    else
                    741:    {
                    742:        liberation(s_etat_processus, s_objet_argument_1);
                    743:        liberation(s_etat_processus, s_objet_argument_2);
                    744: 
                    745:        (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
                    746:        return;
                    747:    }
                    748: 
                    749:    liberation(s_etat_processus, s_objet_argument_1);
                    750:    liberation(s_etat_processus, s_objet_argument_2);
                    751: 
                    752:    if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                    753:            s_objet_resultat) == d_erreur)
                    754:    {
                    755:        return;
                    756:    }
                    757: 
                    758:    return;
                    759: }
                    760: 
                    761: 
                    762: /*
                    763: ================================================================================
                    764:   Fonction 'xcol'
                    765: ================================================================================
                    766:   Entrées : pointeur sur une structure struct_processus
                    767: --------------------------------------------------------------------------------
                    768:   Sorties :
                    769: --------------------------------------------------------------------------------
                    770:   Effets de bord : néant
                    771: ================================================================================
                    772: */
                    773: 
                    774: void
                    775: instruction_xcol(struct_processus *s_etat_processus)
                    776: {
                    777:    struct_objet            *s_objet_argument;
                    778: 
                    779:    (*s_etat_processus).erreur_execution = d_ex;
                    780: 
                    781:    if ((*s_etat_processus).affichage_arguments == 'Y')
                    782:    {
                    783:        printf("\n  XCOL ");
                    784: 
                    785:        if ((*s_etat_processus).langue == 'F')
                    786:        {
                    787:            printf("(définition de la colonne statistique X)\n\n");
                    788:        }
                    789:        else
                    790:        {
                    791:            printf("(definition of statistical X column)\n\n");
                    792:        }
                    793: 
                    794:        printf("    1: %s\n", d_INT);
                    795: 
                    796:        return;
                    797:    }
                    798:    else if ((*s_etat_processus).test_instruction == 'Y')
                    799:    {
                    800:        (*s_etat_processus).nombre_arguments = -1;
                    801:        return;
                    802:    }
                    803: 
                    804:    if (test_cfsf(s_etat_processus, 31) == d_vrai)
                    805:    {
                    806:        if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
                    807:        {
                    808:            return;
                    809:        }
                    810:    }
                    811: 
                    812:    if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                    813:            &s_objet_argument) == d_erreur)
                    814:    {
                    815:        (*s_etat_processus).erreur_execution = d_ex_manque_argument;
                    816:        return;
                    817:    }
                    818: 
                    819:    if ((*s_objet_argument).type == INT)
                    820:    {
                    821:        if ((*((integer8 *) (*s_objet_argument).objet)) <= 0)
                    822:        {
                    823:            liberation(s_etat_processus, s_objet_argument);
                    824: 
                    825:            (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
                    826:            return;
                    827:        }
                    828: 
                    829:        (*s_etat_processus).colonne_statistique_1 =
                    830:                (*((integer8 *) (*s_objet_argument).objet));
                    831:    }
                    832:    else
                    833:    {
                    834:        liberation(s_etat_processus, s_objet_argument);
                    835: 
                    836:        (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
                    837:        return;
                    838:    }
                    839: 
                    840:    liberation(s_etat_processus, s_objet_argument);
                    841: 
                    842:    return;
                    843: }
                    844: 
                    845: // vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>