才是其所对应的起始tag节点。为了解决这个问题，本函数里采用了一个将树路径以vetor存储的方式进行查找匹配。

1.       将所插入节点与当前节点的tagName进行比较。如果相同或者当前节点就是根节点，则前往第三步。

2.       将当前节点重置为当前节点的父节点，并将当前节点按顺序添加至path。回到第1步。

3.       检查是否找到tagName相同的节点，如果找到，我们需要调用flatten()方法调整树的结构，从而消除掉原本正在等待结束tag的起始tag节点。

4.       否则即为未找到，报错。

本方法主要是提供给ParseSax.tcc中的解析方法所调用。

operator<<(ostream &stream, consttree &tr)

本方法主要重写了<<操作符，使其可以直接输出tree类型的对象。

ostream &HTML::operator<<(ostream&stream, const tree &tr)

{

tree::pre_order_iteratorit = tr.begin();

tree::pre_order_iteratorend = tr.end();

introotdepth = tr.depth(it);

stream<< "-----" << endl;

unsignedint n = 0;

while( it != end )

{

intcur_depth = tr.depth(it);

for(inti=0; i < cur_depth - rootdepth; ++i) stream << "  ";

stream<< n << "@";

stream<< "[" << it->offset() << ";";

stream<< it->offset() + it->length() << ") ";

stream<< (string)(*it) << endl;

++it,++n;

}

stream<< "-----" << endl;

returnstream;

}

前面我们介绍过了Sax方式和DOM方式的区别，实际上在HtmlCxx中，这两种方式是结合使用的，即首先用SAX方式对流进行解析，解析出的结果采用DOM方式保存到一个树型的tree数据结构中。

首先我们还是来看一下ParserSax.h头文件中对于数据成员和函数的声明：

classParserSax

{

public:

ParserSax(): mpLiteral(0), mCdata(false) {}    //构造方法，初始化两个成员变量的值

virtual~ParserSax() {}      //析构方法，空

/**Parse the html code */

voidparse(const std::string &html);       //解析一个string格式的html文档

template

voidparse(_Iterator begin, _Iterator end);    //使用两个类型相同的形参格式的解析器模板

protected:

//Redefine this if you want to do some initialization before

//the parsing

virtualvoid beginParsing() {}    //空，可进行扩展

//以下几个虚函数，都在ParseDom.cc中进行了实现

virtualvoid foundTag(Node node, bool isEnd) {}

virtualvoid foundText(Node node) {}

virtualvoid foundComment(Node node) {}

virtualvoid endParsing() {}

//以下是几个模板，大部分都在ParseSax.tcc文件中实现

template

voidparse(_Iterator &begin, _Iterator &end,

std::forward_iterator_tag);

template

voidparseHtmlTag(_Iterator b, _Iterator c);

template

voidparseContent(_Iterator b, _Iterator c);

template

voidparseComment(_Iterator b, _Iterator c);

template

_IteratorskipHtmlTag(_Iterator ptr, _Iterator end);

template

_IteratorskipHtmlComment(_Iterator ptr, _Iterator end);

//几个数据成员

unsignedlong mCurrentOffset;      //当前正在解析的偏移位置

constchar *mpLiteral;    //具体作用需要到ParseSax.tcc中才显现出来

boolmCdata;  //同上

};

打开ParserSax.cc可以看到，里面空荡荡地只有一个Parse(const std::string &html)方法

void htmlcxx::HTML::ParserSax::parse(conststd::string &html)

{

//      std::cerr<< "Parsing string" << std::endl;

parse(html.c_str(),html.c_str() + html.length());

}

该方法实际上直接调用了另一个template void parse(_Iterator begin, _Iterator end)方法，而这个方法和一些其他主要方法都是在ParseSax.tcc中进行实现。

注意.tcc文件和一般的.cc文件有所不同，应当是基于turboc++的，因为turbo c++是很多年没用过的东西了，具体我也不是很懂有什么区别。

ParseSax.tcc这个文件中主要实现了对html文档的文本流的解析，并将其转化为一个个的节点，并存储到Html树中去。其实现了一整套的 Html解析流程，值得我们学习。该流程主要针对的是FireFox生成的Html格式来进行的解析。并且使用 parseContent()，parseTag()，parseComment()对一段内容作为内容，标签，注释等进行不同的处理。

