Dal punto di vista del codice sorgente o anche del codice a tre indirizzi (TAC) puoi visualizzare il problema molto facilmente in questa pagina ...
http://cgm.cs.mcgill.ca/~hagha/topic30/topic30.html#Exptree
Se vai alla sezione dell'albero delle espressioni, e poi scorri un po 'verso il basso, mostra l' "ordinamento topologico" dell'albero e l'algoritmo su come valutare l'espressione.
Quindi in quel caso puoi usare il DAG per valutare le espressioni, il che è utile poiché la valutazione è normalmente interpretata e l'utilizzo di un analizzatore di DAG di questo tipo renderà semplici interpreti più veloci in linea di principio perché non sta spingendo e saltando in una pila e anche perché sta eliminando sottoespressioni comuni.
L'algoritmo di base per calcolare il DAG in egiziano non antico (cioè inglese) è questo:
1) Crea il tuo oggetto DAG in questo modo
È necessario un elenco live e questo elenco contiene tutti i nodi DAG attivi e le sottoespressioni DAG correnti. Una sottoespressione DAG è un nodo DAG oppure puoi anche chiamarla nodo interno. Quello che intendo per nodo DAG live è che se si assegna a una variabile X, diventa live. Una sottoespressione comune che quindi utilizza X utilizza quell'istanza. Se X viene assegnato di nuovo, viene creato un NUOVO NODO DAG che viene aggiunto all'elenco attivo e la vecchia X viene rimossa in modo che la successiva sottoespressione che utilizza X si riferisca alla nuova istanza e quindi non entrerà in conflitto con le sottoespressioni che usa semplicemente lo stesso nome di variabile.
Una volta assegnato a una variabile X, casualmente tutti i nodi delle sottoespressioni DAG che sono attivi nel punto di assegnazione diventano non attivi, poiché la nuova assegnazione invalida il significato delle sottoespressioni utilizzando il vecchio valore.
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;
}
Quindi quello che fai è attraversare il tuo albero nel tuo codice, come ad esempio un albero di espressioni nel codice sorgente. Chiama i nodi esistenti XNodes per esempio.
Quindi per ogni XNode è necessario decidere come aggiungerlo al DAG e c'è la possibilità che sia già nel DAG.
Questo è uno pseudo codice molto semplice. Non destinato alla compilazione.
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;
}
}
Quindi questo è un modo di vederlo. Una passeggiata di base dell'albero e solo l'aggiunta e il riferimento ai nodi Dag mentre procede. La radice del dag è qualunque cosa DagNode restituita dalla radice dell'albero, ad esempio.
Ovviamente la procedura di esempio può essere suddivisa in parti più piccole o realizzata come sottoclassi con funzioni virtuali.
Per quanto riguarda l'ordinamento del Dag, si passa attraverso ciascun DagNode da sinistra a destra. In altre parole, seguire il bordo sinistro dei DagNodes e quindi il bordo del lato destro. I numeri vengono assegnati in ordine inverso. In altre parole, quando raggiungi un DagNode senza figli, assegna a quel Nodo il numero di ordinamento corrente e incrementa il numero di ordinamento, in modo che la ricorsione si svolga i numeri vengono assegnati in ordine crescente.
Questo esempio gestisce solo alberi con nodi che hanno zero o due figli. Ovviamente alcuni alberi hanno nodi con più di due figli, quindi la logica è sempre la stessa. Invece di calcolare sinistra e destra, calcola da sinistra a destra ecc ...
// 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;
}