CPU和IO操作

500)this.width=500;" border="0">

500)this.width=500;" border="0" width="500">

多线程

500)this.width=500;" border="0" width="500">

500)this.width=500;" border="0" width="500">

IO复用

500)this.width=500;" border="0" width="500">

总结

状态机(2)

o 用有穷状态机解一道面试题。

刚毕业的时候，我到一家外企面试，面试题里有这样一道题：

统计一篇英文文章里的单词个数。

有多种方法可以解这道题，这里我们选择用有穷状态机来解，做法如下：

先把这篇英文文章读入到一个缓冲区里，让一个指针从缓冲区的头部一直移到缓冲区的尾部，指针会处于两种状态：“单词内”或“单词外”，加上后面提到的初始状态和接受状态，就是有穷状态机的状态集。缓冲区中的字符集合就是有穷状态机的字母表。

如果当前状态为“单词内”，移到指针时，指针指向的字符是非单词字符(如标点和空格)，那状态会从“单词内”转换到“单词外”。如果当前状态为“单 词外”， 移到指针时，指针指向的字符是单词字符(如字母)，那状态会从“单词外”转换到“单词内”。这些转换规则就是状态转换函数。

指针指向缓冲区的头部时是初始状态。

指针指向缓冲区的尾部时是接受状态。

每次当状态从“单词内”转换到“单词外”时，单词计数增加一。
这个有穷状态机的图形表示如下：

下面我们看看程序怎么写：

int count_word(const char* text)



{



/*定义各种状态，我们不关心接受状态，这里可以不用定义。*/



enum _State



{



STAT_INIT,



STAT_IN_WORD,



STAT_OUT_WORD,



}state = STAT_INIT;







int count = 0;



const char* p = text;







/*在一个循环中，指针从缓冲区头移动缓冲区尾*/



for(p = text; *p != '\0'; p++)



{



switch(state)



{



case STAT_INIT:



{



if(IS_WORD_CHAR(*p))



{



/*指针指向单词字符，状态转换为单词内*/



state = STAT_IN_WORD;



}



else



{



/*指针指向非单词字符，状态转换为单词外*/



state = STAT_OUT_WORD;



}



break;



}



case STAT_IN_WORD:



{



if(!IS_WORD_CHAR(*p))



{



/*指针指向非单词字符，状态转换为单词外，增加单词计数*/



count++;



state = STAT_OUT_WORD;



}



break;



}



case STAT_OUT_WORD:



{



if(IS_WORD_CHAR(*p))



{



/*指针指向单词字符，状态转换为单词内*/



state = STAT_IN_WORD;



}



break;



}



default:break;



}



}







if(state == STAT_IN_WORD)



{



/*如果由单词内进入接受状态，增加单词计数*/



count++;



}







return count;



}

用状态机来解这道题目，思路清晰，程序简单，不易出错。

这道题目只是为了展示一些奇技淫巧，还是有一些实际用处呢？回答这个问题之前，我们先对上面的程序做点扩展，不只是统计单词的个数，而且要分离出里面的每个单词。

int word_segmentation(const char* text, OnWordFunc on_word, void* ctx)



{



enum _State



{



STAT_INIT,



STAT_IN_WORD,



STAT_OUT_WORD,



}state = STAT_INIT;







int count = 0;



char* copy_text = strdup(text);



char* p = copy_text;



char* word = copy_text;







for(p = copy_text; *p != '\0'; p++)



{



switch(state)



{



case STAT_INIT:



{



if(IS_WORD_CHAR(*p))



{



word = p;



state = STAT_IN_WORD;



}



break;



}



case STAT_IN_WORD:



{



if(!IS_WORD_CHAR(*p))



{



count++;



*p = '\0';



on_word(ctx, word);



state = STAT_OUT_WORD;



}



break;



}



case STAT_OUT_WORD:



{



if(IS_WORD_CHAR(*p))



{



word = p;



state = STAT_IN_WORD;



}



break;



}



default:break;



}



}







if(state == STAT_IN_WORD)



{



count++;



on_word(ctx, word);



}







free(copy_text);







return count;



}

状态机不变，只是在状态转换时，做是事情不一样。这里从“单词内”转换到其它状态时，增加单词计数，并分离出当前的单词。至于拿分离出的单词来做什么，由传入的回调函数决定，比如可以用来统计每个单词出现的频率。

但如果讨论还是限于英文文章，这个程序的意义仍然不大，现在来做进一步扩展。我们考虑的文本不再是英文文章，而是一些文本数据，这些数据由一些分隔符分开，我们把数据称为token，现在我们要把这些token分离出来。

typedef void (*OnTokenFunc)(void* ctx, int index, const char* token);







#define IS_DELIM(c) (strchr(delims, c) != NULL)



int parse_token(const char* text, const char* delims, OnTokenFunc on_token, void* ctx)



{



enum _State



{



STAT_INIT,



STAT_IN,



STAT_OUT,



}state = STAT_INIT;







int   count     = 0;



char* copy_text = strdup(text);



char* p         = copy_text;



char* token     = copy_text;







for(p = copy_text; *p != '\0'; p++)



{



switch(state)



{



case STAT_INIT:



case STAT_OUT:



{



if(!IS_DELIM(*p))



{



token = p;



state = STAT_IN;



}



break;



}



case STAT_IN:



{



if(IS_DELIM(*p))



{



*p = '\0';



on_token(ctx, count++, token);



state = STAT_OUT;



}



break;



}



default:break;



}



}







if(state == STAT_IN)



{



on_token(ctx, count++, token);



}







on_token(ctx, -1, NULL);



free(copy_text);







return count;



}

用分隔符分隔的文本数据有很多，如：

环境PATH，它由‘:’分开的多个路径组成。如：
/usr/lib/qt-3.3/bin:/usr/kerberos/bin:/backup/tools/jdk1.5.0_18/bin/:/usr/lib/ccache:/usr/local/bin:/bin:/usr/bin:/home/lixianjing/bin

文件名，它由‘/’分开的路径组成。如：
/usr/lib/qt-3.3/bin

URL中的参数，它‘&’分开的多个key/value对组成。
hl=zh-CN&q=limodev&btnG=Google+搜索&meta=&aq=f&oq=

所有这些数据都可以用上面的函数处理，所以这个小函数是颇具实用价值的。

状态机(1)

o 有穷状态机的形式定义

有穷状态机是一个五元组 (Q，Σ，δ，q0，F)，其中：
Q是一个有穷集合，称为状态集。
Σ是一个有穷集合，称为字母表。
δ: Q xΣQ称为状态转移函数。
q0 是初始状态。
F 是接受状态集。

教科书上是这样定义有穷自动机的，这个形式定义精确的描述了有穷状态机的含义。但是大部分人(包括我自己)第一次看到它时，反复的读上几遍，仍然不知道它在说什么。幸好通过一些实例，我们可以很容易明白有穷状态机的原理。

自动门是一个典型的有穷状态机：

它有“开”和“关”两种状态，这就是它的状态集，也就是上面所说的Q。

人可以从自动门进来或出去，当人进来或出去的时候，自动门会自动打开，如果在规定的时间内没有人进出，自动门会自动关上。人的进来、出去和超时三个事件是自动门的字母表，也就是上面所说的Σ。而自动门在当前状态下，对事件的响应，会引起状态的变化，这就是状态转换函数，也就是上面所说的δ。

自动门刚安装好的时候，我们可以认为它是关上的，所以关闭状态是自动门的初始状态。

在理想情况下，自动门会一直运行，所以它没有接受状态，接受状态集F是空集。

