http://blog.csdn.net/ajian005/article/details/79215072012盛大TeamHost上有个关于学习开源项目的wiki ：http://www./projects/learn-with-open-source/wiki/Wiki
一、为什么要阅读源代码？
很多作家成名之前都阅读过大量的优秀文学作品，经过长期的阅读和写作积累，慢慢的才有可能写出一些好的、甚至是优秀的文学作品。 而程序员与此类似，很多程序员也需要阅读大量的优秀程序或产品，经过不断阅读和实践积累，然后可能写出好的程序或产品。养成阅读高品质代码的习惯 可以提高编写代码的能力。
第一个好处是可以学习到很多编程的方法，看好的源代码，对于提高自己的编程水平，比自己写源代码的帮助更大。当然不是说不用自己写，而是说，自己写代码的同时，可以从别人写的好的源代码中间学习到更多的编程方法和技巧。
第二个好处是，可以提高自己把握大规模源代码的能力。一个比较大型的程序，往往都是经过了很多个版本很长的时间，有很多人参与开发，修正错误，添加功能而发展起来的。所以往往源代码的规模都比较大，少则10-100多k, 多的有好几十个MB. 在阅读大量源代码的时候，能够提高自己对大的软件的把握能力，快速了解脉络，熟悉细节，不仅仅是编程技巧，还能在程序的架构，设计方面提高自己的能力。（这里说一句题外话，<<设计模式>>这本书相信很多人都看过，而且很多人对它推崇备至，奉为经典。现在也出了不少书，都是冠以"设计模式"这一名称。在书中就提到，设计模式并不是一本教材，不是教你如何去编程序，而是把平时编程中一些固定的模式记录下来，加以不断的测试和改进，分发给广大程序员的一些经验之谈。我在看这本书的时候，有一些地方一些设计方法往往让我有似曾相识的感觉，另外一些则是我以前就常常用到的。而这些经验的获得，一部分得益于自己的编码过程，另外一个很重要的来源就是阅读别人写的源代码。)
阅读源代码第三个好处，就是获得一些好的思想。比如，有很多人在开始一个软件项目之前都喜欢到sourceforge.net上去找一下，是否有人以前做过相同或者相似的软件，如果有，则拿下来读一读，可以使自己对这个软件项目有更多更深的认识。我以前曾经想找一本关于如何阅读源代码的书来看看，却没有找到。相反，倒是找到了不少分析源代码的书，比如Linux kernel, Apache source, 等等。
第四个好处是，修复、检查、改进代码、当程序出现bug时或半截接手别人的项目时，需要阅读源代码后更改bug或推进项目。带着目的阅读代码
第五个好处是，阅读的源代码多了，发现了解开源软件的运行机理，提取可重用的材料加以利用。他山之石，可以攻玉，阅读源代码进而从现有的优秀代码、算法、设计、架构中汲取营养，提高自身的开发与设计能力
二、如何有效的阅读源代码？
(1)摘自《代码阅读方法与实践》书籍的知识点总结
(原书目录从微观到宏观，个人习惯先宏观:文档、架构、代码阅读工具、应对大型项目、一个完整的例子......微观,实际阅读代码的流程)
第一章 导论
1. 要养成一个习惯，经常花时间阅读别人编写的高品质代码。 （读好书、多读书）
2. 要有选择地阅读代码，同时，还要有自己的目标。您是想学习新的模式、编码风格、还是满足某些需求的方法？ （搞清楚为什么要阅读代码？ 学习架构、学习业务、学习模式、学习编码风格、学习类库... ... 制定目标，对自己要有要求）
3. 要注意并重视代码中特殊的非功能性需求，这些需求也许会导致特定的实现风格。(如 可维护性、可伸缩性、性能、)
4. 在现有的代码上工作时，请与作者或维护人员进行必须的协调，以避免重复劳动或因此而产生厌恶情绪。
5. 请将从开放源码软件中得到的益处看作是一项贷款，尽可能地寻找各种方式来回报开放源码社团。（比如、报告bug,提出问题，解决bug,添加功能贡献代码及文档... ... 人人为我，我为人人）
6. 多数情况下，如果您想要了解“别人会如何完成这个功能呢？”，除了阅读代码以外，没有更好的方法。
7. 在寻找 BUG时，请从问题的表现形式到问题的根源来分析代码。不要沿着不相关的路径（误入岐途） （先搞清楚问题，然后找与问题相关部分代码阅读，记住带有目的性的阅读）
8. 我们要充分利用调度器，编译器给出的警告或输出的符号代码，系统调用跟踪器，数据库结构化查询语言的日志机制、包转储工具和Windows的消息侦查程序，定出BUG的位置。（要充分利用线索。 侦探破案、医生诊断 都是利用线索或现象的）
9. 对于那些大型且组织良好的系统，您只需要最低限度地了解它的全部功能，就能够对它做出修改。（一个系统可能有几十个模块，只需要了解与问题相关的模块，就有可能把问题解决，但首先必须模块设计合理）
10. 当向系统中增加新功能时，首先的任务就是找到实现类似特性的代码，将它作为待实现功能的模板。（做一个新功能首先考虑到的是有没有类似的 模板或例子，有类似模板或例子可以提供借鉴，让你如何实现该功能有更加深入的认识）
11. 从特性的功能描述到代码的实现，可以按照字符串消息，或使用关键词来搜索代码。
12. 在移植代码或修改接口时， 您可以通过编译器直接定位出问题涉及的范围，从而减少代码阅读的工作量。
13. 进行重构时，您从一个能够正常工作的系统开始做起，希望确保结束时系统能够正常工作。一套恰当的测试用例可以帮助您满足此项约束。（测试用例很关键）
14. 阅读代码寻找重构机会时，先从系统的构架开始，然后逐步细化，能够获得最大的效益。（由宏观到微观，由上到下一种方法）
15. 代码的可重用性是一个诱人的，但难以掌握的思想；降低期望就不会感到失望。
16. 如果您希望重要的代码十分棘手，难以理解与分离，可以试着寻找粒度更大一些的包，甚至其他代码。
17. 在复查软件系统时，要注意，系统是由很多部分组成的，不仅仅只是执行语句。还要注意分析以下内容：文件和目录结构、生成和配置过程、用户界面和系统的文档。
18. 可以将软件复查作为一个学习、讲授、援之以手和接受帮助的机会。
第二章 文档(原书：第八章：文档)
150.阅读代码时, 应该尽可能地利用任何能够得到的文档.
151.阅读一小时代码所得到的信息只不过相当于阅读一分钟文档.
152.使用系统的规格说明文档, 了解所阅读代码的运行环境.
153.软件需求规格说明是阅读和评估代码的基准.
154.可以将系统的设计规格说明作为认知代码结构的路线图, 阅读具体代码的指引.
155.测试规格说明文档为我们提供可以用来对代码进行预演的数据.
156.在接触一个未知系统时, 功能性的描述和用户指南可以提供重要的背景信息,从而更好地理解阅读的代码所处的上下文.
157.从用户参考手册中, 我们可以快速地获取, 应用程序在外观与逻辑上的背景知识, 从管理员手册中可以得知代码的接口|文件格式和错误消息的详细信息.
158.利用文档可以快捷地获取系统的概况, 了解提供特定特性的代码.
159.文档经常能够反映和提示出系统的底层结构.
160.文档有助于理解复杂的算法和数据结构.
161.算法的文字描述能够使不透明(晦涩, 难以理解)的代码变得可以理解.
162.文档常常能够阐明源代码中标识符的含义.
163.文档能够提供非功能性需求背后的理论基础.
164.文档还会说明内部编程接口.
165.由于文档很少像实际的程序代码那样进行测试, 并受人关注, 所以它常常可能存在错误|不完整或过时.
166.文档也提供测试用例, 以及实际应用的例子.
167.文档常常还会包括已知的实现问题或bug.
168.环境中已知的缺点一般都会记录在源代码中.
169.文档的变更能够标出那些故障点.
170.对同一段源代码重复或互相冲突的更改, 常常表示存在根本性的设计缺陷, 从而使得维护人员需要用一系列的修补程序来修复.
171.相似的修复应用到源代码的不同部分, 常常表示一种易犯的错误或疏忽, 它们同样可能会在其他地方存在.
172.文档常常会提供不恰当的信息, 误导我们对源代码的理解.
173.要警惕那些未归档的特性: 将每个实例归类为合理|疏忽或有害, 相应地决定是否应该修复代码或文档.
174.有时, 文档在描述系统时, 并非按照已完成的实现, 而是系统应该的样子或将来的实现.
175.在源代码文档中, 单词gork的意思一般是指”理解”.
176.如果未知的或特殊用法的单词阻碍了对代码的理解, 可以试着在文档的术语表(如果存在的话)|New Hacker’s Dictionary[Ray96]|或在Web搜索引擎中查找它们.
177.总是要以批判的态度来看待文档, 注意非传统的来源, 比如注释|标准|出版物|测试用例|邮件列表|新闻组|修订日志|问题跟踪数据库|营销材料|源代码本身.
178.总是要以批判的态度来看待文档; 由于文档永远不会执行, 对文档的测试和正式复查也很少达到对代码的同样水平, 所以文档常常会误导读者, 或者完全错误.
179.对于那些有缺陷的代码, 我们可以从中推断出它的真实意图.
180.在阅读大型系统的文档时, 首先要熟悉文档的总体结构和约定.
181.在对付体积庞大的文档时, 可以使用工具, 或将文本输出到高品质输出设备上, 比如激光打印机, 来提高阅读的效率.
第三章 系统构架(原书：第九章: 系统构架)、设计模式、编码惯例
182.一个系统可以(在重大的系统中也确实如此)同时出多种不同的构架类型. 以不同的方式检查同一系统|分析系统的不同部分|或使用不同级别的分解, 都有可能发现不同的构架类型.
183.协同式的应用程序, 或者需要协同访问共享信息或资源的半自治进程, 一般会采用集中式储存库构架.
184.黑板系统使用集中式的储存库, 存储非结构化的键/值对, 作为大量不同代码元件之间的通信集线器.
185.当处理过程可以建模|设计和实现成一系列的数据变换时, 常常会使用数据流(或管道—过滤器)构架.
186.在批量进行自动数据处理的环境中, 经常会采用数据流构架, 在对数据工具提供大量支持的平台上尤其如此.
187.数据流构架的一个明显征兆是: 程序中使用临时文件或流水线(pipeline)在不同进程间进行通信.
188.使用图示来建模面向对象构架中类的关系.
189.可以将源代码输入到建模工具中, 逆向推导出系统的构架.
190.拥有大量同级子系统的系统, 常常按照分层构架进行组织.
191.分层构架一般通过堆叠拥有标准化接口的软件组件来实现.
192.系统中每个层可以将下面的层看作抽象实体, 并且(只要该层满足它的需求说明)不关心上面的层如何使用它.
193.层的接口既可以是支持特定概念的互补函数族, 也可以是一系列支持同一抽象接口不同底层实现的可互换函数.
194.用C语言实现的系统, 常常用函数指针的数组, 表达层接口的多路复用操作.
195.用面向对象的语言实现的系统, 使用虚方法调用直接表达对层接口的多路复用操作.
196.系统可以使用不同的|独特的层次分解模型跨各种坐标轴进行组织.
197.使用程序切片技术, 可以将程序中的数据和控制之间依赖关系集中到一起.
198.在并发系统中, 一个单独的系统组件起到集中式管理器的作用, 负责启动|停止和协调其他系统进程和任务的执行.
199.许多现实的系统都会博采众家之长. 当处理此类系统时, 不要徒劳地寻找无所不包的构架图; 应该将不同构架风格作为独立但相关的实体来进行定位|识别并了解.
200.状态变迁图常常有助于理清状态机的动作.
201.在处理大量的代码时, 了解将代码分解成单独单元的机制极为重要.
202.大多数情况下, 模块的物理边界是单个文件|组织到一个目录中的多个文件或拥有统一前缀的文件的集合.
203.C中的模块, 由提供模块公开接口的头文件和提供对应实现的源文件组成.
204.对象的构造函数经常用来分配与对象相关的资源, 并初始化对象的状态. 函数一般用来释放对象在生命期中占用的资源.
205.对象方法经常使用类字段来存储控制所有方法运作的数据(比如查找表或字典)或维护类运作的状态信息(例如, 赋给每个对象一个标识符的计数器).
206.在设计良好的类中, 所有的字段都应在声明为private, 并用公开的访问方法提供对它们的访问.
207.在遇到friend声明时, 要停下来分析一下, 看看绕过类封装在设计上的理由.
208.可以有节制地用运算符增强特定类的可用性, 但用运算符重载, 将类实现为拥有内建算术类型相关的全部功能的类实体, 是不恰当的.
209.泛型实现不是在编译期间通过宏替换或语言所支持的功能(比如C++模板和Ada的泛型包)来实现, 就是在运行期间通过使用数据元素的指针和函数的指针|或对象的多态性实现.
210.抽象数据类型经常用来封装常用的数据组织方案(比如树|列表或栈), 或者对用户隐藏数据类型的实现细节.
211.使用库的目的多种多样: 重用源代码或目标代码, 组织模块集合, 组织和优化编译过程, 或是用来实现应用程序各种特性的按需载入.
212.大型的|分布式的系统经常实现为许多互相协作的进程.
213.对于基于文本的数据储存库, 可以通过浏览存储在其中的数据, 破译出它的结构.
214.可以通过查询数据字典中的表, 或使用数据库专有的SQL命令, 比如show table, 来分析关系型数据库的模式.
215.识别出重用的构架元素后, 可以查找其最初的描述, 了解正确地使用这种构架的方式, 以及可能出现的误用.
216.要详细分析建立在某种框架之上的应用程序, 行动的最佳路线就是从研究框架自身开始.
217.在阅读向导生成的代码时, 不要期望太高, 否则您会感到失望.
218.学习几个基本的设计模式之后, 您会发现, 您查看代码构架的方式会发生改变: 您的视野和词汇将会扩展到能够识别和描述许多通用的形式.
219.频繁使用的一些模式, 但并不显式地指出它们的名称, 这是由于构架性设计的重用经常先于模式的形成.
220.请试着按照底层模式来理解构架, 即使代码中并没有明确地提及模式.
221.大多数解释器都遵循类似的处理构架, 围绕一个状态机进行构建, 状态机的操作依赖于解释器的当前状态|程序指令和程序状态.
222.多数情况下, 参考构架只是为应用程序域指定一种概念性的结构, 具体的实现并非必须遵照这种结构.
第四章 代码阅读工具 （原书：第十章: 代码阅读工具）
223.词汇工具可以高效地在一个大代码文件中或者跨多个文件查找某种模式.
224.使用程序编辑器和正则表达式查找命令, 浏览庞大的源代码文件.
225.以只读方式浏览源代码文件.
226.使用正则表达式 ^function name 可以找出函数的定义.
227.使用正则表达式的字符类, 可以查找名称遵循特定模式的变量.
228.使用正则表达式的否定字符类, 可以避免非积极匹配.
229.使用正则表达式 symbol-1. *symbol-2, 可以查找出现在同一行的符号.
230.使用编辑器的 tags 功能, 可以快速地找出实体的定义.
231.可以用特定的 tag 创建工具, 增加编辑器的浏览功能.
232.使用编辑器的大纲视图, 可以获得源代码结构的鸟瞰图.
233.使用您的编辑器来检测源代码中圆括号|方括号和花括号的匹配.
234.使用 grep 跨多个文件查找代码模式.
235.使用 grep 定位符号的声明|定义和应用.
236.当您不能精确地表述要查找的内容时, 请使用关键单词的词干对程序的源代码进行查找.
237.用 grep 过滤其他工具生成的输出, 分离出您要查找的项.
238.将 grep 的输出输送到其他工具, 使复杂处理任务自动化.
239.通过对 grep 的输出进行流编辑, 重用代码查找的结果.
240.通过选取与噪音模式不匹配的输出行(grep-v), 过滤虚假的 grep 输出.
241.使用 fgrep 在源代码中查找字符串列表.
242.查找注释, 或标识符大小写不敏感的语言编写的代码时, 要使用大小写不敏感的模式匹配(grep -i).
243.使用 grep –n 命令行开关, 可以创建与给定正则表达式匹配的文件和行号的检查表.
244.可以使用 diff 比较文件或程序不同版本之间的差别.
245.在运行 diff 命令时, 可以使用 diff –b, 使文件比较算法忽略结尾的空格, 用 –w 忽略所有空白区域的差异, 用 –i 使文件比较对大小写不敏感.
246.不要对创建自己的代码阅读工具心存畏惧.
247.在构建自己的代码阅读工具时: 要充分利用现代快速原型语言所提供的能力; 从简单开始, 根据需要逐渐改进; 使用利用代码词汇结构的各种试探法; 要允许一些输出噪音或寂静(无关输出或缺失输出); 使用其他工具对输入进行预处理, 或者对输出进行后期处理.
248.要使编译器成为您的: 指定恰当级别的编译器警告, 并小心地评估生成的结果.
249.使用C预处理器理清那些滥用预处理器特性的程序.
250.要彻底地了解编译器如何处理特定的代码块, 需要查看生成的符号(汇编)代码.
251.通过分析相应目标文件中的符号, 可以清晰地了解源文件的输入和输出.
252.使用源代码浏览器浏览大型的代码集合以及对象类型.
253.要抵制住按照您的编码规范对外部代码进行美化的诱惑; 不必要的编排更改会创建不同的代码, 并妨碍工作的组织.
254.优美打印程序和编辑器语法着色可以使得程序的源代码为易读.
255.cdecl 程序可以将难以理解的C和C++类型声明转换成纯英语(反之亦然).
256.实际运行程序, 往往可以更深刻地理解程序的动作.
257.系统调用|事件和数据包跟踪程序可以增进对程序动作的理解.
258.执行剖析器可以找出需要着重优化的代码, 验证输入数据的覆盖性, 以及分析算法的动作.
259.通过检查从未执行的代码行, 可以找出测试覆盖的弱点, 并据此修正测试数据.
260.要探究程序动态动作时的每个细节, 需要在调试器中运作它.
261.将您觉得难以理解的代码打印到纸上.
262.可以绘制图示来描绘代码的动作.
263.可以试着向别人介绍您在阅读的代码, 这样做一般会增进您对代码的理解.
264.理解复杂的算法或巧妙的数据结构, 要选择一个安静的环境, 然后聚精会神地考虑, 不要借助于任何计算机化或自动化的帮助.
第五章 应对大型项目 （第六章: 应对大型项目）
116.我们可以通过浏览项目的源代码树—包含项目源代码的层次目录结构, 来分析一个项目的组织方式. 源码树常常能够反映出项目在构架和软件过程上的结构.
117.应用程序的源代码树经常是该应用程序的部署结构的镜像.
118.不要被庞大的源代码集合吓倒; 它们一般比小型的专门项目组织得更出色.
119.当您首次接触一个大型项目时, 要花一些时间来熟悉项目的目录树结构.
120.项目的源代码远不只是编译后可以获得可执行程序的计算机语言指令; 一个项目的源码树一般还包括规格说明|最终用户和开发人员文档|测试脚本|多媒体资源|编译工具|例子|本地化文件|修订历史|安装过程和许可信息.
121.大型项目的编译过程一般声明性地借助依赖关系来说明. 依赖关系由工具程序, 如make/ant/Maven及其派生程序, 转换成具体的编译行动.
122.大型项目中, 制作文件常常由配置步骤动态地生成; 在分析制作文件之前, 需要先执行项目特定的配置.
123.检查大型编译过程的各个步骤时, 可以使用make程序的-n开关进行预演.
124.修订控制系统提供从储存库中获取源代码最新版本的方式.
125.可以使用相关的命令, 显示可执行文件中的修订标识关键字, 从而将可执行文件与它的源代码匹配起来.
126.使用修订日志中出现的bug跟踪系统内的编号, 可以在bug跟踪系统的数据库中找到有关的问题的说明.
127.可以使用修订控制系统的版本储存库, 找出特定的变更是如何实现的.
128.定制编译工具用在软件开发过程的许多方面, 包括配置|编译过程管理|代码的生成|测试和文档编制.
129.程序的调试输出可以帮助我们理解程序控制流程和数据元素的关键部分.
130.跟踪语句所在的地点一般也是算法运行的重要部分.
131.可以用断言来检验算法运作的步骤|函数接收的参数|程序的控制流程|底层硬件的属性和测试用例的结果.
132.可以使用对算法进行检验的断言来证实您对算法运作的理解, 或将它作为推理的起点.
133.对函数参数和结果的断言经常记录了函数的前置条件和后置条件.
134.我们可以将测试整个函数的断言作为每个给定函数的规格说明.
135.测试用例可以部分地代替函数规格说明.
136.可以使用测试用例的输入数据对源代码序列进行预演.
第六章 一个完整的例子 (第十一章: 一个完整的例子)
265.模仿软件的功能时, 要依照相似实体的线路(类|函数|模块). 在相似的现有实体中, 为简化对源代码库的文本查找, 应选取比较罕见的名称.
266.自动生成的文件常常会在文件的开关有一段注释, 说明这种情况.
267.如果试图精确地分析代码, 一般会陷入数量众多的类|文件和模块中, 这些内容会很快将我们淹没; 因此, 我们必须将需要理解的代码限定在绝对必需的范围之内.
268.采用一种广度优先查找策略, 从多方攻克代码阅读中存在的问题, 进到找出克服它们的方法为止.
第七章基本编程元素 (第二章：基本编程元素)
19.第一次分析一个程序时, main是一个好的起始点.
20.层叠if-else if-...-else序列可以看作是由互斥选择项组成的选择结构.
21.有时, 要想了解程序在某一方面的功能, 运行它可能比阅读源代码更为恰当.（运行，并debug可以降低理解动态流程的难度）
22.在分析重要的程序时, 最好首先识别出重要的组成部分. （打蛇打三寸，抓住关键部分，可以快速理解）
23.了解局部的命名约定, 利用它们来猜测变量和函数的功能用途.（类名用名词或代词或动名词，最好不要用动词，方法用动词）
24.当基于猜测修改代码时, 您应该设计能够验证最初假设的过程. 这个过程可能包括用编译器进行检查|引入断言|或者执行适当的测试用例.
25.理解了代码的某一部分, 可能帮助你理解余下的代码.
26.解决困难的代码要从容易的部分入手.
27.要养成遇到库元素就去阅读相关文档的习惯; 这将会增强您阅读和编写代码的能力.
28.代码阅读有许多可选择的策略: 自底向上和自顶向下的分析|应用试探法和检查注释和外部文档, 应该依据问题的需要尝试所有这些方法.
29.for (i=0; i<n; i++)形式的循环执行n次; 其他任何形式都要小心.
30.涉及两项不等测试(其中一项包括相等条件)的比较表达式('0' <= c && c <= '9')可以看作是区间成员测试（0 <= c <= 9）.
31.我们经常可以将表达式应用在样本数据上, 借以了解它的含义. (用用例去验证表达式)
32.使用De Morgan法则简化复杂的逻辑表达式. （？）
33.在阅读逻辑乘表达式(&&)时, 问题可以认为正在分析的表达式以左的表达式均为true; 在阅读逻辑和表达式（||）时, 类似地, 可以认为正在分析的表达式以左的表达式均为false.
34.重新组织您控制的代码, 使之更为易读.
35.将使用条件运行符? :的表达式理解为if代码.
36.不需要为了效率, 牺牲代码的易读性.
37.高效的算法和特殊的优化确实有可能使得代码更为复杂, 从而更难理解, 但这并不意味着使代码更为紧凑和不易读会提高它的效率.
38.创造性的代码布局可以用来提高代码的易读性.
39.我们可以使用空格|临时变量和括号提高表达式的易读性.
40.在阅读您所控制的代码时, 要养成添加注释的习惯. （在阅读中比较复杂或难懂的地方要加注释备注）
41.我们可以用好的缩进以及对变量名称的明智选择, 提高编写欠佳的程序的易读性.（养成好的编码习惯）
42.用diff程序分析程序的修订历史时, 如果这段历史跨越了整体重新缩排, 常常可以通过指定-w选项, 让diff忽略空白差异, 避免由于更改了进层次而引入的噪音.（SVN/Git是否也有这个功能呢？）
43.do循环的循环体至少执行一次.
44.执行算术运算时, 当b=2n-1时, 可以将a&b理解为a%(b+1). （？）
45.将a<<n理解为a*k, k=2n.
46.将a>>n理解为a/k, k=2n.
47.每次只分析一个控制结构, 将它的内容看作是一个黑盒.
48.将每个控制结构的控制表达式看作是它所包含代码的断言.
49.return, goto, break和continue语句, 还有异常, 都会影响结构化的执行流程. 由于这些语句一般都会终止或重新开始正在进行的循环,因此要单独推理它们的行为.
50.用复杂循环的变式和不变式, 对循环进行推理.
51.使用保持含义不变的变换重新安排代码, 简化代码的推理工作.
第八章 高级C数据类型 （第三章: 高级C数据类型）
52.了解特定语言构造所服务的功能之后, 就能够更好地理解使用它们的代码.
53.识别并归类使用指针的理由.
54.在C程序中, 指针一般用来构造链式数据结构|动态分配的数据结构|实现引用调用|访问和迭代数据元素|传递数组参数|引用函数|作为其他值的别名|代表字符串|以及直接访问系统内存.
55.以引用传递的参数可以用来返回函数的结果, 或者避免参数复制带来的开销.
56.指向数组元素地址的指针, 可以访问位于特定索引位置的元素.
57.指向数组元素的指针和相应的数组索引, 作用在二者上的运算具有相同的语义.
58.使用全局或static局部变量的函数大多数情况都不可重入(reentrant).
59.字符指针不同于字符数组.
60.识别和归类应用结构或共用体的每种理由.
61.C语言中的结构将多个数据元素集合在一起, 使得它们可以作为一个整体来使用, 用来从函数中返回多个数据元素|构造链式数据结构|映射数据在硬件设备|网络链接和存储介质上的组织方式|实现抽象数据类型|以及以面向对象的方式编程.
62.共用体在C程序中主要用于优化存储空间的利用|实现多态|以及访问数据不同的内部表达方式.
63.一个指针, 在初始化为指向N个元素的存储空间之后, 就可以作为N个元素的数组来使用.
64.动态分配的内在块可以电焊工地释放, 或在程序结束时释放, 或由垃圾回收器来完成回收; 在栈上分配的内存块当分配它的函数退出后释放.
65.C程序使用typedef声明促进抽象, 并增强代码的易读性, 从而防范可移植性问题, 并模拟C++和Java的类声明行为.
66.可以将typedef声明理解成变量定义: 变量的名称就是类型的名称; 变量的类型就是与该名称对应的类型.
第九章 C数据结构 （第四章: C数据结构）
67.根据底层的抽象数据类型理解显式的数据结构操作.
68.C语言中, 一般使用内建的数组类型实现向量, 不再对底层实现进行抽象.
69.N个元素的数组可以被序列for (i=0; i<N; i++)完全处理; 所有其他变体都应该引起警惕.
70.表达式sizeof(x)总会得到用memset或memcpy处理数组x(不是指针)所需的正确字节数.
71.区间一般用区间内的第一个元素和区间后的第一个元素来表示.
72.不对称区间中元素的数目等于高位边界与低位边界的差.
73.当不对称区间的高位边界等于低位边界时, 区间为空.
74.不对称区间中的低位边界代表区间的第一个元素; 高位边界代表区间外的第一个元素.
75.结构的数组常常表示由记录和字段组成的表.
76.指向结构的指针常常表示访问底层记录和字段的游标.
77.动态分配的矩阵一般存储为指向数组列的指针或指向元素指针的指针; 这两种类型都可以按照二维数组进行访问.
78.以数组形式存储的动态分配矩阵, 用自定义访问函数定位它们的元素.
79.抽象数据类型为底层实现元素的使用(或误用)方式提供一种信心的量度.
80.数组用从0开始的顺序整数为键, 组织查找表.
81.数组经常用来对控制结构进行高效编码, 简化程序的逻辑.
82.通过在数组中每个位置存储一个数据元素和一个函数指针(指向处理数据元素的函数), 可以将代码与数据关联起来.
83.数组可以通过存储供程序内的抽象机(abstract machine)或虚拟机(virtual machine)使用的数据或代码, 控制程序的运作.
84.可以将表达式sizeof(x) / sizeof(x[0])理解为数组x中元素的个数.
85.如果结构中含有指向结构自身|名为next的元素, 一般说来, 该结构定义的是单向链表的结点.
86.指向链表结点的持久性(如全局|静态或在堆上分配)指针常常表示链表的头部.
87.包含指向自身的next和prev指针的结构可能是双向链表的结点.
88.理解复杂数据结构的指针操作可以将数据元素画为方框|指针画为箭头.
89.递归数据结构经常用递归算法来处理.
90.重要的数据结构操作算法一般用函数参数或模板参数来参数化.
91.图的结点常常顺序地存储在数组中, 链接到链表中, 或通过图的边链接起来.
92.图中的边一般不是隐式地通过指针, 就是显式地作为独立的结构来表示.
93.图的边经常存储为动态分配的数组或链表, 在这两种情况下, 边都锚定在图的结点上.
94.在无向图中, 表达数据时应该将所有的结点看作是等同的, 类似地, 进行处理任务的代码也不应该基于它们的方向来区分边.
95.在非连通图中, 执行遍历代码应该能够接通孤立的子图.
96.处理包含回路的图时, 遍历代码应该避免在处理图的回路进入循环.
97.复杂的图结构中, 可能隐藏着其他类型的独立结构.
第十章 高级控制流程 (第五章: 高级控制流程)
98.采用递归定义的算法和数据结构经常用递归的函数定义来实现.
99.推理递归函数时, 要从基准落伍测试开始, 并认证每次递归调用如何逐渐接近非递归基准范例代码.
100.简单的语言常常使用一系列遵循该语言语法结构的函数进行语法分析.
101.推理互递归函数时, 要基于底层概念的递归定义.
102.尾递归调用等同于一个回到函数开始处的循环.
103.将throws子句从方法的定义中移除, 然后运行Java编译器对类的源代码进行编译, 就可以容易地找到那些可能隐式地生成异常的方法.
104.在多处理器计算机上运行的代码常常围绕进程或线程进行组织.
105.工作群并行模型用于在多个处理器间分配工作, 或者创建一个任务池, 然后将大量需要处理标准化的工作进行分配.
106.基于线程的管理者/工人并行模型一般将耗时的或阻塞的操作分配给工人子任务, 从而维护中心任务的响应性.
107.基于进程的管理者/工人并行模型一般用来重用现有的程序, 或用定义良好的接口组织和分离粗粒度的系统模块.
108.基于流水线的并行处理中, 每个任务都接收到一些输入, 对它们进行一些处理, 并将生成的输出传递给下一个任务, 进行不同的处理.
109.竞争条件很难捉摸, 相关的代码常常会将竞争条件扩散到多个函数或模块; 因而, 很难隔离由于竞争条件导致的问题.
110.对于出现在信号处理器中的数据结构操作代码和库调用要保持高度警惕.
111.在阅读包含宏的代码时, 要注意, 宏既非函数, 也非语句.
112.do…while(0)块中的宏等同于控制块中的语句.
113.宏可以访问在它的使用点可见的所有局部变量.
114.宏调用可改变参数的值
115.基于宏的标记拼接能够创建新的标记符.
第十一章 编码规范和约定 (第七章: 编码规范和约定)
137.了解了给定代码库所遵循的文件组织方式后, 就能更有效率地浏览它的源代码.
138.阅读代码时, 首先要确保您的编辑器或优美打印程序的tab设置, 与代码遵循的风格规范一致.
139.可以使用代码块的缩进, 快速地掌握代码的总体结构.
140.对编排不一致的代码, 应该立即给予足够的警惕.
141.分析代码时, 对标记为XXX, FIXME和TODO的代码序列要格外注意: 错误可能就潜伏在其中.
142.常量使用大写字母命名, 单词用下划线分隔.
143.在遵循Java编码规范的程序中, 包名(package name)总是从一个顶级的域名开始(例如, org, com), 类名和接口名由大写字母开始, 方法
和变量名由小写字母开始.
144.用户界面控件名称之前的匈牙利记法的前缀类型标记可以帮助我们确定它的作用.
145.不同的编程规范对可移植构造的构成有不同的主张.
146.在审查代码的可移植性, 或以某种给定的编码规范作为指南时, 要注意了解规范对可移植性需求的界定与限制.
147.如果GUI功能都使用相应的编程结构来实现, 则通过代码审查可以轻易地验证给定用户界面的规格说明是否被正确地采用.
148.了解项目编译过程的组织方式与自动化方式之后, 我们就能够快速地阅读与理解对应的编译规则.
149.当检查系统的发布过程时, 常常可以将相应发行格式的需求作为基准.
(2)如何阅读linux源代码
随着linux的逐步普及，现在有不少人对于Linux的安装已经比较熟悉了。与Linux的蓬勃发展相适应，想深入了解Linux的也越来越多。而要想深入了解Linux，就需要阅读和分析linux内核的源代码。
Linux的内核源代码可以从很多途径得到。一般来讲，在安装的linux系统下，/usr/src/linux目录下的东西就是内核源代码。另外还可以从互连网上下载,解压缩后文件一般也都位于linux目录下。内核源代码有很多版本，目前最新的稳定版是3.0.3。
许多人对于阅读Linux内核有一种恐惧感，其实大可不必。当然，象Linux内核这样大而复杂的系统代码，阅读起来确实有很多困难，但是也不像想象的那么高不可攀。只要有恒心，困难都是可以克服的。也不用担心水平不够的问题，事实上，有很多事情我们不都是从不会到会，边干边学的吗？再就是根据自己的工作需要针对某一部分进行深入理解，毕竟现在linux内核太庞大了，全面了解的困难不小。
任何事情做起来都需要有方法和工具。正确的方法可以指导工作，良好的工具可以事半功倍。对于Linux内核源代码的阅读也同样如此。下面我就把自己阅读内核源代码的一点经验介绍一下，最后介绍Window平台下的一种阅读工具。
对于源代码的阅读，要想比较顺利，事先最好对源代码的知识背景有一定的了解。对于linux内核源代码来讲，我认为，
基本要求是：a、操作系统的基本知识；b、对C语言比较熟悉，最好要有汇编语言的知识和GNU C对标准C的扩展的知识的了解。另外在阅读之前，还应该知道Linux内核源代码的整体分布情况。我们知道现代的操作系统一般由进程管理、内存管理、文件系统、驱动程序、网络等组成。看一下Linux内核源代码就可看出，各个目录大致对应了这些方面。
Linux内核源代码的组成如下（假设相对于linux目录）：
arch 这个子目录包含了此核心源代码所支持的硬件体系结构相关的核心代码。如对于X86平台就是i386。
include 这个目录包括了核心的大多数include文件。另外对于每种支持的体系结构分别有一个子目录。
init 此目录包含核心启动代码。
mm 此目录包含了所有的内存管理代码。与具体硬件体系结构相关的内存管理代码位于arch/*/mm目录下，如对应于X86的就是arch/i386/mm/fault.c
drivers 系统中所有的设备驱动都位于此目录中。它又进一步划分成几类设备驱动，每一种也有对应的子目录，如声卡的驱动对应于drivers/sound。
ipc 此目录包含了核心的进程间通讯代码。
fs Linux支持的文件系统代码。不同的文件系统有不同的子目录对应，如ext2文件系统对应的就是ext2子目录。
kernel主要核心代码。同时与处理器结构相关代码都放在arch/*/kernel目录下。
net 核心的网络部分代码。里面的每个子目录对应于网络的一个方面。
lib 此目录包含了核心的库代码。与处理器结构相关库代码被放在arch/*/lib/目录下。
scripts此目录包含用于配置核心的脚本文件。
Documentation 此目录是一些文档，起参考作用。
清楚了源代码的结构组成后就可以着手阅读。对于阅读方法或者说顺序，有所谓的纵向与横向之分。所谓纵向就是顺着程序的执行顺序逐步进行；所谓横向，就是分模块进行。其实他们之间不是绝对的，而是经常结合在一起进行。对于Linux源代码来讲，启动的代码就可以顺着linux的启动顺序一步一步来，它的大致流程如下（以X86平台为例）：
./larch/i386/boot/bootSect.S-->./larch/i386/boot/setup.S-->./larch/i386/kernel/head.S-->./init/main.c中的start_kernel()。而对于象内存管理等部分，则可以单独拿出来进行阅读分析。我的体会是：开始最好按顺序阅读启动代码，然后进行专题阅读，如进程部分，内存管理部分等。在每个功能函数内部应该一步步来。实际上这是一个反复的过程，不可能读一遍就理解。
俗话说：“工欲善其事，必先利其器”。 阅读象Linux核心代码这样的复杂程序令人望而生畏。它象一个越滚越大的雪球，阅读核心某个部分经常要用到好几个其他的相关文件，不久你将会忘记你原来在干什么。所以没有一个好的工具是不行的。由于大部分爱好者对于Window平台比较熟悉，并且还是常用Window系列平台，所以在此我介绍一个Window下的一个工具软件：Understand。关于使用参见上一篇博客有兴趣的朋友可以装一个Understand，那样你阅读源代码的效率会有很大提高的。怎么样，试试吧！
(3) Linux开发者谈如何阅读源代码
如何阅读源代码
原始连接：[url]http://study./infoview/Article_726.html[/url]
2005-5-21
写在前面的话：
自从我在linuxaid.com.cn上发表一些文章开始，就不断的有网友发来电子邮件，或者是就其中某些问题进行探讨，或者是查询其他文章的地址（往往这些网友看的是其他网站转载的我的文章），我很高兴自己写出的文章有这么多人回应，因为这是对我最好的赞赏，也很高兴有这么多人对我的文章感兴趣。但是常常因为工作关系。有很多邮件是询问我的其他文章在哪里能够找到，我不一定能够及时回复，也觉得回复同样的问题比较麻烦，所以在这里重复一下，我为linuxaid.com.cn写的文章都能在[url]www.linuxaid.com.cn[/url]的应用开发栏目中找到，我的一部分文章收集在bambi.may10.ca/~ariesram/articles下面（这是一个很简陋的网页，只有文本格式的文章，也欢迎有兴趣的网友帮我设计一下网页），我的邮件地址：[email]ariesram@linuxaid.com.cn[/email],
或者[email]ariesram@may10.ca[/email]。请转载文章的网站保留这一说明，欢迎网友写email给我探讨问题，虽然我不能保证能及时回复。
正文：
由于工作的关系，我常常需要读一些源代码，并在上面做一些修改并且拿来使用，或者是借鉴其中的某些部分。可以说，open source对于程序员来说，是很有意义的事情。根据我的经验，读源代码，至少有3个好处。第一个好处是可以学习到很多编程的方法，看好的源代码，对于提高自己的编程水平，比自己写源代码的帮助更大。当然不是说不用自己写，而是说，自己写代码的同时，可以从别人写的好的源代码中间学习到更多的编程方法和技巧。第二个好处是，可以提高自己把握大规模源代码的能力。一个比较大型的程序，往往都是经过了很多个版本很长的时间，有很多人参与开发，修正错误，添加功能而发展起来的。所以往往源代码的规模都比较大，少则10-100多k,
多的有好几十个MB. 在阅读大量源代码的时候，能够提高自己对大的软件的把握能力，快速了解脉络，熟悉细节，不仅仅是编程技巧，还能在程序的架构，设计方面提高自己的能力。（这里说一句题外话，<<设计模式>>这本书相信很多人都看过，而且很多人对它推崇备至，奉为经典。现在也出了不少书，都是冠以"设计模式"这一名称。在书中就提到，设计模式并不是一本教材，不是教你如何去编程序，而是把平时编程中一些固定的模式记录下来，加以不断的测试和改进，分发给广大程序员的一些经验之谈。我在看这本书的时候，有一些地方一些设计方法往往让我有似曾相识的感觉，另外一些则是我以前就常常用到的。而这些经验的获得，一部分得益于自己的编码过程，另外一个很重要的来源就是阅读别人写的源代码。)阅读源代码第三个好处，就是获得一些好的思想。比如，有很多人在开始一个软件项目之前都喜欢到sourceforge.net上去找一下，是否有人以前做过相同或者相似的软件，如果有，则拿下来读一读，可以使自己对这个软件项目有更多更深的认识。我以前曾经想找一本关于如何阅读源代码的书来看看，却没有找到。相反，倒是找到了不少分析源代码的书，比如Linux
kernel, Apache source, 等等。所以我想，为什么不自己来写下一些经验和大家交流呢？（当然不是写书，没有那个能力也没有那个时间。）所以在这里我准备用一个例子来写一下如何阅读源代码，分享一些经验，算是抛砖引玉吧！
我找的例子是一个统计日志的工具，webalizer. (这个工具我以前用过，似乎记得以前的版本是用perl写的，不知道现在为什么作者把它完全修改成了C，可能是为了效率，也可能根本就是我记错了。）之所以选择这个软件来作为例子，一方面是因为它是用C写的，流程比较简单，没有C++的程序那么多的枝节，而且软件功能不算复杂，代码规模不大，能够在一篇文章的篇幅里面讲完; 另外一个方面是因为恰巧前段时间我因为工作的关系把它拿来修改了一下，刚看过，还没有忘记。 :-)我采用的例子是webalizer2.01-09, 也可以到它的网站[url]http://www./webalizer/[/url]
下载最新的版本。这是一个用C写的，处理文本文件（简单的说是这样，实际上它支持三种日志文本格式：CLF, FTP, SQUID), 并且用html的方式输出结果。读者可以自己去下载它的源代码包，并一边读文章，一边看程序。解压缩它的tar包(我download的是它的源代码tar包），在文件目录中看到这样的结果：
$ ls
aclocal.m4 dns_resolv.c lang output.h webalizer.1
CHANGES dns_resolv.h lang.h parser.c webalizer.c
configure graphs.c linklist.c parser.h webalizer.h
configure.in graphs.h linklist.h preserve.c webalizer_lang.h
COPYING hashtab.c Makefile.in preserve.h webalizer.LSM
Copyright hashtab.h Makefile.std README webalizer.png
country-codes.txt INSTALL msfree.png README.FIRST
DNS.README install-sh output.c sample.conf
首先，我阅读了它的README(这是很重要的一个环节）, 大体了解了软件的功能，历史状况，修改日志，安装方法等等。然后是安装并且按照说明中的缺省方式来运行它，看看它的输出结果。(安装比较简单，因为它带了一个configure, 在没有特殊情况出现的时候，简单的./configure, make, make install就可以安装好。)然后就是阅读源代码了。我从makefile开始入手（我觉得这是了解一个软件的最好的方法）在makefile开头，有这些内容：
prefix = /usr/local
exec_prefix = ${prefix}
BINDIR = ${exec_prefix}/bin
MANDIR = ${prefix}/man/man1
ETCDIR = /etc
CC = gcc
CFLAGS = -Wall -O2
LIBS = -lgd -lpng -lz -lm
DEFS = -DETCDIR="/etc" -DHAVE_GETOPT_H=1 -DHAVE_MATH_H=1
LDFLAGS=
INSTALL= /usr/bin/install -c
INSTALL_PROGRAM=${INSTALL}
INSTALL_DATA=${INSTALL} -m 644
# where are the GD header files?
GDLIB=/usr/include
这些定义了安装的路径，执行程序的安装路径，编译器，配置文件的安装路径，编译的选项，安装程序，安装程序的选项等等。要注意的是，这些并不是软件的作者写的，而是./configure的输出结果。呵呵. :-)下面才是主题内容，也是我们关心的。
# Shouldn't have to touch below here!
all: webalizer
webalizer: webalizer.o webalizer.h hashtab.o hashtab.h
linklist.o linklist.h preserve.o preserve.h
dns_resolv.o dns_resolv.h parser.o parser.h
output.o output.h graphs.o graphs.h lang.h
webalizer_lang.h
$(CC) ${LDFLAGS} -o webalizer webalizer.o hashtab.o linklist.o preserv
e.o parser.o output.o dns_resolv.o graphs.o ${LIBS}
rm -f webazolver
ln -s webalizer webazolver
webalizer.o: webalizer.c webalizer.h parser.h output.h preserve.h
graphs.h dns_resolv.h webalizer_lang.h
$(CC) ${CFLAGS} ${DEFS} -c webalizer.c
parser.o: parser.c parser.h webalizer.h lang.h
$(CC) ${CFLAGS} ${DEFS} -c parser.c
hashtab.o: hashtab.c hashtab.h dns_resolv.h webalizer.h lang.h
$(CC) ${CFLAGS} ${DEFS} -c hashtab.c
linklist.o: linklist.c linklist.h webalizer.h lang.h
$(CC) ${CFLAGS} ${DEFS} -c linklist.c
output.o: output.c output.h webalizer.h preserve.h
hashtab.h graphs.h lang.h
$(CC) ${CFLAGS} ${DEFS} -c output.c
preserve.o: preserve.c preserve.h webalizer.h parser.h
hashtab.h graphs.h lang.h
$(CC) ${CFLAGS} ${DEFS} -c preserve.c
dns_resolv.o: dns_resolv.c dns_resolv.h lang.h webalizer.h
$(CC) ${CFLAGS} ${DEFS} -c dns_resolv.c
graphs.o: graphs.c graphs.h webalizer.h lang.h
$(CC) ${CFLAGS} ${DEFS} -I${GDLIB} -c graphs.c
好了，不用再往下看了，这些就已经足够了。从这里我们可以看到这个软件的几个源代码文件和他们的结构。webalizer.c是主程序所在的文件，其他的是一些辅助程序模块。对比一下目录里面的文件，
$ ls *.c *.h
dns_resolv.c graphs.h lang.h output.c parser.h webalizer.c
dns_resolv.h hashtab.c linklist.c output.h preserve.c webalizer.h
graphs.c hashtab.h linklist.h parser.c preserve.h webalizer_lang.h
于是，让我们从webalizer.c开始吧。
作为一个C程序，在头文件里面，和C文件里面定义的extern变量，结构等等肯定不会少，但是，单独看这些东西我们不可能对这个程序有什么认识。所以，从main函数入手，逐步分析，在需要的时候再回头来看这些数据结构定义才是好的方法。（顺便说一句，Visual C++, 等windows下的IDE工具提供了很方便的方法来获取函数列表，C++的类列表以及资源文件，对于阅读源代码很有帮助。Unix/Linux也有这些工具，但是，我们在这里暂时不说，而只是通过最简单的文本编辑器vi来讲)。跳过webalizer.c开头的版权说明部分（GPL的），和数据结构定义，全局变量声明部分，直接进入main()函数。在函数开头，我们看到：
/* initalize epoch */
epoch=jdate(1,1,1970); /* used for timestamp adj. */
/* add default index. alias */
add_nlist("index.",&index_alias);
这两个函数暂时不用仔细看，后面会提到，略过。
sprintf(tmp_buf,"%s/webalizer.conf",ETCDIR);
/* check for default config file */
if (!access("webalizer.conf",F_OK))
get_config("webalizer.conf");
else if (!access(tmp_buf,F_OK))
get_config(tmp_buf);
从注释和程序本身可以看出，这是查找是否存在一个叫做webalizer.conf的配置文件，如果当前目录下有，则用get_config来读入其中内容，如果没有，则查找ETCDIR/webalizer.conf是否存在。如果都没有，则进入下一部分。(注意：ETCDIR = @ETCDIR@在makefile中有定义）
/* get command line options */
opterr = 0; /* disable parser errors */
while ((i=getopt(argc,argv,"a:A:c:C:dD:e:E:fF:
g:GhHiI:l:Lm:M:n:N:o:pP:qQr:R:s:S:t:Tu:U:vVx:XY"))!=EOF)
{
switch (i)
{
case 'a': add_nlist(optarg,&hidden_agents); break;
/* Hide agents */
case 'A': ntop_agents=atoi(optarg); break;
/* Top agents */
case 'c': get_config(optarg); break;
/* Config file */
case 'C': ntop_ctrys=atoi(optarg); break;
/* Top countries */
case 'd': debug_mode=1; break;
/* Debug */
case 'D': dns_cache=optarg; break;
/* DNS Cache filename */
case 'e': ntop_entry=atoi(optarg); break;
/* Top entry pages */
case 'E': ntop_exit=atoi(optarg); break;
/* Top exit pages */
case 'f': fold_seq_err=1; break;
/* Fold sequence errs */
case 'F': log_type=(optarg[0]=='f')?
LOG_FTP:(optarg[0]=='s')?
LOG_SQUID:LOG_CLF; break;
/* define log type */
case 'g': group_domains=atoi(optarg); break;
/* GroupDomains (0=no) */
case 'G': hourly_graph=0; break;
/* no hourly graph */
case 'h': print_opts(argv[0]); break;
/* help */
case 'H': hourly_stats=0; break;
/* no hourly stats */
case 'i': ignore_hist=1; break;
/* Ignore history */
case 'I': add_nlist(optarg,&index_alias); break;
/* Index alias */
case 'l': graph_lines=atoi(optarg); break;
/* Graph Lines */
case 'L': graph_legend=0; break;
/* Graph Legends */
case 'm': visit_timeout=atoi(optarg); break;
/* Visit Timeout */
case 'M': mangle_agent=atoi(optarg); break;
/* mangle user agents */
case 'n': hname=optarg; break;
/* Hostname */
case 'N': dns_children=atoi(optarg); break;
/* # of DNS children */
case 'o': out_dir=optarg; break;
/* Output directory */
case 'p': incremental=1; break;
/* Incremental run */
case 'P': add_nlist(optarg,&page_type); break;
/* page view types */
case 'q': verbose=1; break;
/* Quiet (verbose=1) */
case 'Q': verbose=0; break;
/* Really Quiet */
case 'r': add_nlist(optarg,&hidden_refs); break;
/* Hide referrer */
case 'R': ntop_refs=atoi(optarg); break;
/* Top referrers */
case 's': add_nlist(optarg,&hidden_sites); break;
/* Hide site */
case 'S': ntop_sites=atoi(optarg); break;
/* Top sites */
case 't': msg_title=optarg; break;
/* Report title */
case 'T': time_me=1; break; /* TimeMe */
case 'u': add_nlist(optarg,&hidden_urls); break;
/* hide URL */
case 'U': ntop_urls=atoi(optarg); break;
/* Top urls */
case 'v':
case 'V': print_version(); break;
/* Version */
case 'x': html_ext=optarg; break;
/* HTML file extension */
case 'X': hide_sites=1; break;
/* Hide ind. sites */
case 'Y': ctry_graph=0; break;
/* Supress ctry graph */
}
}
if (argc - optind != 0) log_fname = argv[optind];
if ( log_fname && (log_fname[0]=='-')) log_fname=NULL;
/* force STDIN? */
/* check for gzipped file - .gz */
if (log_fname) if (!strcmp((log_fname+strlen(log_fname)-3),".gz"))
gz_log=1;
这一段是分析命令行参数及开关。（getopt()的用法我在另外一篇文章中讲过，这里就不再重复了。）可以看到，这个软件虽然功能不太复杂，但是开关选项还是不少。大多数的unix/linux程序的开头部分都是这个套路，初始化配置文件，并且读入分析命令行。在这段程序中，我们需要注意一个函数：add_nlist(). print_opts(), get_config()等等一看就明白，就不用多讲了。这里我们已经是第二次遇到add_nlist这个函数了，就仔细看看吧。
$ grep add_nlist *.h
linklist.h:extern int add_nlist(char *, NLISTPTR *);
/* add list item */
可以发现它定义在linklist.h中。
在这个h文件中，当然会有一些数据结构的定义，比如：
struct nlist { char string[80];
/* list struct for HIDE items */
struct nlist *next; };
typedef struct nlist *NLISTPTR;
struct glist { char string[80];
/* list struct for GROUP items */
char name[80];
struct glist *next; };
typedef struct glist *GLISTPTR;
这是两个链表结构。还有
extern GLISTPTR group_sites ; /* "group" lists */
extern GLISTPTR group_urls ;
extern GLISTPTR group_refs ;
这些都是链表， 太多了，不用一一看得很仔细，因为目前也看不出来什么东西。当然要注意它们是extern的， 也就是说，可以在其他地方(文件）看到它们的数值（类似于C++中的public变量）。这里还定义了4个函数：
extern char *isinlist(NLISTPTR, char *);
/* scan list for str */
extern char *isinglist(GLISTPTR, char *);
/* scan glist for str */
extern int add_nlist(char *, NLISTPTR *);
/* add list item */
extern int add_glist(char *, GLISTPTR *);
/* add group list item */
注意，这些都是extern的，也就是说，可以在其他地方见到它们的调用(有点相当于C++中的public函数）。再来看看linklist.c，
NLISTPTR new_nlist(char *); /* new list node */
void del_nlist(NLISTPTR *); /* del list */
GLISTPTR new_glist(char *, char *); /* new group list node */
void del_glist(GLISTPTR *); /* del group list */
int isinstr(char *, char *);
这5个函数是内部使用的（相当于C++中的private), 也就是说，这些函数只被isinlist(NLISTPTR, char *), isinglist(GLISTPTR, char *), add_nlist(char *, NLISTPTR *), add_glist(char *, GLISTPTR *)调用，而不会出现在其他地方。所以，我们先来看这几个内部函数。举例来说，
add_nlist(char *)
NLISTPTR new_nlist(char *str)
{
NLISTPTR newptr;
if (sizeof(newptr->string) < strlen(str))
{
if (verbose)
fprintf(stderr,"[new_nlist] %s ",msg_big_one);
}
if (( newptr = malloc(sizeof(struct nlist))) != NULL)
{strncpy(newptr->string, str, sizeof(newptr->string));
newptr->next=NULL;}
return newptr;
}
这个函数分配了一个struct nlist, 并且把其中的string赋值为str, next赋值为NULL.这实际上是创建了链表中的一个节点。verbose是一个全局变量，定义了输出信息的类型，如果verbose为1，则输出很详细的信息，否则输出简略信息。这是为了调试或者使用者详细了解程序情况来用的。不是重要内容，虽然我们常常可以在这个源程序的其他地方看到它。另外一个函数：
void del_nlist(NLISTPTR *list)
{
NLISTPTR cptr,nptr;
cptr=*list;
while (cptr!=NULL)
{
nptr=cptr->next;
free(cptr);
cptr=nptr;
}
}
这个函数删除了一个nlist（也可能是list所指向的那一个部分开始知道链表结尾），比较简单。看完了这两个内部函数，可以来看
/*********************************************/
/* ADD_NLIST - add item to FIFO linked list */
/*********************************************/
int add_nlist(char *str, NLISTPTR *list)
{
NLISTPTR newptr,cptr,pptr;
if ( (newptr = new_nlist(str)) != NULL)
{
if (*list==NULL) *list=newptr;
else
{
cptr=pptr=*list;
while(cptr!=NULL) { pptr=cptr; cptr=cptr->next; };
pptr->next = newptr;
}
}
return newptr==NULL;
}
这个函数是建立了一个新的节点，把参数str赋值给新节点的string, 并把它连接到list所指向链表的结尾。另外的三个函数：new_glist(), del_glist(), add_glist()完成的功能和上述三个差不多，所不同的只是它们所处理的数据结构不同。看完了这几个函数，我们回到main程序。接下来是，
/* setup our internal variables */
init_counters(); /* initalize main counters */
我们所阅读的这个软件是用来分析日志并且做出统计的，那么这个函数的名字已经告诉了我们，这是一个初始化计数器的函数。简略的看看吧！
$ grep init_counters *.h
webalizer.h:extern void init_counters();
在webalizer.c中找到：
void init_counters()
{
int i;
for (i=0;i
根据在最开始读过的README文件，这个page_type是用来定义处理的页面的类型的。在README文件中，
-P name Page type. This is the extension of files you consider to
be pages for Pages calculations (sometimes called 'pageviews').
The default is 'htm*' and 'cgi' (plus whatever HTMLExtension
you specified if it is different). Don't use a period!
我们在程序中也可以看到，如果没有在命令行中或者config文件中指定，则根据处理的日志文件的类型来添加缺省的文件类型。比如对于CLF文件(WWW日志)，处理html, htm, cgi文件
if (log_type == LOG_FTP)
{
/* disable stuff for ftp logs */
ntop_entry=ntop_exit=0;
ntop_search=0;
}
else
.....
这一段是对于FTP的日志格式，设置搜索列表。
for (i=0;i
清空哈西表，为下面即将进行的排序工作做好准备。关于哈西表，这是数据结构中常用的一种用来快速排序的结构，如果不清楚，可以参考相关书籍，比如清华的<<数据结构>>教材或者<<数据结构的C++实现>>等书。
if (verbose>1)
{
uname(&system_info);
printf("Webalizer V%s-%s (%s %s) %s ",
version,editlvl,system_info.sysname,
system_info.release,language);
}
这一段，是打印有关系统的信息和webalizer程序的信息（可以参考uname的函数说明）。
#ifndef USE_DNS
if (strstr(argv[0],"webazolver")!=0)
{
printf("DNS support not present, aborting... ");
exit(1);
}
#endif /* USE_DNS */
这一段，回忆我们在看README文件的时候，曾经提到过可以在编译的时候设置选项开关来设定DNS支持，在源代码中可以看到多次这样的代码段出现，如果不指定DNS支持，这些代码段则会出现（ifdef)或者不出现(ifndef).下面略过这些代码段，不再重复。
/* open log file */
if (gz_log)
{
gzlog_fp = gzopen(log_fname,"rb");
if (gzlog_fp==Z_NULL)
{
/* Error: Can't open log file ... */
fprintf(stderr, "%s %s ",msg_log_err,log_fname);
exit(1);
}
}
else
{
if (log_fname)
{
log_fp = fopen(log_fname,"r");
if (log_fp==NULL)
{
/* Error: Can't open log file ... */
fprintf(stderr, "%s %s ",msg_log_err,log_fname);
exit(1);
}
}
}
这一段，回忆在README文件中曾经读到过，如果log文件是gzip压缩格式，则用gzopen函数打开（可以猜想gz***是一套针对gzip压缩格式的实时解压缩函数），如果不是，则用fopen打开。
/* switch directories if needed */
if (out_dir)
{
if (chdir(out_dir) != 0)
{
/* Error: Can't change directory to ... */
fprintf(stderr, "%s %s ",msg_dir_err,out_dir);
exit(1);
}
}
同样，回忆在README文件中读到过，如果参数行有-o out_dir, 则将输出结果到该目录，否则，则输出到当前目录。在这一段中，如果输出目录不存在(chdir(out_dir) != 0)则出错。
#ifdef USE_DNS
if (strstr(argv[0],"webazolver")!=0)
{
if (!dns_children) dns_children=5; /* default dns children if needed */
if (!dns_cache)
{
/* No cache file specified, aborting... */
fprintf(stderr,"%s ",msg_dns_nocf); /* Must have a cache file */
exit(1);
}
}
......
在上面曾经提到过，这是DNS解析的代码部分，可以略过不看，不会影响对整个程序的理解。
/* prep hostname */
if (!hname)
{
if (uname(&system_info)) hname="localhost";
else hname=system_info.nodename;
}
这一段继续处理参数做准备工作。如果在命令行中指定了hostname(机器名）则采用指定的名称，否则调用uname查找机器名，如果没有，则用localhost来作为机器名。(同样在README中说得很详细）
/* get past history */
if (ignore_hist) {if (verbose>1) printf("%s ",msg_ign_hist); }
else get_history();
如果在命令行中指定了忽略历史文件，则不读取历史文件，否则调用get_history()来读取历史数据。在这里，我们可以回想在README文件中同样说过这一细节，在命令行或者配置文件中都能指定这一开关。需要说明的是，我们在这里并不一定需要去看get_history这一函数，因为从函数的名称，README文件和程序注释都能很清楚的得知这一函数的功能，不一定要去看代码。而如果要猜想的话，也可以想到，history是webalizer在上次运行的时候记录下来的一个文件，而这个文件则是去读取它，并将它的数据包括到这次的分析中去。不信，我们可以来看看。
void get_history()
{
int i,numfields;
FILE *hist_fp;
char buffer[BUFSIZE];
/* first initalize internal array */
for (i=0;i<12;i++)
{
hist_month=hist_year=hist_fday=hist_lday=0;
hist_hit=hist_files=hist_site=hist_page=hist_visit=0;
hist_xfer=0.0;
}
hist_fp=fopen(hist_fname,"r");
if (hist_fp)
{
if (verbose>1) printf("%s %s ",msg_get_hist,hist_fname);
while ((fgets(buffer,BUFSIZE,hist_fp)) != NULL)
{
i = atoi(buffer) -1;
if (i>11)
{
if (verbose)
fprintf(stderr,"%s (mth=%d) ",msg_bad_hist,i+1);
continue;
}
/* month# year# requests files sites xfer firstday lastday */
numfields = sscanf(buffer,"%d %d %lu %lu %lu %lf %d %d %lu %lu",
&hist_month,
&hist_year,
&hist_hit,
&hist_files,
&hist_site,
&hist_xfer,
&hist_fday,
&hist_lday,
&hist_page,
&hist_visit);
if (numfields==8) /* kludge for reading 1.20.xx history files */
{
hist_page = 0;
hist_visit = 0;
}
}
fclose(hist_fp);
}
else if (verbose>1) printf("%s ",msg_no_hist);
}
/*********************************************/
/* PUT_HISTORY - write out history file */
/*********************************************/
void put_history()
{
int i;
FILE *hist_fp;
hist_fp = fopen(hist_fname,"w");
if (hist_fp)
{
if (verbose>1) printf("%s ",msg_put_hist);
for (i=0;i<12;i++)
{
if ((hist_month != 0) && (hist_hit != 0))
{
fprintf(hist_fp,"%d %d %lu %lu %lu %.0f %d %d %lu %lu ",
hist_month,
hist_year,
hist_hit,
hist_files,
hist_site,
hist_xfer,
hist_fday,
hist_lday,
hist_page,
hist_visit);
}
}
fclose(hist_fp);
}
else
if (verbose)
fprintf(stderr,"%s %s ",msg_hist_err,hist_fname);
}
在preserve.c中，这两个函数是成对出现的。get_history()读取文件中的数据，并将其记录到hist_开头的一些数组中去。而put_history()则是将一些数据记录到同样的数组中去。我们可以推测得知，hist_数组是全局变量（在函数中没有定义），也可以查找源代码验证。同样，我们可以找一找put_history()出现的地方，来验证刚才的推测是否正确。在webalizer.c的1311行，出现：
month_update_exit(rec_tstamp); /* calculate exit pages */
write_month_html(); /* write monthly HTML file */
write_main_index(); /* write main HTML file */
put_history(); /* write history */
可以知道，推测是正确的。再往下读代码，
if (incremental) /* incremental processing? */
{
if ((i=restore_state())) /* restore internal data structs */
{
/* Error: Unable to restore run data (error num) */
/* if (verbose) fprintf(stderr,"%s (%d) ",msg_bad_data,i); */
fprintf(stderr,"%s (%d) ",msg_bad_data,i);
exit(1);
}
......
}
同样，这也是处理命令行和做数据准备，而且和get_history(), put_history()有些类似，读者可以自己练习一下。下面，终于进入了程序的主体部分, 在做完了命令行分析，数据准备之后，开始从日志文件中读取数据并做分析了。
/*********************************************/
/* MAIN PROCESS LOOP - read through log file */
/*********************************************/
while ( (gz_log)?(our_gzgets(gzlog_fp,buffer,BUFSIZE) != Z_NULL):
(fgets(buffer,BUFSIZE,log_fname?log_fp:stdin) != NULL))
我看到这里的时候，颇有一些不同意作者的这种写法。这一段while中的部分写的比较复杂而且效率不高。因为从程序推断和从他的代码看来，作者是想根据日志文件的类型不同来采用不同的方法读取文件，如果是gzip格式，则用our_gzgets来读取其中一行，如果是普通的文本文件格式，则用fgets()来读取。但是，这段代码是写在while循环中的，每次读取一行就要重复判断一次，明显是多余的而且降低了程序的性能。可以在while循环之前做一次这样的判断，然后就不用重复了。
total_rec++;
if (strlen(buffer) == (BUFSIZE-1))
{
if (verbose)
{
fprintf(stderr,"%s",msg_big_rec);
if (debug_mode) fprintf(stderr,": %s",buffer);
else fprintf(stderr," ");
}
total_bad++; /* bump bad record counter */
/* get the rest of the record */
while ( (gz_log)?(our_gzgets(gzlog_fp,buffer,BUFSIZE)!=Z_NULL):
(fgets(buffer,BUFSIZE,log_fname?log_fp:stdin)!=NULL))
{
if (strlen(buffer) < BUFSIZE-1)
{
if (debug_mode && verbose) fprintf(stderr,"%s ",buffer);
break;
}
if (debug_mode && verbose) fprintf(stderr,"%s",buffer);
}
continue; /* go get next record if any */
}
这一段代码，读入一行，如果这一行超过了程序允许的最大字符数（则是错误的日志数据纪录），则跳过本行剩下的数据，忽略掉（continue进行下一次循环）。同时把total_bad增加一个。如果没有超过程序允许的最大字符数（则是正确的日志数据纪录），则
/* got a record... */
strcpy(tmp_buf, buffer); /* save buffer in case of error */
if (parse_record(buffer)) /* parse the record */
将该数据拷贝到一个缓冲区中，然后调用parse_record()进行处理。我们可以同样的推测一下，get_record()是这个程序的一个主要处理部分，分析了日志数据。在parse_record.c中，有此函数，
/*********************************************/
/* PARSE_RECORD - uhhh, you know... */
/*********************************************/
int parse_record(char *buffer)
{
/* clear out structure */
memset(&log_rec,0,sizeof(struct log_struct));
/*
log_rec.hostname[0]=0;
log_rec.datetime[0]=0;
log_rec.url[0]=0;
log_rec.resp_code=0;
log_rec.xfer_size=0;
log_rec.refer[0]=0;
log_rec.agent[0]=0;
log_rec.srchstr[0]=0;
log_rec.ident[0]=0;
*/
#ifdef USE_DNS
memset(&log_rec.addr,0,sizeof(struct in_addr));
#endif
/* call appropriate handler */
switch (log_type)
{
default:
case LOG_CLF: return parse_record_web(buffer); break;
/* clf */
case LOG_FTP: return parse_record_ftp(buffer); break;
/* ftp */
case LOG_SQUID: return parse_record_squid(buffer); break;
/* squid */
}
}
可以看到，log_rec是一个全局变量，该函数根据日志文件的类型，分别调用三种不同的分析函数。在webalizer.h中，找到该变量的定义，从结构定义中可以看到，结构定义了一个日志文件所可能包含的所有信息（参考CLF，FTP, SQUID日志文件的格式说明）。
/* log record structure */
struct log_struct { char hostname[MAXHOST]; /* hostname */
char datetime[29]; /* raw timestamp */
char url[MAXURL]; /* raw request field */
int resp_code; /* response code */
u_long xfer_size; /* xfer size in bytes */
#ifdef USE_DNS
struct in_addr addr; /* IP address structure */
#endif /* USE_DNS */
char refer[MAXREF]; /* referrer */
char agent[MAXAGENT]; /* user agent (browser) */
char srchstr[MAXSRCH]; /* search string */
char ident[MAXIDENT]; }; /* ident string (user) */
extern struct log_struct log_rec;
先看一下一个parser.c用的内部函数，然后再来以parse_record_web()为例子看看这个函数是怎么工作的，parse_record_ftp, parse_record_squid留给读者自己分析作为练习。
/*********************************************/
/* FMT_LOGREC - terminate log fields w/zeros */
/*********************************************/
void fmt_logrec(char *buffer)
{
char *cp=buffer;
int q=0,b=0,p=0;
while (*cp != '')
{
/* break record up, terminate fields with '' */
switch (*cp)
{
case ' ': if (b || q || p) break; *cp=''; break;
case '"': q^=1; break;
case '[': if (q) break; b++; break;
case ']': if (q) break; if (b>0) b--; break;
case '(': if (q) break; p++; break;
case ')': if (q) break; if (p>0) p--; break;
}
cp++;
}
}
从parser.h头文件中就可以看到，这个函数是一个内部函数，这个函数把一行字符串中间的空格字符用''字符（结束字符）来代替，同时考虑了不替换在双引号，方括号，圆括号中间的空格字符以免得将一行数据错误的分隔开了。（请参考WEB日志的文件格式，可以更清楚的理解这一函数）
int parse_record_web(char *buffer)
{
int size;
char *cp1, *cp2, *cpx, *eob, *eos;
size = strlen(buffer); /* get length of buffer */
eob = buffer+size; /* calculate end of buffer */
fmt_logrec(buffer); /* seperate fields with 's */
/* HOSTNAME */
cp1 = cpx = buffer; cp2=log_rec.hostname;
eos = (cp1+MAXHOST)-1;
if (eos >= eob) eos=eob-1;
while ( (*cp1 != '') && (cp1 != eos) ) *cp2++ = *cp1++;
*cp2 = '';
if (*cp1 != '')
{
if (verbose)
{
fprintf(stderr,"%s",msg_big_host);
if (debug_mode) fprintf(stderr,": %s ",cpx);
else fprintf(stderr," ");
}
while (*cp1 != '') cp1++;
}
if (cp1 < eob) cp1++;
/* skip next field (ident) */
while ( (*cp1 != '') && (cp1 < eob) ) cp1++;
if (cp1 < eob) cp1++;
/* IDENT (authuser) field */
cpx = cp1;
cp2 = log_rec.ident;
eos = (cp1+MAXIDENT-1);
if (eos >= eob) eos=eob-1;
while ( (*cp1 != '[') && (cp1 < eos) ) /* remove embeded spaces */
{
if (*cp1=='') *cp1=' ';
*cp2++=*cp1++;
}
*cp2--='';
if (cp1 >= eob) return 0;
/* check if oversized username */
if (*cp1 != '[')
{
if (verbose)
{
fprintf(stderr,"%s",msg_big_user);
if (debug_mode) fprintf(stderr,": %s ",cpx);
else fprintf(stderr," ");
}
while ( (*cp1 != '[') && (cp1 < eob) ) cp1++;
}
/* strip trailing space(s) */
while (*cp2==' ') *cp2--='';
/* date/time string */
cpx = cp1;
cp2 = log_rec.datetime;
eos = (cp1+28);
if (eos >= eob) eos=eob-1;
while ( (*cp1 != '') && (cp1 != eos) ) *cp2++ = *cp1++;
*cp2 = '';
if (*cp1 != '')
{
if (verbose)
{
fprintf(stderr,"%s",msg_big_date);
if (debug_mode) fprintf(stderr,": %s ",cpx);
else fprintf(stderr," ");
}
while (*cp1 != '') cp1++;
}
if (cp1 < eob) cp1++;
/* minimal sanity check on timestamp */
if ( (log_rec.datetime[0] != '[') ||
(log_rec.datetime[3] != '/') ||
(cp1 >= eob)) return 0;
/* HTTP request */
cpx = cp1;
cp2 = log_rec.url;
eos = (cp1+MAXURL-1);
if (eos >= eob) eos = eob-1;
while ( (*cp1 != '') && (cp1 != eos) ) *cp2++ = *cp1++;
*cp2 = '';
if (*cp1 != '')
{
if (verbose)
{
fprintf(stderr,"%s",msg_big_req);
if (debug_mode) fprintf(stderr,": %s ",cpx);
else fprintf(stderr," ");
}
while (*cp1 != '') cp1++;
}
if (cp1 < eob) cp1++;
if ( (log_rec.url[0] != '"') ||
(cp1 >= eob) ) return 0;
/* response code */
log_rec.resp_code = atoi(cp1);
/* xfer size */
while ( (*cp1 != '') && (cp1 < eob) ) cp1++;
if (cp1 < eob) cp1++;
if (*cp1<'0'||*cp1>'9') log_rec.xfer_size=0;
else log_rec.xfer_size = strtoul(cp1,NULL,10);
/* done with CLF record */
if (cp1>=eob) return 1;
while ( (*cp1 != '') && (*cp1 != ' ') && (cp1 < eob) )
cp1++;
if (cp1 < eob) cp1++;
/* get referrer if present */
cpx = cp1;
cp2 = log_rec.refer;
eos = (cp1+MAXREF-1);
if (eos >= eob) eos = eob-1;
while ( (*cp1 != '') && (*cp1 != ' ') && (cp1 != eos) )
*cp2++ = *cp1++;
*cp2 = '';
if (*cp1 != '')
{
if (verbose)
{
fprintf(stderr,"%s",msg_big_ref);
if (debug_mode) fprintf(stderr,": %s ",cpx);
else fprintf(stderr," ");
}
while (*cp1 != '') cp1++;
}
if (cp1 < eob) cp1++;
cpx = cp1;
cp2 = log_rec.agent;
eos = cp1+(MAXAGENT-1);
if (eos >= eob) eos = eob-1;
while ( (*cp1 != '') && (cp1 != eos) )
*cp2++ = *cp1++;
*cp2 = '';
return 1; /* maybe a valid record, return with TRUE */
}
该函数，一次读入一行（其实是一段日志数据中间的一个域，因为该行数据已经被fmt_logrec分开成多行数据了。根据CLF中的定义，检查该数据并将其拷贝到log_rec结构中去，如果检查该数据有效，则返回1。回到主程序,
/* convert month name to lowercase */
for (i=4;i<7;i++)
log_rec.datetime=tolower(log_rec.datetime);
/* get year/month/day/hour/min/sec values */
for (i=0;i<12;i++)
{
if (strncmp(log_month,&log_rec.datetime[4],3)==0)
{ rec_month = i+1; break; }
}
rec_year=atoi(&log_rec.datetime[8]);
/* get year number (int) */
rec_day =atoi(&log_rec.datetime[1]);
/* get day number */
rec_hour=atoi(&log_rec.datetime[13]);
/* get hour number */
rec_min =atoi(&log_rec.datetime[16]);
/* get minute number */
rec_sec =atoi(&log_rec.datetime[19]);
/* get second number */
....
在parse_record分析完数据之后，做日期的分析，把日志中的月份等数据转换成机器可读（可理解)的数据，并存入到log_rec中去。
if ((i>=12)||(rec_min>59)||(rec_sec>59)||(rec_year<1990))
{
total_bad++; /* if a bad date, bump counter */
if (verbose)
{
fprintf(stderr,"%s: %s [%lu]",
msg_bad_date,log_rec.datetime,total_rec);
......
如果日期，时间错误，则把total_bad计数器增加1，并且打印错误信息到标准错误输出。
good_rec = 1;
/* get current records timestamp
(seconds since epoch) */
req_tstamp=cur_tstamp;
rec_tstamp=((jdate(rec_day,rec_month,rec_year)-epoch)
*86400)+
(rec_hour*3600)+(rec_min*60)+rec_sec;
/* Do we need to check for duplicate records?
(incremental mode) */
if (check_dup)
{
/* check if less than/equal to last record processed */
if ( rec_tstamp <= cur_tstamp )
{
/* if it is, assume we have already
processed and ignore it */
total_ignore++;
continue;
}
else
{
/* if it isn't.. disable any more checks this run */
check_dup=0;
/* now check if it's a new month */
if (cur_month != rec_month)
{
clear_month();
cur_sec = rec_sec; /* set current counters */
cur_min = rec_min;
cur_hour = rec_hour;
cur_day = rec_day;
cur_month = rec_month;
cur_year = rec_year;
cur_tstamp= rec_tstamp;
f_day=l_day=rec_day; /* reset first and last day */
}
}
}
/* check for out of sequence records */
if (rec_tstamp/3600 < cur_tstamp/3600)
{
if (!fold_seq_err && ((rec_tstamp+SLOP_VAL)
/3600
如果该日期、时间没有错误，则该数据是一个好的数据，将good_record计数器加1，并且检查时间戳，和数据是否重复数据。这里有一个函数，jdate()在主程序一开头我们就遇到了，当时跳了过去没有深究，这里留给读者做一个练习。（提示：该函数根据一个日期产生一个字符串，这个字符串是惟一的，可以检查时间的重复性，是一个通用函数，可以在别的程序中拿来使用）
/*********************************************/
/* DO SOME PRE-PROCESS FORMATTING */
/*********************************************/
/* fix URL field */
cp1 = cp2 = log_rec.url;
/* handle null '-' case here... */
if (*++cp1 == '-') { *cp2++ = '-'; *cp2 = ''; }
else
{
/* strip actual URL out of request */
while ( (*cp1 != ' ') && (*cp1 != '') ) cp1++;
if (*cp1 != '')
{
/* scan to begin of actual URL field */
while ((*cp1 == ' ') && (*cp1 != '')) cp1++;
/* remove duplicate / if needed */
if (( *cp1=='/') && (*(cp1+1)=='/')) cp1++;
while ((*cp1 != ' ')&&(*cp1 != '"')&&(*cp1 != ''))
*cp2++ = *cp1++;
*cp2 = '';
}
}
/* un-escape URL */
unescape(log_rec.url);
/* check for service (ie: http://) and lowercase if found */
if ( (cp2=strstr(log_rec.url,"://")) != NULL)
{
cp1=log_rec.url;
while (cp1!=cp2)
{
if ( (*cp1>='A') && (*cp1<='Z')) *cp1 += 'a'-'A';
cp1++;
}
}
/* strip query portion of cgi s cripts */
cp1 = log_rec.url;
while (*cp1 != '')
if (!isurlchar(*cp1)) { *cp1 = ''; break; }
else cp1++;
if (log_rec.url[0]=='')
{ log_rec.url[0]='/'; log_rec.url[1]=''; }
/* strip off index.html (or any aliases) */
lptr=index_alias;
while (lptr!=NULL)
{
if ((cp1=strstr(log_rec.url,lptr->string))!=NULL)
{
if ((cp1==log_rec.url)||(*(cp1-1)=='/'))
{
*cp1='';
if (log_rec.url[0]=='')
{ log_rec.url[0]='/'; log_rec.url[1]=''; }
break;
}
}
lptr=lptr->next;
}
/* unescape referrer */
unescape(log_rec.refer);
......
这一段，做了一些URL字符串中的字符转换工作，很长，我个人认为为了程序的模块化，结构化和可复用性，应该将这一段代码改为函数，避免主程序体太长，造成可读性不强和没有移植性，和不够结构化。跳过这一段乏味的代码，进入到下面一个部分---后处理。
if (gz_log) gzclose(gzlog_fp);
else if (log_fname) fclose(log_fp);
if (good_rec) /* were any good records? */
{
tm_site[cur_day-1]=dt_site; /* If yes, clean up a bit */
tm_visit[cur_day-1]=tot_visit(sd_htab);
t_visit=tot_visit(sm_htab);
if (ht_hit > mh_hit) mh_hit = ht_hit;
if (total_rec > (total_ignore+total_bad))
/* did we process any? */
{
if (incremental)
{
if (save_state()) /* incremental stuff */
{
/* Error: Unable to save current run data */
if (verbose) fprintf(stderr,"%s ",msg_data_err);
unlink(state_fname);
}
}
month_update_exit(rec_tstamp); /* calculate exit pages */
write_month_html(); /* write monthly HTML file */
write_main_index(); /* write main HTML file */
put_history(); /* write history */
}
end_time = times(&mytms);
/* display timing totals? */
if (time_me' '(verbose>1))
{
printf("%lu %s ",total_rec, msg_records);
if (total_ignore)
{
printf("(%lu %s",total_ignore,msg_ignored);
if (total_bad) printf(", %lu %s) ",total_bad,msg_bad);
else printf(") ");
}
else if (total_bad) printf("(%lu %s) ",total_bad,msg_bad);
/* get processing time (end-start) */
temp_time = (float)(end_time-start_time)/CLK_TCK;
printf("%s %.2f %s", msg_in, temp_time, msg_seconds);
/* calculate records per second */
if (temp_time)
i=( (int)( (float)total_rec/temp_time ) );
else i=0;
if ( (i>0) && (i<=total_rec) ) printf(", %d/sec ", i);
else printf(" ");
}
这一段，做了一些后期的处理。接下来的部分，我想在本文中略过，留给感兴趣的读者自己去做分析。原因有两点：
1、这个程序在前面结构化比较强，而到了结构上后面有些乱，虽然代码效率还是比较高，但是可重用性不够强, 限于篇幅，我就不再一一解释了。 2、前面分析程序过程中，也对后面的代码做了一些预测和估计，也略微涉及到了后面的代码，而且读者可以根据上面提到的原则来自己分析代码，也作为一个实践吧。
最后，对于在这篇文章中提到的分析源代码程序的一些方法做一下小结，以作为本文的结束。
分析一个源代码，一个有效的方法是：
1、阅读源代码的说明文档，比如本例中的README, 作者写的非常的详细，仔细读过之后，在阅读程序的时候往往能够从README文件中找到相应的说明，从而简化了源程序的阅读工作。
2、如果源代码有文档目录，一般为doc或者docs， 最好也在阅读源程序之前仔细阅读，因为这些文档同样起了很好的说明注释作用。
3、从makefile文件入手，分析源代码的层次结构，找出哪个是主程序，哪些是函数包。这对于快速把握程序结构有很大帮助。
4、从main函数入手，一步一步往下阅读，遇到可以猜测出意思来的简单的函数，可以跳过。但是一定要注意程序中使用的全局变量（如果是C程序），可以把关键的数据结构说明拷贝到一个文本编辑器中以便随时查找。
5、分析函数包（针对C程序），要注意哪些是全局函数，哪些是内部使用的函数，注意extern关键字。对于变量，也需要同样注意。先分析清楚内部函数，再来分析外部函数，因为内部函数肯定是在外部函数中被调用的。
6、需要说明的是数据结构的重要性：对于一个C程序来说，所有的函数都是在操作同一些数据，而由于没有较好的封装性，这些数据可能出现在程序的任何地方，被任何函数修改，所以一定要注意这些数据的定义和意义，也要注意是哪些函数在对它们进行操作，做了哪些改变。
7、在阅读程序的同时，最好能够把程序存入到cvs之类的版本控制器中去，在需要的时候可以对源代码做一些修改试验，因为动手修改是比仅仅是阅读要好得多的读程序的方法。在你修改运行程序的时候，可以从cvs中把原来的代码调出来与你改动的部分进行比较(diff命令), 可以看出一些源代码的优缺点并且能够实际的练习自己的编程技术。
8、阅读程序的同时，要注意一些小工具的使用，能够提高速度，比如vi中的查找功能，模式匹配查找，做标记，还有grep，find这两个最强大最常用的文本搜索工具的使用。
对于一个Unix/Linux下面以命令行方式运行的程序，有这么一些套路，大家可以在阅读程序的时候作为参考。
1、在程序开头，往往都是分析命令行，根据命令行参数对一些变量或者数组，或者结构赋值，后面的程序就是根据这些变量来进行不同的操作。
2、分析命令行之后，进行数据准备，往往是计数器清空，结构清零等等。
3、在程序中间有一些预编译选项，可以在makefile中找到相应部分。
4、注意程序中对于日志的处理，和调试选项打开的时候做的动作，这些对于调试程序有很大的帮助。
5、注意多线程对数据的操作。（这在本例中没有涉及）
结束语：
当然，在这篇文章中，并没有阐述所有的阅读源代码的方法和技巧，也没有涉及任何辅助工具（除了简单的文本编辑器），也没有涉及面向对象程序的阅读方法。我想把这些留到以后再做讨论。也请大家可以就这些话题展开讨论。
三、选一些比较优秀的开源产品作为源代码阅读对象?
优秀的产品及项目：
1、大型产品：
1.1 C/C++/Object-C:
Linux内核(C):《Linux内核代码》《深入理解LINUX内核》 《Linux内核完全剖析》 《Linux内核源代码情景分析（上册）》
《莱昂氏UNIX源代码分析》《Linux内核设计与实现》 《Linux内核设计的艺术》《自己动手写嵌入式操作系统》
《自己动手写操作系统》 《Orange'S:一个操作系统的实现》
TCP/IP协议栈 《TCP/IP详解》
JVM(C/C++)、OpenJDK7or8：OpenJDK源码阅读导航:http://rednaxelafx./blog/1549577 《深入Java虚拟机(原书第2版)》
《Java Virtual Machine Specification》 《深入理解Java虚拟机》 ----14
GCC 《垃圾收集》 《An Introduction to GCC》
DB: MySQL （C/C++） MySQL JDBC Driver (mysql-connector-java-5.1.13) 《MySQL技术内幕》, PostgreSQL代码结构清晰
Nginx 《实战Nginx》《深入理解Nginx:模块开发与架构解析》 --- 14
LVS:
Apache（C++） 《Apache源代码全景分析第1卷》《Apache Server源代码分析》
Android
1.2 Java/C#:
JDK类库（尤其util(concurrent)包集合容器等） --- 14
Eclipse
OSGI
Servlet规范
JSP规范
Spring 《Spring揭秘》《Spring技术内幕—深入解析Spring架构与设计原理》
Struct2,JDBC连接池,Ibatis
Tomcat 《深入剖析Tomcat》《How Tomcat Works》
消息中间件:ActiveMQ
Hadoop 《Hadoop实战》
1.3 Other:
PHP
Python
Linux工具集/Shell/Perl
Erlang编译器
ruby
人机交互、函数式语言、并发语言、逻辑语言
2、中小型产品：
2.1 C/C++/Object-C:
STL 《C++标准程序库》《标准模板库自修教程与参考手册(STL进行C++编程第2版)》《Effective STL中文版》《STL源码剖析》
《泛型编程与STL》《C++ Templates》
Boost 《超越C++标准库:Boost库导论》 《Boost程序库完全开发指南》
ACE 《C++网络编程（卷1）》《C++网络编程（卷2）》《ACE技术内幕》 libevent
Cache : Redis、 Memcached
安全: OpenSSL
2.2 Java/C#:
Netty(I/O)
Jetty
JDBC
Hibernate
Ibatis iBATIS框架源码剖析 《iBatis in Action》《iBATIS框架源码剖析》
Struts(MVC)： 《Struts 2实战》
WebWork
Velocity1.6
cache:OSCache
2.3 Other:
C#/Flex客户端
JQuery(JS) 《jQuery基础教程》
Python 《Python源码剖析》
3、小型产品:
3.1 C/C++/Object-C:
接入、分发、ptypes
3.2 Java/C#:
log4j
httpclient
JUnit4
MegaClient/MegaServer
数据库连接池:
3.3 Other:
V8 Node
四、参考
[1] 摘自代码阅读方法与实践书籍的知识点总结
[2] 如何阅读linux源代码
[3] 如何阅读源代码（1）
[4] 如何阅读源代码Linux开发者：http://wenku.baidu.com/view/56270184b9d528ea81c77968.html
|
