xmlnode.cpp

可移植的xml库。已经在windows和linux上测试通过。只使用C++ Runtine

	}
	CXMLNode *x = this;
	if(off>0) for(;x && off>0;--off,x=x->m_next);
	else for(;x && off<0;++off,x=x->m_prev);
	assert(x && !off);
	x->insertSibling(p,ahead);
}

void CXMLNode::insertSibling(CXMLNode *p,bool ahead)
{
	if(m_parent)
	{
		m_parent->insertChild(p,this,ahead);
		return;
	}
	if(ahead) preppendSibling(p);
	else appendSibling(p);
}

void CXMLNode::appendAttrib(CXMLAttrib *a)
{
	assert(a && !a->getPrev());
	m_attribs += a->updateNode(this);
	CXMLAttrib *b = a->getlastSibling();
	if(!m_head)
	{
		assert(!m_tail);
		m_head = a;
		m_tail = b;
	}
	else
	{
		m_tail->setNext(a);
		a->setPrev(m_tail);
		m_tail = b;
	}
}

void CXMLNode::preppendAttrib(CXMLAttrib *a)
{
	if(!m_head)
	{
		appendAttrib(a);
		return;
	}
	assert(a && !a->getPrev());
	m_attribs += a->updateNode(this);
	CXMLAttrib *b = a->getlastSibling();
	b->setNext(m_head);
	m_head->setPrev(b);
	m_head = a;
}

void CXMLNode::insertAttrib(CXMLAttrib *a,unsigned ref,bool ahead)
{
	assert(ref<m_attribs);
	insertAttrib(a,getAttribAt(ref),ahead);
}

void CXMLNode::insertAttrib(CXMLAttrib *a,CXMLAttrib *ref,bool ahead)
{
	assert(a && !a->getPrev() && ref && ref->isChildOf(this));
	m_attribs += a->updateNode(this);
	CXMLAttrib *b = a->getlastSibling();
	if(ahead)
	{
		if(!ref->getPrev()) m_head = a;
		else{a->setPrev(ref->getPrev());a->getPrev()->setNext(a);}
		b->setNext(ref);
		ref->setPrev(b);
	}
	else
	{
		if(!ref->getNext()) m_tail = a;
		else{b->setNext(m_tail->getNext());b->getNext()->setPrev(b);}
		ref->setNext(a);
		a->setPrev(ref);
	}
}

void CXMLNode::setIndent(unsigned indent)
{
	CXMLNode::m_indent = indent;
}

const char* CXMLNode::findVar(const char *what,bool exact) const
{
	CXMLAttrib *a = findAttrib(what,exact);
	return a ? a->getValue() : 0;
}

CXMLAttrib* CXMLNode::findAttrib(const char *what,unsigned len,bool exact) const
{
	if(!len) len = strlen(what);
	for(CXMLAttrib *a=m_head;a;a=a->getNext())
	{
		if(exact ? a->isNameOfExact(what,len) : a->isNameOf(what,len)) return a;
	}
	return 0;
}

CXMLNode* CXMLNode::findNode(const char *what,unsigned len,unsigned type,unsigned depth,bool exact) const
{
	if(!len) len = strlen(what);
	if(m_type==type && (exact ? isNodOf(what,len) : isNodOfExact(what,len))) return (CXMLNode*)this;
	if(depth>0 && m_first)
	{
		CXMLNode *x = m_first->findNode(what,len,type,depth-1,exact);
		if(x) return x;
	}
	if(m_next) return m_next->findNode(what,len,type,depth,exact);
	return 0;
}

CXMLNode* CXMLNode::findChild(const char *what,unsigned len,unsigned type,unsigned depth,bool exact) const
{
	if(!len) len = strlen(what);
	if(m_first) return m_first->findNode(what,len,type,depth,exact);
	return 0;
}

CXMLNode* CXMLNode::removeLastChild()
{
	if(!m_first)
	{
		assert(!m_last);
		return 0;
	}
	CXMLNode *x = m_last;
	if(m_first==m_last) m_first = m_last = 0;
	else{m_last=m_last->m_prev;m_last->m_next=0;}
	--m_children;
	x->m_prev = x->m_next = x->m_parent = 0;
	return x;
}

CXMLNode* CXMLNode::removeFirstChild()
{
	if(m_children<=1) return removeLastChild();
	CXMLNode *x = m_first;
	m_first = m_first->m_next;
	m_first->m_prev = 0;
	--m_children;
	x->m_prev = x->m_next = x->m_parent = 0;
	return x;
}

CXMLNode* CXMLNode::removeChild(CXMLNode& x)
{
	assert(x.isChildOf(*this));
	if(x.m_prev) x.m_prev->m_next = x.m_next;
	else{m_first=x.m_next;m_first->m_prev=0;}
	if(x.m_next) x.m_next->m_prev = x.m_prev;
	else{m_last=x.m_prev;m_last->m_next=0;}
	--m_children;
	x.m_prev = x.m_next = x.m_parent = 0;
	return &x;
}