有穷状态机的形式定义很精确，文字描述比较通俗，而图形表示则比较直观。通用建模语言（UML）里的状态图是状态机的常用图形表示方法。简单的状态图包括一些状态，用圆角方框表示，里面有状态的名称。状态之间的转换，用箭头表示，上面可以加转换条件。自动门的状态机可以用下图表示：

有穷状态机很简单，在生活中可以找出很多这样的例子。但是教科书里讲得太复杂了，一会儿证明确定性有穷状态机和非确定性有穷状态机的等价性，一会儿证明正则表达式的正则运算是封闭的，一会儿又来个泵引理。花了很长时间，我才明白这些原理，但两年之后，我又把它们忘得一干二净。

主要原因是工作中没有机会运用它们，这些理论的证明于编程没有太大用处，不过状态机本身却是文本处理利器，由于程序员在很多场合下都是在与文本数据打交道，所以状态机是程序员必备的工具之一。这里我们将一起学习如何用状态机来处理文本数据，后面我们也会提到状态机的其它用途，不过不是本节的重点。



文章出处：http://www.limodev.cn/blog
作者联系方式：李先静 <xianjimli at hotmail dot com>

Builder模式

前面我们学习了状态机，并利用它来解析各种格式的文本数据。解析过程把线性的文本数据转换成一些基本的逻辑单元，但这通常只是任务的一部分，接下来我们还要对这些解析出来的数据进一步处理。对于特定格式的文本数据，它的解析过程是一样的，但是对解析出来的数据的处理却是多种多样的。为了让解析过程能被重用，就需要把数据的解析和数据的处理分开。

现在我们回过头来看一下前面写的函数parse_token，这个函数把用分隔符分隔的文本数据，分离出一个一个的token。

parse_token的函数原型如下：

typedef void (*OnTokenFunc)(void* ctx, int index, const char* token);
int parse_token(const char* text, const char* delims, OnTokenFunc on_token, void* ctx)

parse_token负责解析数据，但它并不关心数据代表的意义及用途。对数据的进一步处理由调用者提供的回调函数来完成，函数 parse_token每解析到一个token，就调用这个回调函数。parse_token负责数据的解析，回调函数负责数据的处理，这样一来，数据的解析和数据的处理就分开了。

parse_token可以认为是Builder模式最朴素的应用。现在我们看看Builder 模式：

Builder 模式的意图：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。“构建”其实就是前面的解析过程，而“表示”就是前面说的对数据的处理。

对象关系：

上面的parse_token与这里的Director对应。

上面的回调函数与这里的Builder对应。

具体的回调函数与这里的ConcreteBuilder对应。

对数据处理的结果就是Product。

对象协作：

Client是parse_token的调用者。

由于parse_token是按面向过程的方式设计的，所以ConcreteBuilder和Director的创建只是对应于一些初始化代码。

调用parse_token相当于调用aDirector的Construct函数。

调用回调函数相当于调用aConcreteBuilder的BuildPart函数。

回调函数可能把处理结果存在它的参数ctx中，GetResult是从里面获取结果，这是可选的过程，依赖于具体回调函数所做的工作。

parse_token的例子简单直接，对于理解Builder模式有较大的帮助，不过毕竟它是面向过程的。现在我们以前面的XML解析器为例来说明Builder模式，虽然我们的代码是用C写的，但完全是用面向对象的思想来设计的。Builder是一个接口，我们先把它定义出来：

struct _XmlBuilder;

typedef struct _XmlBuilder XmlBuilder; 



typedef void (*XmlBuilderOnStartElementFunc)(XmlBuilder* thiz, const char* tag, const char** attrs);

typedef void (*XmlBuilderOnEndElementFunc)(XmlBuilder* thiz, const char* tag);

typedef void (*XmlBuilderOnTextFunc)(XmlBuilder* thiz, const char* text, size_t length);

typedef void (*XmlBuilderOnCommentFunc)(XmlBuilder* thiz, const char* text, size_t length);

typedef void (*XmlBuilderOnPiElementFunc)(XmlBuilder* thiz, const char* tag, const char** attrs);

typedef void (*XmlBuilderOnErrorFunc)(XmlBuilder* thiz, int line, int row, const char* message);

typedef void (*XmlBuilderDestroyFunc)(XmlBuilder* thiz); 



struct _XmlBuilder

{

XmlBuilderOnStartElementFunc on_start_element;

XmlBuilderOnEndElementFunc   on_end_element;

XmlBuilderOnTextFunc         on_text;

XmlBuilderOnCommentFunc      on_comment;

XmlBuilderOnPiElementFunc    on_pi_element;

XmlBuilderOnErrorFunc        on_error;

XmlBuilderDestroyFunc        destroy; 



char priv[1];

}; 



static inline void xml_builder_on_start_element(XmlBuilder* thiz, const char* tag, const char** attrs)



{



return_if_fail(thiz != NULL && thiz->on_start_element != NULL);



thiz->on_start_element(thiz, tag, attrs);



return;



}



static inline void xml_builder_on_end_element(XmlBuilder* thiz, const char* tag)



{



return_if_fail(thiz != NULL && thiz->on_end_element != NULL);



thiz->on_end_element(thiz, tag);



return;



}



...

(其它inline函数不列在这里了)

XmlBuilder接口要求实现下列函数：

on_start_element：解析器解析到一个起始TAG时调用它。
on_end_element：解析器解析到一个结束TAG时调用它。
on_text：解析器解析到一段文本时调用它。
on_comment：解析器解析到一个注释时调用它。
on_pi_element：解析器解析到一个处理指令时调用它。
on_error：解析器遇到错误时调用它。
destroy：用销毁Builder对象。

on_start_element和on_end_element等函数相当于Builder模式中的BuildPartX函数。

XML解析器相当于Director，在前面我们已经写好了，不过它对解析出来的数据没有做任何处理。现在我们对它做些修改，让它调用XmlBuilder的函数。

XML解析器对外提供下面几个函数：

o 构造函数。

XmlParser* xml_parser_create(void);

o 为xmlParser设置builder对象。

void       xml_parser_set_builder(XmlParser* thiz, XmlBuilder* builder);

o 解析XML

void       xml_parser_parse(XmlParser* thiz, const char* xml);

o 析构函数

void       xml_parser_destroy(XmlParser* thiz);

在解析时，解析到相应的tag，就调用XmlBuilder相应的函数：

o 解析到起始tag时调用xml_builder_on_start_element

static void xml_parser_parse_start_tag(XmlParser* thiz)

{

enum _State

{

STAT_NAME,

STAT_ATTR,

STAT_END,

}state = STAT_NAME; 



char* tag_name = NULL;

const char* start = thiz->read_ptr - 1; 



for(; *thiz->read_ptr != '\0'; thiz->read_ptr++)

{

char c = *thiz->read_ptr; 



switch(state)

{

case STAT_NAME:

{

if(isspace(c) || c == '>' || c == '/')

{

tag_name = (char*)xml_parser_strdup(thiz, start, thiz->read_ptr - start);

state = (c != '>' && c != '/') ? STAT_ATTR : STAT_END;

}

break;

}

case STAT_ATTR:

{

xml_parser_parse_attrs(thiz, '/');

state = STAT_END; 



break;

}

default:break;

} 



if(state == STAT_END)

{

break;

}

} 



tag_name = thiz->buffer + (size_t)tag_name;

/*解析完成，调用builder的函数xml_builder_on_start_element。*/

xml_builder_on_start_element(thiz->builder, tag_name, (const char**)thiz->attrs); 



if(thiz->read_ptr[0] == '/')

{

/*如果tag以'/'结束，调用builder的函数xml_builder_on_end_element。*/

xml_builder_on_end_element(thiz->builder, tag_name);

} 



for(; *thiz->read_ptr != '>' && *thiz->read_ptr != '\0'; thiz->read_ptr++); 



return;

}