如果读者曾经写过类似的Html解析器，那么在看这段代码的时候会非常清晰，即使没有写过也没关系，因为这段代码的逻辑很清晰，可以借鉴其作为对Html解析器的标准来进行学习。

其基本思路就是，按序遍历整个字符串，遇到’<’则认为其是tag标签的起始处，在tag中遇到’/’则认为该标签是结束型tag标签，遇 到’>’则认为是tag标签的结束处，遇到’!’则认为其是注释字段的起始或结束处。之后运行相应的 parseContent(),parseTag(),parseComment()进行解析即可。

parse(_Iterator &begin, _Iterator&end, std::forward_iterator_tag)

voidhtmlcxx::HTML::ParserSax::parse(_Iterator &begin, _Iterator &end,std::forward_iterator_tag)

{

typedef_Iterator iterator;

//      std::cerr<< "Parsing forward_iterator" << std::endl;

mCdata= false;

mpLiteral= 0;

mCurrentOffset= 0;

this->beginParsing();        //调用beginParsing()进行初始化

//      DEBUGP("Parsedtext\n");

while(begin != end)

{

*begin;// This is for the multi_pass to release the buffer

while(c != end)

{

//For some tags, the text inside it is considered literal and is

//only closed for its counterpart

while(mpLiteral)

{

//                                  DEBUGP("Treatingliteral %s\n", mpLiteral);

static

struct literal_tag {

intlen;

constchar* str;

intis_cdata;

}

literal_mode_elem[] =

{

{6,"script", 1},

{5,"style", 1},

{3,"xmp", 1},

{9,"plaintext", 1},

{8,"textarea", 0},

{0,0, 0}

};

其意义就是说，当遇到这些特殊节点的时候，需要进入该循环进行一些特别的处理，即应当着手向后寻找该tagName对应的标签，其间遇到的所有内容都应当作为普通文本进行处理。

//                                  DEBUGP("Treatingliteral %s\n", mpLiteral);

while(c != end && *c != '<') ++c;  //向后不断查找，直到找到了文件末尾或’<’才停止，此刻说明解析完毕或者解析到了某个tag标签

if(c == end) {             //如果成立说明解析完毕

if(c != begin) this->parseContent(begin, c);   //此时最后一个解析的标签末尾和文档末尾之间可能还有一段内容需要解析

gotoDONE;      //转到结束阶段

}

iteratorend_text(c);   //申请一个新游标end_text，初始值赋入c

++c; //将c游标前进一步

此处申请的end_text，主要是为了在后面的代码中记录下当前’<’符号的位置。

if(*c == '/')                 //判断’<’后面紧跟的是否为’/’符号

{

++c;           //前进一步，指向tagName的起始位置

constchar *l = mpLiteral;

while(*l && ::tolower(*c) == *l)     //逐字节将mpLiteral和tagName进行比较

{

++c;

++l;

}

//FIXME: Mozilla stops when it sees a /plaintext. Check

//other browsers and decide what to do

if(!*l && strcmp(mpLiteral, "plaintext"))

{

//matched all and is not tag plaintext

//说明不是plaintext标签，且此时l指针为空

while(isspace(*c)) ++c; //跳过空格字符

if(*c == '>')                //直到找到标签结束位置

{

++c;

if(begin != end_text)

this->parseContent(begin,end_text); //处理这段标签之前的那段“文本”

mpLiteral= 0;  //更改循环进入条件

c= end_text;  //修改游标值

begin= c;          //修改游标值

break;                //跳出循环，此时说明已经找到了对应tagName的标签

}

}

elseif (*c == '!')

{

// we may find a comment andwe should support it

iteratore(c);

++e;

if(e != end && *e == '-' && ++e != end && *e == '-')

{

//                                                     DEBUGP("Parsingcomment\n");

++e;

c= this->skipHtmlComment(e, end);

}

}

}

到这里为止while(mpLiteral)循环的代码就结束了，下面的代码则是解析一般tag标签的代码。

if(*c == '<')                         //判断是否是一个标签的开始

{

iteratord(c);             //申请一个新游标d，初始为这个’<’的位置

++d;                             //将其后移一位

if(d != end)                //如果不是文档的结尾

{

此时d所指向的应当是’<’之后的那个字符，现在要通过对这个字符进行判断来进行不同的处理，一共分四种情况进行处理：普通字符，’/’符 号，’!’符号，’?’或’%’符号。分别对应tagName，结束tag标签，注释字段，以及一些特殊字段如<?xml 或 <%VBSCRIPT。

首先是解析普通起始型标签的：

if(isalpha(*d))                    //如果d指向的是普通字符

{

//beginning of tag 说明是tag标签的起始

if(begin != c)    //如果标签之前还有一段文本

this->parseContent(begin,c);          //则对其进行处理

//                                                     DEBUGP("Parsingbeginning of tag\n");

d= this->skipHtmlTag(d, end);         //找到Tag标签的结束位置

this->parseHtmlTag(c,d);        //对Tag标签的起始位置和结束位置之间的这段标签内容适用parseHtmltag(X,X)进行处理。

//continue from the end of the tag

c= d;         //将游标移动到标签之后的位置

begin= c;

break;       //成功解析出一个节点，跳出循环

}

if(*d == '/')

{

if(begin != c)    //如果标签之前还有一段文本

this->parseContent(begin,c); //则对其进行处理

iteratore(d);    //申请一个新标签e，初始化为d

++e;          //将其后移一位

if(e != end && isalpha(*e))

{

//说明此时e指向的是结尾型标签的起始处

d= this->skipHtmlTag(d, end); //寻找标签结束位置

this->parseHtmlTag(c,d); //对这段位置之间的标签进行处理

}

else

{

//不是一个标准的结束型标签，和Mozilla采用一样的处理方式

d= this->skipHtmlTag(d, end);

this->parseComment(c,d);

}

//将游标移动到tag标签之后继续

c= d;

begin= c;

break;       //解析出一个节点，跳出循环

}

之后是处理注释型标签的，即“<!--”型标签：

if(*d == '!')

{

//说明是注释标签

if(begin != c)  //如果此标签之前还有一段文本

this->parseContent(begin,c); //则对其进行处理

iteratore(d);    //申请一个游标e，初始化为d

++e;//将e后移一位

if(e != end && *e == '-' && ++e != end && *e == '-')

{

//                                                              DEBUGP("Parsingcomment\n");

++e;

d= this->skipHtmlComment(e, end); //查找到标签结尾

}

else

{

d= this->skipHtmlTag(d, end); //也可能注释直到文档结束

}

this->parseComment(c,d); //将这段文本作为注释进行处理

//移动游标至标签结尾处

c= d;

begin= c;

break;       //成功解析出一个标签，跳出循环

}

最后这段代码是处理一些诸如<?xml 或 <%VBSCRIPT之类的特殊标签的：

if(*d == '?' || *d == '%')

{

//这段代码很简单

if(begin != c)    //如果标签之前还有一段文本

this->parseContent(begin,c); //则对其进行处理

d= this->skipHtmlTag(d, end);  //找到标签末尾

this->parseComment(c,d);     //对这段标签进行处理

//移动游标至末尾

c= d;

begin= c;

break;//成功解析出标签，跳出循环

}

}

}

}

c++;                    //每次while循环后都需要后移游标c

}

//在所有标签都处理完后，可能在文档末尾还有一些文本要进行处理

if(begin != c)

{

this->parseContent(begin,c);          //处理这段文本

begin= c;

}

}

DONE:               //作为GOTO代码的位置，即为解析结束后执行的收尾工作

this->endParsing();

return;

}