CXMLNode* CXMLNode::removeChildAt(unsigned idx)
{
	CXMLNode *x = getChildAt(idx);
	assert(x);
	return removeChild(*x);
}

CXMLNode* CXMLNode::removeChildrenTree(unsigned *count)
{
	CXMLNode *x= m_first;
	if(count) *count = m_children;
	m_first = m_last = 0;
	m_children = 0;
	return x;
}

CXMLNode* CXMLNode::removeLastSibling()
{
	if(m_parent) return m_parent->removeLastChild();
	if(!m_next) return this;
	CXMLNode *x = m_next;
	if(!x->m_next)
	{
		m_next = 0;
		x->m_prev = 0;
		return x;
	}
	for(;x->m_next;x=x->m_next);
	return x->removeLastSibling();
}

CXMLNode* CXMLNode::removeFirstSibling()
{
	if(m_parent) return m_parent->removeFirstChild();
	if(!m_prev) return this;
	CXMLNode *x = m_prev;
	if(!x->m_prev)
	{
		m_prev = 0;
		x->m_next = 0;
		return x;
	}
	for(;x->m_prev;x=x->m_prev);
	return x->removeFirstSibling();
}

CXMLNode* CXMLNode::removeSibling(CXMLNode& x)
{
	if(x.m_prev) x.m_prev->m_next = x.m_next;
	if(x.m_next) x.m_next->m_prev = x.m_prev;
	x.m_prev = x.m_next = 0;
	return &x;
}

CXMLNode* CXMLNode::removeSiblingAt(unsigned idx)
{
	CXMLNode *x = getSiblingAt(idx);
	assert(x);
	return removeSibling(*x);
}

CXMLAttrib* CXMLNode::removeLastAttrib()
{
	if(!m_head)
	{
		assert(!m_tail);
		return 0;
	}
	CXMLAttrib *a = m_tail;
	if(m_head==m_tail) m_head = m_tail = 0;
	else{m_tail=m_tail->getPrev();m_tail->setNext(0);}
	--m_attribs;
	a->setPrev(0);
	a->setNext(0);
	a->setNext(0);
	a->setNode(0);
	return a;
}

CXMLAttrib* CXMLNode::removeFirstAttrib()
{
	if(m_attribs<=1) return removeLastAttrib();
	CXMLAttrib *a = m_head;
	m_head = a->getNext();
	m_head->setPrev(0);
	--m_attribs;
	a->setPrev(0);
	a->setNext(0);
	a->setNext(0);
	a->setNode(0);
	return a;
}

CXMLAttrib* CXMLNode::removeAttrib(CXMLAttrib& a)
{
	if(a.getPrev()) a.getPrev()->setNext(a.getNext());
	else{m_head=a.getNext();m_head->setPrev(0);}
	if(a.getNext()) a.getNext()->setPrev(a.getPrev());
	else{m_tail=a.getPrev();m_tail->setNext(0);}
	--m_attribs;
	a.setPrev(0);
	a.setNext(0);
	a.setNext(0);
	a.setNode(0);
	return &a;
}

CXMLAttrib* CXMLNode::removeAttribAt(unsigned idx)
{
	CXMLAttrib *a = getAttribAt(idx);
	assert(a);
	return removeAttrib(*a);
}

CXMLAttrib* CXMLNode::removeAttribTree(unsigned *count)
{
	CXMLAttrib *a = m_head;
	m_head = m_tail = 0;
	if(count) *count = m_attribs;
	m_attribs = 0;
	return a;
}

int CXMLNode::build(const char *nod,...)
{
	va_list ap;
	va_start(ap,nod);
	int e = build(nod,ap);
	va_end(ap);
	return e;
}

int CXMLNode::build(const char *nod,va_list ap)
{
	int e = setNod(nod,0);
	if(e) return e;
	CXMLAttrib *a;
	const char *n,*v;
	for(;0!=(n=va_arg(ap,const char *));)
	{
		v = va_arg(ap,const char *);
		assert(v);
		if(!(a=new CXMLAttrib)) return E_OUTOF_MEMORY;
		if((e=a->setBoth(n,v))) return e;
		appendAttrib(a);
	}
	return 0;
}

int CXMLNode::build(const char *nod,CXMLAttrib& a)
{
	int e = setNod(nod,0);
	if(e) return e;
	appendAttrib(&a);
	return 0;
}

int CXMLNode::build(CXMLCodec *xc,const char *nod,unsigned flags)
{
	int e = setNod(nod,xc);
	if(e) return e;
	m_flags = flags;
	return 0;
}

int CXMLNode::build(CXMLCodec *xc,const char *nod,const char *fmt,...)
{
	va_list ap;
	va_start(ap,fmt);
	int e = build(xc,nod,fmt,ap);
	va_end(ap);
	return e;
}

CXMLNode* CXMLNode::findOpenTag(const char *nod,unsigned len) const
{
	const CXMLNode *x = this;
	for(;x;x=x->m_parent)
	{
		if(x->isOpenOf(nod,len)) return (CXMLNode *)x;
	}
	return 0;
}