o 解析到结束tag时调用xml_builder_on_end_element

static void xml_parser_parse_end_tag(XmlParser* thiz)

{

char* tag_name = NULL;

const char* start = thiz->read_ptr;

for(; *thiz->read_ptr != '\0'; thiz->read_ptr++)

{

if(*thiz->read_ptr == '>')

{

tag_name = thiz->buffer + xml_parser_strdup(thiz, start, thiz->read_ptr-start);

/*解析完成，调用builder的函数xml_builder_on_end_element。*/

xml_builder_on_end_element(thiz->builder, tag_name); 



break;

}

} 



return;

}

o 解析到文本时调用xml_builder_on_text

static void xml_parser_parse_text(XmlParser* thiz)

{

const char* start = thiz->read_ptr - 1;

for(; *thiz->read_ptr != '\0'; thiz->read_ptr++)

{

char c = *thiz->read_ptr; 



if(c == '<')

{

if(thiz->read_ptr > start)

{

/*解析完成，调用builder的函数xml_builder_on_text。*/

xml_builder_on_text(thiz->builder, start, thiz->read_ptr-start);

}

thiz->read_ptr--;

return;

}

else if(c == '&')

{

xml_parser_parse_entity(thiz);

}

} 



return;

}

o 解析到注释时调用xml_builder_on_comment

static void xml_parser_parse_comment(XmlParser* thiz)

{

enum _State

{

STAT_COMMENT,

STAT_MINUS1,

STAT_MINUS2,

}state = STAT_COMMENT; 



const char* start = ++thiz->read_ptr;

for(; *thiz->read_ptr != '\0'; thiz->read_ptr++)

{

char c = *thiz->read_ptr; 



switch(state)

{

case STAT_COMMENT:

{

if(c == '-')

{

state = STAT_MINUS1;

}

break;

}

case STAT_MINUS1:

{

if(c == '-')

{

state = STAT_MINUS2;

}

else

{

state = STAT_COMMENT;

}

break;

}

case STAT_MINUS2:

{

if(c == '>')

{

/*解析完成，调用builder的函数xml_builder_on_comment。*/

xml_builder_on_comment(thiz->builder, start, thiz->read_ptr-start-2);

return;

}

}

default:break;

}

} 



return;

}

o 解析到处理指令时调用xml_builder_on_pi_element

static void xml_parser_parse_pi(XmlParser* thiz)

{

enum _State

{

STAT_NAME,

STAT_ATTR,

STAT_END

}state = STAT_NAME; 



char* tag_name = NULL;

const char* start = thiz->read_ptr; 



for(; *thiz->read_ptr != '\0'; thiz->read_ptr++)

{

char c = *thiz->read_ptr; 



switch(state)

{

case STAT_NAME:

{

if(isspace(c) || c == '>')

{

tag_name = (char*)xml_parser_strdup(thiz, start, thiz->read_ptr - start);

state = c != '>' ? STAT_ATTR : STAT_END;

} 



break;

}

case STAT_ATTR:

{

xml_parser_parse_attrs(thiz, '?');

state = STAT_END;

break;

}

default:break;

} 



if(state == STAT_END)

{

break;

}

} 



tag_name = thiz->buffer + (size_t)tag_name;

/*解析完成，调用builder的函数xml_builder_on_pi_element。*/

xml_builder_on_pi_element(thiz->builder, tag_name, (const char**)thiz->attrs);	 



for(; *thiz->read_ptr != '>' && *thiz->read_ptr != '\0'; thiz->read_ptr++); 



return;

}

从上面的代码可以看出，XmlParser在适当的时候调用了XmlBuilder的接口函数，至于XmlBuilder在这些函数里做什么，要看具体的Builder实现了。

先看一个最简单的XmlBuilder实现，它只是在屏幕上打印出传递给它的数据：

o 创建函数

XmlBuilder* xml_builder_dump_create(FILE* fp)

{

XmlBuilder* thiz = (XmlBuilder*)calloc(1, sizeof(XmlBuilder)); 



if(thiz != NULL)

{

PrivInfo* priv = (PrivInfo*)thiz->priv; 



thiz->on_start_element   = xml_builder_dump_on_start_element;

thiz->on_end_element    = xml_builder_dump_on_end_element;

thiz->on_text                  = xml_builder_dump_on_text;

thiz->on_comment         = xml_builder_dump_on_comment;

thiz->on_pi_element      = xml_builder_dump_on_pi_element;

thiz->on_error                = xml_builder_dump_on_error;

thiz->destroy                  = xml_builder_dump_destroy; 



priv->fp = fp != NULL ? fp : stdout;

} 



return thiz;

}

和其它接口的创建函数一样，它只是把接口要求的函数指针指到具体的实现函数上。

o 实现 on_start_element

static void xml_builder_dump_on_start_element(XmlBuilder* thiz, const char* tag, const char** attrs)

{

int i = 0;

PrivInfo* priv = (PrivInfo*)thiz->priv;

fprintf(priv->fp, "<%s", tag); 



for(i = 0; attrs != NULL && attrs[i] != NULL && attrs[i + 1] != NULL; i += 2)

{

fprintf(priv->fp, " %s=\"%s\"", attrs[i], attrs[i + 1]);

}

fprintf(priv->fp, ">"); 



return;

}

o 实现on_end_element

static void xml_builder_dump_on_end_element(XmlBuilder* thiz, const char* tag)

{

PrivInfo* priv = (PrivInfo*)thiz->priv;

fprintf(priv->fp, "\n", tag); 



return;

}

o 实现on_text

static void xml_builder_dump_on_text(XmlBuilder* thiz, const char* text, size_t length)

{

PrivInfo* priv = (PrivInfo*)thiz->priv;

fwrite(text, length, 1, priv->fp); 



return;

}

o 实现on_comment

static void xml_builder_dump_on_comment(XmlBuilder* thiz, const char* text, size_t length)

{

PrivInfo* priv = (PrivInfo*)thiz->priv;

fprintf(priv->fp, "\n"); 



return;

}

o 实现on_pi_element

static void xml_builder_dump_on_pi_element(XmlBuilder* thiz, const char* tag, const char** attrs)

{

int i = 0;

PrivInfo* priv = (PrivInfo*)thiz->priv;

fprintf(priv->fp, "fp, " %s=\"%s\"", attrs[i], attrs[i + 1]);

}

fprintf(priv->fp, "?>\n"); 



return;

}

o 实现on_error

static void xml_builder_dump_on_error(XmlBuilder* thiz, int line, int row, const char* message)

{

fprintf(stderr, "(%d,%d) %s\n", line, row, message); 



return;

}

上面的XmlBuilder实现简单，而且有一定的实用价值，我一般都会先写这样一个Builder。它不但对于调试程序有不小的帮助，而且只要稍做修改，就可以把它改进成一个美化数据格式的小工具，不管原始数据的格式(当然要合符相应的语法规则)有多乱，你都能以一种比较好看的方式打印出来。

下面我们再看一个比较复杂的XmlBuilder的实现，它根据接收的数据构建一棵XML树。

o 创建函数

XmlBuilder* xml_builder_tree_create(void)

