[Scummvm-cvs-logs] SF.net SVN: scummvm:[42314] tools/branches/gsoc2009-decompiler/decompiler
kjdf at users.sourceforge.net
kjdf at users.sourceforge.net
Thu Jul 9 21:25:09 CEST 2009
Revision: 42314
http://scummvm.svn.sourceforge.net/scummvm/?rev=42314&view=rev
Author: kjdf
Date: 2009-07-09 19:25:09 +0000 (Thu, 09 Jul 2009)
Log Message:
-----------
decompiler: Node made an abstract class; subclasses BasicBlock, DerivedNode,
and TestNode (in tests)
Modified Paths:
--------------
tools/branches/gsoc2009-decompiler/decompiler/decompiler.cpp
tools/branches/gsoc2009-decompiler/decompiler/graph.cpp
tools/branches/gsoc2009-decompiler/decompiler/graph.h
tools/branches/gsoc2009-decompiler/decompiler/node.cpp
tools/branches/gsoc2009-decompiler/decompiler/node.h
tools/branches/gsoc2009-decompiler/decompiler/test/data_graph.h
tools/branches/gsoc2009-decompiler/decompiler/test/test_graph_internal.h
Modified: tools/branches/gsoc2009-decompiler/decompiler/decompiler.cpp
===================================================================
--- tools/branches/gsoc2009-decompiler/decompiler/decompiler.cpp 2009-07-09 19:24:39 UTC (rev 42313)
+++ tools/branches/gsoc2009-decompiler/decompiler/decompiler.cpp 2009-07-09 19:25:09 UTC (rev 42314)
@@ -54,7 +54,7 @@
exit(0);
}
ControlFlowGraph cfg;
- cfg.addNodesFromScript(script._instructions.begin(), script._instructions.end());
+ cfg.addBasicBlocksFromScript(script._instructions.begin(), script._instructions.end());
// TODO won't work with empty script
cfg.setEntry(script._instructions.front()->_addr);
if (vars.count("blocks")) {
@@ -71,7 +71,7 @@
if (cfg.isReducible())
exit(0);
foreach (Node *interval, cfg.intervals())
- cout << phex(interval->_instructions.front()->_addr) << endl;
+ cout << phex(dynamic_cast<BasicBlock*>(interval)->_instructions.front()->_addr) << endl;
exit(1);
}
if (vars.count("graph-intervals")) {
Modified: tools/branches/gsoc2009-decompiler/decompiler/graph.cpp
===================================================================
--- tools/branches/gsoc2009-decompiler/decompiler/graph.cpp 2009-07-09 19:24:39 UTC (rev 42313)
+++ tools/branches/gsoc2009-decompiler/decompiler/graph.cpp 2009-07-09 19:25:09 UTC (rev 42314)
@@ -65,15 +65,7 @@
}
-Node *ControlFlowGraph::addNode(list<Instruction*>::iterator first, list<Instruction*>::iterator last) {
- Node* node = new Node;
- _nodes.push_back(node);
- copy(first, last, back_inserter(node->_instructions));
- return node;
-}
-
-
-void ControlFlowGraph::addNodesFromScript(list<Instruction*>::iterator scriptBegin, list<Instruction*>::iterator scriptEnd) {
+void ControlFlowGraph::addBasicBlocksFromScript(list<Instruction*>::iterator scriptBegin, list<Instruction*>::iterator scriptEnd) {
Jump *jump;
for (list<Instruction*>::iterator it = scriptBegin; it != scriptEnd; it++)
if ((jump = dynamic_cast<Jump*>(*it))) {
@@ -84,14 +76,16 @@
list<Instruction*>::iterator first = scriptBegin;
for (list<Instruction*>::iterator last = scriptBegin; last != scriptEnd; last++) {
if (next(last) == scriptEnd || contains(_targets, (*next(last))->_addr)) {
- _targets[(*first)->_addr] = addNode(first, next(last));
+ BasicBlock *block = new BasicBlock(first, next(last));
+ _targets[(*first)->_addr] = block;
+ _nodes.push_back(block);
first = next(last);
}
}
foreach (Node *node, _nodes) {
- if ((jump = dynamic_cast<Jump*>(node->_instructions.back())))
+ if ((jump = dynamic_cast<Jump*>(dynamic_cast<BasicBlock*>(node)->_instructions.back())))
addEdge(node, _targets[jump->target()]);
- map<address_t, Node*>::iterator succ = next(_targets.find(node->_instructions.front()->_addr));
+ map<address_t, BasicBlock*>::iterator succ = next(_targets.find(node->address()));
if (succ != _targets.end() && (!jump || dynamic_cast<CondJump*>(jump)))
addEdge(node, succ->second);
}
@@ -175,21 +169,21 @@
// intervals in the original graph
void ControlFlowGraph::extendIntervals() {
ControlFlowGraph d;
- map<Node*, Node*> trans;
+ map<Node*, DerivedNode*> trans;
foreach (Node *interval, intervals()) {
- trans[interval] = d.addNode(interval->_instructions.begin(), interval->_instructions.end());
- trans[interval]->_primitive = interval;
+ trans[interval] = new DerivedNode(interval);
+ d._nodes.push_back(trans[interval]);
}
foreach (Node *interval, intervals())
foreach (Node *u, interval->_in)
- if (u->_interval != interval)
- d.addEdge(trans[u->_interval], trans[interval]);
- d.setEntry(_entry->_instructions.front()->_addr);
+ if (u->_interval != interval)
+ d.addEdge(trans[u->_interval], trans[interval]);
+ d.setEntry(_entry->address());
d.assignIntervals();
foreach (Node *du, d._nodes)
foreach (Node *v, _nodes)
- if (v->_interval == du->_primitive)
- v->_interval = du->_interval->_primitive;
+ if (v->_interval == dynamic_cast<DerivedNode*>(du)->_primitive)
+ v->_interval = dynamic_cast<DerivedNode*>(du->_interval)->_primitive;
}
@@ -269,7 +263,7 @@
changed = false;
foreach (Node *u, _nodes) {
foreach (Node *v, u->_out) {
- Jump *jump = dynamic_cast<Jump*>(v->_instructions.front());
+ Jump *jump = dynamic_cast<Jump*>(dynamic_cast<BasicBlock*>(v)->_instructions.front());
if (jump && !dynamic_cast<CondJump*>(jump) && jump->target() != jump->_addr) {
changed = true;
replaceEdges(u, v, _targets[jump->target()]);
@@ -310,6 +304,6 @@
void ControlFlowGraph::setEntry(address_t entry) {
foreach (Node *node, _nodes)
- if (node->_instructions.front()->_addr == entry)
+ if (node->address() == entry)
_entry = node;
}
Modified: tools/branches/gsoc2009-decompiler/decompiler/graph.h
===================================================================
--- tools/branches/gsoc2009-decompiler/decompiler/graph.h 2009-07-09 19:24:39 UTC (rev 42313)
+++ tools/branches/gsoc2009-decompiler/decompiler/graph.h 2009-07-09 19:25:09 UTC (rev 42314)
@@ -17,13 +17,12 @@
Node *_entry;
std::list<Node*> _nodes;
- std::map<address_t, Node*> _targets; // helps partitioning code into basic nodes
+ std::map<address_t, BasicBlock*> _targets; // helps partitioning code into basic nodes
ControlFlowGraph();
~ControlFlowGraph();
- Node *addNode(std::list<Instruction*>::iterator first, std::list<Instruction*>::iterator last);
- void addNodesFromScript(std::list<Instruction*>::iterator scriptBegin, std::list<Instruction*>::iterator scriptEnd);
+ void addBasicBlocksFromScript(std::list<Instruction*>::iterator scriptBegin, std::list<Instruction*>::iterator scriptEnd);
void addEdge(Node *from, Node *to);
void assignComponents(); // after order
void assignDominators(); // after order
Modified: tools/branches/gsoc2009-decompiler/decompiler/node.cpp
===================================================================
--- tools/branches/gsoc2009-decompiler/decompiler/node.cpp 2009-07-09 19:24:39 UTC (rev 42313)
+++ tools/branches/gsoc2009-decompiler/decompiler/node.cpp 2009-07-09 19:25:09 UTC (rev 42314)
@@ -17,9 +17,42 @@
Node::~Node() {
}
-string Node::toString() {
+
+BasicBlock::BasicBlock(list<Instruction*>::iterator first, list<Instruction*>::iterator last) : Node() {
+ copy(first, last, back_inserter(_instructions));
+}
+
+
+BasicBlock::~BasicBlock() {
+}
+
+
+uint32 BasicBlock::address() {
+ return _instructions.front()->_addr;
+}
+
+
+string BasicBlock::toString() {
ostringstream ret;
foreach (Instruction *instruction, _instructions)
ret << instruction->toString();
return ret.str();
}
+
+
+DerivedNode::DerivedNode(Node *primitive) : Node(), _primitive(primitive) {
+}
+
+
+DerivedNode::~DerivedNode() {
+}
+
+
+uint32 DerivedNode::address() {
+ return _primitive->address();
+}
+
+
+string DerivedNode::toString() {
+ return _primitive->toString();
+}
Modified: tools/branches/gsoc2009-decompiler/decompiler/node.h
===================================================================
--- tools/branches/gsoc2009-decompiler/decompiler/node.h 2009-07-09 19:24:39 UTC (rev 42313)
+++ tools/branches/gsoc2009-decompiler/decompiler/node.h 2009-07-09 19:25:09 UTC (rev 42314)
@@ -10,19 +10,42 @@
struct Node : boost::noncopyable {
- bool _visited;
- Node *_dominator; // immediate dominator
- Node *_interval; // header node of the interval this node belongs to
- Node *_primitive; // interval header of the graph from which this graph has been derived
Node *_component;
- int _number; // number in post-order
+ Node *_dominator; // immediate dominator
+ Node *_interval; // header node of the interval this node belongs to
+ int _number; // number in post-order
std::list<Node*> _in;
std::list<Node*> _out;
+
+ Node();
+ virtual ~Node();
+
+ virtual uint32 address() = 0;
+ virtual std::string toString() = 0;
+};
+
+
+struct BasicBlock : public Node {
+
std::list<Instruction*> _instructions;
- Node();
- ~Node();
+ BasicBlock(std::list<Instruction*>::iterator first, std::list<Instruction*>::iterator last);
+ ~BasicBlock();
+
+ uint32 address();
std::string toString();
};
+
+struct DerivedNode : public Node {
+
+ Node *_primitive; // interval header of the graph from which this graph has been derived
+
+ DerivedNode(Node *primitive);
+ ~DerivedNode();
+
+ uint32 address();
+ std::string toString();
+};
+
#endif
Modified: tools/branches/gsoc2009-decompiler/decompiler/test/data_graph.h
===================================================================
--- tools/branches/gsoc2009-decompiler/decompiler/test/data_graph.h 2009-07-09 19:24:39 UTC (rev 42313)
+++ tools/branches/gsoc2009-decompiler/decompiler/test/data_graph.h 2009-07-09 19:25:09 UTC (rev 42314)
@@ -3,77 +3,104 @@
#include <boost/foreach.hpp>
#include <list>
+#include <sstream>
#include <graph.h>
#include <instruction.h>
-unsigned addr(Node *node) {
- return node->_instructions.front()->_addr;
-}
+struct TestNode : public Node {
-Node *node(ControlFlowGraph *g, unsigned addr) {
+ int _id;
+
+ TestNode(int id) : _id(id) {
+ }
+
+ ~TestNode() {
+ }
+
+ uint32 address() {
+ return _id;
+ }
+
+ std::string toString() {
+ std::ostringstream ret;
+ ret << _id;
+ return ret.str();
+ }
+};
+
+
+Node *node(ControlFlowGraph *g, int id) {
BOOST_FOREACH (Node *u, g->_nodes)
- if (u->_instructions.front()->_addr == addr)
+ if (u->address() == id)
return u;
return 0;
}
ControlFlowGraph *makeGraph1() {
- std::list<Instruction*> instructions;
- instructions.push_back(new Jump("nop", 1, +1));
- instructions.push_back(new CondJump("jumpif +3", 2, +3));
- instructions.push_back(new Jump("nop", 3, +1));
- instructions.push_back(new Jump("jump -2", 4, -2));
- instructions.push_back(new CondJump("jumpif -4", 5, -4));
- instructions.push_back(new Instruction("ret", 6 ));
ControlFlowGraph *g = new ControlFlowGraph;
- g->addNodesFromScript(instructions.begin(), instructions.end());
+ for (int i = 1; i <= 6; i++)
+ g->_nodes.push_back(new TestNode(i));
+ g->addEdge(node(g,1), node(g,2));
+ g->addEdge(node(g,2), node(g,3));
+ g->addEdge(node(g,2), node(g,5));
+ g->addEdge(node(g,3), node(g,4));
+ g->addEdge(node(g,4), node(g,2));
+ g->addEdge(node(g,5), node(g,1));
+ g->addEdge(node(g,5), node(g,6));
g->setEntry(1);
return g;
}
ControlFlowGraph *makeGraph2() {
- std::list<Instruction*> instructions;
- instructions.push_back(new CondJump("jumpif +4", 1, +4));
- instructions.push_back(new CondJump("jumpif +2", 2, +2));
- instructions.push_back(new Jump("jump +2", 3, +2));
- instructions.push_back(new Jump("nop", 4, +1));
- instructions.push_back(new Jump("nop", 5, +1));
- instructions.push_back(new CondJump("jumpif +5", 6, +5));
- instructions.push_back(new Jump("nop", 7, +1));
- instructions.push_back(new Jump("nop", 8, +1));
- instructions.push_back(new CondJump("jumpif ", 9, -1));
- instructions.push_back(new Jump("-4", 10, -4));
- instructions.push_back(new CondJump("jumpif +2", 11, +2));
- instructions.push_back(new CondJump("jumpif +2", 12, +2));
- instructions.push_back(new Jump("nop", 13, +1));
- instructions.push_back(new Jump("nop", 14, +1));
- instructions.push_back(new Instruction("ret", 15 ));
ControlFlowGraph *g = new ControlFlowGraph;
- g->addNodesFromScript(instructions.begin(), instructions.end());
+ for (int i = 1; i <= 15; i++)
+ g->_nodes.push_back(new TestNode(i));
+ g->addEdge(node(g,1), node(g,2));
+ g->addEdge(node(g,1), node(g,5));
+ g->addEdge(node(g,2), node(g,3));
+ g->addEdge(node(g,2), node(g,4));
+ g->addEdge(node(g,3), node(g,5));
+ g->addEdge(node(g,4), node(g,5));
+ g->addEdge(node(g,5), node(g,6));
+ g->addEdge(node(g,6), node(g,7));
+ g->addEdge(node(g,6), node(g,11));
+ g->addEdge(node(g,7), node(g,8));
+ g->addEdge(node(g,8), node(g,9));
+ g->addEdge(node(g,9), node(g,8));
+ g->addEdge(node(g,9), node(g,10));
+ g->addEdge(node(g,10), node(g,6));
+ g->addEdge(node(g,11), node(g,12));
+ g->addEdge(node(g,11), node(g,13));
+ g->addEdge(node(g,12), node(g,13));
+ g->addEdge(node(g,12), node(g,14));
+ g->addEdge(node(g,13), node(g,14));
+ g->addEdge(node(g,14), node(g,15));
g->setEntry(1);
return g;
}
ControlFlowGraph *makeGraph3() {
- std::list<Instruction*> instructions;
- instructions.push_back(new CondJump("jumpif +2", 1, +2));
- instructions.push_back(new Jump("nop", 2, +1));
- instructions.push_back(new Jump("jump -1", 3, -1));
ControlFlowGraph *g = new ControlFlowGraph;
- g->addNodesFromScript(instructions.begin(), instructions.end());
+ for (int i = 1; i <= 3; i++)
+ g->_nodes.push_back(new TestNode(i));
+ g->addEdge(node(g,1), node(g,2));
+ g->addEdge(node(g,1), node(g,3));
+ g->addEdge(node(g,2), node(g,3));
+ g->addEdge(node(g,3), node(g,2));
g->setEntry(1);
return g;
}
ControlFlowGraph *makeGraph4() {
- std::list<Instruction*> instructions;
- instructions.push_back(new Jump("nop", 1, +1));
- instructions.push_back(new CondJump("jumpif +0", 2, +0));
- instructions.push_back(new Jump("jump -2", 3, -2));
ControlFlowGraph *g = new ControlFlowGraph;
- g->addNodesFromScript(instructions.begin(), instructions.end());
+ for (int i = 1; i <= 3; i++)
+ g->_nodes.push_back(new TestNode(i));
+ g->addEdge(node(g,1), node(g,2));
+ g->addEdge(node(g,2), node(g,2));
+ g->addEdge(node(g,2), node(g,3));
+ g->addEdge(node(g,3), node(g,1));
g->setEntry(1);
return g;
}
Modified: tools/branches/gsoc2009-decompiler/decompiler/test/test_graph_internal.h
===================================================================
--- tools/branches/gsoc2009-decompiler/decompiler/test/test_graph_internal.h 2009-07-09 19:24:39 UTC (rev 42313)
+++ tools/branches/gsoc2009-decompiler/decompiler/test/test_graph_internal.h 2009-07-09 19:25:09 UTC (rev 42314)
@@ -25,30 +25,30 @@
void test_intervals() {
ga->intervals();
- TS_ASSERT_EQUALS(addr(node(ga,1)->_interval), 1);
+ TS_ASSERT_EQUALS(node(ga,1)->_interval->address(), 1);
for (int i = 2; i <= 6; i++)
- TS_ASSERT_EQUALS(addr(node(ga,i)->_interval), 2);
+ TS_ASSERT_EQUALS(node(ga,i)->_interval->address(), 2);
gb->intervals();
for (int i = 1; i <= 5; i++)
- TS_ASSERT_EQUALS(addr(node(gb,i)->_interval), 1);
- TS_ASSERT_EQUALS(addr(node(gb,6)->_interval), 6);
- TS_ASSERT_EQUALS(addr(node(gb,7)->_interval), 6);
- TS_ASSERT_EQUALS(addr(node(gb,8)->_interval), 8);
- TS_ASSERT_EQUALS(addr(node(gb,9)->_interval), 8);
- TS_ASSERT_EQUALS(addr(node(gb,10)->_interval), 8);
+ TS_ASSERT_EQUALS(node(gb,i)->_interval->address(), 1);
+ TS_ASSERT_EQUALS(node(gb,6)->_interval->address(), 6);
+ TS_ASSERT_EQUALS(node(gb,7)->_interval->address(), 6);
+ TS_ASSERT_EQUALS(node(gb,8)->_interval->address(), 8);
+ TS_ASSERT_EQUALS(node(gb,9)->_interval->address(), 8);
+ TS_ASSERT_EQUALS(node(gb,10)->_interval->address(), 8);
for (int i = 11; i <= 15; i++)
- TS_ASSERT_EQUALS(addr(node(gb,i)->_interval), 6);
+ TS_ASSERT_EQUALS(node(gb,i)->_interval->address(), 6);
gc->intervals();
- TS_ASSERT_EQUALS(addr(node(gc,1)->_interval), 1);
- TS_ASSERT_EQUALS(addr(node(gc,2)->_interval), 2);
- TS_ASSERT_EQUALS(addr(node(gc,3)->_interval), 3);
+ TS_ASSERT_EQUALS(node(gc,1)->_interval->address(), 1);
+ TS_ASSERT_EQUALS(node(gc,2)->_interval->address(), 2);
+ TS_ASSERT_EQUALS(node(gc,3)->_interval->address(), 3);
gd->intervals();
- TS_ASSERT_EQUALS(addr(node(gd,1)->_interval), 1);
- TS_ASSERT_EQUALS(addr(node(gd,2)->_interval), 2);
- TS_ASSERT_EQUALS(addr(node(gd,3)->_interval), 2);
+ TS_ASSERT_EQUALS(node(gd,1)->_interval->address(), 1);
+ TS_ASSERT_EQUALS(node(gd,2)->_interval->address(), 2);
+ TS_ASSERT_EQUALS(node(gd,3)->_interval->address(), 2);
}
@@ -56,29 +56,29 @@
ga->intervals();
ga->extendIntervals();
for (int i = 1; i <= 6; i++)
- TS_ASSERT_EQUALS(addr(node(ga,i)->_interval), 1);
+ TS_ASSERT_EQUALS(node(ga,i)->_interval->address(), 1);
gb->intervals();
gb->extendIntervals();
for (int i = 1; i <= 5; i++)
- TS_ASSERT_EQUALS(addr(node(gb,i)->_interval), 1);
+ TS_ASSERT_EQUALS(node(gb,i)->_interval->address(), 1);
for (int i = 6; i <= 15; i++)
- TS_ASSERT_EQUALS(addr(node(gb,i)->_interval), 6);
+ TS_ASSERT_EQUALS(node(gb,i)->_interval->address(), 6);
gb->extendIntervals();
for (int i = 1; i <= 15; i++)
- TS_ASSERT_EQUALS(addr(node(gb,i)->_interval), 1);
+ TS_ASSERT_EQUALS(node(gb,i)->_interval->address(), 1);
gc->intervals();
gc->extendIntervals();
- TS_ASSERT_EQUALS(addr(node(gc,1)->_interval), 1);
- TS_ASSERT_EQUALS(addr(node(gc,2)->_interval), 2);
- TS_ASSERT_EQUALS(addr(node(gc,3)->_interval), 3);
+ TS_ASSERT_EQUALS(node(gc,1)->_interval->address(), 1);
+ TS_ASSERT_EQUALS(node(gc,2)->_interval->address(), 2);
+ TS_ASSERT_EQUALS(node(gc,3)->_interval->address(), 3);
gd->intervals();
gd->extendIntervals();
- TS_ASSERT_EQUALS(addr(node(gd,1)->_interval), 1);
- TS_ASSERT_EQUALS(addr(node(gd,2)->_interval), 1);
- TS_ASSERT_EQUALS(addr(node(gd,3)->_interval), 1);
+ TS_ASSERT_EQUALS(node(gd,1)->_interval->address(), 1);
+ TS_ASSERT_EQUALS(node(gd,2)->_interval->address(), 1);
+ TS_ASSERT_EQUALS(node(gd,3)->_interval->address(), 1);
}
@@ -86,41 +86,41 @@
ga->orderNodes();
ga->assignDominators();
TS_ASSERT(!node(ga,1)->_dominator);
- TS_ASSERT_EQUALS(addr(node(ga,2)->_dominator), 1);
- TS_ASSERT_EQUALS(addr(node(ga,3)->_dominator), 2);
- TS_ASSERT_EQUALS(addr(node(ga,4)->_dominator), 3);
- TS_ASSERT_EQUALS(addr(node(ga,5)->_dominator), 2);
- TS_ASSERT_EQUALS(addr(node(ga,6)->_dominator), 5);
+ TS_ASSERT_EQUALS(node(ga,2)->_dominator->address(), 1);
+ TS_ASSERT_EQUALS(node(ga,3)->_dominator->address(), 2);
+ TS_ASSERT_EQUALS(node(ga,4)->_dominator->address(), 3);
+ TS_ASSERT_EQUALS(node(ga,5)->_dominator->address(), 2);
+ TS_ASSERT_EQUALS(node(ga,6)->_dominator->address(), 5);
gb->orderNodes();
gb->assignDominators();
TS_ASSERT(!node(gb,1)->_dominator);
- TS_ASSERT_EQUALS(addr(node(gb,2)->_dominator), 1);
- TS_ASSERT_EQUALS(addr(node(gb,3)->_dominator), 2);
- TS_ASSERT_EQUALS(addr(node(gb,4)->_dominator), 2);
- TS_ASSERT_EQUALS(addr(node(gb,5)->_dominator), 1);
- TS_ASSERT_EQUALS(addr(node(gb,6)->_dominator), 5);
- TS_ASSERT_EQUALS(addr(node(gb,7)->_dominator), 6);
- TS_ASSERT_EQUALS(addr(node(gb,8)->_dominator), 7);
- TS_ASSERT_EQUALS(addr(node(gb,9)->_dominator), 8);
- TS_ASSERT_EQUALS(addr(node(gb,10)->_dominator), 9);
- TS_ASSERT_EQUALS(addr(node(gb,11)->_dominator), 6);
- TS_ASSERT_EQUALS(addr(node(gb,12)->_dominator), 11);
- TS_ASSERT_EQUALS(addr(node(gb,13)->_dominator), 11);
- TS_ASSERT_EQUALS(addr(node(gb,14)->_dominator), 11);
- TS_ASSERT_EQUALS(addr(node(gb,15)->_dominator), 14);
+ TS_ASSERT_EQUALS(node(gb,2)->_dominator->address(), 1);
+ TS_ASSERT_EQUALS(node(gb,3)->_dominator->address(), 2);
+ TS_ASSERT_EQUALS(node(gb,4)->_dominator->address(), 2);
+ TS_ASSERT_EQUALS(node(gb,5)->_dominator->address(), 1);
+ TS_ASSERT_EQUALS(node(gb,6)->_dominator->address(), 5);
+ TS_ASSERT_EQUALS(node(gb,7)->_dominator->address(), 6);
+ TS_ASSERT_EQUALS(node(gb,8)->_dominator->address(), 7);
+ TS_ASSERT_EQUALS(node(gb,9)->_dominator->address(), 8);
+ TS_ASSERT_EQUALS(node(gb,10)->_dominator->address(), 9);
+ TS_ASSERT_EQUALS(node(gb,11)->_dominator->address(), 6);
+ TS_ASSERT_EQUALS(node(gb,12)->_dominator->address(), 11);
+ TS_ASSERT_EQUALS(node(gb,13)->_dominator->address(), 11);
+ TS_ASSERT_EQUALS(node(gb,14)->_dominator->address(), 11);
+ TS_ASSERT_EQUALS(node(gb,15)->_dominator->address(), 14);
gc->orderNodes();
gc->assignDominators();
TS_ASSERT(!node(gc,1)->_dominator);
- TS_ASSERT_EQUALS(addr(node(gc,2)->_dominator), 1);
- TS_ASSERT_EQUALS(addr(node(gc,3)->_dominator), 1);
+ TS_ASSERT_EQUALS(node(gc,2)->_dominator->address(), 1);
+ TS_ASSERT_EQUALS(node(gc,3)->_dominator->address(), 1);
gd->orderNodes();
gd->assignDominators();
TS_ASSERT(!node(gd,1)->_dominator);
- TS_ASSERT_EQUALS(addr(node(gd,2)->_dominator), 1);
- TS_ASSERT_EQUALS(addr(node(gd,3)->_dominator), 2);
+ TS_ASSERT_EQUALS(node(gd,2)->_dominator->address(), 1);
+ TS_ASSERT_EQUALS(node(gd,3)->_dominator->address(), 2);
}
};
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
More information about the Scummvm-git-logs
mailing list