int CXMLNode::formatNod(CXMLCodec *xc,CXMLNode*& p,const char*& fmt,va_list& ap)
{
	char tmp[32];
	char buf[1024];
	bool done = false;
	*buf = 0;
	char *s = buf;
	for(;*fmt && !done;++fmt)
	{
		switch(*fmt)
		{
		case 'c':
			*s = va_arg(ap,char);
			if(!*s) return E_XML_BAD_ARG;
			++s;
			break;
		case 'd':
		case 'n':
			s += sprintf(s,"%d",va_arg(ap,int));
			break;
		case 'l':
			ltoa(va_arg(ap,long),tmp,10);
			s += sprintf(s,"%s",tmp);
			break;
		case 'p':
			s += sprintf(s,"%d",va_arg(ap,void *));
			break;
		case 's':
			s += sprintf(s,"%s",va_arg(ap,const char *));
			break;
		case 'u':
			s += sprintf(s,"%u",va_arg(ap,unsigned));
			break;
		case 'w':
			ultoa(va_arg(ap,unsigned long),tmp,10);
			s += sprintf(s,"%s",tmp);
			break;
		case 'X':
			s += sprintf(s,"%X",va_arg(ap,unsigned));
			break;
		case 'x':
			s += sprintf(s,"%x",va_arg(ap,unsigned));
			break;
		default:done=true;
		}
	}
	if(!*buf) return E_XML_BAD_FORMAT;
	*s = 0;
	int e = p->setNod(buf,xc);
	return e;
}

int CXMLNode::formatAttrib(CXMLNode*& p,const char*& fmt,va_list& ap)
{
	char tmp[32];
	char val[4096];
	char name[1024];
	bool done = false;
	*name = *val = 0;
	char *s = name;
	for(;*fmt && !done;++fmt)
	{
		switch(*fmt)
		{
		case 'c':
			*s = va_arg(ap,char);
			if(!*s) return E_XML_BAD_ARG;
			++s;
			break;
		case 'd':
		case 'n':
			s += sprintf(s,"%d",va_arg(ap,int));
			break;
		case 'l':
			ltoa(va_arg(ap,long),tmp,10);
			s += sprintf(s,"%s",tmp);
			break;
		case 'p':
			s += sprintf(s,"%d",va_arg(ap,void *));
			break;
		case 's':
			s += sprintf(s,"%s",va_arg(ap,const char *));
			break;
		case 'u':
			s += sprintf(s,"%u",va_arg(ap,unsigned));
			break;
		case 'w':
			ultoa(va_arg(ap,unsigned long),tmp,10);
			s += sprintf(s,"%s",tmp);
			break;
		case 'X':
			s += sprintf(s,"%X",va_arg(ap,unsigned));
			break;
		case 'x':
			s += sprintf(s,"%x",va_arg(ap,unsigned));
			break;
		case '=':
			*s = 0;
			if(!*name) return E_XML_NO_ATTR_NAME;
			s = val;
		default:done=true;
		}
	}
	if(!*name) return E_XML_NO_ATTR_NAME;
	*s = 0;
	if(!*val && p->m_type!=XNT_META) return E_XML_NO_ATTR_VALUE;
	CXMLAttrib *a = new CXMLAttrib;
	if(!a) return E_OUTOF_MEMORY;
	int e = *val ? a->setBoth(name,val) : a->setName(name);
	if(e) return e;
	p->appendAttrib(a);
	return 0;
}

//格式符：
//	| - 新标签作为兄弟节点添加
//	- - 新标签作为父节点的兄弟节点添加
//	+ - CXMLNode * 类型的参数
//	* - CXMLAttrib * 类型的参数
//	# - const char * 类型的CDATA节点参数
//	< - 开始新标签(默认是开放标签)
//	/ - 关闭标签
//	! - !元标签
//	? - ?元标签
//	c,d,l,n,p,s,u,w(ul),x,X - 数值类型参数
//	' ' - 标签和属性之间的分隔符
//	= - 属性和值之间的分隔
//	/ - 独立标签
//	> - 结束标签
//示例:
//	build("<s s=s/>","iq","type","result") => "<iq type='result'>"
//	build("<?s s=s?>","xml","version","1.0") => "<?xml version='1.0'?>"
//	build("<s s=s s=sd><s>s</s>") => "<message to='...' id='msg1'><body>...</body></message>"
int CXMLNode::build(CXMLCodec *xc,const char *nod,const char *fmt,va_list ap)
{
	try
	{
		int e = setNod(nod,xc);
		if(e) return e;
		if(!fmt) return 0;
		bool child = true;
		CXMLNode *x;
		unsigned len;
		CXMLAttrib *a;
		const char *s;
		CXMLNode *p = this;
		for(;*fmt;++fmt)
		{
			child = true;
			switch(*fmt)
			{
			case '|':
				child = false;
				break;
			case '-':
				if(!p->m_nod) return E_XML_NO_TAG;
				if(!p->m_parent) return E_XML_BAD_TILE;
				p = p->m_parent;
				child = false;
				break;