{

XmlBuilder* thiz = (XmlBuilder*)calloc(1, sizeof(XmlBuilder)); 



if(thiz != NULL)

{

PrivInfo* priv = (PrivInfo*)thiz->priv; 



thiz->on_start_element   = xml_builder_tree_on_start_element;

thiz->on_end_element    = xml_builder_tree_on_end_element;

thiz->on_text                  = xml_builder_tree_on_text;

thiz->on_comment         = xml_builder_tree_on_comment;

thiz->on_pi_element      = xml_builder_tree_on_pi_element;

thiz->on_error                = xml_builder_tree_on_error;

thiz->destroy                  = xml_builder_tree_destroy; 



priv->root = xml_node_create_normal("__root__", NULL);

priv->current = priv->root;

} 



return thiz;

}

和其它接口的创建函数一样，它只是把接口要求的函数指针指到具体的实现函数上。这里还创建了一个根结点__root__，以保证整棵树只有一个根结点。

o 实现 on_start_element

static void xml_builder_tree_on_start_element(XmlBuilder* thiz, const char* tag, const char** attrs)

{

XmlNode* new_node = NULL;

PrivInfo* priv = (PrivInfo*)thiz->priv; 



new_node = xml_node_create_normal(tag, attrs);

xml_node_append_child(priv->current, new_node);

priv->current = new_node; 



return;

}

这里创建了一个新的结点，并追加为priv->current的子结点，然后让priv->current指向新的结点。

o 实现 on_end_element

static void xml_builder_tree_on_end_element(XmlBuilder* thiz, const char* tag)

{

PrivInfo* priv = (PrivInfo*)thiz->priv;

priv->current = priv->current->parent;

assert(priv->current != NULL); 



return;

}

这里只是让priv->current指向它的父结点。

o 实现 on_text

static void xml_builder_tree_on_text(XmlBuilder* thiz, const char* text, size_t length)

{

XmlNode* new_node = NULL;

PrivInfo* priv = (PrivInfo*)thiz->priv; 



new_node = xml_node_create_text(text);

xml_node_append_child(priv->current, new_node); 



return;

}

这里创建一个文本结点， 并追加为priv->current的子结点。

o 实现 on_comment

static void xml_builder_tree_on_comment(XmlBuilder* thiz, const char* text, size_t length)

{

XmlNode* new_node = NULL;

PrivInfo* priv = (PrivInfo*)thiz->priv; 



new_node = xml_node_create_comment(text);

xml_node_append_child(priv->current, new_node); 



return;

}

这里创建一个注释结点， 并追加为priv->current的子结点。

o 实现 on_pi_element

static void xml_builder_tree_on_pi_element(XmlBuilder* thiz, const char* tag, const char** attrs)

{

XmlNode* new_node = NULL;

PrivInfo* priv = (PrivInfo*)thiz->priv; 



new_node = xml_node_create_pi(tag, attrs);

xml_node_append_child(priv->current, new_node); 



return;

}

这里创建一个处理指令结点， 并追加为priv->current的子结点。

o 实现on_error

static void xml_builder_tree_on_error(XmlBuilder* thiz, int line, int row, const char* message)

{

fprintf(stderr, "(%d,%d) %s\n", line, row, message); 



return;

}

下面我们再看XmlNode的数据结构和主要函数：

o 数据结构

typedef struct _XmlNode

{

XmlNodeType type;

union

{

char* text;

char* comment;

XmlNodePi pi;

XmlNodeNormal normal;

}u;

struct _XmlNode* parent;

struct _XmlNode* children;

struct _XmlNode* sibling;

}XmlNode;

type决定了结点的类型，可以是处理指令(XML_NODE_PI)、文本(XML_NODE_TEXT)、注释(XML_NODE_COMMENT)或普通TAG(XML_NODE_NORMAL)。

联合体用于存放具体结点信息。

parent指向父结点。

children指向第一个子结点。

sibling指向下一个兄弟结点。

o 创建普通TAG结点

XmlNode* xml_node_create_normal(const char* name, const char** attrs)

{

XmlNode* node = NULL;

return_val_if_fail(name != NULL, NULL);



if((node = calloc(1, sizeof(XmlNode))) != NULL)

{

int i = 0;

node->type = XML_NODE_NORMAL;

node->u.normal.name = strdup(name);



if(attrs != NULL)

{

for(i = 0; attrs[i] != NULL && attrs[i+1] != NULL; i += 2)

{

xml_node_append_attr(node, attrs[i], attrs[i+1]);

}

}

}



return node;

}

o 创建处理指令结点

XmlNode* xml_node_create_pi(const char* name, const char** attrs)

{

XmlNode* node = NULL;

return_val_if_fail(name != NULL, NULL);



if((node = calloc(1, sizeof(XmlNode))) != NULL)

{

int i = 0;

node->type = XML_NODE_PI;

node->u.pi.name = strdup(name);

if(attrs != NULL)

{

for(i = 0; attrs[i] != NULL && attrs[i+1] != NULL; i += 2)

{

xml_node_append_attr(node, attrs[i], attrs[i+1]);

}

}

}



return node;

}

o 创建文本结点

XmlNode* xml_node_create_text(const char* text)

{

XmlNode* node = NULL;

return_val_if_fail(text != NULL, NULL);



if((node = calloc(1, sizeof(XmlNode))) != NULL)

{

node->type = XML_NODE_TEXT;

node->u.text = strdup(text);

}



return node;

}

o 创建注释结点

XmlNode* xml_node_create_comment(const char* comment)

{

XmlNode* node = NULL;

return_val_if_fail(comment != NULL, NULL);



if((node = calloc(1, sizeof(XmlNode))) != NULL)

{

node->type = XML_NODE_COMMENT;

node->u.comment = strdup(comment);

}



return node;

}

o 追加一个兄弟结点

XmlNode* xml_node_append_sibling(XmlNode* node, XmlNode* sibling)

{

return_val_if_fail(node != NULL && sibling != NULL, NULL);



if(node->sibling == NULL)

{

/*没有兄弟结点，让兄弟结点指向sibling */

node->sibling = sibling;

}

else

{

/*否则，把sibling追加为最后一个兄弟结点*/

XmlNode* iter = node->sibling;

while(iter->sibling != NULL) iter = iter->sibling;

iter->sibling = sibling;

}

/*让兄弟结点的父结点指向自己的父结点*/



sibling->parent = node->parent;



return sibling;

}

o 追加一个子结点

XmlNode* xml_node_append_child(XmlNode* node, XmlNode* child)

{

return_val_if_fail(node != NULL && child != NULL, NULL);



if(node->children == NULL)

{

/*没有子结点，让子结点指向child */

node->children = child;

}

else

{

/*否则，把child 追加为最后一个子结点*/

XmlNode* iter = node->children;

while(iter->sibling != NULL) iter = iter->sibling;

iter->sibling = child;

}

/*让子结点的父结点指向自己*/



child->parent = node;



return child;

}

回头再看一下XmlParser，XmlBuilder及几个具体的XmlBuilder的实现，我们可以看到，它们的实现都非常简单，其实这完全得益于Builder模式的设计方法。它利用分而治之的思想，把数据的解析和数据的处理分开，降低了实现的复杂度。其次它利用了抽象的思想，从而数据的解析只关心处理数据处理的接口，而不关心的它的实现，使得数据解析和数据处理可以独立变化。

分而治之和抽象是降低复杂度最有效的手段之一，它们在Builder模式里得到了很好的体现。初学者应该多花些时间去体会。


文章出处：http://www.limodev.cn/blog
作者联系方式：李先静 <xianjimli at hotmail dot com>

系统程序员成长计划-文本处理(一)

状态机(4)

XML解析器

XML（Extensible Markup Language）即可扩展标记语言，也是一种常用的数据文件格式。相对于INI来说，它要复杂得多，INI只能保存线性结构的数据，而XML可以保存树形结构的数据。先看下面的例子：