parseComment(_Iteratorb, _Iterator c)

template

voidhtmlcxx::HTML::ParserSax::parseComment(_Iterator b, _Iterator c)

{

//      DEBUGP("Creatingcomment node %s\n", std::string(b, c).c_str());

//申请一个新的Node节点

htmlcxx::HTML::Nodecom_node;

//FIXME:set_tagname shouldn't be needed, but first I must check

//legacycode

//申请一个string类型，用游标b,c之间的这段文本为其初始化赋值

std::stringcomment(b, c);

//以下是利用各种变量为代表该Node的一些属性的数据成员进行复制

//具体方法的细节我们在后面分析Node.h(.cc)的时候再进行解释

com_node.tagName(comment);     //tag名

com_node.text(comment);     //文本

com_node.offset(mCurrentOffset);         //在文档中的偏移值

com_node.length((unsignedint)comment.length());      //节点长度

com_node.isTag(false);   //是否是标签

com_node.isComment(true); //是否是注释

mCurrentOffset+= com_node.length();          //将当前解析位置后移，移动到该节点的结束位置

//Call callback method

//回调方法，将该节点插入已有的Html树中

this->foundComment(com_node);

}

parseContent(_Iteratorb, _Iterator c)

template

voidhtmlcxx::HTML::ParserSax::parseContent(_Iterator b, _Iterator c)

