CDGNode *getTopPath(CDGNode * node, Stack * changedNodes, Stack * changedBranches) {
CDGNode *pathNode = newBlankNode();
CDGNode *temp = pathNode;
int branch;
while (node) {
if (0 != getScore(node)) {
stackPush(changedNodes, &node);
branch = getOutcome(node);
stackPush(changedBranches, &branch);
if (isLeaf(node)) {
setScore(node, 0);
} else {
setNextNode(temp, copyToPathNode(newBlankNode(), node));
temp = getNextNode(temp);
if (getOutcome(node)) {
setBranchInfo(getID(node), 1, getBranchInfo(getID(node), 0));
setTrueNodeSet(temp, getTopPath(getTrueNodeSet(node), changedNodes, changedBranches));
} else {
setBranchInfo(getID(node), getBranchInfo(getID(node), 1), 1);
setFalseNodeSet(temp, getTopPath(getFalseNodeSet(node), changedNodes, changedBranches));
}
}
}
node = getNextNode(node);
}
if (temp == pathNode) {
deleteNode(pathNode);
pathNode = NULL;
} else {
temp = pathNode;
pathNode = getNextNode(pathNode);
deleteNode(temp);
}
return pathNode;
}
//Adiciona na arvore
Arvore* adicionaInternal(Arvore* raiz,Arvore* pai, Arvore* filho){
if(raiz){
if(filho->hash > pai->hash){
if(pai->direita == VAZIO){
filho->pai = pai->pos;
pai->direita = salvaFilho(filho);
atualizaNo(pai);
raiz = balanceia(raiz,filho);
}
else
raiz = adicionaInternal(raiz,getNextNode(pai->direita),filho);
}
else{
if(pai->esquerda ==VAZIO){
filho->pai = pai->pos;
pai->esquerda = salvaFilho(filho);
atualizaNo(pai);
raiz = balanceia(raiz,filho);
}
else
raiz = adicionaInternal(raiz,getNextNode(pai->esquerda),filho);
}
}
else{
salvaRaiz(filho);
raiz = filho;
}
return raiz;
}
//Faz rotacao a direita na arvore
Arvore * rotacaoDireita(Arvore * raiz, Arvore * atual) {
Arvore * esquerda = atual->esquerda;
Arvore* aux;
atual->esquerda = esquerda->direita;
if (esquerda->direita != VAZIO) {
aux = getNextNode(esquerda->direita);
aux->pai = atual->pos;
atualizaNo(aux);
}
esquerda->pai = atual->pai;
if (atual->pai == RAIZ) {
raiz = esquerda; //raiz
} else {
aux = getNextNode(atual->pai);
if (atual->pos == aux->direita) {
aux->direita = esquerda->pos;
} else {
aux->esquerda = esquerda->pos;
atualizaNo(aux);
}
}
esquerda->direita = atual->pos;
atual->pai = esquerda->pos;
atualizaNo(esquerda);
atualizaNo(atual);
return raiz;
}
//Busca -- MELHORAR
char* buscaInternal(Arvore* raiz, Arvore* corrente, char data[], long int hash,int count){
count++;
if(raiz){
if(hash == corrente->hash){
if(strcmp(corrente->data, data) == 0){
//printf("COR: %c POSICAO %d PAI: %d\n",corrente->cor,corrente->pos,corrente->pai);
return novoRetorno(TRUE,count,corrente->data);
}else if(corrente->esquerda != VAZIO)
return buscaInternal(raiz,getNextNode(corrente->esquerda),data,hash,count);
else
return novoRetorno(FALSE,count,data);
}else if(hash < corrente->hash)
if(corrente->esquerda != VAZIO)
return buscaInternal(raiz,getNextNode(corrente->esquerda),data,hash,count);
else
return novoRetorno(FALSE,count,data);
else
if(corrente->direita != VAZIO)
return buscaInternal(raiz,getNextNode(corrente->direita),data,hash,count);
else
return novoRetorno(FALSE,count,data);
}
else
return novoRetorno(FALSE,count,data);
}
GasMeter::GasMeter(llvm::IRBuilder<>& _builder, RuntimeManager& _runtimeManager) :
CompilerHelper(_builder),
m_runtimeManager(_runtimeManager)
{
llvm::Type* gasCheckArgs[] = {Type::Gas->getPointerTo(), Type::Gas, Type::BytePtr};
m_gasCheckFunc = llvm::Function::Create(llvm::FunctionType::get(Type::Void, gasCheckArgs, false), llvm::Function::PrivateLinkage, "gas.check", getModule());
m_gasCheckFunc->setDoesNotThrow();
m_gasCheckFunc->setDoesNotCapture(1);
auto checkBB = llvm::BasicBlock::Create(_builder.getContext(), "Check", m_gasCheckFunc);
auto updateBB = llvm::BasicBlock::Create(_builder.getContext(), "Update", m_gasCheckFunc);
auto outOfGasBB = llvm::BasicBlock::Create(_builder.getContext(), "OutOfGas", m_gasCheckFunc);
auto gasPtr = &m_gasCheckFunc->getArgumentList().front();
gasPtr->setName("gasPtr");
auto cost = gasPtr->getNextNode();
cost->setName("cost");
auto jmpBuf = cost->getNextNode();
jmpBuf->setName("jmpBuf");
InsertPointGuard guard(m_builder);
m_builder.SetInsertPoint(checkBB);
auto gas = m_builder.CreateLoad(gasPtr, "gas");
auto gasUpdated = m_builder.CreateNSWSub(gas, cost, "gasUpdated");
auto gasOk = m_builder.CreateICmpSGE(gasUpdated, m_builder.getInt64(0), "gasOk"); // gas >= 0, with gas == 0 we can still do 0 cost instructions
m_builder.CreateCondBr(gasOk, updateBB, outOfGasBB, Type::expectTrue);
m_builder.SetInsertPoint(updateBB);
m_builder.CreateStore(gasUpdated, gasPtr);
m_builder.CreateRetVoid();
m_builder.SetInsertPoint(outOfGasBB);
m_runtimeManager.abort(jmpBuf);
m_builder.CreateUnreachable();
}
void ex4_6() {
std::cout << "ex4.6 \n";
std::vector<int> in;
for (int sample = 0; sample < 10; ++sample)
in.push_back(std::rand() % 2000);
std::sort(in.begin(), in.end());
TreeNode<int>* node = createBST(in, 0, (int) in.size()) ;
auto root = node;
TreeNode<int>* rightmost = root;
std::cout << "root.value=" << root->value << ", node.value=" << node->value << ", rightmost.value=" << rightmost->value << std::endl;
rightmost = rightmost->right;
rightmost = rightmost->right;
auto next = getNextNode(rightmost);
std::cout << "next node of node " << rightmost->value << " is " << (next ? next->value : -1 ) << std::endl; // std::cout << " sample size=" << in.size() << ", max height = " << height << ", log(size)=" << log2(in.size()) << std::endl;
//std::cout << "is it a BST? " << checkBST(node);
auto lists = createLists(node);
for (int depth = 0; depth < lists.size(); ++depth) {
std::cout << " level " << depth << ": ";
for (auto elem : lists[depth]) {
std::cout << elem->value << ", ";
}
std::cout << std::endl;
}
std::cout << "next node of node " << node->value << " is " << getNextNode(node)->value << std::endl;
node = node->right;
std::cout << "next node of node " << node->value << " is " << getNextNode(node)->value << std::endl;
node = node->left;
std::cout << "next node of node " << node->value << " is " << getNextNode(node)->value << std::endl;
node = node->left;
std::cout << "next node of node " << node->value << " is " << getNextNode(node)->value << std::endl;
}
inline void delete_node(void** seg, void** tail, void *bp)
{
#ifdef __DEBUG__
printf("Delete node / *seg : %u, tail : %u, bp : %u\n", *seg, *tail, bp);
#endif
if(isHead(bp) && isTail(bp)) //make list empty
{
*seg = NULL;
*tail = NULL;
return;
}
else if(isHead(bp)) //move head
{
*seg = getNextNode(*seg);
setPrevNode(*seg, *seg);
return;
}
else if(isTail(bp)) //move tail
{
*tail = getPrevNode(bp);
setNextNode(*tail, *tail);
return;
}
void *prev_bp, *next_bp; //link change
prev_bp = getPrevNode(bp);
next_bp = getNextNode(bp);
setNextNode(prev_bp, next_bp);
setPrevNode(next_bp, prev_bp);
}
//faz rotacao a esquerda na arvore
Arvore * rotacaoEsquerda(Arvore * raiz, Arvore * avo) {
Arvore * pai = getNextNode(avo->direita);
Arvore* aux;
avo->direita = pai->esquerda;
if (pai->esquerda != VAZIO) {
aux = getNextNode(pai->esquerda);
aux->pai = avo->pos;
atualizaNo(aux);
}
pai->pai = avo->pai;
if (avo->pai == RAIZ) {
raiz = pai;
} else {
aux = getNextNode(avo->pai);
if (avo->pos == aux->esquerda) {
aux->esquerda = pai->pos;
} else {
aux->direita = pai->pos;
}
atualizaNo(aux);
}
pai->esquerda = avo->pos;
avo->pai = pai->pos;
atualizaNo(pai);
atualizaNo(avo);
return raiz;
}
CDGNode *getLastNode(CDGNode * node) {
assert(NULL != node);
CDGNode *curr = node;
while (getNextNode(curr)) {
curr = getNextNode(curr);
}
return curr;
}
CDGNode *buildFeasiblePath(CDGNode * node, CDGNode * list) {
while (node && 0 == nodeExists(list, getID(node))) {
node = getNextNode(node);
}
if (NULL == node)
return NULL;
CDGNode *out = NULL;
out = copyToPathNode(newBlankNode(), node);
setTrueNodeSet(out, buildFeasiblePath(getTrueNodeSet(node), list));
setFalseNodeSet(out, buildFeasiblePath(getFalseNodeSet(node), list));
setNextNode(out, buildFeasiblePath(getNextNode(node), list));
return out;
}
int hasConditionalChild(CDGNode * node) {
CDGNode *temp;
temp = getTrueNodeSet(node);
while (temp) {
if (!isLeaf(temp))
return 1;
temp = getNextNode(temp);
}
temp = getFalseNodeSet(node);
while (temp) {
if (!isLeaf(temp))
return 1;
temp = getNextNode(temp);
}
return 0;
}
node *getTail(node* headNode)
{
node *currentNode = headNode;
if(currentNode == NULL)
{
printf("error: invalid head node given to getTail\n");
return NULL;
}
node *nextNode;
while(getNextNode(currentNode) != NULL)
{
nextNode = getNextNode(currentNode);
currentNode = nextNode;
}
return currentNode;
}
// Ben's implementation that inserts in blockbased order
int insertNode(int *array, int node, int size) {
/**
* 1. Find the node to insert after
* 2. Set our size up
* 3. Set our next using preceding's next.
* 4. Set the preceding node's next to point to new
* 5. Set following node's prev to us.
*/
int firstNode = array[0];
int currentNodeIndex = array[0];
array[node] = size;
array[node+size -1] = size;
while(array[currentNodeIndex + NEXT] < node) {
if(array[currentNodeIndex + NEXT] == firstNode) {
//Been around linked list, we must be the last block.
break; //Current node will be the last in the list
}
currentNodeIndex = getNextNode(array, currentNodeIndex);
}
//Should have our node...
array[node + NEXT] = array[currentNodeIndex + NEXT];
array[node + PREV] = currentNodeIndex;
array[currentNodeIndex + NEXT] = node;
array[ array[node + NEXT] + PREV ] = node;
return 1;
}
llvm::Function* Array::createExtendFunc()
{
llvm::Type* argTypes[] = {m_array->getType(), Type::Size};
auto func = llvm::Function::Create(llvm::FunctionType::get(Type::Void, argTypes, false), llvm::Function::PrivateLinkage, "array.extend", getModule());
func->setDoesNotThrow();
func->setDoesNotCapture(1);
auto arrayPtr = &func->getArgumentList().front();
arrayPtr->setName("arrayPtr");
auto newSize = arrayPtr->getNextNode();
newSize->setName("newSize");
InsertPointGuard guard{m_builder};
m_builder.SetInsertPoint(llvm::BasicBlock::Create(m_builder.getContext(), {}, func));
auto dataPtr = m_builder.CreateBitCast(arrayPtr, Type::BytePtr->getPointerTo(), "dataPtr");// TODO: Use byte* in Array
auto sizePtr = m_builder.CreateStructGEP(getType(), arrayPtr, 1, "sizePtr");
auto capPtr = m_builder.CreateStructGEP(getType(), arrayPtr, 2, "capPtr");
auto data = m_builder.CreateLoad(dataPtr, "data");
auto size = m_builder.CreateLoad(sizePtr, "size");
auto extSize = m_builder.CreateNUWSub(newSize, size, "extSize");
auto newData = m_reallocFunc.call(m_builder, {data, newSize}, "newData"); // TODO: Check realloc result for null
auto extPtr = m_builder.CreateGEP(newData, size, "extPtr");
m_builder.CreateMemSet(extPtr, m_builder.getInt8(0), extSize, 16);
m_builder.CreateStore(newData, dataPtr);
m_builder.CreateStore(newSize, sizePtr);
m_builder.CreateStore(newSize, capPtr);
m_builder.CreateRetVoid();
return func;
}
// -----------------------------------------------------------------------------
void ArenaGraph::loadGoalNodes(const XMLNode *node)
{
const XMLNode *check_node = node->getNode("checks");
for (unsigned int i = 0; i < check_node->getNumNodes(); i++)
{
const XMLNode *goal = check_node->getNode(i);
if (goal->getName() =="goal")
{
Vec3 p1, p2;
bool first_goal = false;
goal->get("first_goal", &first_goal);
goal->get("p1", &p1);
goal->get("p2", &p2);
int first = Graph::UNKNOWN_SECTOR;
findRoadSector(p1, &first, NULL, true);
int last = Graph::UNKNOWN_SECTOR;
findRoadSector(p2, &last, NULL, true);
first_goal ? m_blue_node.insert(first) : m_red_node.insert(first);
first_goal ? m_blue_node.insert(last) : m_red_node.insert(last);
while (first != last)
{
// Find all the nodes which connect the two points of
// goal, notice: only work if it's a straight line
first = getNextNode(first, last);
first_goal ? m_blue_node.insert(first) :
m_red_node.insert(first);
}
}
}
} // loadGoalNodes
/*Release dynamic memory allocated to the list, including all its nodes*/
void deleteLst(sequenceLst *seqLst,int counter)
{
node * Node = seqLst->head, *toDelete;
if (seqLst != NULL)
{
/* First release memory of all existing nodes */
if(counter>0)
{
while (Node != NULL)
{
toDelete = Node;
Node = getNextNode(Node);
deleteNode(toDelete);
}
}
free(seqLst);
}
}
static void* find_fit(size_t size) //find best place
{
#ifdef __DEBUG__
fprintf(stderr, "find fitting place - size : %d\n", size);
#endif
void* bp;
void* s;
size_t sizeIndex = size;
for(s = getSegBySize(size); ; s = getSegBySize(sizeIndex)) //increase seg size
{
sizeIndex = getNextSize(sizeIndex);
for(bp = s; ; bp = getNextNode(bp)) //iterate list
{
if(bp==NULL) break;
#ifdef __DEBUG__
fprintf(stderr, "searching : %u / allocated? : %u / size? : %u\n", getBlockHeader(bp), isAllocated(getBlockHeader(bp)), getSize(getBlockHeader(bp)));
#endif
if(!isAllocated(getBlockHeader(bp)) && size <= getSize(getBlockHeader(bp)))
{
return bp;
}
if(isTail(bp)) break;
}
if(s==seg_inf) break;
}
return NULL;
}
void dijkstra(graph* G, long initial_node, char debug)
{
long i,j,k;
long aN; //actualNode
G->D[initial_node] = 0;
aN = initial_node;
printf("Running dijkstra on graph\n");
if(debug)
printGraph(G);
for(i = 0; i < G->N; i++)
{
G->visited[aN] = VISITED;
if(debug){
printf("It[%d] aN [%d]",i, aN); printStatus(G); printf("\n");
}
//Find all nodes connected to aN
for(j=0;j<G->N;j++){
if( (G->node[aN][j] != NO_CONN) ){
if( (G->D[aN] + G->node[aN][j]) < G->D[j] ){
G->D[j] = (G->D[aN] + G->node[aN][j]);
}
}
}
aN = getNextNode(G);
}
printf("Finished Dijkstra\n");
}
void pushNodeListToStack(Stack * s, CDGNode * node) {
assert(NULL != node);
do {
stackPush(s, &node);
node = getNextNode(node);
} while (node);
}
void deleteNodeList(CDGNode * node) {
assert(NULL != node);
CDGNode *next;
do {
next = getNextNode(node);
deleteNode(node);
node = next;
} while (node);
}
int getConditionalNodeSum(CDGNode * node) {
int sum = 0;
while (node != NULL) {
if (!isLeaf(node)) {
sum += getScore(node);
}
node = getNextNode(node);
}
return sum;
}
void traverseAndPrint(node *headNode)
{
node *currentNode = headNode;
while(currentNode != NULL)
{
printNode(currentNode);
currentNode = getNextNode(currentNode);
}
return;
}
CDGNode *visitAnyOneNode(CDGNode * node) {
assert(NULL != node);
do {
if (isLeaf(node) && 1 == getScore(node)) {
setScore(node, 0);
return node;
}
node = getNextNode(node);
} while (node);
return NULL;
}
void preOrderCDG(CDGNode* node) {
while (node) {
if ( 0 == getID(node) )
printf("ID: %d, PID: 0", getID(node));
else
printf("ID: %d, PID: %d", getID(node), getID(getParent(node)));
preOrderCDG(getTrueNodeSet(node));
preOrderCDG(getFalseNodeSet(node));
node = getNextNode(node);
}
}
bool XmlTestParser::LoadTest(lc3_test_suite& suite, wxXmlNode* root)
{
wxXmlNode* child = root->GetChildren();
lc3_test test;
test.has_halted = false;
test.executions = 0;
test.has_max_executions = false;
test.has_disable_plugins = false;
test.disable_plugins = false;
test.max_executions = 0;
test.passed = false;
test.randomize = false;
test.true_traps = false;
test.interrupt_enabled = false;
test.warnings = false;
test.points = 0;
test.max_points = 0;
while(child)
{
if (child->GetName() == "name")
test.name = child->GetNodeContent();
else if (child->GetName() == "true-traps")
test.true_traps = wxAtoi(child->GetNodeContent()) != 0;
else if (child->GetName() == "has-max-executions")
test.has_max_executions = wxAtoi(child->GetNodeContent()) != 0;
else if (child->GetName() == "has-disable-plugins")
test.has_disable_plugins = wxAtoi(child->GetNodeContent()) != 0;
else if (child->GetName() == "disable-plugins")
test.disable_plugins = wxAtoi(child->GetNodeContent()) != 0;
else if (child->GetName() == "max-executions")
test.max_executions = wxAtol(child->GetNodeContent());
else if (child->GetName() == "randomize")
test.randomize = wxAtoi(child->GetNodeContent()) != 0;
else if (child->GetName() == "interrupt-enabled")
test.interrupt_enabled = wxAtoi(child->GetNodeContent()) != 0;
else if (child->GetName() == "input")
{
if (!LoadTestInput(test, child)) throw "test-input improperly formatted";
}
else if (child->GetName() == "output")
{
if (!LoadTestOutput(test, child)) throw "test-output improperly formatted";
}
child = getNextNode(child);
}
suite.tests.push_back(test);
return true;
}
CDGNode *getMaxScoreConditionNode(CDGNode * node) {
CDGNode *out = NULL;
do {
if (!isLeaf(node) && 0 < getScore(node)) {
if ((NULL == out) || (getScore(out) < getScore(node))) {
out = node;
}
}
node = getNextNode(node);
} while (NULL != node);
return out;
}
List *lmap(List *src, void *(*func)(void *)) {
List *results = NULL;
if (src != NULL && func != NULL) {
Node *head = src->head;
while (head != NULL) {
results = append(results, func(head->data));
head = getNextNode(head);
}
}
return results;
}
int hasUncoveredChild(CDGNode * node, int branch) {
CDGNode *temp;
if (branch)
temp = getTrueNodeSet(node);
else
temp = getFalseNodeSet(node);
while (temp) {
if (isLeaf(temp) && 0 < getScore(temp))
return 1;
temp = getNextNode(temp);
}
return 0;
}
//------------------------------------------------------------------------
KdTree::KdTree(const SphereSet& set) :
m_AxisAlignedBoundingBox(set.getAABB()),
m_NextNodeIndex(0)
{
m_Root = getNextNode();
for (auto it = set.begin(); it != set.end(); it++)
{
m_Root->add(&*it);
}
m_Root->build(this, m_AxisAlignedBoundingBox, 0);
}
void XMLSceneryReader::parse() {
DOMNode* firstNode = getFirstChild(); // scenery>tracks
DOMNode* node = getFirstChild(); // tracks>track
// m_tracks->read(this); // read tracks
m_node = firstNode; // reset current node to scenery>tracks
getNextNode(); // scenery>vehicles
node = getFirstChild(); // vehicles>vehicle
// m_vehicles->read(this); // read vehicles
}