<?xml version="1.0" encoding="utf-8"?>

<mime-type xmlns="http://www.freedesktop.org/standards/shared-mime-info" type="all/all">

<!--Created automatically by update-mime-database. DO NOT EDIT!-->

<comment>all files and folders</comment>

</mime-type>

第一行称为处理指令(PI)，是给解析器用的。这里告诉解析器，当前的XML文件遵循XML 1.0规范，文件内容用UTF-8编码。

第二行是一个起始TAG，TAG的名称为mime-type。它有两个属性，第一个属性的名称为xmlns，值为 http://www.freedesktop.org/standards/shared-mime-info。第二个属性的名称为type，值为 all/all。

第三行是一个注释。

第四行包括一个起始TAG，一段文本和结束TAG。

第五行是一个结束TAG。

XML本身的格式不是本文的重点，我们不详细讨论了。这里的重点是如何用状态机解析格式复杂的数据。

按照前面的方法，先把数据读入到一个缓冲区中，让一个指针指向缓冲区的头部，然后移动指针，直到指向缓冲区的尾部。在这个过程中，指针可能指向：起始TAG，结束TAG，注释，处理指令和文本。由此我们定义出状态机的主要状态：

1. 起始TAG状态
2. 结束TAG状态
3. 注释状态
4. 处理指令状态
5. 文本状态

由于起始TAG、结束TAG、注释和处理指令都在字符‘<’和‘>’之间，所以当读入字符‘<’时，我们还无法知道当前的状态，为了便于处理，我们引入一个中间状态，称为“小于号之后”的状态。在读入字符‘<’和‘!’之后，还要读入两个‘-’，才能确定进入注释状态，为了便于处理，再引入两个中间状态“注释前一”和“注释前二”。再引入一个“空”状态，表示不在上述任何状态中。

状态转换函数：
1. 在“空”状态下，读入字符‘<’，进入“小于号之后”状态。
2. 在“空”状态下，读入非‘<’非空白的字符，进入“文本”状态。
3. 在“小于号之后”状态下，读入字符‘！’，进入“注释前一” 状态。
4. 在“小于号之后”状态下，读入字符‘?’，进入“处理指令”状态。
5. 在“小于号之后”状态下，读入字符‘/’，进入“结束TAG”状态。
6. 在“小于号之后”状态下，读入有效的ID字符，进入“起始TAG”状态。
7. 在“注释前一” 状态下，读入字符‘-’， 进入“注释前二” 状态。
8. 在“注释前二” 状态下，读入字符‘-’， 进入“注释” 状态。
9. 在 “起始TAG” 状态、“结束TAG” 状态 、“文本” 状态、“注释”状态 和“处理指令”状态结束后，重新回到“空”状态下。

这个状态机的图形表示如下：

下面我们来看看代码实现：

void xml_parser_parse(XmlParser* thiz, const char* xml)

{

/*定义状态的枚举值*/

enum _State

{

STAT_NONE,

STAT_AFTER_LT,

STAT_START_TAG,

STAT_END_TAG,

STAT_TEXT,

STAT_PRE_COMMENT1,

STAT_PRE_COMMENT2,

STAT_COMMENT,

STAT_PROCESS_INSTRUCTION,

}state = STAT_NONE;



thiz->read_ptr = xml;

/*指针从头移动到尾*/

for(; *thiz->read_ptr != '\0'; thiz->read_ptr++)

{

char c = thiz->read_ptr[0];



switch(state)

{

case STAT_NONE:

{

if(c == '<')

{

/*在“空”状态下，读入字符‘<’，进入“小于号之后”状态。*/

xml_parser_reset_buffer(thiz);

state = STAT_AFTER_LT;

}

else if(!isspace(c))

{

/*在“空”状态下，读入非‘<’非空白的字符，进入“文本”状态。*/

state = STAT_TEXT;

}

break;

}

case STAT_AFTER_LT:

{

if(c == '?')

{

/*在“小于号之后”状态下，读入字符‘?’，进入“处理指令”状态。*/

state = STAT_PROCESS_INSTRUCTION;

}

else if(c == '/')

{

/*在“小于号之后”状态下，读入字符‘/’，进入“结束TAG”状态。*/

state = STAT_END_TAG;

}

else if(c == '!')

{

/*在“小于号之后”状态下，读入字符‘！’，进入“注释前一” 状态*/

state = STAT_PRE_COMMENT1;

}

else if(isalpha(c) || c == '_')

{

/*在“小于号之后”状态下，读入有效的ID字符，进入“起始TAG”状态。*/

state = STAT_START_TAG;

}

else

{

}

break;

}

case STAT_START_TAG:

{

/*进入子状态*/

xml_parser_parse_start_tag(thiz);

state = STAT_NONE;

break;

}

case STAT_END_TAG:

{

/*进入子状态*/

xml_parser_parse_end_tag(thiz);

state = STAT_NONE;

break;

}

case STAT_PROCESS_INSTRUCTION:

{

/*进入子状态*/

xml_parser_parse_pi(thiz);

state = STAT_NONE;

break;

}

case STAT_TEXT:

{

/*进入子状态*/

xml_parser_parse_text(thiz);

state = STAT_NONE;

break;

}

case STAT_PRE_COMMENT1:

{

if(c == '-')

{

/*在“注释前一” 状态下，读入字符‘-’， 进入“注释前二” 状态。*/

state = STAT_PRE_COMMENT2;

}

else

{

}

break;

}

case STAT_PRE_COMMENT2:

{

if(c == '-')

{

/*在“注释前二” 状态下，读入字符‘-’， 进入“注释” 状态。*/

state = STAT_COMMENT;

}

else

{

}

}

case STAT_COMMENT:

{

/*进入子状态*/

xml_parser_parse_comment(thiz);

state = STAT_NONE;

break;

}

default:break;

}



if(*thiz->read_ptr == '\0')

{

break;

}

}



return;

}

解析并没有在此结束，原因是像“起始TAG”状态和“处理指令”状态等，它们不是原子的，内部还包含一些子状态，如TAG名称，属性名和属性值等，它们需要进一步分解。在考虑子状态时，我们可以忘掉它所处的上下文，只考虑子状态本身，这样问题会得到简化。下面看一下起始TAG的状态机。

假设我们要解析下面这样一个起始TAG：
<mime-type xmlns=”http://www.freedesktop.org/standards/shared-mime-info” type=”all/all”>

我们应该怎样去做呢？还是按前面的方法，让一个指针指向缓冲区的头部，然后移动指针，直到指向缓冲区的尾部。在这个过程中，指针可能指向，TAG名称，属性名和属性值。由此我们可以定义出状态机的主要状态：

1. “TAG名称”状态
2. “属性名”状态
3. “属性值”状态

为了方便处理，再引两个中间状态，“属性名之前”状态和“属性值之前”状态。

状态转换函数：

初始状态为“TAG名称”状态
1. 在“TAG名称”状态下，读入空白字符，进入“属性名之前”状态。
2. 在“TAG名称”状态下，读入字符‘/’或‘>’，进入“结束”状态。
3. 在“属性名之前”状态下，读入其它非空白字符，进入“属性名”状态。
4. 在“属性名”状态下，读入字符‘=’，进入“属性值之前”状态。
5. 在“属性值之前”状态下，读入字符‘“’，进入“属性值”状态。
6. 在“属性值”状态下，读入字符‘”’，成功解析属性名和属性值，回到“属性名之前”状态。
7. 在“属性名之前”状态下，读入字符‘/’或‘>’，进入“结束”状态。

由于处理指令(PI)里也包含了属性状态，为了重用属性解析的功能，我们把属性的状态再提取为一个子状态。这样，“起始TAG”状态的图形表示如下：