{

//      DEBUGP("Creatingtext node %s\n", (std::string(b, c)).c_str());

//申请一个新的Node节点

htmlcxx::HTML::Nodetxt_node;

//FIXME:set_tagname shouldn't be needed, but first I must check

//legacycode

//申请一个string类型，用游标b,c之间的这段文本为其初始化赋值

std::stringtext(b, c);

//以下是利用各种变量为代表该Node的一些属性的数据成员进行复制

//具体方法的细节我们在后面分析Node.h(.cc)的时候再进行解释

txt_node.tagName(text);        //tag名

txt_node.text(text);                  //文本

txt_node.offset(mCurrentOffset);  //在文档中的偏移值

txt_node.length((unsignedint)text.length());                   //节点长度

txt_node.isTag(false);      //是否是标签

txt_node.isComment(false);   //是否是注释

mCurrentOffset+= txt_node.length();    //将当前解析位置后移，移动到该节点的结束位置

//Call callback method

//回调方法，将该节点插入已有的Html树中

this->foundText(txt_node);

}

parseHtmlTag(_Iteratorb, _Iterator c)

我们分三段来看这段代码，首先看第一段：

template

voidhtmlcxx::HTML::ParserSax::parseHtmlTag(_Iterator b, _Iterator c)

{

_Iteratorname_begin(b);        //申请一个新的游标name_begin游标，初始为b

++name_begin;        //将name_begin后移一位

boolis_end_tag = (*name_begin == '/');          //判断name_begin是否是’/’，如果是则说明是结束型tag标签

if(is_end_tag) ++name_begin;        //如果是结束型的tag标签，则再将name_begin前进一位，跳过’/’符号

_Iteratorname_end(name_begin);         //申请一个新的name_end游标，记录一下name_begin标签。

while(name_end != c && isalnum(*name_end))  //将name_end后移，直到遇到了文档末尾或者普通字符为止。

{

++name_end;

}

std::stringname(name_begin, name_end); //取name_begin和name_end之间的这段文本认为是tagName并赋值给一个string型的变量name

if(!is_end_tag)       //当然首先得判断这不是一个结束型的标签

{

std::string::size_typetag_len = name.length();

for(int i = 0; literal_mode_elem[i].len; ++i)     //循环进行查找

{

if(tag_len == literal_mode_elem[i].len)  //进行比较

{

#ifdefined(WIN32) && !defined(__MINGW32__) //这段就是根据系统采用不同的string比较函数

if(!_stricmp(name.c_str(), literal_mode_elem[i].str))

#else

if(!strcasecmp(name.c_str(), literal_mode_elem[i].str))

#endif

{

mpLiteral= literal_mode_elem[i].str;     //如果找到，则将其赋值为mpLiteral

break;       //并退出循环

}

}

}

}

htmlcxx::HTML::Nodetag_node;

//bynow, length is just the size of the tag

//注意到，目前这还只是起始节点，因此长度只是本身的长度

std::stringtext(b, c);

tag_node.length(static_cast(text.length()));  //节点长度

tag_node.tagName(name);    //tag名

tag_node.text(text);        //节点文本

tag_node.offset(mCurrentOffset);          //在文档中的偏移位置

tag_node.isTag(true);      //是否是tag标签

tag_node.isComment(false);  //是否是注释

mCurrentOffset+= tag_node.length();   //将当前的解析位置后移

this->foundTag(tag_node,is_end_tag);         //调用方法将其加入到已有的Html树中

}

find_next_quote(_Iteratorc, _Iterator end, char quote)

template

static inline

_Iterator find_next_quote(_Iterator c,_Iterator end, char quote)

{

//      std::cerr<< "generic find" << std::endl;

while(c != end && *c != quote) ++c;

returnc;

}

*find_next_quote(constchar *c, const char *end, char quote)

template <>

inline

const char *find_next_quote(const char *c,const char *end, char quote)

{

//      std::cerr<< "fast find" << std::endl;

constchar *d = reinterpret_cast(memchr(c, quote, end - c));

if(d) return d;

elsereturn end;

}

skipHtmlTag(_Iteratorc, _Iterator end)

