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;
}