下面我们看代码实现：

static void xml_parser_parse_attrs(XmlParser* thiz, char end_char)

{

int i = 0;

enum _State

{

STAT_PRE_KEY,

STAT_KEY,

STAT_PRE_VALUE,

STAT_VALUE,

STAT_END,

}state = STAT_PRE_KEY;



char value_end = '\"';

const char* start = thiz->read_ptr;



thiz->attrs_nr = 0;

for(; *thiz->read_ptr != '\0' && thiz->attrs_nr < MAX_ATTR_NR; thiz->read_ptr++)

{

char c = *thiz->read_ptr;



switch(state)

{

case STAT_PRE_KEY:

{

if(c == end_char || c == '>')

{

/*在“属性名之前”状态下，读入字符‘/’或‘>’，进入“结束”状态。*/

state = STAT_END;

}

else if(!isspace(c))

{

/*在“属性名之前”状态下，读入其它非空白字符，进入“属性名”状态。*/

state = STAT_KEY;

start = thiz->read_ptr;

}

}

case STAT_KEY:

{

if(c == '=')

{

/*在“属性名”状态下，读入字符‘=’，进入“属性值之前”状态。*/

thiz->attrs[thiz->attrs_nr++] = (char*)xml_parser_strdup(thiz, start, thiz->read_ptr - start);

state = STAT_PRE_VALUE;

}



break;

}

case STAT_PRE_VALUE:

{

/*在“属性值之前”状态下，读入字符‘“’，进入“属性值”状态。*/

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

{

state = STAT_VALUE;

value_end = c;

start = thiz->read_ptr + 1;

}

break;

}

case STAT_VALUE:

{

/*在“属性值”状态下，读入字符‘”’，成功解析属性名和属性值，回到“属性名之前”状态。*/

if(c == value_end)

{

thiz->attrs[thiz->attrs_nr++] = (char*)xml_parser_strdup(thiz, start, thiz->read_ptr - start);

state = STAT_PRE_KEY;

}

}

default:break;

}



if(state == STAT_END)

{

break;

}

}



for(i = 0; i < thiz->attrs_nr; i++)

{

thiz->attrs[i] = thiz->buffer + (size_t)(thiz->attrs[i]);

}

thiz->attrs[thiz->attrs_nr] = NULL;



return;

}

记得在XML里，单引号和双引号都可以用来界定属性值，所以上面对此做了特殊处理。

static void xml_parser_parse_start_tag(XmlParser* thiz)

{

enum _State

{

STAT_NAME,

STAT_ATTR,

STAT_END,

}state = STAT_NAME;



char* tag_name = NULL;

const char* start = thiz->read_ptr - 1;



for(; *thiz->read_ptr != '\0'; thiz->read_ptr++)

{

char c = *thiz->read_ptr;



switch(state)

{

case STAT_NAME:

{

/*在“TAG名称”状态下，读入空白字符，属性子状态。*/

/*在“TAG名称”状态下，读入字符‘/’或‘>’，进入“结束”状态。*/

if(isspace(c) || c == '>' || c == '/')

{

state = (c != '>' && c != '/') ? STAT_ATTR : STAT_END;

}

break;

}

case STAT_ATTR:

{

/*进入“属性”子状态*/

xml_parser_parse_attrs(thiz, '/');

state = STAT_END;



break;

}

default:break;

}



if(state == STAT_END)

{

break;

}

}



for(; *thiz->read_ptr != '>' && *thiz->read_ptr != '\0'; thiz->read_ptr++);



return;

}

处理指令的解析和起始TAG的解析基本上是一样的，这里只是看一下代码：

static void xml_parser_parse_pi(XmlParser* thiz)

{

enum _State

{

STAT_NAME,

STAT_ATTR,

STAT_END

}state = STAT_NAME;



char* tag_name = NULL;

const char* start = thiz->read_ptr;



for(; *thiz->read_ptr != '\0'; thiz->read_ptr++)

{

char c = *thiz->read_ptr;



switch(state)

{

case STAT_NAME:

{

/*在“TAG名称”状态下，读入空白字符，属性子状态。*/

/*在“TAG名称”状态下，‘>’，进入“结束”状态。*/

if(isspace(c) || c == '>')

{

state = c != '>' ? STAT_ATTR : STAT_END;

}



break;

}

case STAT_ATTR:

{

/*进入“属性”子状态*/

xml_parser_parse_attrs(thiz, '?');

state = STAT_END;

break;

}

default:break;

}



if(state == STAT_END)

{

break;

}

}



tag_name = thiz->buffer + (size_t)tag_name;



for(; *thiz->read_ptr != '>' && *thiz->read_ptr != '\0'; thiz->read_ptr++);



return;

}

注释，结束TAG和文本的解析非常简单，这里结合代码看看就行了：

“注释”子状态的处理：

static void xml_parser_parse_comment(XmlParser* thiz)

{

enum _State

{

STAT_COMMENT,

STAT_MINUS1,

STAT_MINUS2,

}state = STAT_COMMENT;



const char* start = ++thiz->read_ptr;

for(; *thiz->read_ptr != '\0'; thiz->read_ptr++)

{

char c = *thiz->read_ptr;



switch(state)

{

case STAT_COMMENT:

{

/*在“注释”状态下，读入‘-’，进入“减号一”状态。*/

if(c == '-')

{

state = STAT_MINUS1;

}

break;

}

case STAT_MINUS1:

{

if(c == '-')

{

/*在“减号一”状态下，读入‘-’，进入“减号二”状态。*/

state = STAT_MINUS2;

}

else

{

state = STAT_COMMENT;

}

break;

}

case STAT_MINUS2:

{

if(c == '>')

{

/*在“减号二”状态下，读入‘>’，结束解析。*/

return;

}

else

{

state = STAT_COMMENT;

}

}

default:break;

}

}



return;

}

“结束TAG”子状态的处理：

static void xml_parser_parse_end_tag(XmlParser* thiz)

{

char* tag_name = NULL;

const char* start = thiz->read_ptr;

for(; *thiz->read_ptr != '\0'; thiz->read_ptr++)

{

/*读入‘>’，结束解析。*/

if(*thiz->read_ptr == '>')

{

break;

}

}



return;

}

“文本”子状态的处理：

static void xml_parser_parse_text(XmlParser* thiz)

{

const char* start = thiz->read_ptr - 1;

for(; *thiz->read_ptr != '\0'; thiz->read_ptr++)

{

char c = *thiz->read_ptr;

/*读入‘>’，结束解析。*/

if(c == '<')

{

if(thiz->read_ptr > start)

{

}

thiz->read_ptr--;

return;

}

else if(c == '&')

{

/*读入‘&’，进入实体(entity)解析子状态。*/

xml_parser_parse_entity(thiz);

}

}



return;

}

实体(entity)子状态比较简单，这里不做进一步分析了，留给读者做练习吧

转自:http://carllgc.blog.ccidnet.com/blog-htm-do-showone-uid-4092-type-blog-itemid-263093.html