从游标c的位置开始，直到游标end的位置之间，寻找到该标签所对应的结束’>’符号的位置，并以游标形式返回。其中要注意对tag标签内的属性做了另外的处理，即能够识别并跳过属性中的’>’符号，防止出错。

template

_Iteratorhtmlcxx::HTML::ParserSax::skipHtmlTag(_Iterator c, _Iterator end)

{

while(c != end && *c != '>')

{

if(*c != '=')

{

++c;

}

else

{// found an attribute

++c;

while(c != end && isspace(*c)) ++c;

if(c == end) break;

if(*c == '\"' || *c == '\'')

{

_Iteratorsave(c);

charquote = *c++;

c= find_next_quote(c, end, quote);

//                                  while(c != end && *c != quote) ++c;

//                                  c= static_cast(memchr(c, quote, end - c));

if(c != end)

{

++c;

}

else

{

c= save;

++c;

}

//                                  DEBUGP("Quotes:%s\n", std::string(save, c).c_str());

}

}

}

if(c != end) ++c;

returnc;

}

protected:

std::stringmText;    //节点的内部文本

std::stringmClosingText;

unsignedint mOffset;      //节点在原文档中的偏移值

unsignedint mLength;     //节点的字符长度的

std::stringmTagName;   //节点的Tag名

std::map mAttributes; //存放属性的二维数组

boolmIsHtmlTag;    //节点是否是HtmlTag标签

boolmComment;     //节点是否是注释

public:

Node(){}          //构造函数

//Node(constNode &rhs); //uses default

~Node(){}         //析构函数

inlinevoid text(const std::string& text) { this->mText = text; }

inlineconst std::string& text() const { return this->mText; }

inlinevoid closingText(const std::string &text) { this->mClosingText = text; }

inlineconst std::string& closingText() const { return mClosingText; }

inlinevoid offset(unsigned int offset) { this->mOffset = offset; }

inlineunsigned int offset() const { return this->mOffset; }

inlinevoid length(unsigned int length) { this->mLength = length; }

inlineunsigned int length() const { return this->mLength; }

inlinevoid tagName(const std::string& tagname) { this->mTagName = tagname; }

inlineconst std::string& tagName() const { return this->mTagName; }

boolisTag() const { return this->mIsHtmlTag; }

voidisTag(bool is_html_tag){ this->mIsHtmlTag = is_html_tag; }

boolisComment() const { return this->mComment; }

voidisComment(bool comment){ this->mComment = comment; }

主要了解一下下面这个函数

std::pair attribute(const std::string &attr) const

{

std::map::const_iterator i = this->mAttributes.find(attr);

if(i != this->mAttributes.end()) {

returnmake_pair(true, i->second);

}else {

returnmake_pair(false, std::string());

}

}

该函数主要功能是根据参数string &attr，查找到mAttributes[]中的某个项，并且返回该项的第二个成员值，即根据属性的名称查找该属性的值。返回的形式为一个 make_pair数据类型，如果不为最后一个属性，则为make_pair(true，属性值)，而如果是最后一个属性则返回一个 make_pair(false,空字符串)。

operatorstd::string() const;

std::ostream&operator<<(std::ostream &stream) const;

conststd::map& attributes() const { returnthis->mAttributes; }

voidparseAttributes();

booloperator==(const Node &rhs) const;

parseAttributes()

由于这段代码较长，因此我们也分段对其进行解析。这段代码默认在mText中已经存放了节点的文本数据。并且通过对该文本数据进行解析，将所有诸如<…..ID = “abc”…>之类的属性信息识别并储存起来。

if(!(this->isTag())) return;        //判断是否是Tag标签节点，不是则返回

constchar *end;

constchar *ptr = mText.c_str();      //*ptr作为mText的*char类型指针

if((ptr = strchr(ptr, '<')) == 0) return;       //将ptr指向字符串中首先出现的<位置，并判断该位置是否合法，如果不合法则返回。

++ptr;       //将ptr后移一个字节

//Skip initial blankspace

while(isspace(*ptr)) ++ptr;     //跳过接下来所有遇到的空格字符

//Skip tagname

if(!isalpha(*ptr)) return;          //判断是否是普通字符，不是则返回

while(!isspace(*ptr)) ++ptr;   //不断后移ptr指针，直到遇到空格字符

//Skip blankspace after tagname

