Annotation of rpl/src/simplification.c, revision 1.1
1.1 ! bertrand 1: /*
! 2: ================================================================================
! 3: RPL/2 (R) version 4.0.9
! 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: Fonction 'simplication' (ne libère pas les paramètres)
! 29: ================================================================================
! 30: Entrées : pointeur sur une structure struct_processus
! 31: --------------------------------------------------------------------------------
! 32: Sorties :
! 33: --------------------------------------------------------------------------------
! 34: Effets de bord : néant
! 35: ================================================================================
! 36: */
! 37:
! 38: struct_objet *
! 39: simplification(struct_processus *s_etat_processus, struct_objet *s_objet)
! 40: {
! 41:
! 42: struct_arbre *s_arbre;
! 43: struct_arbre *s_noeud_courant;
! 44:
! 45: struct_liste_chainee *l_element_courant;
! 46:
! 47: struct_objet *s_objet_simplifie;
! 48: struct_objet **t_expression;
! 49:
! 50: unsigned long i;
! 51: unsigned long nombre_elements;
! 52:
! 53: s_arbre = NULL;
! 54:
! 55: if ((*s_objet).type == ALG)
! 56: {
! 57: #ifdef EXPERIMENTAL_CODE
! 58: // Inversion de l'ordre des instructions dans l'expression
! 59:
! 60: nombre_elements = 0;
! 61: l_element_courant = (*s_objet).objet;
! 62:
! 63: while(l_element_courant != NULL)
! 64: {
! 65: nombre_elements++;
! 66: l_element_courant = (*l_element_courant).suivant;
! 67: }
! 68:
! 69: if ((t_expression = malloc(nombre_elements * sizeof(struct_objet *)))
! 70: == NULL)
! 71: {
! 72: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 73: return(NULL);
! 74: }
! 75:
! 76: i = nombre_elements - 1;
! 77: l_element_courant = (*s_objet).objet;
! 78:
! 79: while(l_element_courant != NULL)
! 80: {
! 81: if ((t_expression[i--] = copie_objet(s_etat_processus,
! 82: (*l_element_courant).donnee, 'O')) == NULL)
! 83: {
! 84: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 85: return(NULL);
! 86: }
! 87:
! 88: l_element_courant = (*l_element_courant).suivant;
! 89: }
! 90:
! 91: // L'objet est toujours évaluable car il s'agit d'une expression
! 92: // algébrique (cela revient à dire qu'il n'y a qu'un seul arbre
! 93: // et que celui-ci est terminé).
! 94:
! 95: s_arbre = creation_arbre(s_etat_processus, t_expression, 0,
! 96: nombre_elements - 1);
! 97:
! 98: for(i = 0; i < nombre_elements; liberation(t_expression[i++]));
! 99: free(t_expression);
! 100: #endif
! 101:
! 102: s_objet_simplifie = copie_objet(s_etat_processus, s_objet, 'P');
! 103:
! 104: // On essaye déjà de voir si l'arbre est cohérent...
! 105: }
! 106: else
! 107: {
! 108: s_objet_simplifie = copie_objet(s_etat_processus, s_objet, 'P');
! 109: }
! 110:
! 111: return(s_objet_simplifie);
! 112: }
! 113:
! 114:
! 115: /*
! 116: ================================================================================
! 117: Fonction créant un noeud dans l'arbre
! 118: ================================================================================
! 119: Entrées : pointeur sur une structure struct_arbre
! 120: --------------------------------------------------------------------------------
! 121: Sorties :
! 122: --------------------------------------------------------------------------------
! 123: Effets de bord : néant
! 124: ================================================================================
! 125: */
! 126:
! 127: struct_arbre *
! 128: creation_arbre(struct_processus *s_etat_processus,
! 129: struct_objet **t_objets, unsigned long indice,
! 130: unsigned long indice_maximal)
! 131: {
! 132: struct_arbre *s_noeud;
! 133:
! 134: unsigned long i;
! 135:
! 136: if ((s_noeud = malloc(sizeof(struct_arbre))) == NULL)
! 137: {
! 138: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 139: return(NULL);
! 140: }
! 141:
! 142: // indice ne peut jamais être supérieur à indice_maximal
! 143:
! 144: #if 0
! 145: // Création de la racine de l'arbre
! 146:
! 147: if ((s_arbre = malloc(sizeof(struct_arbre))) == NULL)
! 148: {
! 149: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 150: return(NULL);
! 151: }
! 152:
! 153: s_noeud_courant = s_arbre;
! 154:
! 155: for(i = 0; i < nombre_elements; i++)
! 156: {
! 157: if (strcmp((*t_expression[i]).type, "FCT") == 0)
! 158: {
! 159: if ((strcmp((*((struct_fonction *) (*t_expression[i]).objet))
! 160: .nom_fonction, "<<") != 0) &&
! 161: (strcmp((*((struct_fonction *)
! 162: (*t_expression[i]).objet)).nom_fonction, ">>") != 0))
! 163: {
! 164: // Création d'un noeud
! 165: }
! 166: }
! 167: }
! 168: #endif
! 169: return(NULL);
! 170: }
! 171:
! 172:
! 173: /*
! 174: ================================================================================
! 175: Fonction simplifiant l'arbre q-aire en arbre q'-aire (q <= q')
! 176: ================================================================================
! 177: Entrées : pointeur sur une structure struct_arbre
! 178: --------------------------------------------------------------------------------
! 179: Sorties :
! 180: --------------------------------------------------------------------------------
! 181: Effets de bord : néant
! 182: ================================================================================
! 183: */
! 184:
! 185: void
! 186: simplification_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud)
! 187: {
! 188: unsigned long i;
! 189:
! 190: if ((*s_noeud).feuilles != NULL)
! 191: {
! 192: for(i = 0; i < (*s_noeud).nombre_feuilles; i++)
! 193: {
! 194: simplification_arbre(s_etat_processus, (*s_noeud).feuilles[i]);
! 195:
! 196: /*
! 197: * Si le noeud est une fonction compatible avec une fonction
! 198: * présente dans les feuilles, on réunit les deux.
! 199: */
! 200:
! 201: if ((*(*((*s_noeud).feuilles[i])).objet).type == FCT)
! 202: {
! 203: if (((strcmp((*((struct_fonction *) (*s_noeud).objet))
! 204: .nom_fonction, "+") == 0) && (strcmp(
! 205: (*((struct_fonction *) (*(*((*s_noeud).feuilles[i]))
! 206: .objet).objet)).nom_fonction, "+") == 0)) ||
! 207: ((strcmp((*((struct_fonction *) (*s_noeud).objet))
! 208: .nom_fonction, "*") == 0) && (strcmp(
! 209: (*((struct_fonction *) (*(*((*s_noeud).feuilles[i]))
! 210: .objet).objet)).nom_fonction, "*") == 0)))
! 211: {
! 212: }
! 213: }
! 214: }
! 215: }
! 216:
! 217: return;
! 218: }
! 219:
! 220:
! 221: /*
! 222: ================================================================================
! 223: Fonction parcourant l'arbre q-aire
! 224: ================================================================================
! 225: Entrées : pointeur sur une structure struct_arbre
! 226: --------------------------------------------------------------------------------
! 227: Sorties :
! 228: --------------------------------------------------------------------------------
! 229: Effets de bord : néant
! 230: ================================================================================
! 231: */
! 232:
! 233: void
! 234: parcours_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud)
! 235: {
! 236: unsigned long i;
! 237:
! 238: if ((*s_noeud).feuilles != NULL)
! 239: {
! 240: for(i = 0; i < (*s_noeud).nombre_feuilles; i++)
! 241: {
! 242: parcours_arbre(s_etat_processus, (*s_noeud).feuilles[i]);
! 243: }
! 244: }
! 245:
! 246: return;
! 247: }
! 248:
! 249:
! 250: /*
! 251: ================================================================================
! 252: Fonction libérant l'arbre q-aire
! 253: ================================================================================
! 254: Entrées : pointeur sur une structure struct_arbre
! 255: --------------------------------------------------------------------------------
! 256: Sorties :
! 257: --------------------------------------------------------------------------------
! 258: Effets de bord : néant
! 259: ================================================================================
! 260: */
! 261:
! 262: void
! 263: liberation_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud)
! 264: {
! 265: unsigned long i;
! 266:
! 267: if ((*s_noeud).feuilles != NULL)
! 268: {
! 269: for(i = 0; i < (*s_noeud).nombre_feuilles; i++)
! 270: {
! 271: }
! 272: }
! 273:
! 274: return;
! 275: }
! 276:
! 277: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to simplification.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src