Annotation of rpl/src/gestion_pile_systeme.c, revision 1.12

1.1       bertrand    1: /*
                      2: ================================================================================
1.11      bertrand    3:   RPL/2 (R) version 4.0.16
1.1       bertrand    4:   Copyright (C) 1989-2010 Dr. BERTRAND Joël
                      5: 
                      6:   This file is part of RPL/2.
                      7: 
                      8:   RPL/2 is free software; you can redistribute it and/or modify it
                      9:   under the terms of the CeCILL V2 License as published by the french
                     10:   CEA, CNRS and INRIA.
                     11:  
                     12:   RPL/2 is distributed in the hope that it will be useful, but WITHOUT
                     13:   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
                     14:   FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
                     15:   for more details.
                     16:  
                     17:   You should have received a copy of the CeCILL License
                     18:   along with RPL/2. If not, write to info@cecill.info.
                     19: ================================================================================
                     20: */
                     21: 
                     22: 
                     23: #include "rpl.conv.h"
                     24: 
                     25: 
                     26: /*
                     27: ================================================================================
                     28:   Procédure d'estimation de la longueur du tampon
                     29: ================================================================================
                     30:   Entrée :
                     31: --------------------------------------------------------------------------------
                     32:   Sortie :
                     33: --------------------------------------------------------------------------------
                     34:   Effets de bord : néant
                     35: ================================================================================
                     36: */
                     37: 
                     38: static inline void
                     39: estimation_taille_pile_systeme(struct_processus *s_etat_processus)
                     40: {
                     41:    (*s_etat_processus).estimation_taille_pile_systeme_tampon =
                     42:            ((*s_etat_processus).estimation_taille_pile_systeme_tampon *
                     43:            ((double) 0.9)) + ((*s_etat_processus)
                     44:            .hauteur_pile_systeme * ((double) 0.1));
                     45:    return;
                     46: }
                     47: 
                     48: 
                     49: /*
                     50: ================================================================================
                     51:   Procédure d'empilement d'un nouvel élément
                     52: ================================================================================
                     53:   Entrée :
                     54: --------------------------------------------------------------------------------
                     55:   Sortie :
                     56: --------------------------------------------------------------------------------
                     57:   Effets de bord : néant
                     58: ================================================================================
                     59: */
                     60: 
                     61: void
                     62: empilement_pile_systeme(struct_processus *s_etat_processus)
                     63: {
                     64:    struct_liste_pile_systeme       *l_ancienne_base_liste;
                     65:    struct_liste_pile_systeme       *l_nouvelle_base_liste;
                     66: 
                     67:    l_ancienne_base_liste = (*s_etat_processus).l_base_pile_systeme;
                     68: 
                     69:    if ((*s_etat_processus).debug == d_vrai)
                     70:        if (((*s_etat_processus).type_debug &
                     71:                d_debug_pile_systeme) != 0)
                     72:    {
                     73:        if (strlen((*s_etat_processus).instruction_courante) != 0)
                     74:        {
                     75:            if ((*s_etat_processus).langue == 'F')
                     76:            {
                     77:                printf("[%d] Empilement sur la pile système à la suite de "
                     78:                        "l'instruction %s\n", (int) getpid(),
                     79:                        (*s_etat_processus).instruction_courante);
                     80:            }
                     81:            else
                     82:            {
                     83:                printf("[%d] Pushing on system stack (instruction %s)\n",
                     84:                        (int) getpid(),
                     85:                        (*s_etat_processus).instruction_courante);
                     86:            }
                     87:        }
                     88:        else
                     89:        {
                     90:            if ((*s_etat_processus).langue == 'F')
                     91:            {
                     92:                printf("[%d] Empilement sur la pile système\n",
                     93:                        (int) getpid());
                     94:            }
                     95:            else
                     96:            {
                     97:                printf("[%d] Pushing on system stack\n", (int) getpid());
                     98:            }
                     99:        }
                    100: 
                    101:        fflush(stdout);
                    102:    }
                    103: 
                    104:    if ((*s_etat_processus).pile_systeme_tampon == NULL)
                    105:    {
                    106:        // Tampon vide, on alloue un élément.
                    107: 
                    108:        if ((l_nouvelle_base_liste = malloc(sizeof(struct_liste_pile_systeme)))
                    109:                == NULL)
                    110:        {
                    111:            (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                    112:            return;
                    113:        }
                    114:    }
                    115:    else
                    116:    {
                    117:        // Tampon utilisable, on retire un élément du tampon.
                    118: 
                    119:        l_nouvelle_base_liste = (*s_etat_processus).pile_systeme_tampon;
                    120:        (*s_etat_processus).pile_systeme_tampon =
                    121:                (*l_nouvelle_base_liste).suivant;
                    122:        (*s_etat_processus).taille_pile_systeme_tampon--;
                    123:    }
                    124: 
                    125:    (*s_etat_processus).hauteur_pile_systeme++;
                    126:    (*s_etat_processus).l_base_pile_systeme = l_nouvelle_base_liste;
                    127:    (*(*s_etat_processus).l_base_pile_systeme).suivant =
                    128:            l_ancienne_base_liste;
                    129: 
                    130:    (*(*s_etat_processus).l_base_pile_systeme).type_cloture = ' ';
                    131:    (*(*s_etat_processus).l_base_pile_systeme).clause = ' ';
                    132:    (*(*s_etat_processus).l_base_pile_systeme).adresse_retour = 0;
                    133:    (*(*s_etat_processus).l_base_pile_systeme).niveau_courant = 0;
                    134:    (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N';
                    135:    (*(*s_etat_processus).l_base_pile_systeme).indice_boucle = NULL;
                    136:    (*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle = NULL;
                    137:    (*(*s_etat_processus).l_base_pile_systeme).objet_de_test = NULL;
                    138:    (*(*s_etat_processus).l_base_pile_systeme).nom_variable = NULL;
                    139:    (*(*s_etat_processus).l_base_pile_systeme).pointeur_objet_retour = NULL;
                    140:    (*(*s_etat_processus).l_base_pile_systeme)
                    141:            .origine_routine_evaluation = 'N';
                    142:    (*(*s_etat_processus).l_base_pile_systeme).arret_si_exception =
                    143:            (*s_etat_processus).arret_si_exception;
                    144:    (*(*s_etat_processus).l_base_pile_systeme).creation_variables_statiques
                    145:            = (*s_etat_processus).creation_variables_statiques;
                    146:    (*(*s_etat_processus).l_base_pile_systeme).creation_variables_partagees
                    147:            = (*s_etat_processus).creation_variables_partagees;
                    148:    (*(*s_etat_processus).l_base_pile_systeme).evaluation_expression =
                    149:            d_faux;
                    150: 
                    151:    (*s_etat_processus).erreur_systeme = d_es;
                    152:    (*s_etat_processus).creation_variables_statiques = d_faux;
                    153:    (*s_etat_processus).creation_variables_partagees = d_faux;
                    154: 
                    155:    return;
                    156: }
                    157: 
                    158: 
                    159: /*
                    160: ================================================================================
                    161:   Procédure de dépilement d'un élément
                    162: ================================================================================
                    163:   Entrée :
                    164: --------------------------------------------------------------------------------
                    165:   Sortie :
                    166: --------------------------------------------------------------------------------
                    167:   Effets de bord : néant
                    168: ================================================================================
                    169: */
                    170: 
                    171: void
                    172: depilement_pile_systeme(struct_processus *s_etat_processus)
                    173: {
                    174:    struct_liste_pile_systeme       *l_ancienne_base_liste;
                    175:    struct_liste_pile_systeme       *l_nouvelle_base_liste;
                    176: 
                    177:    if ((*s_etat_processus).debug == d_vrai)
                    178:        if (((*s_etat_processus).type_debug &
                    179:                d_debug_pile_systeme) != 0)
                    180:    {
                    181:        if (strlen((*s_etat_processus).instruction_courante) != 0)
                    182:        {
                    183:            if ((*s_etat_processus).langue == 'F')
                    184:            {
                    185:                printf("[%d] Dépilement de la pile système à la suite "
                    186:                        "de l'instruction %s\n", (int) getpid(),
                    187:                        (*s_etat_processus).instruction_courante);
                    188:            }
                    189:            else
                    190:            {
                    191:                printf("[%d] Pulling from system stack (instruction %s)\n",
                    192:                        (int) getpid(),
                    193:                        (*s_etat_processus).instruction_courante);
                    194:            }
                    195:        }
                    196:        else
                    197:        {
                    198:            if ((*s_etat_processus).langue == 'F')
                    199:            {
                    200:                printf("[%d] Dépilement de la pile système\n",
                    201:                        (int) getpid());
                    202:            }
                    203:            else
                    204:            {
                    205:                printf("[%d] Pulling from system stack\n", (int) getpid());
                    206:            }
                    207:        }
                    208: 
                    209:        fflush(stdout);
                    210:    }
                    211: 
                    212:    if ((*s_etat_processus).l_base_pile_systeme == NULL)
                    213:    {
                    214:        (*s_etat_processus).erreur_systeme = d_es_pile_vide;
                    215:    }
                    216:    else
                    217:    {
                    218:        (*s_etat_processus).hauteur_pile_systeme--;
                    219:        l_ancienne_base_liste = (*s_etat_processus).l_base_pile_systeme;
                    220:        l_nouvelle_base_liste = (*l_ancienne_base_liste).suivant;
                    221: 
                    222:        (*s_etat_processus).l_base_pile_systeme = l_nouvelle_base_liste;
                    223:        (*s_etat_processus).erreur_systeme = d_es;
                    224: 
                    225:        // On positionne le drapeau de création des variables statiques.
                    226: 
                    227:        (*s_etat_processus).creation_variables_statiques =
                    228:                 (*l_ancienne_base_liste).creation_variables_statiques;
                    229:        (*s_etat_processus).creation_variables_partagees =
                    230:                 (*l_ancienne_base_liste).creation_variables_partagees;
                    231: 
                    232:        if ((*l_ancienne_base_liste).nom_variable != NULL)
                    233:        {
                    234:            free((*l_ancienne_base_liste).nom_variable);
                    235:        }
                    236: 
                    237:        liberation(s_etat_processus, (*l_ancienne_base_liste).indice_boucle);
                    238:        liberation(s_etat_processus,
                    239:                (*l_ancienne_base_liste).limite_indice_boucle);
                    240:        liberation(s_etat_processus, (*l_ancienne_base_liste).objet_de_test);
                    241: 
                    242:        if ((*s_etat_processus).taille_pile_systeme_tampon <= (10 *
                    243:                ((*s_etat_processus).estimation_taille_pile_systeme_tampon
                    244:                + 1)))
                    245:        {
                    246:            // Enregistrement de la structure pour un usage ultérieur.
                    247: 
                    248:            (*l_ancienne_base_liste).suivant =
                    249:                    (*s_etat_processus).pile_systeme_tampon;
                    250:            (*s_etat_processus).pile_systeme_tampon = l_ancienne_base_liste;
                    251:            (*s_etat_processus).taille_pile_systeme_tampon++;
                    252:        }
                    253:        else
                    254:        {
                    255:            // Libération car le tampon est plein.
                    256: 
                    257:            free(l_ancienne_base_liste);
                    258:        }
                    259:    }
                    260: 
                    261:    return;
                    262: }
                    263: 
1.7       bertrand  264: 
                    265: /*
                    266: ================================================================================
                    267:   Procédure d'effacement de la pile système
                    268: ================================================================================
                    269:   Entrée :
                    270: --------------------------------------------------------------------------------
                    271:   Sortie :
                    272: --------------------------------------------------------------------------------
                    273:   Effets de bord : néant
                    274: ================================================================================
                    275: */
                    276: 
                    277: void
                    278: effacement_pile_systeme(struct_processus *s_etat_processus)
                    279: {
                    280:    while((*s_etat_processus).l_base_pile_systeme != NULL)
                    281:    {
                    282:        depilement_pile_systeme(s_etat_processus);
                    283:    }
                    284: 
                    285:    return;
                    286: }
                    287: 
1.12    ! bertrand  288: 
        !           289: /*
        !           290: ================================================================================
        !           291:   Procédure d'affichage de la pile système
        !           292: ================================================================================
        !           293:   Entrée :
        !           294: --------------------------------------------------------------------------------
        !           295:   Sortie :
        !           296: --------------------------------------------------------------------------------
        !           297:   Effets de bord : néant
        !           298: ================================================================================
        !           299: */
        !           300: 
        !           301: void
        !           302: trace(struct_processus *s_etat_processus, FILE *flux)
        !           303: {
        !           304:    struct_liste_pile_systeme       *l_element_courant;
        !           305: 
        !           306:    integer8                        i;
        !           307: 
        !           308:    l_element_courant = (*s_etat_processus).l_base_pile_systeme;
        !           309:    i = 0;
        !           310: 
        !           311:    while(l_element_courant != NULL)
        !           312:    {
        !           313:        i++;
        !           314:        l_element_courant = (*l_element_courant).suivant;
        !           315:    }
        !           316: 
        !           317:    l_element_courant = (*s_etat_processus).l_base_pile_systeme;
        !           318:    flockfile(flux);
        !           319: 
        !           320:    if ((flux == stderr) || (flux == stdout))
        !           321:    {
        !           322:        fprintf(flux, "+++Backtrace\n");
        !           323:    }
        !           324: 
        !           325:    while(l_element_courant != NULL)
        !           326:    {
        !           327:        fprintf(flux, "%d : D=", i--);
        !           328: 
        !           329:        fprintf(flux, ((*l_element_courant).creation_variables_statiques
        !           330:                == d_vrai) ? "1" : "0");
        !           331:        fprintf(flux, ((*l_element_courant).creation_variables_partagees
        !           332:                == d_vrai) ? "1" : "0");
        !           333:        fprintf(flux, ((*l_element_courant).arret_si_exception == d_vrai)
        !           334:                ? "1" : "0");
        !           335:        fprintf(flux, ((*l_element_courant).evaluation_expression == d_vrai)
        !           336:                ? "1" : "0");
        !           337: 
        !           338:        fprintf(flux, " F=%c%c L=%lu ",
        !           339:                ((*l_element_courant).clause == ' ') ? '-' :
        !           340:                (*l_element_courant).clause,
        !           341:                ((*l_element_courant).type_cloture == ' ') ? '-' :
        !           342:                (*l_element_courant).type_cloture,
        !           343:                (*l_element_courant).niveau_courant);
        !           344: 
        !           345:        if ((*l_element_courant).retour_definition == 'Y')
        !           346:        {
        !           347:            fprintf(flux, "RTRN ");
        !           348: 
        !           349:            if ((*l_element_courant).origine_routine_evaluation == 'Y')
        !           350:            {
        !           351:                fprintf(flux, "EVL ");
        !           352: 
        !           353:                if ((*l_element_courant).adresse_retour != 0)
        !           354:                {
        !           355:                    fprintf(flux, "P=%lu", (*l_element_courant)
        !           356:                            .adresse_retour);
        !           357:                }
        !           358:            }
        !           359:            else
        !           360:            {
        !           361:                fprintf(flux, "SEQ ");
        !           362: 
        !           363:                if ((*l_element_courant).pointeur_objet_retour != NULL)
        !           364:                {
        !           365:                    fprintf(flux, "A=%X", (*l_element_courant)
        !           366:                            .pointeur_objet_retour);
        !           367:                }
        !           368:            }
        !           369:        }
        !           370:        else
        !           371:        {
        !           372:            fprintf(flux, "NONE ");
        !           373: 
        !           374:            if ((*l_element_courant).origine_routine_evaluation == 'Y')
        !           375:            {
        !           376:                fprintf(flux, "EVL ");
        !           377: 
        !           378:                if ((*l_element_courant).adresse_retour != 0)
        !           379:                {
        !           380:                    fprintf(flux, "P=%lu", (*l_element_courant)
        !           381:                            .adresse_retour);
        !           382:                }
        !           383:            }
        !           384:            else
        !           385:            {
        !           386:                fprintf(flux, "SEQ ");
        !           387: 
        !           388:                if ((*l_element_courant).pointeur_objet_retour != NULL)
        !           389:                {
        !           390:                    fprintf(flux, "A=%X", (*l_element_courant)
        !           391:                            .pointeur_objet_retour);
        !           392:                }
        !           393:            }
        !           394:        }
        !           395: 
        !           396:        fprintf(flux, "\n");
        !           397: 
        !           398:        l_element_courant = (*l_element_courant).suivant;
        !           399:    }
        !           400: 
        !           401:    fprintf(flux, "\n");
        !           402:    funlockfile(flux);
        !           403: 
        !           404:    return;
        !           405: }
        !           406: 
1.1       bertrand  407: // vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>