version 1.70, 2019/11/05 15:37:51
|
version 1.71, 2019/11/06 17:31:47
|
Line 218 ordonnancement_branches(const void *a1,
|
Line 218 ordonnancement_branches(const void *a1,
|
|
|
if (((**_a1).feuille != NULL) && ((**_a2).feuille != NULL)) |
if (((**_a1).feuille != NULL) && ((**_a2).feuille != NULL)) |
{ |
{ |
|
// Si les types sont identiques, on ne change rien. |
|
|
if ((*(*(**_a1).feuille).donnee).type == |
if ((*(*(**_a1).feuille).donnee).type == |
(*(*(**_a2).feuille).donnee).type) |
(*(*(**_a2).feuille).donnee).type) |
{ |
{ |
return(0); |
return(0); |
} |
} |
|
|
if (((*(*(**_a1).feuille).donnee).type == INT) || |
// On rejette les nombres à la fin. |
|
|
|
if ((((*(*(**_a1).feuille).donnee).type == INT) || |
((*(*(**_a1).feuille).donnee).type == REL) || |
((*(*(**_a1).feuille).donnee).type == REL) || |
((*(*(**_a1).feuille).donnee).type == CPL)) |
((*(*(**_a1).feuille).donnee).type == CPL)) && |
|
((((*(*(**_a2).feuille).donnee).type != INT) && |
|
((*(*(**_a2).feuille).donnee).type != REL) && |
|
((*(*(**_a2).feuille).donnee).type != CPL)))) |
{ |
{ |
return(1); |
return(1); |
} |
} |
Line 248 simplification_arbre(struct_processus *s
|
Line 255 simplification_arbre(struct_processus *s
|
integer8 j; |
integer8 j; |
integer8 nouveaux_elements; |
integer8 nouveaux_elements; |
|
|
|
struct_arbre *s_branche; |
|
|
struct_objet *s_objet; |
struct_objet *s_objet; |
|
|
if ((*(*(*s_arbre).feuille).donnee).type != FCT) |
if ((*(*(*s_arbre).feuille).donnee).type != FCT) |
Line 258 simplification_arbre(struct_processus *s
|
Line 267 simplification_arbre(struct_processus *s
|
return; |
return; |
} |
} |
|
|
|
// Transformation des soustractions que l'on remplace par |
|
// une addition de l'opposé. Si l'on a une soustraction, |
|
// on greffe donc une instruction NEG dans l'arbre. |
|
// Note : à cet instant, l'instruction '-' ne peut avoir que deux |
|
// opérandes. |
|
|
|
if (strcmp((*((struct_fonction *) (*(*((*s_arbre).feuille)).donnee).objet)) |
|
.nom_fonction, "-") == 0) |
|
{ |
|
if ((*s_arbre).nombre_branches != 2) |
|
{ |
|
(*s_etat_processus).erreur_execution = d_ex_simplification; |
|
return; |
|
} |
|
|
|
liberation(s_etat_processus, (*((*s_arbre).feuille)).donnee); |
|
|
|
if (((*((*s_arbre).feuille)).donnee = allocation(s_etat_processus, |
|
FCT)) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
if (((*((struct_fonction *) (*(*((*s_arbre).feuille)).donnee).objet)) |
|
.nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
strcpy((*((struct_fonction *) (*(*((*s_arbre).feuille)).donnee).objet)) |
|
.nom_fonction, "+"); |
|
(*((struct_fonction *) (*(*((*s_arbre).feuille)).donnee).objet)) |
|
.nombre_arguments = 1; |
|
|
|
if ((s_branche = malloc(sizeof(struct_arbre))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
if (((*s_branche).branches = malloc(sizeof(struct_arbre *))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
if (((*s_branche).feuille = allocation_maillon(s_etat_processus)) |
|
== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
(*(*s_branche).feuille).suivant = NULL; |
|
|
|
if (((*(*s_branche).feuille).donnee = allocation(s_etat_processus, FCT)) |
|
== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
if (((*((struct_fonction *) (*(*(*s_branche).feuille).donnee).objet)) |
|
.nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
strcpy((*((struct_fonction *) (*(*(*s_branche).feuille).donnee).objet)) |
|
.nom_fonction, "NEG"); |
|
(*((struct_fonction *) (*(*(*s_branche).feuille).donnee).objet)) |
|
.nombre_arguments = 1; |
|
(*s_branche).branches[0] = (*s_arbre).branches[1]; |
|
(*s_branche).nombre_branches = 1; |
|
(*s_arbre).branches[1] = s_branche; |
|
} |
|
|
// La feuille est une fonction, on peut envisager la simplification |
// La feuille est une fonction, on peut envisager la simplification |
// de l'arbre. Pour cela, on descend d'un niveau pour greffer |
// de l'arbre. Pour cela, on descend d'un niveau pour greffer |
// de nouvelles branches. |
// de nouvelles branches. |
Line 274 simplification_arbre(struct_processus *s
|
Line 363 simplification_arbre(struct_processus *s
|
if (strcmp((*((struct_fonction *) (*s_objet).objet)) |
if (strcmp((*((struct_fonction *) (*s_objet).objet)) |
.nom_fonction, "-") == 0) |
.nom_fonction, "-") == 0) |
{ |
{ |
|
simplification_arbre(s_etat_processus, |
|
(*s_arbre).branches[i]); |
|
s_objet = (*((*((*s_arbre).branches[i])).feuille)).donnee; |
} |
} |
|
|
if (strcmp((*((struct_fonction *) (*s_objet).objet)) |
if (strcmp((*((struct_fonction *) (*s_objet).objet)) |
Line 555 simplification(struct_processus *s_etat_
|
Line 647 simplification(struct_processus *s_etat_
|
*/ |
*/ |
|
|
affichage_arbre(s_etat_processus, s_arbre, 0); |
affichage_arbre(s_etat_processus, s_arbre, 0); |
|
|
//# ifdef EXPERIMENTAL_CODE |
|
simplification_arbre(s_etat_processus, s_arbre); |
simplification_arbre(s_etat_processus, s_arbre); |
affichage_arbre(s_etat_processus, s_arbre, 0); |
affichage_arbre(s_etat_processus, s_arbre, 0); |
|
|
Line 564 simplification(struct_processus *s_etat_
|
Line 654 simplification(struct_processus *s_etat_
|
{ |
{ |
return(NULL); |
return(NULL); |
} |
} |
//# endif |
|
|
|
/* |
/* |
* Transcription de l'arbre q-aire simplifié en expression algébrique. |
* Transcription de l'arbre q-aire simplifié en expression algébrique. |