Du point de vue du code source ou même du code à trois adresses (TAC), vous pouvez visualiser le problème très facilement sur cette page ...
http://cgm.cs.mcgill.ca/~hagha/topic30/topic30.html#Exptree
Si vous allez dans la section de l'arborescence d'expression et que vous descendez un peu la page, cela montre le "tri topologique" de l'arborescence et l'algorithme pour évaluer l'expression.
Donc, dans ce cas, vous pouvez utiliser le DAG pour évaluer des expressions, ce qui est pratique car l'évaluation est normalement interprétée et l'utilisation d'un tel évaluateur de DAG rendra les simples interprètes plus rapides en principe car il ne pousse pas et ne saute pas vers une pile et aussi parce qu'il élimine sous-expressions courantes.
L'algorithme de base pour calculer le DAG en égyptien non ancien (c'est-à-dire en anglais) est le suivant:
1) Faites de votre objet DAG comme ça
Vous avez besoin d'une liste en direct et cette liste contient tous les nœuds DAG et sous-expressions DAG actuels. Une sous-expression DAG est un nœud DAG, ou vous pouvez également l'appeler un nœud interne. Ce que je veux dire par live DAG Node, c'est que si vous assignez à une variable X, il devient live. Une sous-expression commune qui utilise ensuite X utilise cette instance. Si X est à nouveau attribué, un NOUVEAU NŒUD DAG est créé et ajouté à la liste en direct et l'ancien X est supprimé de sorte que la sous-expression suivante qui utilise X fera référence à la nouvelle instance et ne sera donc pas en conflit avec les sous-expressions qui utilisez simplement le même nom de variable.
Une fois que vous affectez à une variable X, tous les nœuds de sous-expression DAG qui sont actifs au point d'attribution deviennent co-accessoirement non actifs, car la nouvelle affectation invalide la signification des sous-expressions utilisant l'ancienne valeur.
class Dag {
TList LiveList;
DagNode Root;
}
// In your DagNode you need a way to refer to the original things that
// the DAG is computed from. In this case I just assume an integer index
// into the list of variables and also an integer index for the opertor for
// Nodes that refer to operators. Obviously you can create sub-classes for
// different kinds of Dag Nodes.
class DagNode {
int Variable;
int Operator;// You can also use a class
DagNode Left;
DagNode Right;
DagNodeList Parents;
}
Donc ce que vous faites est de parcourir votre arbre dans votre propre code, comme un arbre d'expressions dans le code source par exemple. Appelez les nœuds existants XNodes par exemple.
Donc, pour chaque XNode, vous devez décider comment l'ajouter dans le DAG, et il est possible qu'il soit déjà dans le DAG.
C'est un pseudo-code très simple. Non destiné à la compilation.
DagNode XNode::GetDagNode(Dag dag) {
if (XNode.IsAssignment) {
// The assignment is a special case. A common sub expression is not
// formed by the assignment since it creates a new value.
// Evaluate the right hand side like normal
XNode.RightXNode.GetDagNode();
// And now take the variable being assigned to out of the current live list
dag.RemoveDagNodeForVariable(XNode.VariableBeingAssigned);
// Also remove all DAG sub expressions using the variable - since the new value
// makes them redundant
dag.RemoveDagExpressionsUsingVariable(XNode.VariableBeingAssigned);
// Then make a new variable in the live list in the dag, so that references to
// the variable later on will see the new dag node instead.
dag.AddDagNodeForVariable(XNode.VariableBeingAssigned);
}
else if (XNode.IsVariable) {
// A variable node has no child nodes, so you can just proces it directly
DagNode n = dag.GetDagNodeForVariable(XNode.Variable));
if (n) XNode.DagNode = n;
else {
XNode.DagNode = dag.CreateDagNodeForVariable(XNode.Variable);
}
return XNode.DagNode;
}
else if (XNode.IsOperator) {
DagNode leftDagNode = XNode.LeftXNode.GetDagNode(dag);
DagNode rightDagNode = XNode.RightXNode.GetDagNode(dag);
// Here you can observe how supplying the operator id and both operands that it
// looks in the Dags live list to check if this expression is already there. If
// it is then it returns it and that is how a common sub-expression is formed.
// This is called an internal node.
XNode.DagNode =
dag.GetOrCreateDagNodeForOperator(XNode.Operator,leftDagNode,RightDagNode) );
return XNode.DagNode;
}
}
C'est donc une façon de voir les choses. Une promenade de base de l'arbre et juste ajouter et faire référence aux nœuds Dag au fur et à mesure. La racine du dag est le DagNode que la racine de l'arbre renvoie par exemple.
Évidemment, la procédure d'exemple peut être divisée en parties plus petites ou transformée en sous-classes avec des fonctions virtuelles.
En ce qui concerne le tri du Dag, vous parcourez chaque DagNode de gauche à droite. En d'autres termes, suivez le bord gauche de DagNodes, puis le bord droit. Les numéros sont attribués à l'envers. En d'autres termes, lorsque vous atteignez un DagNode sans enfant, attribuez à ce nœud le numéro de tri actuel et incrémentez le numéro de tri, de sorte que lorsque la récursivité se déroule, les numéros sont attribués dans un ordre croissant.
Cet exemple ne traite que les arbres avec des nœuds qui ont zéro ou deux enfants. De toute évidence, certains arbres ont des nœuds avec plus de deux enfants, donc la logique est toujours la même. Au lieu de calculer gauche et droite, calculez de gauche à droite etc ...
// Most basic DAG topological ordering example.
void DagNode::OrderDAG(int* counter) {
if (this->AlreadyCounted) return;
// Count from left to right
for x = 0 to this->Children.Count-1
this->Children[x].OrderDag(counter)
// And finally number the DAG Node here after all
// the children have been numbered
this->DAGOrder = *counter;
// Increment the counter so the caller gets a higher number
*counter = *counter + 1;
// Mark as processed so will count again
this->AlreadyCounted = TRUE;
}