作为一位Java程序员，如果您没有接触过开源软件、项目或框架的话，恐怕有些不可思议。轰轰烈烈的开源运动起源于Linux操作系统，Apache基金会在其中扮演了中流砥柱的角色，业界巨擘SUN，IBM， BEA 和Oracle等公司的积极参与，使得声势浩大的开源运动成为软件开发领域势不可挡的力量。2001年11月，IBM向Apache基金会捐献出Visual Age for Java，这个看似穷途末路的产品经众多高手的改造，演变为辉煌一时的Eclipse，直接击败了不开源的JBuilder，让做编译器起家的Borland公司几乎关张大吉。Eclipse这个产品如此经典，以至于微软的Visual Studio都得向它学习。在Apache Harmony的围追堵截下，Java的发明者Sun公司一看势头不妙，于2006年宣布Java开源，随后又公开了其旗舰级产品Solaris的源代码。今年1月，开源的死对头、冷酷自私的微软也不得不在MS-RL协议下公开.Net的源代码。但是，在这如火如荼的开源运动中，我们中国的程序员又有多少贡献呢，我们开创了哪些框架、项目和产品，为开源界添砖加瓦呢？以笔者短浅的目光看来，我们对开源界贡献的东西恐怕很少，能够与国外经典开源项目一较高下的，少之又少矣！

作为一名中国的程序员，咱们能没有遗憾吗？为什么经典的Apache Web Server不是中国人写的；为什么Linus Torvalds在大学时代就写出Linux并振臂一呼，应者云集；为什么JBoss能与巨无霸式的Websphere相抗衡；为什么MySQL能在Oracle和SQL Server的夹击下发展并壮大…… ？如此等等问题，在遗憾之余，我想我们应该花点时间好好思考一下，中国的软件产业怎么了，中国的程序员又怎么啦？

在笔者看来，我们的程序员对开源的理解是相当狭隘的。国学大师王国维曾说过，古往今来成大学问大事业者要经历三种境界，“昨夜西风凋碧树，独上高楼，望尽天涯路”，这是第一重境界，迷惘也；“衣带渐宽终不悔，为伊消得人憔悴”，苦苦求索之境界也；第三重境界为“众里寻他千百度，蓦然回首，那人却在灯火阑珊处”，经历多少次的失败和挫折后，终于参透真谛，领悟真理。我觉得开源也有三重境界：

首先，我们要敞开心胸，拥抱开源（Open to Open Source)。这重境界我们大家都能做到，拿来主义嘛，谁人不会。当我们的项目需要数据库时，就去下载一个免费MySQL；需要IDE时，去下载 Eclipse；需要版本控制工具时，就去下载CVS；需要写搜索引擎时，Lucene可能是我们的最爱；当我们开发J2EE Web应用时，Struts/JSF加Hibernate/iBATIS再加上Spring或许成为我们的首选架构。但是，我们绝大部分程序员都停留在这 个层次上，大家下载之后，看看文档介绍，安装、配置并能运行，就以为万事大吉，一切顺利。偶尔遇到一些问题，去Google一搜，答案立马可得。

其次，我们要深入开源，了解开源（Dig into Open Source)。要达到这个层次，就有些难度了。我们不但要知其然，还要知其所以然。“知其所以然”的最好办法就是下载源代码，仔细研读，揣摩并领会源代 码的精义，看看这些经过诸多高手修改的源代码究竟藏有什么玄机，我们能从其中学习到哪些设计思想及设计模式，能复用其中哪些源代码，人家运用了哪些软件管 理思想把这些来自世界各地程序员的劳动汇集成一个产品，代码架构如何，软件配置管理又是怎样进行的……，等等等等，我们从源代码中学习的东西太多了。在阅 读源代码时，我们要多问自己几个为什么，这样就会收获更多。

再次，我们要融入开源，贡献开源（Get involved in Open Source)。当我们彻底理解该项目源代码后，我们应发挥一下“人人为我，我为人人”的思想，或结合您的实际需要，或结合您的新想法，或针对Mail lists上的问题，对该开源项目加以改进和创新，并把自己的代码贡献出来，让大家评估。当然，如果您有好的想法，您完全可以创建自己的开源项 目，Apache基金会中众多的开源项目不都是我们广大程序员一手创建的吗？但是，在创建新开源项目时，切忌不要重新发明轮子。

笔者才疏学浅，想以Apache Jakarta项目包中的核心项目Tomcat为例，希望通过阅读源码，能从这个经典项目中学到更多的东西，为我们中国的开源事业起到抛砖引玉的作用。

下面我们就开始我们的Tomcat源码学习之旅。

1. 下载Tomcat6.0的源代码

首先，我们得下载Tomcat6.0的源代码。Tomcat源代码的版本控制工具不是CVS，而是Subversion，如果您的机器上没有安装Subversion，请从 http://subversion.tigris.org/servlets/ProjectDocumentList?folderID=91 下载并安装这个开源的版本控制工具。当然，如果您想从Eclipse中直接导入Tomcat源代码，请从http://subclipse.tigris.org/update_1.0.x下载Subversion插件，即可导入Tomcat源代码。安装完成后，请在MS-DOS窗口中键入svn export help，您将会看到：

C:\Documents and Settings\carlwu>svn help export

export: 产生一个无版本控制的目录树副本。

用法: 1、export [-r REV] URL[@PEGREV] [PATH]

2、export [-r REV] PATH1[@PEGREV] [PATH2]

1、从 URL 指定的仓库，导出一个干净的目录树到 PATH。如果有指定

REV 的话，内容即为该版本的，否则就是 HEAD 版本。如果 PATH

被省略的话，URL的最后部份会被用来当成本地的目录名称。

2、在工作副本中，从指定的 PATH1 导出一个干净的目录树到 PATH2。如果

有指定 REV 的话，会从指定的版本导出，否则从工作副本导出。如果

PATH2 被省略的话，PATH1 的最后部份会被用来当成本地的目录名称。

如果没有指定 REV 的话，所有的本地修改都保留，但是未纳入版本控制

的文件不会被复制。



如果指定了 PEGREV ，将从指定的版本本开始查找。

有效选项:。。。。。。

我们看到Subversion给我们提供了非常友好的帮助，并且是中文的，看来中国程序员对这个开源项目有所贡献。接下来，请在MS-DOS下键入：

svn export http://svn.apache.org/repos/asf/tomcat/tc6.0.x/tags/TOMCAT_6_0_0/ D:\carl_wu\tomcat\src\

这个命令的意思是把Tomcat6.0的源代码从Subversion库中导入到本机的D:\carl_wu\tomcat\src\目录，命令运行后，您稍等几分钟，就会看到Tomcat的源代码顺利导入到目标目录。下面是源代码的目录机构，从这个目录结构中，我们可以看出该项目的开发者使用的IDE是Eclipse，因为我们看到了熟悉的.project及.classpath文件。如果您打算开发一个Stand alone的Java应用程序，不妨借鉴一下Tomcat的目录结构，把脚本文件放在bin目录，将xml和properties配置文件放在conf目录中，把Java源码文件放在java或者src目录中，资源文件比如说图片文件，ini文件及其它的一些静态资源文件可以放在res目录，测试源代码可以放在test目录中。这是一个典型的Java应用程序的目录机构，笔者以前曾接触到一个来自美国的产品，其源代码目录结构和Tomcat及其相像。






2. 编译并运行

代码下载后，我们接下来就是要编译并运行Tomcat。一提编译，我们不禁会想到可爱的Ant。不错，Tomcat正是以Ant作为编译工具，如果您还没有安装，请从http://ant.apache.org/bindownload.cgi 处下载并安装它。然后，请从Tomcat的源代码文件找到build.properties.default文件，并将该文件复制到build.properties，然后打开build.properties，找到下面这行：

base.path=/usr/share/java

将它改为：

base.path= D:/carl_wu/tomcat/share

在Tomcat编译过程中，Ant会让我们下载一些必要的依赖项目，base.path目录就是用来保存这些项目文件的，我们可以将这个属性指向一个已经存在的目录。修改完base.path后，我们回到MS-DOS窗口，切换到Tomcat源代码所在目录，然后运行ant download命令，如下图所示：





