Node* Scene::findNode(const char* id, bool recursive, bool exactMatch) const { GP_ASSERT(id); // Search immediate children first. for (Node* child = getFirstNode(); child != NULL; child = child->getNextSibling()) { // Does this child's ID match? if ((exactMatch && child->_id == id) || (!exactMatch && child->_id.find(id) == 0)) { return child; } } // Recurse. if (recursive) { for (Node* child = getFirstNode(); child != NULL; child = child->getNextSibling()) { Node* match = child->findNode(id, true, exactMatch); if (match) { return match; } } } return NULL; }
unsigned int Scene::findNodes(const char* id, std::vector<Node*>& nodes, bool recursive, bool exactMatch) const { GP_ASSERT(id); unsigned int count = 0; // Search immediate children first. for (Node* child = getFirstNode(); child != NULL; child = child->getNextSibling()) { // Does this child's ID match? if ((exactMatch && child->_id == id) || (!exactMatch && child->_id.find(id) == 0)) { nodes.push_back(child); ++count; } } // Recurse. if (recursive) { for (Node* child = getFirstNode(); child != NULL; child = child->getNextSibling()) { count += child->findNodes(id, nodes, true, exactMatch); } } return count; }
/* ASSUMES that theDnode can be deleted * * when this Dlist is deleted!!! * * (if deletesContainedObjects == TRUE) */ status_t _TDL_Dlist::prependNode ( _TDL_Dnode * theDnode ) { if ( ( getFirstNode() != (_TDL_Dnode *) NULL ) && ( ( getLastNode() == (_TDL_Dnode *) NULL ) || ( getLastNode() -> getNextNode() != (_TDL_Dnode *) NULL ) ) ) { TDL::getLogStream() << "[_TDL_Dlist::prependNode] Warning: " << "LastNode inconsistent. Repairing..." << endl; repairList(); } if ( getFirstNode() == (_TDL_Dnode *) NULL ) { theDnode -> setNextNode ( (_TDL_Dnode *) NULL ); theDnode -> setPreviousNode ( (_TDL_Dnode *) NULL ); setFirstNode ( theDnode ); setLastNode ( theDnode ); } else { getFirstNode() -> setPreviousNode ( theDnode ); theDnode -> setNextNode ( getFirstNode() ); theDnode -> setPreviousNode ( (_TDL_Dnode *) NULL ); setFirstNode ( theDnode ); } return SUCCESS; }
void EventDeque::addNode(DQNode *newNode){ if (getFirstNode() == NULL || getFirstNode()->getEventTick() > newNode->getEventTick()){ newNode->setNextNode(firstNode); firstNode = lastNode = newNode; tickIndex.insert(std::pair<int, DQNode*>(newNode->getEventTick(), newNode)); size++; return; } DQNode* checkNode = getFirstNodeAtTick(newNode->getEventTick()); unsigned int i = 0; // does the keyframe exist? if (checkNode == NULL){ tickIndex.insert(std::pair<int, DQNode*>(newNode->getEventTick(), newNode)); while(i < keyframes.size()) { if (newNode->getEventTick() < keyframes.at(i)) { keyframes.insert(keyframes.begin() + i, newNode->getEventTick()); break; } i++; } } else { // find last node in that queue; while(i < keyframes.size()) { if (newNode->getEventTick() < keyframes.at(i)) { break; } else { i++; } } } // i now holds the index of the current keyframe if (i + 1 >= keyframes.size()) { checkNode = lastNode; } else { checkNode = getFirstNodeAtTick(keyframes.at(i+1)); } newNode->setPrevNode(checkNode); if (checkNode->getNextNode() != NULL){ newNode->setNextNode(checkNode->getNextNode()); checkNode->getNextNode()->setPrevNode(newNode); } else { lastNode = newNode; } checkNode->setNextNode(newNode); size++; }
Node* Scene::getNext() { if (_nextReset) { _nextItr = findNextVisibleSibling(getFirstNode()); _nextReset = false; } else if (_nextItr) { Node* node = findNextVisibleSibling(_nextItr->getFirstChild()); if (node == NULL) { node = findNextVisibleSibling(_nextItr->getNextSibling()); if (node == NULL) { // Find first parent with a sibling node = _nextItr->getParent(); while (node && (!findNextVisibleSibling(node->getNextSibling()))) { node = node->getParent(); } if (node) { node = findNextVisibleSibling(node->getNextSibling()); } } } _nextItr = node; } return _nextItr; }
_TDL_Dnode * _TDL_Dlist::pop() { /* Error check */ if ( ( getFirstNode() != (_TDL_Dnode *) NULL ) && ( ( getLastNode() == (_TDL_Dnode *) NULL ) || ( getLastNode() -> getNextNode() != (_TDL_Dnode *) NULL ) ) ) { TDL::getLogStream() << "[_TDL_Dlist::pop] Warning: " << "LastNode inconsistent. Repairing..." << endl; repairList(); } if ( getLastNode() == (_TDL_Dnode *)NULL ) { return (_TDL_Dnode *)NULL; } else { return removeNode ( getLastNode(), _TDL_Dlist::BACKWARD ); } }
/** Pop out one StackNodeData from top of stack. */ StackNodeData pop(Stack *stack) { // null check if (!stack) { fprintf(stderr, "[error] pop: the stack doesn't exist. Return NULL.\n"); StackNodeData error_rt; return error_rt; } // pop from the begining of list StackNode* first_node = getFirstNode(stack); // set return value StackNodeData rt_data; // if stack is empty if (!first_node) { fprintf(stderr, "[error] pop: stack is empty now. Return NULL\n"); StackNodeData error_rt; return error_rt; } else { // get first data rt_data = getData(first_node); // remove first node removeNode(stack, first_node); } return rt_data; }
int CzXmlNode::Save(const char* filename) { // Dont save root node if (Name == ".") { CzXmlNode* node = getFirstNode(); if (node == NULL) return -1; return node->Save(filename); } CzFile file; if (file.Open(filename, "wb", true)) { const char* xml_head = "<?xml version=\"1.0\"?>\n"; if (!file.Write((void*)xml_head, strlen(xml_head))) return -1; int err = SaveTree(&file); if (err < 0) return err; } else return -1; return 0; }
BOOLEAN _TDL_Dlist::contains ( const _TDL_Dnode * theDnode, _TDL_Dlist::DIRECTION theSearchDiretion /* = BACKWARD */ ) const { _TDL_Dnode * dnode; if ( theSearchDiretion == _TDL_Dlist::FORWARD ) dnode = getFirstNode(); else dnode = getLastNode(); while ( dnode != (_TDL_Dnode *) NULL ) { if ( dnode == theDnode ) return TRUE; if ( theSearchDiretion == _TDL_Dlist::FORWARD ) dnode = dnode -> getNextNode(); else dnode = dnode -> getPreviousNode(); } return FALSE; }
_TDL_Dnode * _TDL_Dlist::getNodeAtIndex ( u_int4 theIndex ) const { _TDL_Dnode * dnode = getFirstNode(); while ( ( theIndex > 0 ) && ( dnode != (_TDL_Dnode *) NULL ) ) { theIndex --; dnode = dnode -> getNextNode(); } return dnode; }
u_int4 _TDL_Dlist::count() const { u_int4 ourCount = 0; _TDL_Dnode * dnode; for ( dnode = getFirstNode(); dnode != (_TDL_Dnode *) NULL; dnode = dnode -> getNextNode() ) { ourCount++; } return ourCount; }
void _TDL_Dlist::repairList() { _TDL_Dnode * lastNode = (_TDL_Dnode *) NULL; for ( _TDL_Dnode * node = getFirstNode(); node != (_TDL_Dnode *) NULL; node = node -> getNextNode() ) { node -> setPreviousNode ( lastNode ); lastNode = node; } setLastNode ( lastNode ); }
void Search_Branch_And_Bound_Basic<RETURNTYPE,DIMTYPE,SUBSET,CRITERION>::post_process_tree_level() { assert(parent::get_criterion()); const PSubset ¤tset=parent::get_currentset(); assert(currentset); // enable to re-evaluate chosen candidate values (e.g., supply missing true criterion values, etc.) PNode nod; for(bool got=getFirstNode(nod);got;got=getNextNode(nod)) { if(nod->type!=parent::COMPUTED) { assert(currentset->selected_raw(nod->feature)); currentset->deselect_raw(nod->feature); if(!parent::get_criterion()->evaluate(nod->value,currentset)) throw FST::fst_error("Criterion evaluation failure."); nod->type=parent::COMPUTED; currentset->select_raw(nod->feature); } } }
/* Note: Deletes all elements if deletesContainedObjects == TRUE */ void _TDL_Dlist::emptyAllElementsInList() { _TDL_Dnode * node = getFirstNode(); _TDL_Dnode * nextNode; while ( ( getDeletesContainedObjects() ) && ( node != (_TDL_Dnode *) NULL ) ) { nextNode = node -> getNextNode(); delete node; node = nextNode; } setFirstNode ( (_TDL_Dnode *) NULL ); setLastNode ( (_TDL_Dnode *) NULL ); }
/*virtual*/ ostream & _TDL_Dlist::printObject ( ostream & theOstream, const char * theIndentString /*=""*/ ) const { char subIndentString [ iostreamBase::MAXIMUM_INDENT ]; iostreamBase::createSubIndentString ( subIndentString, theIndentString ); theOstream << theIndentString << "-Begin- Dlist: " << ((void *)this) << endl; for ( _TDL_Dnode * node = getFirstNode(); node != (_TDL_Dnode *) NULL; node = node -> getNextNode() ) { node -> printObject ( theOstream, subIndentString ); } theOstream << theIndentString << "--End-- Dlist: " << ((void *)this) << endl; return theOstream; }
void EventDeque::removeNode(DQNode *remNode){ //manage the hash map if (getFirstNodeAtTick(remNode->getEventTick()) == remNode){ //if remNode is the one in the hash, remove it tickIndex.erase(remNode->getEventTick()); // if more events exist in that tick if (remNode->getNextNode() && remNode->getNextNode()->getEventTick() == remNode->getEventTick()) { tickIndex.insert(std::pair<int,DQNode*>(remNode->getEventTick(), remNode->getNextNode())); } } //take care of the deque if (size > 1){ if (remNode->getNextNode() != NULL) {remNode->getNextNode()->setPrevNode(remNode->getPrevNode());} if (remNode->getPrevNode() != NULL){remNode->getPrevNode()->setNextNode(remNode->getNextNode());} } if (remNode == getFirstNode()) { firstNode = remNode->getNextNode(); } if (remNode == getLastNode()) { lastNode = remNode->getPrevNode(); } size--; }
// -------------------------------------------------------------- void CollectionParserSLC::_parse( std::ifstream& file, Collection& collection ) { rapidxml::xml_document<> doc; // Read file into vector<char> std::vector<char> buffer( ( std::istreambuf_iterator<char>( file ) ), std::istreambuf_iterator<char>( ) ); buffer.push_back( '\0' ); try { // parse the darn thing with rapidxml doc.parse<0>( &buffer[0] ); } catch( rapidxml::parse_error& e ) { throw Exception( std::string("Error during xml parsing: ") + e.what() ); } rapidxml::xml_node<>* rootNode = getFirstNode( &doc, "SokobanLevels" ); // read all the meta tags into the metaTagValues array std::string metaTagValues [NUM_META_TAG_NAMES]; for( int i = 0; i < NUM_META_TAG_NAMES; ++i ) { rapidxml::xml_node<>* metaTag = getFirstNode( rootNode, META_TAG_NAMES[i] ); if (metaTag != 0) // if there actually is such a meta tag { metaTagValues[i] = metaTag->value(); } } rapidxml::xml_node<>* levelCollectionNode = getFirstNode(rootNode, "LevelCollection"); std::string levelCollectionCopyright = getFirstAttribute(levelCollectionNode, "Copyright"); for( rapidxml::xml_node<>* levelNode = levelCollectionNode->first_node("Level"); levelNode; levelNode = levelNode->next_sibling() ) { std::string levelName = getFirstAttribute(levelNode, "Id"); Level* lvl; // = listener->_constructNewLevel(); lvl->addMetaData("Author", levelCollectionCopyright); // set the meta tags from the collection tag for the level for( int i = 0; i < NUM_META_TAG_NAMES; ++i ) { lvl->addMetaData(META_TAG_NAMES[i], metaTagValues[i]); } //listener->_generateLevelName( levelName ); lvl->setLevelName( levelName ); int y = 0; for( rapidxml::xml_node<>* levelLineNode = levelNode->first_node("L"); levelLineNode; levelLineNode = levelLineNode->next_sibling() ) { lvl->insertTileLine(y++, levelLineNode->value()); } } //TODO return metaTagValues[0]; }
void Track::loadFromFile(const string& filename) { TiXmlDocument doc( filename.c_str() ); bool loadOkay = doc.LoadFile(); if(!loadOkay) { cerr << "Unable to open file." << endl; return; } TiXmlElement* root = doc.FirstChildElement(); TiXmlElement* elem; TiXmlElement* innerElem; if(!root) return; //block: Nodes { nodes.clear(); for(elem = root->FirstChildElement("Nodes")->FirstChildElement("Node"); elem; elem = elem->NextSiblingElement("Node")) { string label(elem->Attribute("label")); NodeFlags flags = parseNodeFlags(elem->Attribute("flags")); //if(label == "" || flags == NODE_NONE) // continue; nodes.push_back(new Node(label, flags)); } } //block: Edges { for(elem = root->FirstChildElement("Nodes")->FirstChildElement("Node"); elem; elem = elem->NextSiblingElement("Node")) { string nodeLabel(elem->Attribute("label")); Node* node = getNodes(nodeLabel)[0]; for(innerElem = elem->FirstChildElement("Edge"); innerElem; innerElem = innerElem->NextSiblingElement("Edge")) { string label(innerElem->Attribute("label")); EdgeFlags flags = parseEdgeFlags(innerElem->Attribute("flags")); Direction dir = parseDirection(innerElem->Attribute("direction")); string endpointLabel(innerElem->Attribute("endpoint")); Node* otherNode = getNodes(endpointLabel)[0]; node->makeEdge(*otherNode, flags, dir, label); } } } //block: Constraints { for(elem = root->FirstChildElement("Nodes")->FirstChildElement("Node"); elem; elem = elem->NextSiblingElement("Node")) { string nodeLabel(elem->Attribute("label")); Node* node = getFirstNode(nodeLabel); for(innerElem = elem->FirstChildElement("Constraint"); innerElem; innerElem = innerElem->NextSiblingElement("Constraint")) { Constraint* c = parseConstraint(innerElem, this, node); vector<Node*> nodes = c->getAffectedNodes(); for(size_t x = 0; x < nodes.size(); ++x) { nodes[x]->addConstraint(c); } } } } }
void solveFifteen() { NODE node[4]; NODE pnode[4]; NODE inode; int r; int c; int spos; int depth = 0; int i; int x = 0; char *dir[4] = {"up", "down", "left", "right"}; int stack[4]={1000}; int top=0; int prevdir = 0; int cdir = -10; TREENODE *paddr = 0; inode = getFirstNode(&paddr); while(1) { node[0] = node[1] = node[2] = node[3] = inode; spos = inode.spos-1; r = spos/4; c = spos%4+1; x = (r+c+1)%2; depth = inode.depth + 1; prevdir = cdir; top = 0; if( r>=1 ){ // up direction swap(&node[0].arr[node[0].spos], &node[0].arr[(r-1)*4+c]); node[0].spos = (r-1) * 4 +c; node[0].depth = depth; node[0].paddr = paddr; node[0].dir = -4; insertNode(node[0], 0 ); } if( r<=2 ){ // down direction swap(&node[1].arr[node[1].spos], &node[1].arr[(r+1)*4+c]); node[1].spos = (r+1) * 4 + c; node[1].depth = depth; node[1].paddr = paddr; node[1].dir = 4; insertNode(node[1], 1); } if( c>=2 ){ //left direction swap(&node[2].arr[node[2].spos], &node[2].arr[r*4+(c-1)]); node[2].spos = r * 4 + (c-1); node[2].depth = depth; node[2].paddr = paddr; node[2].dir = -1; insertNode(node[2],2); } if( c<=3 ){ // right direction swap(&node[3].arr[node[3].spos], &node[3].arr[r*4+(c+1)]); node[3].spos = r * 4 + (c+1); node[3].depth = depth; node[3].paddr = paddr; node[3].dir = 1; insertNode(node[3],3); } inode = getFirstNode(&paddr); // printf(" the node number = %d\n", inode.no); } }
Error CodeBuilder::serialize(CodeEmitter* dst) { Error err = kErrorOk; CBNode* node_ = getFirstNode(); do { dst->setInlineComment(node_->getInlineComment()); switch (node_->getType()) { case CBNode::kNodeAlign: { CBAlign* node = static_cast<CBAlign*>(node_); err = dst->align(node->getMode(), node->getAlignment()); break; } case CBNode::kNodeData: { CBData* node = static_cast<CBData*>(node_); err = dst->embed(node->getData(), node->getSize()); break; } case CBNode::kNodeFunc: case CBNode::kNodeLabel: { CBLabel* node = static_cast<CBLabel*>(node_); err = dst->bind(node->getLabel()); break; } case CBNode::kNodeLabelData: { CBLabelData* node = static_cast<CBLabelData*>(node_); err = dst->embedLabel(node->getLabel()); break; } case CBNode::kNodeConstPool: { CBConstPool* node = static_cast<CBConstPool*>(node_); err = dst->embedConstPool(node->getLabel(), node->getConstPool()); break; } case CBNode::kNodeInst: case CBNode::kNodeFuncCall: { CBInst* node = static_cast<CBInst*>(node_); uint32_t instId = node->getInstId(); uint32_t options = node->getOptions(); const Operand* opArray = node->getOpArray(); uint32_t opCount = node->getOpCount(); const Operand_* o0 = &dst->_none; const Operand_* o1 = &dst->_none; const Operand_* o2 = &dst->_none; const Operand_* o3 = &dst->_none; switch (opCount) { case 6: dst->_op5 = opArray[5]; options |= CodeEmitter::kOptionOp5; ASMJIT_FALLTHROUGH; case 5: dst->_op4 = opArray[4]; options |= CodeEmitter::kOptionOp4; ASMJIT_FALLTHROUGH; case 4: o3 = &opArray[3]; ASMJIT_FALLTHROUGH; case 3: o2 = &opArray[2]; ASMJIT_FALLTHROUGH; case 2: o1 = &opArray[1]; ASMJIT_FALLTHROUGH; case 1: o0 = &opArray[0]; ASMJIT_FALLTHROUGH; case 0: break; } dst->setOptions(options); err = dst->_emit(instId, *o0, *o1, *o2, *o3); break; } case CBNode::kNodeComment: { CBComment* node = static_cast<CBComment*>(node_); err = dst->comment(node->getInlineComment()); break; } default: break; } if (err) break; node_ = node_->getNext(); } while (node_); return err; }
/* Note: Does NOT delete theDnode. * * Returns NULL for failure. */ _TDL_Dnode * _TDL_Dlist::removeNode( _TDL_Dnode * theDnode, _TDL_Dlist::DIRECTION theSearchDiretion /*=BACKWARD*/) { _TDL_Dnode * dnode; _TDL_Dnode * lastDnode = (_TDL_Dnode *) NULL; /* Error check */ if ( ( getFirstNode() != (_TDL_Dnode *) NULL ) && ( ( getLastNode() == (_TDL_Dnode *) NULL ) || ( getLastNode() -> getNextNode() != (_TDL_Dnode *) NULL ) ) ) { TDL::getLogStream() << "[_TDL_Dlist::removeNode] Warning: " << "LastNode inconsistent. Repairing..." << endl; repairList(); } if ( theSearchDiretion == _TDL_Dlist::FORWARD ) dnode = getFirstNode(); else dnode = getLastNode(); while ( dnode != (_TDL_Dnode *) NULL ) { if ( dnode == theDnode ) { if ( lastDnode == (_TDL_Dnode *) NULL ) { if ( theSearchDiretion == _TDL_Dlist::FORWARD ) { setFirstNode ( dnode -> getNextNode() ); if ( dnode -> getNextNode() != (_TDL_Dnode *) NULL ) dnode -> getNextNode() -> setPreviousNode ( (_TDL_Dnode *) NULL ); } else { setLastNode ( dnode -> getPreviousNode() ); if ( dnode -> getPreviousNode() != (_TDL_Dnode *) NULL ) dnode -> getPreviousNode() -> setNextNode ( (_TDL_Dnode *) NULL ); } } else { if ( theSearchDiretion == _TDL_Dlist::FORWARD ) { lastDnode -> setNextNode ( dnode -> getNextNode() ); if ( dnode -> getNextNode() != (_TDL_Dnode *) NULL ) dnode -> getNextNode() -> setPreviousNode ( lastDnode ); } else { lastDnode -> setPreviousNode ( dnode -> getPreviousNode() ); if ( dnode -> getPreviousNode() != (_TDL_Dnode *) NULL ) dnode -> getPreviousNode() -> setNextNode ( lastDnode ); } } if ( ( theSearchDiretion == _TDL_Dlist::FORWARD ) && ( ( getLastNode() == dnode ) || ( dnode -> getNextNode() == (_TDL_Dnode *) NULL ) ) ) { setLastNode ( lastDnode ); if ( lastDnode != (_TDL_Dnode *) NULL ) lastDnode -> setNextNode ( (_TDL_Dnode *) NULL ); } if ( ( theSearchDiretion != _TDL_Dlist::FORWARD ) && ( ( getFirstNode() == dnode ) || ( dnode -> getPreviousNode() == (_TDL_Dnode *) NULL ) ) ) { setFirstNode ( lastDnode ); if ( lastDnode != (_TDL_Dnode *) NULL ) lastDnode -> setPreviousNode ( (_TDL_Dnode *) NULL ); } dnode -> setNextNode ( (_TDL_Dnode *) NULL ); dnode -> setPreviousNode ( (_TDL_Dnode *) NULL ); return dnode; } else { lastDnode = dnode; if ( theSearchDiretion == _TDL_Dlist::FORWARD ) dnode = dnode -> getNextNode(); else dnode = dnode -> getPreviousNode(); } } /* WHILE ( dnodes ) */ return (_TDL_Dnode *) NULL; }
int main(int argc, char* argv[]) { /* Declarations */ List list; List list_1; List list_2; List list_3; List list_4; List list_5; List list_6; Position pos; Position pos_1; Position pos_2; Position pos_3; Position pos_4; Position pos_a, pos_b; int len; int idx; ElementType elem; /* Initialize list */ list=createList(); /* Test functions 'insertNode' and 'appendNode' */ printf("Test functions 'insertNode' and 'appendNode'\n\n"); printf("Before 'insertNode':\n"); printList(list); pos_1=getHeaderNode(list); insertNode(11, list, pos_1); pos_2=advanceNode(pos_1); insertNode(2, list, pos_2); pos_3=advanceNode(pos_2); insertNode(3, list, pos_3); pos_4=advanceNode(pos_3); insertNode(10, list, pos_4); insertNode(9, list, pos_2); printf("After 'insertNode':\n"); printList(list); printf("Before 'appendNode':\n"); printList(list); appendNode(7, list); appendNode(2, list); printf("After 'appendNode'\n"); printList(list); printf("\n"); /* Test functions 'cloneList', 'deleteNode' and 'deleteList' */ printf("Test functions 'cloneList', 'deleteNode' and 'deleteList'\n\n"); list_1=cloneList(list); printf("Before 'deleteNode':\n"); printList(list_1); deleteNode(2, list_1); printf("After 'deleteNode':\n"); printList(list_1); printf("Before 'deleteList':\n"); printList(list_1); deleteList(list_1); printf("After 'deleteList':\n"); printList(list_1); printf("\n"); /* Test function 'getListLength' */ printf("Test function 'getListLength'\n\n"); len=getListLength(list); printf("Length: %d\n", len); printf("\n"); /* Test functions 'findNode', 'findNodePrevious' and 'getNodeIndex' */ printf("Test functions 'findNode', 'findNodePrevious' and 'getNodeIndex'\n\n"); elem=2; pos=findNode(elem, list); if(pos!=NULL) { idx=getNodeIndex(pos, list); printList(list); printf("finding %d, Element at index %d found\n", elem, idx); } else { printf("finding %d, not found\n", elem); } elem=3; pos=findNodePrevious(elem, list); /* Check whether elem is found in list */ if(pos->m_next!=NULL) { idx=getNodeIndex(pos, list); printf("finding previous element of %d, Element at index %d found\n", elem, idx); } else { /* elem is not in list */ printf("finding previous element of %d, not found\n", elem); } printf("\n"); /* Test functions 'makeListEmpty' and 'isListEmpty' */ printf("Test functions 'makeListEmpty' and 'isListEmpty'\n\n"); list_2=cloneList(list); printf("Before 'makeListEmpty':\n"); printList(list_2); list_2=makeListEmpty(list_2); if(isListEmpty(list_2)) { printf("List emptied successfully\n"); printf("After 'makeListEmpty'\n"); printList(list_2); } printf("\n"); /* Test functions 'getHeaderNode', 'getFirstNode', 'getLastNode', 'advanceNode' and 'getNodeElem' */ printf("Test functions 'getHeaderNode', 'getFirstNode', 'getLastNode', 'advanceNode' and 'getNodeElem'\n\n"); printList(list); pos=getHeaderNode(list); printf("Header at index %d\n", getNodeIndex(pos, list)); pos=getFirstNode(list); printf("First element at index %d have value %d\n", getNodeIndex(pos, list), getNodeElem(pos)); pos=getLastNode(list); printf("Last element at index %d have value %d\n", getNodeIndex(pos, list), getNodeElem(pos)); pos=getFirstNode(list); pos=advanceNode(pos); printf("Second element at index %d have value %d\n", getNodeIndex(pos, list), getNodeElem(pos)); printf("\n"); /* Test function 'reverseList' */ printf("Test function 'reverseList'\n\n"); list_3=cloneList(list); printf("Before 'reverseList':\n"); printList(list_3); list_3=reverseList(list_3); printf("After 'reverseList':\n"); printList(list_3); printf("\n"); /* Test function 'swapNode' */ printf("Test function 'swapNode'\n\n"); list_4=cloneList(list); printf("Before 'swapNode':\n"); printList(list_4); pos_a=getHeaderNode(list_4); pos_a=advanceNode(pos_a); pos_a=advanceNode(pos_a); pos_b=advanceNode(pos_a); swapNode(pos_a, pos_b, list_4); printf("After 'swapNode':\n"); printList(list_4); printf("\n"); /* Test function 'bubbleSortList' */ printf("Test function 'bubbleSortList'\n\n"); list_5=cloneList(list); printf("Before 'bubbleSortList':\n"); printList(list_5); bubbleSortList(list_5); printf("After 'bubbleSortList':\n"); printList(list_5); printf("\n"); /* Test function 'connectList' */ printf("Test function 'connectList'\n\n"); printf("List 1:\n"); printList(list); printf("Length: %d\n", getListLength(list)); printf("List 2:\n"); printList(list_5); printf("Length: %d\n", getListLength(list_5)); list_6=connectList(list, list_5); printf("Connected list:\n"); printList(list_6); printf("Length: %d\n", getListLength(list_6)); printf("\n"); /* Cleanup memory */ destroyList(list); destroyList(list_1); destroyList(list_2); destroyList(list_3); destroyList(list_4); destroyList(list_5); destroyList(list_6); return 0; }
Error CodeBuilder::serialize(CodeEmitter* dst) { Error err = kErrorOk; CBNode* node_ = getFirstNode(); do { dst->setInlineComment(node_->getInlineComment()); switch (node_->getType()) { case CBNode::kNodeAlign: { CBAlign* node = static_cast<CBAlign*>(node_); err = dst->align(node->getMode(), node->getAlignment()); break; } case CBNode::kNodeData: { CBData* node = static_cast<CBData*>(node_); err = dst->embed(node->getData(), node->getSize()); break; } case CBNode::kNodeFunc: case CBNode::kNodeLabel: { CBLabel* node = static_cast<CBLabel*>(node_); err = dst->bind(node->getLabel()); break; } case CBNode::kNodeLabelData: { CBLabelData* node = static_cast<CBLabelData*>(node_); err = dst->embedLabel(node->getLabel()); break; } case CBNode::kNodeConstPool: { CBConstPool* node = static_cast<CBConstPool*>(node_); err = dst->embedConstPool(node->getLabel(), node->getConstPool()); break; } case CBNode::kNodeInst: case CBNode::kNodeFuncCall: { CBInst* node = node_->as<CBInst>(); dst->setOptions(node->getOptions()); dst->setExtraReg(node->getExtraReg()); err = dst->emitOpArray(node->getInstId(), node->getOpArray(), node->getOpCount()); break; } case CBNode::kNodeComment: { CBComment* node = static_cast<CBComment*>(node_); err = dst->comment(node->getInlineComment()); break; } default: break; } if (err) break; node_ = node_->getNext(); } while (node_); return err; }