while(isspace(*ptr)) ++ptr;     //跳过接下来所有遇到的空格字符

下面进入一个循环，该循环将一直不断向后解析该tag标签，直到遇到了’>’字符或者指针为空才退出。

while(*ptr && *ptr != '>')

{

stringkey, val;

//跳过所有无法识别的字节

while(*ptr && !isalnum(*ptr) && !isspace(*ptr)) ++ptr;

//跳过所有的空格字符

while(isspace(*ptr)) ++ptr;

end= ptr;

//将end指向ptr之后第一个不为普通字符或’-’字符的位置

while(isalnum(*end) || *end == '-') ++end;

//将ptr至end之间的这段文本变为小写字符赋值给key

key.assign(end- ptr, '\0');

transform(ptr,end, key.begin(), ::tolower);

ptr= end;

//此时key中应当存放的是属性名

//跳过所有的空格字符

while(isspace(*ptr)) ++ptr;

while(*ptr && *ptr != '>')

{

stringkey, val;

//跳过所有无法识别的字节

while(*ptr && !isalnum(*ptr) && !isspace(*ptr)) ++ptr;

//跳过所有的空格字符

while(isspace(*ptr)) ++ptr;

end= ptr;

//将end指向ptr之后第一个不为普通字符或’-’字符的位置

while(isalnum(*end) || *end == '-') ++end;

//将ptr至end之间的这段文本变为小写字符赋值给key

key.assign(end- ptr, '\0');  //注意要加上’\0’

transform(ptr,end, key.begin(), ::tolower);

ptr= end;

//此时key中应当存放的是属性名

//跳过所有的空格字符

while(isspace(*ptr)) ++ptr;

if(*ptr == '=')           //如果后面跟的是’=’符号，说明后面就是属性值

{

++ptr;                //将ptr后移一位

while(isspace(*ptr)) ++ptr;     //跳过所有的空格字符

if(*ptr == '"' || *ptr == '\'')     //判断属性值是否被引号括起

{

charquote = *ptr;

//                                  fprintf(stderr,"Trying to find quote: %c\n", quote);

constchar *end = strchr(ptr + 1, quote);

if(end == 0)

{

//b= mText.find_first_of(" >", a+1);

constchar *end1, *end2;

end1= strchr(ptr + 1, ' ');

end2= strchr(ptr + 1, '>');

if(end1 && end1 < end2) end = end1;

elseend = end2;

if(end == 0) return;

}

constchar *begin = ptr + 1;

while(isspace(*begin) && begin < end) ++begin;

constchar *trimmed_end = end - 1;

while(isspace(*trimmed_end) && trimmed_end >= begin) --trimmed_end;

val.assign(begin,trimmed_end + 1);

ptr= end + 1;

}

else                  //否则直接获取其值

{

end= ptr;

while(*end && !isspace(*end) && *end != '>') end++;

val.assign(ptr,end);

ptr= end;

}

//                         fprintf(stderr,"%s = %s\n", key.c_str(), val.c_str());

mAttributes.insert(make_pair(key,val));

}

else//否则说明格式有错误，并将该key对应的值按空字符串插入结果集

{

//                         fprintf(stderr,"D: %s\n", key.c_str());

mAttributes.insert(make_pair(key,string()));

}

}

}

bool Node::operator==(const Node &n)const //判断两个Node是否都为tag标签，且tag名是否相等

{

if(!isTag() || !n.isTag()) return false;

return!(strcasecmp(tagName().c_str(), n.tagName().c_str()));

}

Node::operator string() const {                 //根据是否是tag标签，返回tagName或者text

if(isTag()) return this->tagName();

returnthis->text();

}

ostream &Node::operator<<(ostream&stream) const {       //按对象输出Node

stream<< (string)(*this);

returnstream;

}

三.总结

对HtmlCxx进行学习，可以很好地掌握标准Html解析的流程，以及解析器的内部结构，并掌握C++编程时的一些好习惯和系统组织方式。遗憾的是 HtmlCxx在2005年之后就不再更新，且仅仅支持Mozilla的Html标准。它对Html的良构性要求比较高，对于一些含有错误的Html文 档，在解析时可能会出现一些意想不到的错误。

目前的文档中没有包含tree.h的代码说明，因为它属于第三方代码，希望了解的可以去http://tree.phi-sci.com/documentation.html了解具体的情况。后续有机会还会专门写一篇关于这个tree.h的文档。