一分钟未到，Ant就告诉我们一个错误并提示我们编译失败，具体错误信息如下：

downloadzip:

[get] Getting: http://sunsite.informatik.rwth-aachen.de/eclipse/downloads/drops/R-3.2-200606291905/eclipse-JDT-3.2.zip
[get] To: D:\carl_wu\tomcat\share\file.zip
[get] Error opening connection java.io.FileNotFoundException: http://sunsite.informatik.rwth-aachen.de:3080/eclipse/downloads/drops/R-3.2-200606291905/eclipse-JDT-3.2.zip

[get] Error opening connection java.io.FileNotFoundException: http://sunsite.informatik.rwth-aachen.de:3080/eclipse/downloads/drops/R-3.2-200606291905/eclipse-JDT-3.2.zip

[get] Error opening connection java.io.FileNotFoundException: http://sunsite.informatik.rwth-aachen.de:3080/eclipse/downloads/drops/R-3.2-200606291905/eclipse-JDT-3.2.zip

[get] Can't get http://sunsite.informatik.rwth-aachen.de/eclipse/downloads/drops/R-3.2-200606291905/eclipse-JDT-3.2.zip to D:\carl_wu\tomcat\share\file.zip

BUILD FAILED

D:\carl_wu\tomcat\src\build.xml:554: The following error occurred while executing this line:

D:\carl_wu\tomcat\src\build.xml:514: Can't get http://sunsite.informatik.rwth-aachen.de/eclipse/downloads/drops/R-3.2-200606291905/eclipse-JDT-3.2.zip to D:\carl_wu\tomcat\share\file.zip

Total time: 41 seconds

这个编译错误非常简单，就是找不到http://sunsite.informatik.rwth-aachen.de/eclipse/downloads/drops/R-3.2-200606291905/eclipse-JDT-3.2.zip 文件。有人可能会想，Tomcat的编译和Eclipse的JDT有什么关系？其实不然，Tomcat是在Eclipse下开发的，所以需要Eclipse的JDT（Java Development tooling）插件来编译Tomat源代码。既然找不到，我们只好自己动手，上Google一搜，马上发现这个文件的有效下载地址为：http://mirror.calvin.edu/eclipse/downloads/drops/R-3.2-200606291905/eclipse-JDT-3.2.zip。我们打开刚才的build.properties文件，将其34行修改为：

jdt.loc= http://mirror.calvin.edu/eclipse/downloads/drops/R-3.2-200606291905/eclipse-JDT-3.2.zip

修改保存build.properties文件后，重新开始ant download任务。这次我们等的时间较长，因为eclipse-JDT-3.2.zip大约有19M，下载需要一段时间。我们可乘此机会去泡杯茶弄点咖啡什么的，等我们品茶回来，发现敬业的蚂蚁Ant告诉我们编译成功，虽然编译器给出几个警告。这时我们可发现刚才创建的base.path目录（D:\carl_wu\tomcat\share）中已经下载了6个依赖项目，它们都是Tomcat编译所必须的。

下面就开始真正的编译任务了，请在MS-DOS窗口内键入ant并回车，Ant将在2分钟内编译1000多个源文件并将Tomcat部署到output目录。编译顺利完成后，请打开Tomcat的源代码目录，会发现多了一个output目录，这是Ant的编译后的输出目录。请打开Tomcat源代码的output\build\bin子目录，双击startup.bat文件，我们即可成功启动Tomcat6.0，此时我们的编译工作就算顺利完成了。


3. 导入源代码到Eclipse

3.1 请打开Eclipse，新建一个Java项目，然后点击“Next”按钮，请选择“Create project from existing source”， 并在Directory文本框内填入我们刚才下载的Tomcat源代码目录（i.e. D:\carl_wu\tomcat\src)，然后点击“Next”直至结束。




3.2 我们将会看到Eclipse拒绝编译，这是因为Eclipse找不到该项目指定的库文件。请右击该项目，在弹出菜单中选择“Properties”à“Libraries”，然后删除两个以TOMCAT_LIBS开头的两个库文件，只保留一个JRE库文件，然后点击“OK”按钮，这时Eclipse开始编译Tomcat源代码，但是发现一堆错误，这是因为我们没有为该项目添加编译所必须的Jar包。

3.3 准备好Tomcat项目所必须的jar文件，其实，刚才我们运行ant download任务时，已经下载过这些jar文件包。

ant.jar （请在ant安装目录的lib子目录中拷贝）

commons-collections-3.1.jar （从刚才Ant下载的commons-collections-3.1子目录中拷贝）

commons-dbcp-1.2.1.jar（从刚才Ant下载的commons-dbcp-1.2.1子目录中拷贝）

commons-logging-1.1.jar（如果您本机没有这个jar包，请从http://commons.apache.org/downloads/download_logging.cgi处下载）

commons-pool-1.2.jar（从刚才Ant下载的commons-pool-1.2子目录中拷贝）

org.eclipse.jdt.core_3.2.0.v_671.jar（从刚才Ant下载的eclipse\plugins子目录中拷贝）

3.4 当我们准备好这些jar文件后，将这些文件拷贝到某一目录（比如说D:\carl_wu\tomcat\tomcat_lib目录），然后在Eclipse中新建一个User Libraries，我们将这个新建的User Libraries命名为TOMCAT_LIBS，并把这些文件加到TOMCAT_LIBS。然后将我们新建的TOMCAT_LIBS添加到Tomcat6项目。另外，别忘了把JUnit库也加到Tomcat6项目。这时Eclipse开始重新编译，编译过程顺利通过，所有错误均消失，此时Tomcat6项目的目录结构如下：





还有，请把test目录也加入到源代码中，方法是在Eclipse中右击”test”目录，然后在弹出菜单中选择“Build path”à”Use as Source Folder”，之后我们会看到test目录上就多了个源代码的符号，如上图所示。

3.5在Eclipse中运行Tomcat。请找到Tomcat的启动主类org.apache.catalina.startup.Bootstrap，右击这个类，在弹出菜单中选择“Run As…”à”Open Run Dialog…”，然后在弹出的“Run”窗口中填入程序运行参数“start”和JVM运行参数catalina.home，如下面窗口所示：




然后点击“Run”按钮，我们将会看到Tomcat正常启动。恭喜，咱们的Tomcat源码已经成功导入Eclipse，这时，可视化的UML分析工具及Debug工具就能派上用场了。

3.5 调试Tomcat，请打开org.apache.jasper.compiler.Compiler类的源代码，在generateJava()方法的第一行打一个断点，然后在Eclipse的调试状态下运行Tomcat，等Tomcat运行后，打开我们的浏览器，在地址栏中输入http://localhost:8080/examples/jsp/jsp2/el/basic-comparisons.jsp并回车，然后我们可观察到Eclipse此时切换至调试视图：







上面的小实验表明我们可以在Eclipse中通过Debugger观察Tomcat的内部运行机理。另外补充一点，上面的generateJava方法是将jsp动态编译至java class，这个方法只是在第一次请求或者Jsp源码发生变化时执行，如果您再次在浏览器中发送同样的请求，您将看不到上图的Debug界面，因为该方法不再执行。

另外，还有一点很有意思。Tomcat6以前版本的源代码分散在好几个子项目中，他们分别叫做jakarta-servletapi-5，jakarta-tomcat-5，jakarta-tomcat-catalina，jakarta-tomcat-connectors和jakarta-tomcat-jasper，我觉得Tomcat的开发者可能嫌这样做太麻烦了，所以Tomcat6版本中将这些子项目都合并在一起了。但是，这种做法不利于我们阅读理解源代码