![]() ![]() | ![]() |
Passage de la branche 4.1 en branche stable.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.0 4: Copyright (C) 1989-2011 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 'simplification' (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