void delAt(List &L, address Data){
address P,prev,last;
if(!isEmpty(L) && Data!=NULL)
{
prev=P=L.First;
last=findLast(L);
do
{
if(P==Data)
{
if(P==L.First)
{
L.First=L.First->Next;
last=L.First;
}
else
{
prev=prevNode(L,Data);
prev->Next=Data->Next;
}
delete(Data);
return;
}
P=P->Next;
}while(P->Next!=L.First);
}
}
void RecursiveCFGBuilder::visitStmt(ShPtr<Statement> stmt, bool visitSuccessors,
bool visitNestedStmts) {
if (!stmt) {
return;
}
if (hasItem(accessedStmts, stmt)) {
// The statement has been accessed.
ShPtr<CFG::Node> stmtNode(firstStmtNodeMapping[stmt]);
cfg->addEdge(currNode, stmtNode);
return;
}
// When the statement is a goto target and there are some statements in the
// current node, we have to emit the statement into a new node.
if (stmt->isGotoTarget() && !currNode->stmts.empty()) {
ShPtr<CFG::Node> prevNode(currNode);
ShPtr<CFG::Node> stmtNode(addNode(stmt));
cfg->addEdge(prevNode, stmtNode);
return;
}
accessedStmts.insert(stmt);
// The statement is not a goto target, so process it normally.
stmt->accept(this);
}
// Retrieve the index of the midnode of an edge, if it exists
int OctreeGrid::getMidEdgeNode(int node1, int node2, int axis) const {
const Node &n1 = m_Nodes[node1];
const Node &n2 = m_Nodes[node2];
oct_debug(n1.position[axis] < n2.position[axis]);
if (n1.next(axis) == node2) {
oct_debug(n2.prev(axis) == node1);
return -1;
} else {
const int c1 = n1.position[axis];
const int c2 = n2.position[axis];
const int c3 = (c1 + c2) / 2;
oct_debug((c1 + c2) % 2 == 0);
int m1 = n1.next(axis);
int m2 = n2.prev(axis);
while (m_Nodes[m1].position[axis] != c3 && m_Nodes[m2].position[axis] != c3) {
m1 = nextNode(m1, axis);
m2 = prevNode(m2, axis);
oct_debug(m1 != -1 && m2 != -1);
oct_debug(m1 != node2 && m2 != node1);
}
if (m_Nodes[m1].position[axis] == c3) {
return m1;
} else {
return m2;
}
}
}
void OctreeGrid::assertIsValid() {
// Check node adjacency relations
for (int node1 = 0; node1 < (int) m_Nodes.size(); ++node1) {
for (int axis = 0; axis < 3; ++axis) {
int node0 = prevNode(node1, axis);
int node2 = nextNode(node1, axis);
if (m_Nodes[node1].position[axis] == 0) {
oct_debug(node0 == -1);
} else if (node0 != -1) {
oct_debug(nextNode(node0, axis) == node1);
}
if (m_Nodes[node1].position[axis] == m_CellGridSize[axis]) {
oct_debug(node2 == -1);
} else if (node2 != -1) {
oct_debug(prevNode(node2, axis) == node1);
}
}
}
// Check cell adjacency relations
for (int cell1 = 0; cell1 < (int) m_Cells.size(); ++cell1) {
for (int axis = 0; axis < 3; ++axis) {
int cell0 = prevCell(cell1, axis);
int cell2 = nextCell(cell1, axis);
if (cellCornerPos(cell1, CORNER_X0_Y0_Z0)[axis] == 0) {
oct_debug(cell0 == -1);
} else {
oct_debug(cell0 != -1);
if (cellExtent(cell1) == cellExtent(cell0)) {
oct_debug(nextCell(cell0, axis) == cell1);
}
}
if (cellCornerPos(cell1, CORNER_X1_Y1_Z1)[axis] == m_CellGridSize[axis]) {
oct_debug(cell2 == -1);
} else {
oct_debug(cell2 != -1);
if (cellExtent(cell1) == cellExtent(cell2)) {
oct_debug(prevCell(cell2, axis) == cell1);
}
}
}
}
}
// Create a new double-link adjacency relation along axis
void OctreeGrid::createNodeLinks(int node1, int node2, int axis) {
oct_debug(node1 != -1 && node2 != -1);
if (nextNode(node1, axis) == -1) {
oct_debug(prevNode(node2, axis) == -1);
m_Nodes[node1].setNext(axis, node2);
m_Nodes[node2].setPrev(axis, node1);
for (int c = 0; c < 3; ++c) {
if (c == axis) { continue; }
oct_debug(m_Nodes[node1].position[c] == m_Nodes[node2].position[c]);
}
}
}
// Add a node at the middle of an edge
int OctreeGrid::addMidEdgeNode(int node1, int node2, int axis) {
oct_debug(node1 != -1 && node2 != -1);
oct_debug(nextNode(node1, axis) == node2);
oct_debug(prevNode(node2, axis) == node1);
// Setup node position
Node newNode;
newNode.position = m_Nodes[node1].position;
newNode.position[axis] = (m_Nodes[node1].position[axis] + m_Nodes[node2].position[axis]) / 2;
oct_debug((m_Nodes[node1].position[axis] + m_Nodes[node2].position[axis]) % 2 == 0);
// Setup node adjacency
int newId = (int) m_Nodes.size();
m_Nodes.emplace_back(newNode);
updateNodeLinks(node1, node2, newId, axis);
return newId;
}
// Return true iff the cell cellId is 2:1 graded
bool OctreeGrid::cellIs2to1Graded(int cellId) const {
const Cell &cell = m_Cells[cellId];
const int v0 = cell.corner(CORNER_X0_Y0_Z0);
const int v1 = cell.corner(CORNER_X1_Y0_Z0);
const int v2 = cell.corner(CORNER_X1_Y1_Z0);
const int v3 = cell.corner(CORNER_X0_Y1_Z0);
const int v4 = cell.corner(CORNER_X0_Y0_Z1);
const int v5 = cell.corner(CORNER_X1_Y0_Z1);
const int v6 = cell.corner(CORNER_X1_Y1_Z1);
const int v7 = cell.corner(CORNER_X0_Y1_Z1);
auto testEdge = [this] (int a, int b, int axis) {
return (nextNode(a, axis) == b || nextNode(a, axis) == prevNode(b, axis));
};
return testEdge(v0, v1, X) && testEdge(v3, v2, X) && testEdge(v4, v5, X) && testEdge(v7, v6, X)
&& testEdge(v0, v3, Y) && testEdge(v1, v2, Y) && testEdge(v4, v7, Y) && testEdge(v5, v6, Y)
&& testEdge(v0, v4, Z) && testEdge(v1, v5, Z) && testEdge(v3, v7, Z) && testEdge(v2, v6, Z);
}
Node* Add(Node *H1, Node *H2, int diff)
{
Node *prevNode(NULL);
int temp_val=0;
if(H1->next != NULL && H2->next != NULL){
if(diff <= 0){
prevNode = Add(H1->next, H2->next, --diff);
temp_val = H1->Val + H2->Val + carry;}
else{
prevNode = Add(H1->next, H2, --diff);
temp_val = H1->Val + carry;}}
if(diff < 0){
temp_val = H1->Val + H2->Val + carry;}
else{
temp_val = H1->Val + carry;}
carry = 0;
if(temp_val >=10) {carry = temp_val /10; temp_val =temp_val %10;}
Node *newNode = new Node; newNode->Val=temp_val; newNode->next=prevNode;
return newNode;
}
