2.3.1 解释器

　　使用解释器的计算机语言就像一个环境。解释器给出提示符后，你输入一个命 令，解释器就会执行这个命令。对于更复杂的程序，可以把命令写入一个文件然后 让解释器装入这个文件再执行其中的命令。如果有错误发生，许多解释器会进入一个 调试环境让你来追踪问题。

　　这种方式的优点就是可以马上看见命令的执行结果，并且迅速的改正错误。如 果你想和别人分享自己的程序，最大的坏处就显现出来了。别人需要和你一样的解释 器，或者你必须把解释器给他们，而且他们还要知道怎么使用这个解释器。用户也不 希望在按错一个键的情况下就被扔到调试环境中。从程序执行效率来看，解释器会 使用很多内存，而且通常情况下生成的代码也不如编译器生成的有效率。

　　我觉得，如果你从未编过程序，最好从解释类语言开始。Lisp，Smalltalk， Perl 和 Basic 语言就提供了这样的环境。UNIX 中的 shell (sh, csh) 自身就是一个解释器。实际情 况中，很多人都在他们自己的机器上写 shell “scripts” 来做很多 “维护”工作。的确，UNIX 的哲学中有一部分就是提供很多小工具， 并使用 shell scripts 把这些工具组合起来去做有用的工作。

2.3.2 FreeBSD 提供的解释器

　　在 FreeBSD Ports Collection 中，有一个列表列出了提供的解释器。同时还简 单讨论了一些更受欢迎的解释类语言。

　　从 Ports Collection 中如何取得并安装应用程序的教程可以从手册的 Ports section 中找到。

2.3.3 编译器

　　编译器则非常不同。首先，代码可以使用编辑器写到一个或多个文件里面。然 后再使用编译器来编译代码，看这些代码是否能被接受。如果编译不能通过，咬紧牙 关您再打开编辑器重新修改吧；如果编译通过，并且编译器给了你一个程序。您可以 在命令行下执行或者到调试环境中执行以便查看代码有没有被正确执行。 [1]

　　很明显，这种方式并不如解释器直接。但却可以让你做很多解释类语言无法做 的困难的甚至无法完成的工作。例如直接与操作系统交互──或者，你甚至可以 写自己的操作系统。如果你要写非常有效率的代码，编译器也很有用。编译器可以花 一些时间来优化代码，而解释器是无法完成的。另外，分享你写的编译类程序比解释 类语言要直接得多。只要把编译好的程序给别人就行，当然我们假定别人和你都有同 一类操作系统。

　　编译类语言包括 Pascal，C 和 C++。C 和 C++ 很严格，适合那些有更多经验 的程序员；而 Pascal，从另一方面来说，被设计成为一个教学语言，适合初学者。 FreeBSD 在基本系统中没有提供 Pascal。但是在 Ports 套件中提供了 Free Pascal Compiler， 可以从 lang/fpc 安装它。

　　如果你使用不同的程序来写编译类语言，编辑-编译-运行-调试 这个循环会变 得很烦人。很多商业编译器开发了 Integrated Development Environments (缩写为 IDE)。FreeBSD 在基本系统中没有包含 IDE，但是在 devel/kdevelop 提供了一个例子。你也可 以使用 Emacs 当作 IDE。把 Emacs 当作 IDE 在 第 2.7 节 中有讨 论。

2.4.1 常见 cc 问题

/var/tmp/cc0143941.o: Undefined symbol `_sin' referenced from text segment
         

% cc -o foobar foobar.c -lm
         

#include <stdio.h>

int main() {
    float f;

    f = pow(2.1, 6);
    printf("2.1 ^ 6 = %f\n", f);
    return 0;
}
         

% cc temp.c -lm
         

% ./a.out
2.1 ^ 6 = 1023.000000
         

#include <math.h>
#include <stdio.h>

int main() {
...
         

% ./a.out
2.1 ^ 6 = 85.766121
         

% cc -o foobar foobar.c
         

bin:/usr/bin:/usr/local/bin:.
         

% ./test
         

% ps
       

% kill -ABRT pid
       

2.5.1 什么是 make？

　　当你写一个简单的程序，只有一到两个源文件的时候，输入

% cc file1.c file2.c

　　就没什么问题，但如果有很多源文件就会很烦人──编译的时间也会很长。

　　一个方法就是使用目标文件，只在源文件有改变的情况下才重新编译源文件。 因此你可以这样做：

% cc file1.o file2.o ... file37.c ...

　　上次编译后，file37.c 发生了改变，但其他文 件没有。这样做可以让编译过程快很多，但是也不能解决累人的输入问题。

　　或者我们可以使用一个 shell script 来解决输入问题，但是也需要重新编译 所有文件，在大型项目上很没有效率。

　　如果有成百上千的源文件的话怎么办？如果我们在与很多人合作写程序，别人 对源文件进行了修改，又没有告诉你，该怎么办？

　　也许我们可以把以上两种方法结合，写一种像 shell script 一样的东西。这 种文件包含某种技巧可以决定什么时候该对源文件进行编译。现在所有我们要的就是 一个程序可以懂得这种技巧，因为要懂得这种技巧，shell 还没那么大的能耐。

　　这个程序就叫 make。它读入一个文件，叫 makefile，这个文件决定了源文件之间的依赖关系。而且 决定了源文件什么时候该编译什么时候不应该编译。例如，某个规则可以说 “ 如果 fromboz.o 比 fromboz.c 要旧， 意思就是有人修改了 fromboz.c，因此我们需要重新编译这 个文件。”这个 makefile 还有规则通知 make 该 怎么 重新编译源文件，因此 make 是一个强大得多的工具。

　　makefile 通常和相关的源文件保存在同一个目录下，可以叫做 makefile，Makefile 或者 MAKEFILE。大多数程序员会使用 Makefile 这个名字，因为这样可以让这个文件被放在目录列 表的顶端，可以很容易得看见。 [6]

2.5.2 使用 make 的例子

　　这是一个非常简单的 make 文件：

foo: foo.c
    cc -o foo foo.c

　　包含两行，一行是依赖关系，一行是执行动作。

　　依赖关系的那一行包含了程序的名字 (叫做 target)，紧跟着一个冒号，然后是空格，最后是源文件的 名字。当 make读入这一行的时候，会检查 foo 是否存在；如果存在，就比较 foo 和 foo.c 最后的修改时间有什 么不同。如果 foo 不存在，或者比 foo.c 要旧，就检查执行动作那一行看看该怎么做。换句话 说，就是 foo.c 需要重新编译的时候该怎么办。

　　执行动作那一行以一个 tab (按下 tab) 开始，然后是你在命令行下产生 foo 所执行的命令。如果 foo 过期了，或者不存在，make 就会 执行这个命令来产生 foo。换句话说，这就是重新编译 foo.c 的规则。

　　因此，当你输入 make 时，它会确定 foo 和 foo.c 在修改时间上是否同 步。这个原则可以在 Makefile 里扩展到成百上千的目标文 件上──实际上，在 FreeBSD 里，你只要在合适的目录下输入 make world 就可以编译整个操作系统！

　　makefile 另一个有用的特点就是目标文件不一定就是程序。例如，我们可以 有这样的 make 文件。

foo: foo.c
    cc -o foo foo.c

install:
    cp foo /home/me

　　我们可以输入如下的命令告诉 make 该执行哪个目标：

% make target

　　make 会只执行这个目标而忽略其他的目标。例如，如果 我们输入 make foo，就只有 foo 被执行，必要的情况下重新编译 foo 而不会继续执行 install 这个目标。

　　如果我们只是输入 make 这个命令，make 总会寻找 第一个目标，并且在执行完以后就不管其他的目标了。例如，如果我们输入 make foo，make 就会转到 foo 这个目标，在必要的情况下重新编译 foo，而不会执行 install 目标， 然后就停止了。

　　一定要注意，install 这个目标不依赖任何其他 的东西！这意味着我们一旦输入 make install，这个目标 下的所有命令都将被执行。这种情况下，foo 将被安装到用 户的家目录下。应用程序的 makefile 正是这样写的，以便程序在正确编译后可以被 安装到正确的目录。

　　要尝试解释的话会比较容易让人混淆。如果你不太懂 make 是如何工作的，最好的办法就是先写一个简单的程序例如 “hello world” 以及和上面的例子相同的 make 文件再去实验。然后 再进一步，使用多个源文件，或者让你的源文件包含一个头文件。 touch 命令在这里就非常有用了──它能让在不改变文件内 容的情况下改变文件的日期。

2.5.3 Make 和 include-文件

　　C 源码的开头经常有一系列被包含的头文件，例如 stdio.h。有一些是系统级的 头文件，有一些是你正在写的项目的头文件：

#include <stdio.h>
#include "foo.h"

int main(....

　　要确定在你的 foo.h 被改变之后，这个文件也会被重 新编译，就要在你的 Makefile 这样写：

foo: foo.c foo.h

　　当你的项目变得越来越大，你自己的头文件越来越多的时候，要追踪所有这些 头文件和所有依赖它的文件会是一件痛苦的事情。如果你改变了其中一个头文件，却 忘了重新编译所有依赖它的源文件，结果会是很失望的。gcc 有一个选项可以分析你的源文件然后产生一个头文件的列表和它的依赖关系： -MM。

　　如果你把下面的内容加到你的 Makefile 里面：

depend:
    gcc -E -MM *.c > .depend

　　然后运行 make depend，就会产生一个 .depend，里面包含了目标文件，C 文件和头文件的列表：

foo.o: foo.c foo.h

　　如果你改变了 foo.h，下一次运行 make 的时候，所有依赖 foo.h 的文件 就会被重新编译。

　　每一次你增加一个头文件的时候，别忘了运行一次 make depend。

2.5.4 FreeBSD 的 Makefile 文件

　　写 Makefile 文件可以是很难的一件事情。幸运的是，像 FreeBSD 这样基于 BSD 的系统，系统本身就自带了一些非常强大的 Makefile 文件。一个很好的例子就 是 FreeBSD 的 ports 系统。这里列出了一个典型的 ports 的 Makefile 的重要部分：

MASTER_SITES=   ftp://freefall.cdrom.com/pub/FreeBSD/LOCAL_PORTS/
DISTFILES=      scheme-microcode+dist-7.3-freebsd.tgz

.include <bsd.port.mk>

　　现在，如果我们进入这个 port 的目录然后输入 make，就有如下的步骤发生：

　　现在我想你一定会同意，对于一个只有四行的脚本，这让人印象非常深刻！

　　秘密就在最后一行，这一行告诉 make 去找系统级的 make 文件，叫做 bsd.port.mk。要忽略这一行很简单，但是 就是这一行做了所有聪明的工作──有人已经写好了一个 make 文件，让 make 去做刚才提到的步骤 (加上一些我没提到的，包括对可能 的错误的处理)。而且任何人都可以在自己的 make 文件中简单的加上一行命令来使 用这个文件！

　　如果你想看看这些系统级的 make 文件，可以到 /usr/share/mk 里面找找。不过最好等到你对 make 文件有 了一点点感性的经验以后再去看。因为这些文件都非常复杂(而且如果你在看的时 候，最好准备一大杯浓浓的绿茶！)。

2.5.5 更多 make 的高级用法

　　Make 是一个非常强大的工具，甚至还可以做比以上提到 的更复杂的工作。不幸的是，make 有不同的版本，各个版本之 间差别还很大。学习使用这个命令的最好的方法可能就是阅读文档──希望这一 章能够给你的学习打一个基础。

　　FreeBSD 自带的 make 叫做 Berkeley make； /usr/share/doc/psd/12.make 是一个教程。要看这个教程， 在那个目录中执行

% zmore paper.ascii.gz

　　 Ports 中的很多应用程序使用 GNU make，它 包含一个非常棒的 “info” 页面的集合。如果你安装了任何一个这样 的 port，GNU make 就会自动被安装为 gmake 命令。当然你也可以用正常的 port 或 package 的方式 来安装。

　　要查看 GNU make 的 info 页面，你必须编辑 /usr/local/info 路径下的 dir 文 件，在其中添加一个条目。需要添加的内容可以是这样

 * Make: (make).                 The GNU Make utility.

　　一旦你完成编辑，就可以输入命令 info 然后从菜 单中选择 make (或者在 Emacs 中，输入 C-h i)。

2.6.1 调试器

　　FreeBSD 自带的调试器叫 gdb (GNU debugger)。要运行，输入

% gdb progname

　　然而大多数人喜欢在 Emacs 中运行这个命令。 可以这样来起动这个命令：

M-x gdb RET progname RET

　　调试器能让你在一个可控制的环境中运行一个程序。例如，你可以一次运行程 序的一行代码，检查变量的值，改变这些值，或者让程序运行到某个定点然后停止等 等。你甚至可以调试内核，当然这样会比我们将要讨论的问题要多一点点技巧。

　　gdb 有非常棒的在线帮助，还有同样棒的 info 页面。 因此这一章我们会把注意力集中到一些基本的命令上。

　　最后，如果你不习惯这个命令的命令行界面，在 Ports 中还有一个它的图形 前端 (devel/xxgdb)。

　　这一章准备只介绍 gdb 的使用方法，而不会牵涉到特殊 的问题比如调试内核。

2.6.2 在调试器中运行一个程序

　　要最大限度的利用 gdb，需要使用 -g 这个选项来编译你的程序。如果你没有这样做，那么你只会看 到你正在调试的函数名字，而不是它的源代码。如果 gdb起动 时提示：

... (no debugging symbols found) ...

　　你就知道你的程序在编译的时候没有使用 -g 选项。

　　当 gdb 给出提示符，输入 break main。 这就是告诉调试器你对正在运行的程序中预先设置的代码没有兴趣， 并且调试器应该停在你的代码的开头。然后输入 run 来开始你的程序──这会从 预先设置的代码开始然后在调试器调用 main() 的时候就停 下来。(如果你曾迷惑 main() 是在哪里被调用的，现在应该 明白了吧！)

　　现在你可以一步一步来检查你的程序，按下 n一次就查 一行。一旦你碰见了一个函数调用，可以输入 f 从函数调用中 退出来。你可以输入 up 或 down 来快速 检查这个调用。

　　这里列出了一个简单的例子。展示了怎样用 gdb 定位一个错 误。这是我们的程序(其中有一个明显的错误)：

#include <stdio.h>

int bazz(int anint);

main() {
    int i;

    printf("This is my program\n");
    bazz(i);
    return 0;
}

int bazz(int anint) {
    printf("You gave me %d\n", anint);
    return anint;
}

　　这个程序给 i 赋值 5 并把它传递给 一个函数 bazz()，这个函数将打印出我们给出的数值。

　　我们现在编译并运行这个程序，我们会得到

% cc -g -o temp temp.c
% ./temp
This is my program
anint = 4231

　　但这并不是我们想要的！应该看看到底发生了什么！

% gdb temp
GDB is free software and you are welcome to distribute copies of it
 under certain conditions; type "show copying" to see the conditions.
There is absolutely no warranty for GDB; type "show warranty" for details.
GDB 4.13 (i386-unknown-freebsd), Copyright 1994 Free Software Foundation, Inc.
(gdb) break main               Skip the set-up code
Breakpoint 1 at 0x160f: file temp.c, line 9.    gdb puts breakpoint at main()
(gdb) run                   Run as far as main()
Starting program: /home/james/tmp/temp      Program starts running

Breakpoint 1, main () at temp.c:9       gdb stops at main()
(gdb) n                       Go to next line
This is my program              Program prints out
(gdb) s                       step into bazz()
bazz (anint=4231) at temp.c:17          gdb displays stack frame
(gdb)

　　停住！怎么 anint 会是 4231？难道 我们没有在函数 main() 中设定为 5 吗？现在我们转到 main() 来看看。

(gdb) up                   Move up call stack
#1  0x1625 in main () at temp.c:11      gdb displays stack frame
(gdb) p i                   Show us the value of i
$1 = 4231                   gdb displays 4231

　　哦，天哪！看看这代码，我们忘了初始化 i 了。本来我们 是想的

...
main() {
    int i;

    i = 5;
    printf("This is my program\n");
...

　　但是我们忘了 i=5; 这一行。因为我们没有初始化 i，这个变量在程序运行的时候就储存了偶然在那块内存中存在的 任意值。

2.6.3 检查 core 文件

　　基本上 core 文件就是一个包含了程序崩溃时这个进程的所有信息的文件。在那 “遥远的黄金年代”，程序员不得不把 core 文件以十六进制的方式显示 出来，然后满头大汗的阅读机器码的手册，但是现在事情就简单得多了。顺便说一下， 在 FreeBSD 和其他的 4.4BSD 系统下，core 文件都叫作 progname.core 而不是简单叫 core，这样可以很清楚的表示出这个 core 文件是属于哪个 程序。

　　要检查一个 core 文件，以通常的方式起动 gdb。不要 输入 break 或者 run，而要输入

(gdb) core progname.core

　　如果你没有和 core 文件在同一个目录，首先要执行 dir /path/to/core/file。

　　你应该可以看见：

% gdb a.out
GDB is free software and you are welcome to distribute copies of it
 under certain conditions; type "show copying" to see the conditions.
There is absolutely no warranty for GDB; type "show warranty" for details.
GDB 4.13 (i386-unknown-freebsd), Copyright 1994 Free Software Foundation, Inc.
(gdb) core a.out.core
Core was generated by `a.out'.
Program terminated with signal 11, Segmentation fault.
Cannot access memory at address 0x7020796d.
#0  0x164a in bazz (anint=0x5) at temp.c:17
(gdb)

　　这种情况下，运行的程序叫 a.out，因此 core 文件 就叫 a.out.core。我们知道程序崩溃的原因就是函数 bazz 试图访问一块不属于它的内存。

　　有时候，能知道一个函数是怎么被调用的是非常有用处的。因为在一个复杂的 程序里面问题可能会发生在函数调用栈上面很远的地方。命令 bt 会让 gdb 输出函数调用栈的回溯追踪。

(gdb) bt
#0  0x164a in bazz (anint=0x5) at temp.c:17
#1  0xefbfd888 in end ()
#2  0x162c in main () at temp.c:11
(gdb)

　　函数 end() 在一个程序崩溃的时候将被调用；在本例 中，函数 bazz() 是从 main() 中被 调用的。

2.6.4 粘付到一个正在运行的程序

　　gdb 一个最精致的特性就是它能粘付到一个已经在运行 的程序上。当然，我们得首先假定你有足够的权限这样去做。一个常见的问题就是， 当我们在追踪一个包含子进程的程序时，如果你要追踪子进程，但是调试器只允许你 追踪父进程。

　　你要做的就是起动另一个 gdb，然后用 ps 找出子进程的进程号。然后在 gdb中执行

(gdb) attach pid

　　就可以像平时一样调试了。

　　“这很好，”你可能在想，“当我这样做了以后，子进程就 会不见了”。别怕，亲爱的读者，我们可以这样来做(参照 gdb 的 info 页)

...
if ((pid = fork()) < 0)      /* _Always_ check this */
    error();
else if (pid == 0) {        /* child */
    int PauseMode = 1;

    while (PauseMode)
        sleep(10);  /* Wait until someone attaches to us */
    ...
} else {            /* parent */
    ...

　　现在所有你要做的就是粘付到子进程，设置 PauseMode 为 0，然后等待函数 sleep 返回！

2.7.1 Emacs

　　很不幸，UNIX 系统不像其他的系统那样带有一种“你要的全有，不要的更多”的，包含所有 的，巨大的程序开发环境。 [7] 但是，你可以搭建一个自己的开发环境。可能不会很漂亮，也不会非常集成化。但 是你可以按自己的需求来搭建。而且是免费的。你将拥有所有的源码。

　　问题的答案就是 Emacs。如今有很多人厌恶它，也有很多喜欢它。如果你是前 者之一，恐怕这一章不会引起你的兴趣。而且，你需要一定量的内存来运行 Emacs──文字界面我推荐 8MB，而在 X 下最少需要 16MB 来获得合理的性能。

　　Emacs 基本上是一个高度可配置的编辑器──实际上，Emacs 更像一个操 作系统而不像一个编辑器！很多开发人员和系统管理员把所有的时间都花在 Emacs 里面，只在退出登陆的时候才退出这个编辑器。

　　要在这里概括所有 Emacs 能做的事情是不可能的，但是这里列出了一些开发人员可能感 兴趣的特性：

• 非常强大的编辑器，允许对字串和正则表达式(类型)进行搜索和替代。跳 至块结构的开始/末尾，等等。

• 下拉菜单和在线帮助。

• 语言相关的语法高亮显示和缩进。

• 完全可配置。

• 你可以在 Emacs 中编译和调试程序。

• 出现编译错误以后，你可以直接跳至出问题的那一行代码。

• 比较友好的 info 的前端，可以阅读 GNU 超文本文 档。当然包括 Emacs 自己的文档。

• 友好的 gdb 的前端，允许你在追踪程序的时候查看 源代码。

• 你可以在编译程序的同时查看 Usenet 新闻和阅读邮件。

　　毫无疑问还有很多被我忽略的。

　　在 FreeBSD 上可以用 editors/emacs port 来安装 Emacs。

　　一旦安装好了，就可以运行 Emacs，然后输入 C-h t 阅读 Emacs 教程──意思就是说按住 control，再按 h，松开 control，然后再按 t。(或者，你可以使用鼠 标从 Help 菜单重选择 Emacs Tutorial)。

　　尽管 Emacs 有菜单，最好还是学习一下键组合。因为在你编辑的时候，连续 地按下一系列按键，比找到鼠标然后点击正确的地方要快得多。而且，当你和一个老 Emacs 用户交流的时候，你经常会碰到下列的表达 “M-x replace-s RET foo RET bar RET”，因此知道这些东西会很有用。而且在任 何情况下，Emacs 的菜单里永远放不下所有它实际上拥有的有用的功能。

　　幸运的是，很容易学习键组合。因为菜单每个项目的后面都标示了对应的键组 合。我的建议就是，首先使用菜单项，比如，打开一个文件，直到你明白了其中的奥 妙，并且可以自信的使用这个菜单项，再尝试使用 C-x C-f。当你一点困难也没有的 时候，就可以转到下一个菜单项继续练习。

　　如果记不住一个特殊的键组合到底能做什么，可以从 Help 菜单中选择 Describe Key ，然后输入这个键组合──Emacs 会告诉你它到底能干什么。你也可以点击 Command Apropos来寻找包含一个特定词的命令， 后面紧跟的就是键组合。

　　另外，刚才那个表达式的意思就是按住 Meta 键，按下 x 键，松开 Meta 键，输入 replace-s (replace-string的简写 ──Emacs 另一个特性就是命令的缩写)，按下 return键，输 入 foo(你要替换的字串)，输入 bar (你要用来替换 foo 的字串) 然后再次按下 return 键。 Emacs 就会按你的要求进行搜索和替换操作。

　　你一定在疑惑 Meta 键是个什么键。这是一个很多 UNIX 工作站都有的特殊的键。很不幸，PC没有这样一个键。通常在 PC 上这个键是 alt 键(如果你运气不好，这个键在你的 PC 上会是 escape 键)。

　　哦，要退出 Emacs，键入 C-x C-c (意思就是按住 control 键，按下 x，按下 c，再松开 control 键)。如果你还有已经打 开的未保存的文件，Emacs 会问你是否要保存文件。(不要理会文档中说的退出 Emacs 的常用方法 C-z──这个键组合会把 Emacs 放到后 台，而且这个方法只在没有虚拟控制台的系统上有用)。

2.7.2 配置 Emacs

　　Emacs 能做很多有用的事情；一些是内置的，另外一些需要我们进行配置。

　　Emacs 没有用一种私有的宏语言来配置自身，而是使用了某种特别适应编辑器 的 Lisp 版本，叫做 Emacs Lisp。如果你要继续读下去并且想学习一点 Common Lisp，学习使用 Emacs Lisp 是很有用的。Emacs Lisp 有很多 Common Lisp 的特性， 虽然前者相当小 (因此更容易掌握)。

　　学习 Emacs Lisp 最好的方法就是下载 Emacs Tutorial。

　　但是，要配置 Emacs 并不需要任何实际的 Lisp 知识，因为我已经列出了一 个 .emacs 例子，足够让你顺利的开始工作。只要把这个文 件复制到你的家目录，如果 Emacs 已经在运行，就重新起动；Emacs 会从这个文件 中读取命令，然后(希望)能给你一个有用的基本设置。

2.7.3 一个 .emacs 配置文件的例子

　　不幸的是，要详细解释的话话就长了；但是还是有一两点值得注意。

• 以 ; 开头的是注释，会被 Emacs 忽略掉。

• 第一行里面的 -*- Emacs-Lisp -*- 能 让我们在 Emacs 里面编辑这个 .emacs，并且打开所 有 Emacs Lisp 的编辑特性。Emacs 一般会尝试根据文件名来猜测，而且很有可 能猜错。

• 在某些模式下，tab 键被绑定到一个缩进函数上。因 此按下 tab 键后，它能缩进一行代码。如果你想把 tab 当作 一个字符插入到你编辑的东西里面，需要在按下 tab 键的时 同时按住 control 键。

• 这个文件通过识别文件名后缀来支持 C，C++，Perl，Lisp 和 Scheme 的语法高亮。

• Emacs 已经有一个预先定义的函数叫 next-error。 在一个编译错误输出窗口，按下 M-n 能让从一个编译错误 移动到另一个；我们还定义了一个类似的函数， previous-error，这个函数在你按下 M-p 后，能让你回到上一个编译错误。其中最好的特性就是按 下 C-c C-c 后，能根据错误打开相应的文件并且跳到相应 的那行代码。

• 我们打开了 Emacs 作为 服务端运行的特性，这样当你在 Emacs 外做一 些事情的时候，又需要编辑一个文件的时候，只需要输入

  % emacsclient filename
       
  

  然后就可以在 Emacs 编辑那个文件了！ [8]

;; -*-Emacs-Lisp-*-

;; This file is designed to be re-evaled; use the variable first-time
;; to avoid any problems with this.
(defvar first-time t
  "Flag signifying this is the first time that .emacs has been evaled")

;; Meta
(global-set-key "\M- " 'set-mark-command)
(global-set-key "\M-\C-h" 'backward-kill-word)
(global-set-key "\M-\C-r" 'query-replace)
(global-set-key "\M-r" 'replace-string)
(global-set-key "\M-g" 'goto-line)
(global-set-key "\M-h" 'help-command)

;; Function keys
(global-set-key [f1] 'manual-entry)
(global-set-key [f2] 'info)
(global-set-key [f3] 'repeat-complex-command)
(global-set-key [f4] 'advertised-undo)
(global-set-key [f5] 'eval-current-buffer)
(global-set-key [f6] 'buffer-menu)
(global-set-key [f7] 'other-window)
(global-set-key [f8] 'find-file)
(global-set-key [f9] 'save-buffer)
(global-set-key [f10] 'next-error)
(global-set-key [f11] 'compile)
(global-set-key [f12] 'grep)
(global-set-key [C-f1] 'compile)
(global-set-key [C-f2] 'grep)
(global-set-key [C-f3] 'next-error)
(global-set-key [C-f4] 'previous-error)
(global-set-key [C-f5] 'display-faces)
(global-set-key [C-f8] 'dired)
(global-set-key [C-f10] 'kill-compilation)

;; Keypad bindings
(global-set-key [up] "\C-p")
(global-set-key [down] "\C-n")
(global-set-key [left] "\C-b")
(global-set-key [right] "\C-f")
(global-set-key [home] "\C-a")
(global-set-key [end] "\C-e")
(global-set-key [prior] "\M-v")
(global-set-key [next] "\C-v")
(global-set-key [C-up] "\M-\C-b")
(global-set-key [C-down] "\M-\C-f")
(global-set-key [C-left] "\M-b")
(global-set-key [C-right] "\M-f")
(global-set-key [C-home] "\M-<")
(global-set-key [C-end] "\M->")
(global-set-key [C-prior] "\M-<")
(global-set-key [C-next] "\M->")

;; Mouse
(global-set-key [mouse-3] 'imenu)

;; Misc
(global-set-key [C-tab] "\C-q\t")   ; Control tab quotes a tab.
(setq backup-by-copying-when-mismatch t)

;; Treat 'y' or <CR> as yes, 'n' as no.
(fset 'yes-or-no-p 'y-or-n-p)
(define-key query-replace-map [return] 'act)
(define-key query-replace-map [?\C-m] 'act)

;; Load packages
(require 'desktop)
(require 'tar-mode)

;; Pretty diff mode
(autoload 'ediff-buffers "ediff" "Intelligent Emacs interface to diff" t)
(autoload 'ediff-files "ediff" "Intelligent Emacs interface to diff" t)
(autoload 'ediff-files-remote "ediff"
  "Intelligent Emacs interface to diff")

(if first-time
    (setq auto-mode-alist
      (append '(("\\.cpp$" . c++-mode)
            ("\\.hpp$" . c++-mode)
            ("\\.lsp$" . lisp-mode)
            ("\\.scm$" . scheme-mode)
            ("\\.pl$" . perl-mode)
            ) auto-mode-alist)))

;; Auto font lock mode
(defvar font-lock-auto-mode-list
  (list 'c-mode 'c++-mode 'c++-c-mode 'emacs-lisp-mode 'lisp-mode 'perl-mode 'scheme-mode)
  "List of modes to always start in font-lock-mode")

(defvar font-lock-mode-keyword-alist
  '((c++-c-mode . c-font-lock-keywords)
    (perl-mode . perl-font-lock-keywords))
  "Associations between modes and keywords")

(defun font-lock-auto-mode-select ()
  "Automatically select font-lock-mode if the current major mode is in font-lock-auto-mode-list"
  (if (memq major-mode font-lock-auto-mode-list)
      (progn
    (font-lock-mode t))
    )
  )

(global-set-key [M-f1] 'font-lock-fontify-buffer)

;; New dabbrev stuff
;(require 'new-dabbrev)
(setq dabbrev-always-check-other-buffers t)
(setq dabbrev-abbrev-char-regexp "\\sw\\|\\s_")
(add-hook 'emacs-lisp-mode-hook
      '(lambda ()
         (set (make-local-variable 'dabbrev-case-fold-search) nil)
         (set (make-local-variable 'dabbrev-case-replace) nil)))
(add-hook 'c-mode-hook
      '(lambda ()
         (set (make-local-variable 'dabbrev-case-fold-search) nil)
         (set (make-local-variable 'dabbrev-case-replace) nil)))
(add-hook 'text-mode-hook
      '(lambda ()
         (set (make-local-variable 'dabbrev-case-fold-search) t)
         (set (make-local-variable 'dabbrev-case-replace) t)))

;; C++ and C mode...
(defun my-c++-mode-hook ()
  (setq tab-width 4)
  (define-key c++-mode-map "\C-m" 'reindent-then-newline-and-indent)
  (define-key c++-mode-map "\C-ce" 'c-comment-edit)
  (setq c++-auto-hungry-initial-state 'none)
  (setq c++-delete-function 'backward-delete-char)
  (setq c++-tab-always-indent t)
  (setq c-indent-level 4)
  (setq c-continued-statement-offset 4)
  (setq c++-empty-arglist-indent 4))

(defun my-c-mode-hook ()
  (setq tab-width 4)
  (define-key c-mode-map "\C-m" 'reindent-then-newline-and-indent)
  (define-key c-mode-map "\C-ce" 'c-comment-edit)
  (setq c-auto-hungry-initial-state 'none)
  (setq c-delete-function 'backward-delete-char)
  (setq c-tab-always-indent t)
;; BSD-ish indentation style
  (setq c-indent-level 4)
  (setq c-continued-statement-offset 4)
  (setq c-brace-offset -4)
  (setq c-argdecl-indent 0)
  (setq c-label-offset -4))

;; Perl mode
(defun my-perl-mode-hook ()
  (setq tab-width 4)
  (define-key c++-mode-map "\C-m" 'reindent-then-newline-and-indent)
  (setq perl-indent-level 4)
  (setq perl-continued-statement-offset 4))

;; Scheme mode...
(defun my-scheme-mode-hook ()
  (define-key scheme-mode-map "\C-m" 'reindent-then-newline-and-indent))

;; Emacs-Lisp mode...
(defun my-lisp-mode-hook ()
  (define-key lisp-mode-map "\C-m" 'reindent-then-newline-and-indent)
  (define-key lisp-mode-map "\C-i" 'lisp-indent-line)
  (define-key lisp-mode-map "\C-j" 'eval-print-last-sexp))

;; Add all of the hooks...
(add-hook 'c++-mode-hook 'my-c++-mode-hook)
(add-hook 'c-mode-hook 'my-c-mode-hook)
(add-hook 'scheme-mode-hook 'my-scheme-mode-hook)
(add-hook 'emacs-lisp-mode-hook 'my-lisp-mode-hook)
(add-hook 'lisp-mode-hook 'my-lisp-mode-hook)
(add-hook 'perl-mode-hook 'my-perl-mode-hook)

;; Complement to next-error
(defun previous-error (n)
  "Visit previous compilation error message and corresponding source code."
  (interactive "p")
  (next-error (- n)))

;; Misc...
(transient-mark-mode 1)
(setq mark-even-if-inactive t)
(setq visible-bell nil)
(setq next-line-add-newlines nil)
(setq compile-command "make")
(setq suggest-key-bindings nil)
(put 'eval-expression 'disabled nil)
(put 'narrow-to-region 'disabled nil)
(put 'set-goal-column 'disabled nil)
(if (>= emacs-major-version 21)
    (setq show-trailing-whitespace t))

;; Elisp archive searching
(autoload 'format-lisp-code-directory "lispdir" nil t)
(autoload 'lisp-dir-apropos "lispdir" nil t)
(autoload 'lisp-dir-retrieve "lispdir" nil t)
(autoload 'lisp-dir-verify "lispdir" nil t)

;; Font lock mode
(defun my-make-face (face color &optional bold)
  "Create a face from a color and optionally make it bold"
  (make-face face)
  (copy-face 'default face)
  (set-face-foreground face color)
  (if bold (make-face-bold face))
  )

(if (eq window-system 'x)
    (progn
      (my-make-face 'blue "blue")
      (my-make-face 'red "red")
      (my-make-face 'green "dark green")
      (setq font-lock-comment-face 'blue)
      (setq font-lock-string-face 'bold)
      (setq font-lock-type-face 'bold)
      (setq font-lock-keyword-face 'bold)
      (setq font-lock-function-name-face 'red)
      (setq font-lock-doc-string-face 'green)
      (add-hook 'find-file-hooks 'font-lock-auto-mode-select)

      (setq baud-rate 1000000)
      (global-set-key "\C-cmm" 'menu-bar-mode)
      (global-set-key "\C-cms" 'scroll-bar-mode)
      (global-set-key [backspace] 'backward-delete-char)
                    ;      (global-set-key [delete] 'delete-char)
      (standard-display-european t)
      (load-library "iso-transl")))

;; X11 or PC using direct screen writes
(if window-system
    (progn
      ;;      (global-set-key [M-f1] 'hilit-repaint-command)
      ;;      (global-set-key [M-f2] [?\C-u M-f1])
      (setq hilit-mode-enable-list
        '(not text-mode c-mode c++-mode emacs-lisp-mode lisp-mode
          scheme-mode)
        hilit-auto-highlight nil
        hilit-auto-rehighlight 'visible
        hilit-inhibit-hooks nil
        hilit-inhibit-rebinding t)
      (require 'hilit19)
      (require 'paren))
  (setq baud-rate 2400)         ; For slow serial connections
  )

;; TTY type terminal
(if (and (not window-system)
     (not (equal system-type 'ms-dos)))
    (progn
      (if first-time
      (progn
        (keyboard-translate ?\C-h ?\C-?)
        (keyboard-translate ?\C-? ?\C-h)))))

;; Under UNIX
(if (not (equal system-type 'ms-dos))
    (progn
      (if first-time
      (server-start))))

;; Add any face changes here
(add-hook 'term-setup-hook 'my-term-setup-hook)
(defun my-term-setup-hook ()
  (if (eq window-system 'pc)
      (progn
;;  (set-face-background 'default "red")
    )))

;; Restore the "desktop" - do this as late as possible
(if first-time
    (progn
      (desktop-load-default)
      (desktop-read)))

;; Indicate that this file has been read at least once
(setq first-time nil)

;; No need to debug anything now

(setq debug-on-error nil)

;; All done
(message "All done, %s%s" (user-login-name) ".")
   

2.7.4 扩展 Emacs 所支持语言的范围

　　现在，如果你只是想用 .emacs 设定好的语言 (C, C++, Perl, Lisp 和 Scheme) 来编程，事情就很好办。但是，如果突然一个新的语 言，叫 “whizbang”，有很多激动人心的特性，出来了，会发生什么事情？

　　第一件要做的事情就是找到是否有任何文件能够告诉 Emacs 关于这个语言的 信息。这种文件通常以 .el 结尾，是 “Emacs Lisp” 的缩写。例如，如果 whizbang 是 FreeBSD 的一个 port，那么我们 可以用如下命令来定位这些文件

% find /usr/ports/lang/whizbang -name "*.el" -print

　　然后安装这些文件到 Emacs 的系统级 Lisp 目录。在 FreeBSD 2.1.0-Release 里，这个目录就是 /usr/local/share/emacs/site-lisp。

　　例如，如果刚才的定位命令的输出是

/usr/ports/lang/whizbang/work/misc/whizbang.el

　　我们可以执行

# cp /usr/ports/lang/whizbang/work/misc/whizbang.el /usr/local/share/emacs/site-lisp

　　下一步，我们需要确定 whizbang 的源文件是以什么后缀结尾。我们假定这些 源文件都是以 .wiz 结尾。我们需要在 .emacs 加上一条使 Emacs 能够使用 whizbang.el 中的信息。

　　在 .emacs 中找到 auto-mode-alist entry，为 whizbang 添加一行，例如：

...
("\\.lsp$" . lisp-mode)
("\\.wiz$" . whizbang-mode)
("\\.scm$" . scheme-mode)
...

　　意思就是，当你编辑一个以 .wiz 结尾的文件的时候， Emacs 会自动进入 whizbang-mode。

　　就在下面，你会发现 font-lock-auto-mode-list 这一条。 添加 whizbang-mode

;; Auto font lock mode
(defvar font-lock-auto-mode-list
  (list 'c-mode 'c++-mode 'c++-c-mode 'emacs-lisp-mode 'whizbang-mode 'lisp-mode 'perl-mode 'scheme-mode)
  "List of modes to always start in font-lock-mode")

　　这意味着当你编辑 .wiz 文件的时候，Emacs 会自动 打开 font-lock-mode(就是语法高亮)。

　　这就是所有必要的步骤。如果在你打开一个 .wiz 文 件的时候，还有需要自动执行的任何其他步骤，你可以添加一个 whizbang-mode hook (查看 my-scheme-mode-hook 中添加 auto-indent 的步骤作为例子)。

3.3.1 缓冲区溢出示例

　　下面的示例代码包含了一个缓冲区溢出的情况，它会覆盖函数的返回地址并且 立即跳过了紧随此函数之后调用。(授权于5)

#include <stdio.h>

void manipulate(char *buffer) {
  char newbuffer[80];
  strcpy(newbuffer,buffer);
}

int main() {
  char ch,buffer[4096];
  int i=0;

  while ((buffer[i++] = getchar()) != '\n') {};
  
  i=1;
  manipulate(buffer);
  i=2;
  printf("The value of i is : %d\n",i);
  return 0;
}

　　让我们来查看一下如果在输入回车之前输入160个空格后这个小程序 的内存映象是个什么样子。

　　[XXX figure here!]

　　很明显更多的恶意输入能被设计出执行实际的编译指令(例如 exec(/bin/sh))。

3.3.2 避免缓冲区溢出

　　对于栈溢出的最直接的解决方法就是总是使用长度有限的内存和 字符串复制函数。strncpy和strncat 是C标准库的一部分。 这些函数接收一个不大于目标缓冲区长度的值作为参数。这些函数会从 源地址复制此值长的字节数到目标地址。然而这些函数还是有一些问题。 如果输入缓冲区的长度和目标缓冲区的一样长则函数不保证两者都以NUL 作为结束符。 长度参数在strncpy和strncat函数中同样的不一致很容易导致程序员在 正常使用时感到困惑。同时当复制一个较短的字符串到一个很大的缓冲 区中时相对于strcpy也有很重大的性能损失， 因为strncpy会用NUL填充所指定的长度。

　　在OpenBSD中，另一个内存复制的实现已经规避了这些问题。 函数strlcpy和strlcat 保证了当指定了非零的长度参数时目标字符串总是以NUL作为结束符。 关于这些函数的更多信息请参考7。OpenBSD 的strlcpy和strlcat 自从FreeBSD3.3的版本已经被引入了。

3.5.1 FreeBSD的jail功能

　　Jail的概念在chroot()之上作了延伸，它 靠限制超级用户的权力来创建了一个真正的"虚拟服务器"。一旦一个监 狱被设置好后整个网络必须通过特别的IP地址才能到达，在这里"超级用 户权限"的力量完全的受到限制。

　　当在jail中时，所有在内核中使用suser() 调用的超级用户权限的尝试都会失败。然而，一些对suser() 的调用已经被更改为新的接口suser_xxx() 。这个函数对认可或者拒绝被限制的进程去取得超级用户的权 限的行为负责。

　　一个在Jail环境中的超级用户进程有以下权力:

• 使用可信任的操作： setuid, seteuid, setgid, setegid, setgroups, setreuid, setregid, setlogin

• 使用setrlimit设置资源限制

• 编辑一些sysctl节点值 (kern.hostname)

• chroot()

• 在 vnode 上设置标志： chflags、 fchflags

• 设置 vnode 节点的属性， 如访问权限、 所有者、 所有组、 尺寸、 上次访问时间， 以及修改时间。

• 在互联网域上绑定特权端口 (端口号 < 1024)

　　Jail是一个对于在一个安全环境中 运行一个仍有一些缺点的程序非常有用的工具。目前，IPC机制还没有被 更改到suser_xxx以至于像MySQL之类的程序还不 能运行在jail中。在jail中超级用户的存取可能还有非常有限的含义， 但是没有途径能正确的指出"非常有限"意味着什么。

3.5.2 POSIX®.1e 处理能力

　　POSIX已经发布了一个工作草案，增加了事件审计，访问控制列表， 精细特权控制，信息标签和强制访问控制。

　　这是一个正在进展中的工作并且是 TrustedBSD项目的重点。一些初始化的工作已经被提交到 FreeBSD-CURRENT(cap_set_proc(3))。

4.1.1 整合I18N成果的号召

　　值得我们注意的是各个国家自己的I18N/L10N 的工作已经变成了重复彼此的工作。 我们中的许多人一直在做着重复的无效率的重复发明工作。 我们希望各个主要I18N的组织能聚集成一个大的组织担负起像 核心团队一样的责任。

　　当前，我们希望，当你在编写或者移植I18N程序时， 能够发布给各个国家相关的FreeBSD邮件列表作为测试。 将来，我们希望能生成可以直接使用各种语言的应用程序 而不是还要做一些混乱的破解。

　　FreeBSD 国际化邮件列表 已经建立。如果你是一个I18N/L10N的开发者， 请发送给我们任何你能想到的与之相关的说明，想法，问题等等。

4.1.2 Perl 和 Python

　　Perl和Python拥有I18N和处理宽字符的库。请使用他们来兼容I18N。

4.2.1 在编录文件 (Catalog Files) 中编排本地化消息

　　POSIX.1 NLS 是基于包含使用需要的编码编写的本地化消息所组成的编录文件工作的。 这些消息需要编写成以整数标识的集合。 习惯上， 编录文件应使用其编码命名， 并加上扩展名 .msg。 例如， 采用 ISO8859-2 编码的匈牙利文编录对应的文件名是 hu_HU.ISO8859-2。

　　这些编录文件都是带编号消息的普通文本文件。 如果希望在文件中添加注释， 可以在一行的开头加上 $ 作为标志。 每个集合的边界则是用特殊的注释加以区分， 这里使用的关键词 set 必须紧接注释符 $。 在关键词 set 之后则是集合的编号。 例如：

$set 1

　　接下来是消息项， 其内容是消息编号， 接着是本地化的消息内容。 在此处可以使用为人们所熟知的 printf(3) 格式串：

15 "File not found: %s\n"

　　语言编录文件必须首先编译成二进制格式才能为应用程序使用。 这个转换过程是通过 gencat(1) 工具来完成的。 它的第一个参数是输出的文件名， 随后的所有参数则都是作为输入的编录源文件。 是的， 本地化的消息也可以写到多个文件当中， 然后通过 gencat(1) 来汇集成一个文件。

4.2.2 在源代码中使用编录文件

　　使用编录文件比较简单， 要使用相关的函数， 需要引用头文件 nl_types.h。 在开始使用编录文件中的内容之前， 需要首先用 catopen(3) 打开它。 这个函数有两个参数。 第一个参数是安装好并事先编译过的编录的名字， 一般来说是应用程序的名字， 例如 grep。 系统会使用这个名字来查找事先编译的编录文件。 catopen(3) 函数会在 /usr/share/nls/locale/catname 以及 /usr/local/share/nls/locale/catname 中查找编录， 其中， locale 是 locale 的名字， 而 catname 则是前面调用时使用的编录名。 第二个参数是以下两者之一：

• NL_CAT_LOCALE， 表示使用 LC_MESSAGES 的设置来查找编录。

• 0， 表示使用 LANG 来查找编录。

　　catopen(3) 函数会返回类型为 nl_catd 的编录描述符。 请参见联机手册以了解发生错误时返回代码的含义。

　　打开编录文件之后， 可以用 catgets(3) 来提取消息。 它的第一个参数是由 catopen(3) 返回的编录描述符， 第二个是消息集合的编号， 第三个是消息的编号， 第四个是当无法从编录中获得消息时使用的替代消息。

　　用完编录文件之后， 应使用 catclose(3) 将其关闭。 这个函数的参数是编录描述符。

4.2.3 实例

　　下面的例子展示了如何以灵活的方式使用 NLS 编录。

　　下面几行是放在一个用于在所有需要本地化消息的源代码中的公共头文件中的内容：

#ifdef WITHOUT_NLS
#define getstr(n)    nlsstr[n]
#else
#include <nl_types.h>

extern nl_catd       catalog;
#define getstr(n)    catgets(catalog, 1, n, nlsstr[n])
#endif

extern char     *nlsstr[];

　　接下来， 把这几行放到主源文件中的全局声明部分：

#ifndef WITHOUT_NLS
#include <nl_types.h>
nl_catd  catalog;
#endif

/*
 * Default messages to use when NLS is disabled or no catalog
 * is found.
 */
char    *nlsstr[] = {
        "",
/* 1*/  "some random message",
/* 2*/  "some other message"
};

　　下面是实际的代码片段， 这里展示了如何打开， 读取和关闭编录：

#ifndef WITHOUT_NLS
    catalog = catopen("myapp", NL_CAT_LOCALE);
#endif

...

printf(getstr(1));

...

#ifndef WITHOUT_NLS
    catclose(catalog);
#endif

#include <err.h>
...
if (!S_ISDIR(st.st_mode))
    err(1, "argument is not a directory");
     

#include <err.h>
#include <errno.h>
...
if (!S_ISDIR(st.st_mode)) {
    errno = ENOTDIR;
    err(1, NULL);
}
     

#include <err.h>
...
if ((p = malloc(size)) == NULL)
    err(1, NULL);
     

4.2.4 使用 bsd.nls.mk

　　使用编录文件需要一些重复的步骤， 例如编译编录， 并将它们安装到合适的位置。 为了进一步简化这些工作， bsd.nls.mk 提供了一些宏。 一般而言， 并不需要显式地引入 bsd.nls.mk， 因为其他公共 Makefiles， 如 bsd.prog.mk 和 bsd.lib.mk 会直接将其包含进来。

　　通常， 只要定义 NLSNAME 和 NLS 就可以了， 前者内容是前面提到的 catopen(3) 第一个参数即编录本身的名字， 而后者则是不包含 .msg 后缀的编录源文件的名字。 下面是一个例子， 它允许使用 make(1) 变量 WITHOUT_NLS 来控制是否在联编程序时加入 NLS 支持。

.if !defined(WITHOUT_NLS)
NLS=    es_ES.ISO8859-1
NLS+=   hu_HU.ISO8859-2
NLS+=   pt_BR.ISO8859-1
.else
CFLAGS+=    -DWITHOUT_NLS
.endif

　　习惯上， 编录的源文件应放在程序源文件的 nls 子目录中， 这也是 bsd.nls.mk 的默认行为。 不过， 通过 make(1) 变量 NLSSRCDIR 可以改变默认的源文件目录。 预编译的编录文件名字默认也遵循前面的规范， 与此对应的 NLSNAME 变量则可以改变它。 还有一些其他微调编录文件处理方式的选项， 但通常并不需要调整那些配置， 此处不再赘述。 如欲了解进一步的详情， 请参阅 bsd.nls.mk 文件， 它很短并且很容易理解。

5.2.1 在 CVS 中的 Vendor 汇入过程

　　用于检查文件格式的 file 工具， 在这里将作为如何进行这些操作的范例：

　　src/contrib/file 目录中包含了由软件包作者发布的代码。 完全不适于 FreeBSD 的那些部分可以完全删去。 对于 file(1) 而言， 在导入之前就可以删去 python 目录， 以及包含 lt 前缀的文件， 等等。

　　src/lib/libmagic 包含了 bmake 风格的使用标准 bsd.lib.mk makefile 规则的 Makefile 来联编函数库， 并安装文档。

　　src/usr.bin/file 包含了 bmake 风格的使用标准 bsd.prog.mk 规则的 Makefile， 能够联编并安装 file 程序， 以及与之相关的联机手册。

　　这里比较重要的事情是， src/contrib/file 目录是按照一定的规则创建的： 其中包含的源代码与原作者发布的相同 (也就是说， 这些文件会放到 vendor 分支上， 并且不进行 RCS 关键字扩展)， 而只做尽可能少的专属于 FreeBSD 的改动。 如果对此有任何疑问， 则一定要先询问一下有经验的人， 而不要在对它能 “正常运转” 的期望中铸成大错。

　　由于前面提到的那些关于 vendor 分支设计的制约， 我们要求来自软件原作者的 “官方” 补丁， 必须首先打在其分发的源代码之上， 然后再将修改过的代码重新导入到 vendor 分支。 官方补丁在任何时候， 都不应直接应用于从 FreeBSD 源代码库检出的源代码， 并执行 “commit” 操作， 因为这会破坏 vendor 分支的一致性， 并且， 由于这样的操作会导致产生修改冲突， 会给未来导入新版时带来麻烦。

　　由于许多软件包可能会包含用于 FreeBSD 以外的体系结构和环境的文件， 我们允许在导入前从官方发行的代码中删去那些对 FreeBSD 无用的部分， 以期节省磁盘空间。 包含版权声明和发行说明， 以及其他类似的用于说明其他文件的文档， 则 不 应删除。

　　如果方便的话， 应尽可能使用使用某些工具生成的 bmake Makefile 文件， 这些工具可以使升级到未来的新版本时的工作变得简单。 如果您完成了这类工作， 请务必将这些工具 (如果需要的话) 放到 src/tools 目录中与您所移植的程序对应的目录中， 以便为将来的维护者所利用。

　　在 src/contrib/file 的顶级目录中， 应增加一个名为 FREEBSD-upgrade 的文件， 在其中说明一些类似下面的内容：

• 删去了哪些文件。

• 从何处可以获得原始的发行版本， 以及官方网站。

• 如果有补丁， 应如何反馈给原作者。

• 如果需要的话， 对专属于 FreeBSD 改动的概要说明。

　　下面是来自 src/contrib/groff/FREEBSD-upgrade 的例子：

$FreeBSD: src/contrib/groff/FREEBSD-upgrade,v 1.5.12.1 2005/11/15 22:06:18 ru Exp $

This directory contains virgin copies of the original distribution files
on a "vendor" branch.  Do not, under any circumstances, attempt to upgrade
the files in this directory via patches and a cvs commit.

To upgrade to a newer version of groff, when it is available:
    1. Unpack the new version into an empty directory.
       [Do not make ANY changes to the files.]

    2. Use the command:
        cvs import -m 'Virgin import of FSF groff v<version>' \
            src/contrib/groff FSF v<version>

       For example, to do the import of version 1.19.2, I typed:
        cvs import -m 'Virgin import of FSF groff v1.19.2' \
            src/contrib/groff FSF v1_19_2

    3. Follow the instructions printed out in step 2 to resolve any
       conflicts between local FreeBSD changes and the newer version.

Do not, under any circumstances, deviate from this procedure.

To make local changes to groff, simply patch and commit to the main
branch (aka HEAD).  Never make local changes on the FSF branch.

All local changes should be submitted to Werner Lemberg <wl@gnu.org> or 
Ted Harding <ted.harding@nessie.mcc.ac.uk> for inclusion in the next
vendor release.

ru@FreeBSD.org - 20 October 2005

　　还有另一种方法来列出需要排除在汇入过程之外的文件， 如果需要排除的文件很多或很复杂， 或者经常要汇入的话， 这种方法会更加实用。 通过在汇入源代码的 vendor 源代码目录中加入 FREEBSD-Xlist， 并在其中逐行列出需要排除的文件名模式， 未来的汇入过程， 便可以通过下列操作来完成：

% tar -X FREEBSD-Xlist -xzf vendor-source.tgz

　　下面的示范 FREEBSD-Xlist 文件来自 src/contrib/tcsh：

*/BUGS
*/config/a*
*/config/bs2000
*/config/bsd
*/config/bsdreno
*/config/[c-z]*
*/tests
*/win32

5.2.2 SVN 中的 Vendor 汇入过程

　　这一节介绍了在使用 Subversion 时汇入第三方软件的详细过程。

7.5.1 客户端-服务器差异

　　典型情况中，以套接字为基础的数据通信一端是一个 服务器，另一端是一个客户端。

int socket(int domain, int type, int protocol);

/*
 * 内核用来存储大多数种类地址的结构
 */
struct sockaddr {
    unsigned char   sa_len;     /* 总长度 */
    sa_family_t sa_family;  /* 地址族 */
    char        sa_data[14];    /* 地址值，实际可能更长 */
};
#define SOCK_MAXADDRLEN 255     /* 可能的最长的地址长度 */

/*
 * 地址族
 */
#define AF_UNSPEC       0               /* 未指定 */
#define AF_LOCAL        1               /* 本机 (管道，portal) */
#define AF_UNIX         AF_LOCAL        /* 为了向前兼容 */
#define AF_INET         2               /* 网间协议: UDP, TCP, 等等 */
#define AF_IMPLINK      3               /* arpanet imp 地址 */
#define AF_PUP          4               /* pup 协议: 例如BSP */
#define AF_CHAOS        5               /* MIT CHAOS 协议 */
#define AF_NS           6               /* 施乐(XEROX) NS 协议 */
#define AF_ISO          7               /* ISO 协议 */
#define AF_OSI          AF_ISO
#define AF_ECMA         8               /* 欧洲计算机制造商协会 */
#define AF_DATAKIT      9               /* datakit 协议 */
#define AF_CCITT        10              /* CCITT 协议, X.25 等 */
#define AF_SNA          11              /* IBM SNA */
#define AF_DECnet       12              /* DECnet */
#define AF_DLI          13              /* DEC 直接数据链路接口 */
#define AF_LAT          14              /* LAT */
#define AF_HYLINK       15              /* NSC Hyperchannel */
#define AF_APPLETALK    16              /* Apple Talk */
#define AF_ROUTE        17              /* 内部路由协议 */
#define AF_LINK         18              /* 协路层接口 */
#define pseudo_AF_XTP   19              /* eXpress Transfer Protocol (no AF) */
#define AF_COIP         20              /* 面向连接的IP, 又名 ST II */
#define AF_CNT          21              /* Computer Network Technology */
#define pseudo_AF_RTIP  22              /* 用于识别RTIP包 */
#define AF_IPX          23              /* Novell 网间协议 */
#define AF_SIP          24              /* Simple 网间协议 */
#define pseudo_AF_PIP   25              /* 用于识别PIP包 */
#define AF_ISDN         26              /* 综合业务数字网(Integrated Services Digital Network) */
#define AF_E164         AF_ISDN         /* CCITT E.164 推荐 */
#define pseudo_AF_KEY   27              /* 内部密钥管理功能 */
#define AF_INET6        28              /* IPv6 */
#define AF_NATM         29              /* 本征ATM访问 */
#define AF_ATM          30              /* ATM */
#define pseudo_AF_HDRCMPLT 31           /* 由BPF使用，就不必在接口输出例程
                                         * 中重写头文件了
                                         */
#define AF_NETGRAPH     32              /* Netgraph 套接字 */
#define AF_SLOW         33              /* 802.3ad 慢速协议 */
#define AF_SCLUSTER     34              /* Sitara 集群协议 */
#define AF_ARP          35
#define AF_BLUETOOTH    36              /* 蓝牙套接字 */
#define AF_MAX          37

/*
 * 套接字地址，Internet风格
 */
struct sockaddr_in {
    uint8_t     sin_len;
    sa_family_t sin_family;
    in_port_t   sin_port;
    struct  in_addr sin_addr;
    char    sin_zero[8];
};

/*
 * Internet 地址 (由历史原因而形成的结构)
 */
struct in_addr {
    in_addr_t s_addr;
};

   sa.sin_family      = AF_INET;
    sa.sin_port        = 13;
    sa.sin_addr.s_addr = (((((192 << 8) | 43) << 8) | 244) << 8) | 18;

   sa.sin_family      = AF_INET;
    sa.sin_port        = 13 << 8;
    sa.sin_addr.s_addr = (((((18 << 8) | 244) << 8) | 43) << 8) | 192;

int connect(int s, const struct sockaddr *name, socklen_t namelen);

/*
 * daytime.c
 *
 * G. Adam Stanislav 编程
 */
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main() {
  register int s;
  register int bytes;
  struct sockaddr_in sa;
  char buffer[BUFSIZ+1];

  if ((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
    perror("socket");
    return 1;
  }

  bzero(&sa, sizeof sa);

  sa.sin_family = AF_INET;
  sa.sin_port = htons(13);
  sa.sin_addr.s_addr = htonl((((((192 << 8) | 43) << 8) | 244) << 8) | 18);
  if (connect(s, (struct sockaddr *)&sa, sizeof sa) < 0) {
    perror("connect");
    close(s);
    return 2;
  }

  while ((bytes = read(s, buffer, BUFSIZ)) > 0)
    write(1, buffer, bytes);

  close(s);
  return 0;
}

% cc -O3 -o daytime daytime.c
% ./daytime

52079 01-06-19 02:29:25 50 0 1 543.9 UTC(NIST) * 
%

int bind(int s, const struct sockaddr *addr, socklen_t addrlen);

#define    INADDR_ANY      (u_int32_t)0x00000000

int listen(int s, int backlog);

int accept(int s, struct sockaddr *addr, socklen_t *addrlen);

/*
 * daytimed - 端口 13 的服务器
 *
 * G. Adam Stanislav 编程
 * 2001年6月19日
 */
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define BACKLOG 4

int main() {
    register int s, c;
    int b;
    struct sockaddr_in sa;
    time_t t;
    struct tm *tm;
    FILE *client;

    if ((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
        perror("socket");
        return 1;
    }

    bzero(&sa, sizeof sa);

    sa.sin_family = AF_INET;
    sa.sin_port   = htons(13);

    if (INADDR_ANY)
        sa.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(s, (struct sockaddr *)&sa, sizeof sa) < 0) {
        perror("bind");
        return 2;
    }

    switch (fork()) {
        case -1:
            perror("fork");
            return 3;
            break;
        default:
            close(s);
            return 0;
            break;
        case 0:
            break;
    }

    listen(s, BACKLOG);

    for (;;) {
        b = sizeof sa;

        if ((c = accept(s, (struct sockaddr *)&sa, &b)) < 0) {
            perror("daytimed accept");
            return 4;
        }

        if ((client = fdopen(c, "w")) == NULL) {
            perror("daytimed fdopen");
            return 5;
        }

        if ((t = time(NULL)) < 0) {
            perror("daytimed time");

            return 6;
        }

        tm = gmtime(&t);
        fprintf(client, "%.4i-%.2i-%.2iT%.2i:%.2i:%.2iZ\n",
            tm->tm_year + 1900,
            tm->tm_mon + 1,
            tm->tm_mday,
            tm->tm_hour,
            tm->tm_min,
            tm->tm_sec);

        fclose(client);
    }
}

    if (INADDR_ANY)
        sa.sin_addr.s_addr = htonl(INADDR_ANY);

% ./daytimed
bind: Permission denied
%

# ./daytimed
#

# ./daytimed

bind: Address already in use
#

% telnet localhost 13

Trying ::1...
telnet: connect to address ::1: Connection refused
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
2001-06-19T21:04:42Z
Connection closed by foreign host.
%

% who

whizkid          ttyp0   Jun 19 16:59   (216.127.220.143)
xxx              ttyp1   Jun 19 16:06   (xx.xx.xx.xx)
% telnet 216.127.220.143 13

Trying 216.127.220.143...
Connected to r47.bfm.org.
Escape character is '^]'.
2001-06-19T21:31:11Z
Connection closed by foreign host.
%

% telnet r47.bfm.org 13

Trying 216.127.220.143...
Connected to r47.bfm.org.
Escape character is '^]'.
2001-06-19T21:31:40Z
Connection closed by foreign host.
%

7.6.1 gethostbyname

　　域名是不能直接传送给任何套接字函数的， FreeBSD C 语言库携带了函数 gethostbyname(3)和gethostbyname2(3)， 声明在netdb.h中。

struct hostent * gethostbyname(const char *name);
struct hostent * gethostbyname2(const char *name, int af);

　　这两个函数都返回hostent结构指针， 内含有关域的许多信息。对于我们的情况，结构体中的域 h_addr_list[0]指向长度 h_length字节的地址， 也按网络字节顺序存储。

　　这允许我们建立一个要有弹性得多的──也要有用得多的 ──版本的daytime程序：

/*
 * daytime.c
 *
 * G. Adam Stanislav 编程
 * 2001年6月19日
 */
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>

int main(int argc, char *argv[]) {
  register int s;
  register int bytes;
  struct sockaddr_in sa;
  struct hostent *he;
  char buf[BUFSIZ+1];
  char *host;

  if ((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
    perror("socket");
    return 1;
  }

  bzero(&sa, sizeof sa);

  sa.sin_family = AF_INET;
  sa.sin_port = htons(13);

  host = (argc > 1) ? (char *)argv[1] : "time.nist.gov";

  if ((he = gethostbyname(host)) == NULL) {
    herror(host);
    return 2;
  }

  bcopy(he->h_addr_list[0],&sa.sin_addr, he->h_length);

  if (connect(s, (struct sockaddr *)&sa, sizeof sa) < 0) {
    perror("connect");
    return 3;
  }

  while ((bytes = read(s, buf, BUFSIZ)) > 0)
    write(1, buf, bytes);

  close(s);
  return 0;
}

　　现在我们可以在命令行打一个域名(或者一个IP地址， 两种方式都可以)，程序将尝试连接daytime服务器。 否则，将仍然缺省为time.nist.gov。然后， 即使在使用缺省值的情形中我们将使用gethostbyname 而不是硬性指定192.43.244.18。这样，即使将来 IP地址变更，我们也能找到。

　　由于从我们的本地计算机获取时间几乎不需要时间， 你可以一并运行daytime两次： 第一次从time.nist.gov取得时间， 第二次从你自己的系统取得时间。然后你可以比较结果， 看看你的系统时钟到底怎么样：

% daytime ; daytime localhost


52080 01-06-20 04:02:33 50 0 0 390.2 UTC(NIST) * 
2001-06-20T04:02:35Z
%

　　正如你看见的，我的系统比NIST时间快两秒钟。

7.6.2 getservbyname

　　有时你不能确定某种服务该用什么端口。 函数getservbyname(3)，也声明在 netdb.h中，此时就很上手：

struct servent * getservbyname(const char *name, const char *proto);

　　结构体servent包含 s_port，这是正确的端口号， 已经按照网络字节顺序存储。

　　假如我们不知道daytime服务的正确端口， 我们可以这样找到：

  struct servent *se;
  ...
  if ((se = getservbyname("daytime", "tcp")) == NULL {
    fprintf(stderr, "Cannot determine which port to use.\n");
    return 7;
  }
  sa.sin_port = se->s_port;

　　你通常知道端口。但是如何你正开发一个新协议， 你可能正在一个非正式端口上测试。 有一天，你要注册那个协议和端口 (如果不在别处，至少要在你的 /etc/services里，那是 getservbyname查找的地方)。 上面的代码就不再会返回错误，你就可以使用临时端口号。 一旦你已经将协议列入/etc/services， 你的软件不必重写代码也可以找到端口。

8.1.1 IPv6

   fe80:1::200:f8ff:fe01:6317
   

Internet6:
Destination                   Gateway                   Flags      Netif Expire
fe80:1::%ed0/64               link#1                    UC          ed0
fe80:2::%ep0/64               link#2                    UC          ep0

   accept_rtadv    转发        结点的角色
    ---     ---     ---
    0       0       主机 (待手工配置)
    0       1       路由器
    1       0       被自动配置的主机
                    (规格假定主机只有一个接口，
                    有多个接口的自动配置的主机
                    在作用域外)
    1       1       非法，或实验性的
                    (规格中的“作用域外”)

% ping6 -b 70000 -s 68000 ::1

% netstat -s -p ip6
      ip6:
        (略)
        1 with data size < data length

Mbuf statistics:
                317 one mbuf
                two or more mbuf::
                        lo0 = 8
            cce0 = 10
                3282 one ext mbuf
                0 two or more ext mbuf
   

                监听方                  初始化方
                (AF_INET6 通配套接字    (连接到 ::ffff:10.1.1.1)
                获得 IPv4 连接)
                ---                     ---
FreeBSD 4.x     可配置缺省：已被允许    已被支持
                
   

   int on;

    setsockopt(s, IPPROTO_IPV6, IPV6_BINDV6ONLY,
           (char *)&on, sizeof (on)) < 0));
   

   int on;

    setsockopt(s, IPPROTO_IPV6, IPV6_BINDV6ONLY,
           (char *)&on, sizeof (on)) < 0));
   

   struct sockaddr_storage {
        u_char  __ss_len;       /* 地址长度 */
        u_char  __ss_family;    /* 地址族 */
        /* 以及一些填充 */
    };
   

   struct sockaddr_storage {
        u_char  ss_len;         /* 地址长度 */
        u_char  ss_family;      /* 地址族 */
        /* 以及一些填充 */
    };
   

8.1.2 网络驱动程序

　　现在如下两项被要求由标准驱动程序支持：

1. mbuf聚集。在这个稳定发行版中， 我们为所有操作系统将MINCLSIZE改为MHLEN+1， 以便使所有驱动程序按照我们期望的那样工作。

2. 组播。如果ifmcstat(8)没有对一个接口产生组播群， 此接口就需要被打补丁。

　　如果驱动程序中的任何一个不支持这些要求， 那么驱动程序不能用于IPv6和/或IPsec通信。 如果你发觉你的使用IPv6/IPsec的网卡有问题，那么， 请报告给FreeBSD 问题报告邮件列表。

　　(注意：过去我们要求所有PCMCIA驱动程序有一个对in6_ifattach()的调用。 我们现在不再有那样的要求。)

8.1.3 翻译器

　　我们将IPv4/IPv6翻译器分为4类：

• 翻译器 A ── 被用于过度的早期阶段，使得从IPv6岛中的IPv6主机建立一个到 IPv4海中的IPv4主机成为可能。

• 翻译器 B ── 被用于过度的早期阶段，使得从IPv4海中的IPv4主机建立一个到 IPv6岛中的IPv6主机成为可能。

• 翻译器 C ── 被用于过度的晚期阶段，使得从IPv4岛中的IPv4主机建立一个到 IPv6海中的IPv6主机成为可能。

• 翻译器 D ── 被用于过度的晚期阶段，使得从IPv6海中的IPv6主机建立一个到 IPv4岛中的IPv4主机成为可能。

　　A类的TCP延时翻译器已被支持。 这被称为“FAITH”。我们也提供A类的IP头部翻译器。 (后者还没有被放入FreeBSD 4.x。)

   目的 IPv4 结点 (163.221.202.12)
      ^
      | IPv4 tcp toward 163.221.202.12
    FAITH-中转 双堆栈结点
      ^
      | IPv6 TCP toward 2001:0DB8:0200:ffff::163.221.202.12
    源 IPv6 结点
   

8.1.4 IPsec

　　IPsec主要按三个部分组织。

1. 策略管理

2. 钥匙管理

3. AH和ESP处理

                加封装                          去封装
                ---                             ---
RFC2401         把所有 TOS 位                   抛弃外部的 TOS 位
                从内部复制到外部                (原样的使用内部 TOS 位)

ECN 被禁用      除 ECN (掩码 0xfc) 外将         抛弃外部的 TOS 位
                TOS 位从内部复制到外部。        (原样的使用内部 TOS 位)
                设置 ECN 位为 0 。

ECN 被允许      除 ECN CE (掩码 0xfe) 外将      使用内部 TOS 位，有一些改变。
                TOS 位从内部复制到外部。        如果外部 ECN CE 位是1，
                设置 ECN CE 位为 0 。           则在内部使能 ECN CE 位。

   

10.1.1 配置内核转存设备

　　只有在配置内核转存设备之后， 内核才会向其写入崩溃时内存中的数据。 dumpon(8) 命令告诉内核在何处保存崩溃的内核。 dumpon(8) 只能在已经通过 swapon(8) 配置好的交换分区上使用。 通常， 只需在 rc.conf(5) 中把 dumpdev 变量设为交换分区的设备路径既可 (推荐用这种方法提取内核转存数据)； 另外， 也可以将其设置为 AUTO 表示使用第一个交换设备。 从 FreeBSD 6.0 开始， AUTO 成为了系统默认的配置。

10.1.2 提取内核转存数据

　　一旦内核转存到转存设备之后， 就需要在下次交换设备挂载之前， 将其提取并保存到文件中。 要从转存设备中提取内核转存数据， 就需要使用 savecore(8) 程序。 如果在 rc.conf(5) 中配置了 dumpdev， 则崩溃之后的首次多用户方式启动过程中， 在配置交换区设备之前便会自动执行 savecore(8)。 提取出来的内核数据将存放在 rc.conf(5) 变量 dumpdir 所指定的位置， 其默认值为 /var/crash， 而保存的文件名则是 vmcore.0。

　　若 /var/crash 目录下 (或 dumpdev设置的其它目录)， 已存在了名为 vmcore.0 的文件， 则每次保存内核转存数据时， 其末尾的数字会顺次递增 (例如 vmcore.1) 以避免覆盖之前存档的转存数据。 所以， 调试内核时， /var/crash 目录下序号最大的 vmcore 通常就是希望找的那个 vmcore。

11.2.1 汇编器

　　汇编语言编程最重要的工具是汇编器， 它将汇编语言代码转换成机器语言。

　　在 FreeBSD 中有两个完全不同的汇编器。 一个是 as(1), 使用传统的UNIX汇编语法， 它是随系统发布的。

　　另外一个是 /usr/ports/devel/nasm。 它使用 Intel 的语法规范， 其最大的好处是可以在许多操作系统上汇编代码。 它需要你单独安装， 不过它是完全免费的。

　　本章节使用 nasm 的语法规范， 这是因为许多从其他操作系统移植到 FreeBSD 的汇编语言可以更好地被理解。 不过， 坦白地说， 这是因为我更习惯这样的语法规范。

11.2.2 连接器

　　像任何编译器一样， 汇编器的输出需要被连接后才能成为可执行文件。

　　标准的连接器 ld(1) 随 FreeBSD 发布。 它可以和以上任何一个汇编器一起完成代码组装。

11.3.1 默认的调用规范

　　通常， FreeBSD 的内核使用 C 语言的调用规范。 此外， 虽然我们使用 int 80h 来访问内核， 但是我们常常通过调用一个函数来执行 int 80h， 而不是直接访问。

　　这个规范是非常方便的， 比 Microsoft 的 MS-DOS 上使用的规范更加优越。 为什么呢？ 因为 UNIX 的规范允许任何语言所写的程序访问内核。

　　汇编语言也可以这样做， 比如， 我们可以编写一个文件：

kernel:
    int 80h ; Call kernel
    ret

open:
    push    dword mode
    push    dword flags
    push    dword path
    mov eax, 5
    call    kernel
    add esp, byte 12
    ret

　　这是一种非常清晰而易于移植的编码方法。 如果你需要将代码移植到一个使用和 FreeBSD 完全不同中断或参数传递方式的 UNIX 系统， 那么你所需要做的仅仅是改变那一段内核程序。

　　但是汇编程序员喜欢使用一些技巧来削减程序执行所需的时钟周期数。 以上的例子需要一个 call/ret 组合， 我们可以通过压栈 push 一个额外的双字节来去除它。

open:
    push    dword mode
    push    dword flags
    push    dword path
    mov eax, 5
    push    eax     ; Or any other dword
    int 80h
    add esp, byte 16

　　在上一个 open 的例子中， 我们放在 EAX 中的数字 5 表示了一个内核函数。

11.3.2 另一种调用规范

　　 FreeBSD 是一个非常灵活的系统。 它提供了访问内核的其他方式。 但是， 如果你要用到它， 你的系统必须安装 Linux emulation。

　　 Linux 是一个类 UNIX 操作系统。 但是， 它的内核在传递参数的时候， 使用和 MS-DOS 相同系统调用规范。 比如在 UNIX 的规范中， 代表内核函数的数字存放在 EAX 中。 但是在 Linux 中， 参数不进行压栈而是存放在 EBX, ECX, EDX, ESI, EDI, EBP：

open:
    mov eax, 5
    mov ebx, path
    mov ecx, flags
    mov edx, mode
    int 80h

　　这种做法与 UNIX 的常规做法相比有一个严重的缺点， 至少现在汇编语言程序需要注意的： 每次进行系统调用， 你必须对寄存器的值进行压栈和出栈操作， 这让你的程序变得冗长而效率低下。 因此， FreeBSD 提供给你了一个其他的选择。

　　如果你确实选择了 Linux 的规范， 你必要让你的系统知道这一点。 在你的程序完成汇编和连接之后， 你需要对可执行文件进行标识：

% brandelf -t Linux filename

11.3.3 你该选择哪个规范？

　　如果你专门为 FreeBSD 写代码， 你必须使用 UNIX 的规范： 因为它快速， 你可以在寄存器中存取全局变量， 而且不需要进行可执行的标识， 更不需要在你的系统上安装 Linux emulation。

　　如果你想做一些可以在 Linux 上运行的程序， 并且你打算尽可能地给 FreeBSD 用户提供最有效率地程序。 我将在我讲解完汇编基础之后， 告诉你怎样完成这样地程序。

11.3.4 系统调用号

　　要通知内核你调用了什么系统服务， 将代表调用的数字放入 EAX 中。 当然， 你需要知道那些系统调用号代表了什么。

0  STD NOHIDE  { int nosys(void); } syscall nosys_args int
1   STD NOHIDE  { void exit(int rval); } exit rexit_args void
2   STD POSIX   { int fork(void); }
3   STD POSIX   { ssize_t read(int fd, void *buf, size_t nbyte); }
4   STD POSIX   { ssize_t write(int fd, const void *buf, size_t nbyte); }
5   STD POSIX   { int open(char *path, int flags, int mode); }
6   STD POSIX   { int close(int fd); }
etc...

11.4.1 联机手册

　　传统情况下，寻找 UNIX 下不同系统调用的地方是手册页。 FreeBSD 会在手册页的第2节描述系统调用，有的时候会在第三节。

　　例如， open(2) 所描述的:

如果执行成功， open() 将返回一个表示文件描述符的非负整数。 如果执行失败， 它会返回 -1 并且设置 errno 来标识错误。

　　刚刚接触 UNIX 和 FreeBSD的汇编程序员或许会马上提出一个难题： 那些 errno 在哪里？我怎么才能找得到它们？

11.4.2 返回值在哪里？

　　很不幸， 它有依赖性。。。 大部分系统调用都使用 EAX 但不是所有的系统调用都会这样。 不过当第一次使用系统调用的时候，直接在 EAX 检查返回值是个不错的查找方法。 如果它不在那里， 你再需要深入调查。

11.4.3 哪里可以找到 errno?

　　实际上，没什么地方。。。

　　errno 不属于 UNIX 内核， 而是 C 语言中的一部分。 当直接访问内核服务的时候， 错误代码返回到 EAX 中，也就是那个通常用来保存返回值得寄存器。

　　这个处理方式非常有意义。 如果这里没有错误， 这里就没有错误代码。 如果这里有错误，这里就没有返回值。 使用一个寄存器可以涵盖以上任意一种情况。

11.4.4 判断错误的出现

　　当使用标准的 FreeBSD 调用规范时，标志位 carry flag 在程序运行成功时被清零，在失败时被置位。

　　当使用 Linux emulation 模式的时候， EAX 中的有符号数反映了执行结果。 当为非负数时，表示执行成功， 并包含了返回值。 如果失败， 返回值即为负数， 如 -errno。

11.5.1 功能号的处理

　　许多情况下， 两个平台下的功能号是相同的。 当然， 即使它们不一样的时候， 问题也一样容易解决。 方法很简单，就是在代码中用常量替代数字， 这样你可以根据不同的系统结构进行不同的声明：

%ifdef LINUX
%define SYS_execve  11
%else
%define SYS_execve  59
%endif

11.5.2 编程规范的处理

　　调用规范和返回值（ errno 相关的问题） 可以通过使用宏一起得到解决：

%ifdef LINUX

%macro  system  0
    call    kernel
%endmacro

align 4
kernel:
    push    ebx
    push    ecx
    push    edx
    push    esi
    push    edi
    push    ebp

    mov ebx, [esp+32]
    mov ecx, [esp+36]
    mov edx, [esp+40]
    mov esi, [esp+44]
    mov ebp, [esp+48]
    int 80h

    pop ebp
    pop edi
    pop esi
    pop edx
    pop ecx
    pop ebx

    or  eax, eax
    js  .errno
    clc
    ret

.errno:
    neg eax
    stc
    ret

%else

%macro  system  0
    int 80h
%endmacro

%endif

11.5.3 与移植相关的其他问题处理

　　以上的方法可以解决 FreeBSD 和 Linux 之间的代码移植过程。 尽管如此， 一些内核服务之间的差异还是很大。

　　如果那样的话， 你需要针对那些特殊的调用编写代码， 并且使用针对环境的条件汇编。 不过， 幸运的是， 你的代码所进行地大部分工作不是在调用内核， 所以通常情况下， 你只需要在你的代码中增加一些针对环境的条件片段就可以了。

11.5.4 使用函数库

　　你可以通过为系统调用编写函数库来完全避免你主程序中的移植性问题。 所以，为 FreeBSD 建议一个独立的函数库吧， 为 Linux 建立另外的一个， 再为其他的操作系统建立这样的函数库。

　　在你的函数库中，为每一个系统调用编写独立的函数。 （ 如果你习惯于传统的汇编语言术语，我们也可以称之为程序） 使用 C 语言传递参数的方式，但是依然使用 EAX 来传递功能号。 如果那样， 你的 FreeBSD 函数库将非常简单， 因为许多看似不同的函数， 实际上都只是同一段代码的不同标签：

sys.open:
sys.close:
[etc...]
    int 80h
    ret

　　你的 Linux 函数库需要更多彼此不同的函数。 然而， 尽管如此， 仍可以将系统调用按其参数的个数进行分组：

sys.exit:
sys.close:
[etc... one-parameter functions]
    push    ebx
    mov ebx, [esp+12]
    int 80h
    pop ebx
    jmp sys.return

...

sys.return:
    or  eax, eax
    js  sys.err
    clc
    ret

sys.err:
    neg eax
    stc
    ret

　　使用函数库的方法起初会看起来很不方便，因为它需要你去建立一个你的程序所依赖的独立的文件。 但是它又有很多优点：首先， 你只需要编写一次， 就可以在你所有的程序中使用。 甚至你可以让其他的汇编程序员或者其他程序使用。 不过， 使用函数库的最大的好处在于： 仅仅需要增加一个新的函数库， 你的程序就可以被任何人移植到其他系统上了。

　　如果你对使用函数库没有任何概念， 你至少可以将你所有的系统调用放置在一个独立的汇编语言文件中， 然后将它和你的主程序连接。这里，再次强调， 所有的移植程序的程序员所做的，就是建立一个新的对象文件， 然后连接到你的主程序中。

11.5.5 使用头文件

　　如果你发布的软件中包含代码， 你可以在你包含代码的地方使用宏， 将它们放置在一个独立的文件中。

　　移植你的软件的人只需要简单地写一个头文件， 不需要外部的对象文件。 你的程序将不加修改地被移植。

　　我们从声明标准文件描述符开始，编写我们的 system.inc ：

%define    stdin   0
%define stdout  1
%define stderr  2

　　接下来，为每个系统调用指定符号名：

%define    SYS_nosys   0
%define SYS_exit    1
%define SYS_fork    2
%define SYS_read    3
%define SYS_write   4
; [etc...]

　　接下来增加一个短小的非全局子程序， 并给它其一个够长的名字， 以避免我们不慎在代码中使用同样的名字。

section    .text
align 4
access.the.bsd.kernel:
    int 80h
    ret

　　我们建立了一个带有一个参数的宏， 其系统调用号为：

%macro system  1
    mov eax, %1
    call    access.the.bsd.kernel
%endmacro

　　最后， 我们为每一个系统调用建立了一个宏。 这些宏不带有任何参数。

%macro sys.exit    0
    system  SYS_exit
%endmacro

%macro  sys.fork    0
    system  SYS_fork
%endmacro

%macro  sys.read    0
    system  SYS_read
%endmacro

%macro  sys.write   0
    system  SYS_write
%endmacro

; [etc...]

　　继续， 把它添加到你的编辑器中， 然后把它保存为 system.inc 。 我们将随着讨论得深入，将更多的系统调用添加进来。

11.6.1 汇编你的代码

　　在编辑器里输入这些代码 （不包括那些行号）， 然后保存为名叫 hello.asm 的文件。 现在你需要做的是使用 nasm 对代码进行汇编。

% su
Password:your root password
# cd /usr/ports/devel/nasm
# make install
# exit
%

% nasm -f elf hello.asm
% ld -s -o hello hello.o
% ./hello
Hello, World!
%

11.8.1 如何将字符放回输入流

　　尽管我们的示范程序并不需要它， 但更复杂一些的过滤器可能会用到。 换言之， 这些过滤器可能需要知道下一个字符 (甚至接下来的几个字符) 是什么。 如果下一个字符是某个特定的值， 则它是当前短语 (token) 的一部分， 反之则可能不是。

　　例如， 您可能正对输入流进行语义串的词法分析 (例如， 实现某种语言的编译器)： 如果一个字符跟着另一个字符或数字， 则后面这个字符是正在处理的短语的一部分。 如果这个字符后面是空格， 或某个其它的值， 则它就不是当前短语的一部分了。

　　这带来了一个很有意思的问题： 如何将接下来的这个字符送回输入流， 使之能够在稍后被重新读取？

　　一种可行的方法是将其保存到一个字符变量中， 并设置一个标志。 我们可以修改 getchar 使之检查这一标志， 如果这个标志被置位， 则从变量而非输入缓冲区中获取字符， 并复位标志。 不过， 很显然， 这会拖慢我们的脚步。

　　C 语言中有一个 ungetc() 函数， 它正是用于实现这个目的的。 那么， 有没有办法在我们的代码中迅速实现这一函数呢？ 在阅读下一节之前， 希望您能回到前面， 并查看 getchar 过程， 并思考您是否能找到一个漂亮且快捷的解决方案。 接着回到这里来看看我的解法。

　　将字符放回流的关键是， 如何获取开始的字符：

　　首先， 我们会通过检查 EBX 的值来检测输入缓冲区是否为空。 如果它是零， 则调用 read 过程。

　　如果有可用的字符， 则使用 lodsb， 接着对 EBX 的值做递减。 lodsb 指令实际上相当于：

   mov al, [esi]
    inc esi

　　我们拿到的这个字节会保留在缓冲区中， 直到下次调用 read 为止。 尽管我们不知道这会在何时发生， 但我们知道它不会在下次 getchar 之前。 因此， 要将读取的最后一个字节 “还给” 流， 我们需要做的就是将 ESI 的值递减， 并使 EBX 的值递增：

ungetc:
    dec esi
    inc ebx
    ret

　　但是， 一定要小心！ 如果我们每次只向前读取一个字符的话， 这样做没有任何问题。 但是如果我们会读取多个字符， 并多次调用 ungetc 的话， 有时就会出问题了 (而且会很难调试)。 为什么呢？

　　这是因为 getchar 并不必然调用 read， 所有预先读入的字符仍会出于缓冲区， 而我们的 ungetc 也会毫无问题地运行。 但是如果 getchar 调用了 read， 则缓冲区的内容就会随之变化。

　　我们可以认为 ungetc 一定能在使用 getchar 读入的最后一个字符上正确工作， 但在这之前的则没有任何保证。

　　如果您的程序需要一次读取多个字节， 则有两个选择：

　　如果可能的话， 修改程序使其一次只向前读最多一个字符。 这是最简单的办法。

　　如果没办法这样做， 首先要确定程序最多会向流交还多少各字符。 保险起见， 适当地增大这个数字， 最好是 16 的整数倍 ── 使其能够对齐。 接着， 修改您的代码中的 .bss 节， 并在输入缓冲区之前建立一个小的 “预留” 缓冲， 类似下面这样：

section    .bss
    resb    16  ; or whatever the value you came up with
ibuffer resb    BUFSIZE
obuffer resb    BUFSIZE

　　您还需要修改 ungetc 以便将还回的字符放入 AL：

ungetc:
    dec esi
    inc ebx
    mov [esi], al
    ret

　　经过这样的修改， 您就可以安全地调用最多 17 次 ungetc 了 (第一次调用仍会使用输入缓冲， 而余下的 16 次则有可能在输入缓冲， 也可能在 “预留缓冲” 中)。

11.10.1 如何找到环境变量

　　我曾经说过，当一个程序开始执行的时候, 堆栈包含了参数 argc 并且在 argc 之后包含了 argv 数组， 或者其他的一些东西。这些所谓的其他的东西，是所 环境 或者更确切的说是以 NULL 结尾的指向 环境变量 的指针数组。 这通常称作 env。

　　env 和 argv 的结构是相同的， 以 NULL ( 0 )结尾的一系列的内存地址。 在这种情况下，不存在 "envc" ── 我们将通过查找最后的 NULL 来定位数组的结尾。

　　变量常常以 name=value 的形式表现， 但是有的时候 =value 的部分会遗失。 我们需要考虑到这样的情况发生的可能性。

11.10.2 webvars

　　我可以给你展示一些如 UNIX env 命令一样输出环境变量的代码。 但是我想通过写一个简单的汇编 CGI 程序来说明， 将更有意义。

;;;;;;; webvars.asm ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Copyright (c) 2000 G. Adam Stanislav
; All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions
; are met:
; 1. Redistributions of source code must retain the above copyright
;    notice, this list of conditions and the following disclaimer.
; 2. Redistributions in binary form must reproduce the above copyright
;    notice, this list of conditions and the following disclaimer in the
;    documentation and/or other materials provided with the distribution.
;
; THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
; ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
; FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
; OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
; HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
; LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
; OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
; SUCH DAMAGE.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Version 1.0
;
; Started:   8-Dec-2000
; Updated:   8-Dec-2000
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%include    'system.inc'

section .data
http    db  'Content-type: text/html', 0Ah, 0Ah
    db  '<?xml version="1.0" encoding="UTF-8"?>', 0Ah
    db  '<!DOCTYPE html PUBLIC "-//W3C/DTD XHTML Strict//EN" '
    db  '"DTD/xhtml1-strict.dtd">', 0Ah
    db  '<html xmlns="http://www.w3.org/1999/xhtml" '
    db  'xml.lang="en" lang="en">', 0Ah
    db  '<head>', 0Ah
    db  '<title>Web Environment</title>', 0Ah
    db  '<meta name="author" content="G. Adam Stanislav" />', 0Ah
    db  '</head>', 0Ah, 0Ah
    db  '<body bgcolor="#ffffff" text="#000000" link="#0000ff" '
    db  'vlink="#840084" alink="#0000ff">', 0Ah
    db  '<div class="webvars">', 0Ah
    db  '<h1>Web Environment</h1>', 0Ah
    db  '<p>The following <b>environment variables</b> are defined '
    db  'on this web server:</p>', 0Ah, 0Ah
    db  '<table align="center" width="80" border="0" cellpadding="10" '
    db  'cellspacing="0" class="webvars">', 0Ah
httplen equ $-http
left    db  '<tr>', 0Ah
    db  '<td class="name"><tt>'
leftlen equ $-left
middle  db  '</tt></td>', 0Ah
    db  '<td class="value"><tt><b>'
midlen  equ $-middle
undef   db  '<i>(undefined)</i>'
undeflen    equ $-undef
right   db  '</b></tt></td>', 0Ah
    db  '</tr>', 0Ah
rightlen    equ $-right
wrap    db  '</table>', 0Ah
    db  '</div>', 0Ah
    db  '</body>', 0Ah
    db  '</html>', 0Ah, 0Ah
wraplen equ $-wrap

section .text
global  _start
_start:
    ; First, send out all the http and xhtml stuff that is
    ; needed before we start showing the environment
    push    dword httplen
    push    dword http
    push    dword stdout
    sys.write

    ; Now find how far on the stack the environment pointers
    ; are. We have 12 bytes we have pushed before "argc"
    mov eax, [esp+12]

    ; We need to remove the following from the stack:
    ;
    ;   The 12 bytes we pushed for sys.write
    ;   The  4 bytes of argc
    ;   The EAX*4 bytes of argv
    ;   The  4 bytes of the NULL after argv
    ;
    ; Total:
    ;   20 + eax * 4
    ;
    ; Because stack grows down, we need to ADD that many bytes
    ; to ESP.
    lea esp, [esp+20+eax*4]
    cld     ; This should already be the case, but let's be sure.

    ; Loop through the environment, printing it out
.loop:
    pop edi
    or  edi, edi    ; Done yet?
    je  near .wrap

    ; Print the left part of HTML
    push    dword leftlen
    push    dword left
    push    dword stdout
    sys.write

    ; It may be tempting to search for the '=' in the env string next.
    ; But it is possible there is no '=', so we search for the
    ; terminating NUL first.
    mov esi, edi    ; Save start of string
    sub ecx, ecx
    not ecx     ; ECX = FFFFFFFF
    sub eax, eax
repne   scasb
    not ecx     ; ECX = string length + 1
    mov ebx, ecx    ; Save it in EBX

    ; Now is the time to find '='
    mov edi, esi    ; Start of string
    mov al, '='
repne   scasb
    not ecx
    add ecx, ebx    ; Length of name

    push    ecx
    push    esi
    push    dword stdout
    sys.write

    ; Print the middle part of HTML table code
    push    dword midlen
    push    dword middle
    push    dword stdout
    sys.write

    ; Find the length of the value
    not ecx
    lea ebx, [ebx+ecx-1]

    ; Print "undefined" if 0
    or  ebx, ebx
    jne .value

    mov ebx, undeflen
    mov edi, undef

.value:
    push    ebx
    push    edi
    push    dword stdout
    sys.write

    ; Print the right part of the table row
    push    dword rightlen
    push    dword right
    push    dword stdout
    sys.write

    ; Get rid of the 60 bytes we have pushed
    add esp, byte 60

    ; Get the next variable
    jmp .loop

.wrap:
    ; Print the rest of HTML
    push    dword wraplen
    push    dword wrap
    push    dword stdout
    sys.write

    ; Return success
    push    dword 0
    sys.exit

% nasm -f elf webvars.asm
% ld -s -o webvars webvars.o

11.11.1 有限状态自动机

　　这些问题可以很容易地通过一种名为 有限状态自动机 的技术来解决， 这种技术先前是由设计数字电路的人们发明的。 有限状态自动机 是一种其输出不仅取决于输入， 并且还取决于之前的输入， 也就是其状态的数字电路。 微处理器便是一种 有限状态自动机 的例子： 我们使用的汇编语言代码， 有些会对应于单字节的机器指令， 而另一些则对应于多字节机器指令。 微处理器会从内存中逐个字节地抓取指令， 而在这个过程中， 有些只是简单地改变处理器状态， 而并不产生个输出。 当完成了整个机器指令的抓取之后， 微处理器才会产生输出， 或改变寄存器的值， 等等。

　　正因为如此， 所有的软件， 对微处理器而言， 其实都是一系列的状态指令。 因而， 有限状态自动机 的概念对于软件设计而言也很有用。

　　我们将文本文件转换成许设计为一个包含三个状态的 有限状态自动机。 我们可以把这三个状态称作状态 0-2， 不过为了明确起见， 将它们符号化为：

• ordinary

• cr

• lf

　　我们的程序开始时处于 ordinary 状态。 在这个状态中， 程序的动作取决于其输入：

• 如果输入是除了回车符和换行符之外的任何其他字符， 则这输入会直接送到输出， 同时程序状态保持不变。

• 如果输入是回车符， 则程序状态变为 cr。 而输入则被丢弃， 也就是说不输入任何东西。

• 如果输入是换行符， 则程序状态变为 lf。 同时丢弃输入内容。

　　如够程序进入了 cr 状态， 说明之前的输出是回车符， 并且还没有进行处理。 这种情况下的输出仍然取决于当前的输入：

• 如果输入是任何回车或换行符之外的其它字符， 则首先输出一个换行符， 然后输出输入内容， 并将程序状态变为 ordinary。

• 如果输入是回车符， 说明我们收到了在同一行中的两个 (或更多) 换行符。 此时应丢弃输入， 并输出一个换行符， 同时保持状态不变。

• 如果输入是换行符， 则输出一个换行符， 并将程序状态变为 ordinary。 请注意， 这和前面的地一种情况不同 - 如果我们把它们合并， 则结果将是输出两次换行符， 而不是所希望的一次。

　　最后， 如果我们收到的输入是一个在前面没有回车符的换行符的话， 则程序会进入 lf 状态。 如果我们的文件已经是 UNIX 格式， 或者一行中一个回车之后跟随了若干换行符， 或者行尾是换行/回车序列时便会发生这种情况。 下面是如何处理这种情况时的输入：

• If the input is anything other than a carriage return or line feed, we output a line feed, then output the input, then change the state to ordinary. This is exactly the same action as in the cr state upon receiving the same kind of input.

• If the input is a carriage return, we discard the input, we output a line feed, then change the state to ordinary.

• If the input is a line feed, we output the line feed, and leave the state unchanged.

11.11.2 Implementing FSM in Software

　　The hardest part of working with a finite state machine is analyzing the problem and expressing it as a finite state machine. That accomplished, the software almost writes itself.

　　In a high-level language, such as C, there are several main approaches. One is to use a switch statement which chooses what function should be run. For example,

   switch (state) {
    default:
    case REGULAR:
        regular(inputchar);
        break;
    case CR:
        cr(inputchar);
        break;
    case LF:
        lf(inputchar);
        break;
    }

　　Another approach is by using an array of function pointers, something like this:

   (output[state])(inputchar);

　　Yet another is to have state be a function pointer, set to point at the appropriate function:

   (*state)(inputchar);

　　This is the approach we will use in our program because it is very easy to do in assembly language, and very fast, too. We will simply keep the address of the right procedure in EBX, and then just issue:

   call    ebx

　　This is possibly faster than hardcoding the address in the code because the microprocessor does not have to fetch the address from the memory──it is already stored in one of its registers. I said possibly because with the caching modern microprocessors do, either way may be equally fast.

11.11.3 Memory Mapped Files

　　Because our program works on a single file, we cannot use the approach that worked for us before, i.e., to read from an input file and to write to an output file.

　　UNIX allows us to map a file, or a section of a file, into memory. To do that, we first need to open the file with the appropriate read/write flags. Then we use the mmap system call to map it into the memory. One nice thing about mmap is that it automatically works with virtual memory: We can map more of the file into the memory than we have physical memory available, yet still access it through regular memory op codes, such as mov, lods, and stos. Whatever changes we make to the memory image of the file will be written to the file by the system. We do not even have to keep the file open: As long as it stays mapped, we can read from it and write to it.

　　The 32-bit Intel microprocessors can access up to four gigabytes of memory - physical or virtual. The FreeBSD system allows us to use up to a half of it for file mapping.

　　For simplicity sake, in this tutorial we will only convert files that can be mapped into the memory in their entirety. There are probably not too many text files that exceed two gigabytes in size. If our program encounters one, it will simply display a message suggesting we use the original tuc instead.

　　If you examine your copy of syscalls.master, you will find two separate syscalls named mmap. This is because of evolution of UNIX: There was the traditional BSD mmap, syscall 71. That one was superseded by the POSIX mmap, syscall 197. The FreeBSD system supports both because older programs were written by using the original BSD version. But new software uses the POSIX version, which is what we will use.

　　The syscalls.master file lists the POSIX version like this:

197    STD BSD { caddr_t mmap(caddr_t addr, size_t len, int prot, \
                int flags, int fd, long pad, off_t pos); }

　　This differs slightly from what mmap(2) says. That is because mmap(2) describes the C version.

　　The difference is in the long pad argument, which is not present in the C version. However, the FreeBSD syscalls add a 32-bit pad after pushing a 64-bit argument. In this case, off_t is a 64-bit value.

　　When we are finished working with a memory-mapped file, we unmap it with the munmap syscall:

11.11.4 Determining File Size

　　Because we need to tell mmap how many bytes of the file to map into the memory, and because we want to map the entire file, we need to determine the size of the file.

　　We can use the fstat syscall to get all the information about an open file that the system can give us. That includes the file size.

　　Again, syscalls.master lists two versions of fstat, a traditional one (syscall 62), and a POSIX one (syscall 189). Naturally, we will use the POSIX version:

189    STD POSIX   { int fstat(int fd, struct stat *sb); }

　　This is a very straightforward call: We pass to it the address of a stat structure and the descriptor of an open file. It will fill out the contents of the stat structure.

　　I do, however, have to say that I tried to declare the stat structure in the .bss section, and fstat did not like it: It set the carry flag indicating an error. After I changed the code to allocate the structure on the stack, everything was working fine.

11.11.5 Changing the File Size

　　Because our program may combine carriage return / line feed sequences into straight line feeds, our output may be smaller than our input. However, since we are placing our output into the same file we read the input from, we may have to change the size of the file.

　　The ftruncate system call allows us to do just that. Despite its somewhat misleading name, the ftruncate system call can be used to both truncate the file (make it smaller) and to grow it.

　　And yes, we will find two versions of ftruncate in syscalls.master, an older one (130), and a newer one (201). We will use the newer one:

201    STD BSD { int ftruncate(int fd, int pad, off_t length); }

　　Please note that this one contains a int pad again.

11.11.6 ftuc

　　We now know everything we need to write ftuc. We start by adding some new lines in system.inc. First, we define some constants and structures, somewhere at or near the beginning of the file:

;;;;;;; open flags
%define O_RDONLY    0
%define O_WRONLY    1
%define O_RDWR  2

;;;;;;; mmap flags
%define PROT_NONE   0
%define PROT_READ   1
%define PROT_WRITE  2
%define PROT_EXEC   4
;;
%define MAP_SHARED  0001h
%define MAP_PRIVATE 0002h

;;;;;;; stat structure
struc   stat
st_dev      resd    1   ; = 0
st_ino      resd    1   ; = 4
st_mode     resw    1   ; = 8, size is 16 bits
st_nlink    resw    1   ; = 10, ditto
st_uid      resd    1   ; = 12
st_gid      resd    1   ; = 16
st_rdev     resd    1   ; = 20
st_atime    resd    1   ; = 24
st_atimensec    resd    1   ; = 28
st_mtime    resd    1   ; = 32
st_mtimensec    resd    1   ; = 36
st_ctime    resd    1   ; = 40
st_ctimensec    resd    1   ; = 44
st_size     resd    2   ; = 48, size is 64 bits
st_blocks   resd    2   ; = 56, ditto
st_blksize  resd    1   ; = 64
st_flags    resd    1   ; = 68
st_gen      resd    1   ; = 72
st_lspare   resd    1   ; = 76
st_qspare   resd    4   ; = 80
endstruc

　　We define the new syscalls:

%define    SYS_mmap    197
%define SYS_munmap  73
%define SYS_fstat   189
%define SYS_ftruncate   201

　　We add the macros for their use:

%macro sys.mmap    0
    system  SYS_mmap
%endmacro

%macro  sys.munmap  0
    system  SYS_munmap
%endmacro

%macro  sys.ftruncate   0
    system  SYS_ftruncate
%endmacro

%macro  sys.fstat   0
    system  SYS_fstat
%endmacro

　　And here is our code:

;;;;;;; Fast Text-to-Unix Conversion (ftuc.asm) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Started: 21-Dec-2000
;; Updated: 22-Dec-2000
;;
;; Copyright 2000 G. Adam Stanislav.
;; All rights reserved.
;;
;;;;;;; v.1 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%include    'system.inc'

section .data
    db  'Copyright 2000 G. Adam Stanislav.', 0Ah
    db  'All rights reserved.', 0Ah
usg db  'Usage: ftuc filename', 0Ah
usglen  equ $-usg
co  db  "ftuc: Can't open file.", 0Ah
colen   equ $-co
fae db  'ftuc: File access error.', 0Ah
faelen  equ $-fae
ftl db  'ftuc: File too long, use regular tuc instead.', 0Ah
ftllen  equ $-ftl
mae db  'ftuc: Memory allocation error.', 0Ah
maelen  equ $-mae

section .text

align 4
memerr:
    push    dword maelen
    push    dword mae
    jmp short error

align 4
toolong:
    push    dword ftllen
    push    dword ftl
    jmp short error

align 4
facerr:
    push    dword faelen
    push    dword fae
    jmp short error

align 4
cantopen:
    push    dword colen
    push    dword co
    jmp short error

align 4
usage:
    push    dword usglen
    push    dword usg

error:
    push    dword stderr
    sys.write

    push    dword 1
    sys.exit

align 4
global  _start
_start:
    pop eax     ; argc
    pop eax     ; program name
    pop ecx     ; file to convert
    jecxz   usage

    pop eax
    or  eax, eax    ; Too many arguments?
    jne usage

    ; Open the file
    push    dword O_RDWR
    push    ecx
    sys.open
    jc  cantopen

    mov ebp, eax    ; Save fd

    sub esp, byte stat_size
    mov ebx, esp

    ; Find file size
    push    ebx
    push    ebp     ; fd
    sys.fstat
    jc  facerr

    mov edx, [ebx + st_size + 4]

    ; File is too long if EDX != 0 ...
    or  edx, edx
    jne near toolong
    mov ecx, [ebx + st_size]
    ; ... or if it is above 2 GB
    or  ecx, ecx
    js  near toolong

    ; Do nothing if the file is 0 bytes in size
    jecxz   .quit

    ; Map the entire file in memory
    push    edx
    push    edx     ; starting at offset 0
    push    edx     ; pad
    push    ebp     ; fd
    push    dword MAP_SHARED
    push    dword PROT_READ | PROT_WRITE
    push    ecx     ; entire file size
    push    edx     ; let system decide on the address
    sys.mmap
    jc  near memerr

    mov edi, eax
    mov esi, eax
    push    ecx     ; for SYS_munmap
    push    edi

    ; Use EBX for state machine
    mov ebx, ordinary
    mov ah, 0Ah
    cld

.loop:
    lodsb
    call    ebx
    loop    .loop

    cmp ebx, ordinary
    je  .filesize

    ; Output final lf
    mov al, ah
    stosb
    inc edx

.filesize:
    ; truncate file to new size
    push    dword 0     ; high dword
    push    edx     ; low dword
    push    eax     ; pad
    push    ebp
    sys.ftruncate

    ; close it (ebp still pushed)
    sys.close

    add esp, byte 16
    sys.munmap

.quit:
    push    dword 0
    sys.exit

align 4
ordinary:
    cmp al, 0Dh
    je  .cr

    cmp al, ah
    je  .lf

    stosb
    inc edx
    ret

align 4
.cr:
    mov ebx, cr
    ret

align 4
.lf:
    mov ebx, lf
    ret

align 4
cr:
    cmp al, 0Dh
    je  .cr

    cmp al, ah
    je  .lf

    xchg    al, ah
    stosb
    inc edx

    xchg    al, ah
    ; fall through

.lf:
    stosb
    inc edx
    mov ebx, ordinary
    ret

align 4
.cr:
    mov al, ah
    stosb
    inc edx
    ret

align 4
lf:
    cmp al, ah
    je  .lf

    cmp al, 0Dh
    je  .cr

    xchg    al, ah
    stosb
    inc edx

    xchg    al, ah
    stosb
    inc edx
    mov ebx, ordinary
    ret

align 4
.cr:
    mov ebx, ordinary
    mov al, ah
    ; fall through

.lf:
    stosb
    inc edx
    ret

11.12.1 CSV

　　I will illustrate this principle with a specific real-life example I was faced with recently:

　　I needed to extract the 11th field of each record from a database I downloaded from a web site. The database was a CSV file, i.e., a list of comma-separated values. That is quite a standard format for sharing data among people who may be using different database software.

　　The first line of the file contains the list of various fields separated by commas. The rest of the file contains the data listed line by line, with values separated by commas.

　　I tried awk, using the comma as a separator. But because several lines contained a quoted comma, awk was extracting the wrong field from those lines.

　　Therefore, I needed to write my own software to extract the 11th field from the CSV file. However, going with the UNIX spirit, I only needed to write a simple filter that would do the following:

• Remove the first line from the file;

• Change all unquoted commas to a different character;

• Remove all quotation marks.

　　Strictly speaking, I could use sed to remove the first line from the file, but doing so in my own program was very easy, so I decided to do it and reduce the size of the pipeline.

　　At any rate, writing a program like this took me about 20 minutes. Writing a program that extracts the 11th field from the CSV file would take a lot longer, and I could not reuse it to extract some other field from some other database.

　　This time I decided to let it do a little more work than a typical tutorial program would:

• It parses its command line for options;

• It displays proper usage if it finds wrong arguments;

• It produces meaningful error messages.

　　Here is its usage message:

Usage: csv [-t<delim>] [-c<comma>] [-p] [-o <outfile>] [-i <infile>]

　　All parameters are optional, and can appear in any order.

　　The -t parameter declares what to replace the commas with. The tab is the default here. For example, -t; will replace all unquoted commas with semicolons.

　　I did not need the -c option, but it may come in handy in the future. It lets me declare that I want a character other than a comma replaced with something else. For example, -c@ will replace all at signs (useful if you want to split a list of email addresses to their user names and domains).

　　The -p option preserves the first line, i.e., it does not delete it. By default, we delete the first line because in a CSV file it contains the field names rather than data.

　　The -i and -o options let me specify the input and the output files. Defaults are stdin and stdout, so this is a regular UNIX filter.

　　I made sure that both -i filename and -ifilename are accepted. I also made sure that only one input and one output files may be specified.

　　To get the 11th field of each record, I can now do:

% csv '-t;' data.csv | awk '-F;' '{print $11}'

　　The code stores the options (except for the file descriptors) in EDX: The comma in DH, the new separator in DL, and the flag for the -p option in the highest bit of EDX, so a check for its sign will give us a quick decision what to do.

　　Here is the code:

;;;;;;; csv.asm ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Convert a comma-separated file to a something-else separated file.
;
; Started:  31-May-2001
; Updated:   1-Jun-2001
;
; Copyright (c) 2001 G. Adam Stanislav
; All rights reserved.
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

%include    'system.inc'

%define BUFSIZE 2048

section .data
fd.in   dd  stdin
fd.out  dd  stdout
usg db  'Usage: csv [-t<delim>] [-c<comma>] [-p] [-o <outfile>] [-i <infile>]', 0Ah
usglen  equ $-usg
iemsg   db  "csv: Can't open input file", 0Ah
iemlen  equ $-iemsg
oemsg   db  "csv: Can't create output file", 0Ah
oemlen  equ $-oemsg

section .bss
ibuffer resb    BUFSIZE
obuffer resb    BUFSIZE

section .text
align 4
ierr:
    push    dword iemlen
    push    dword iemsg
    push    dword stderr
    sys.write
    push    dword 1     ; return failure
    sys.exit

align 4
oerr:
    push    dword oemlen
    push    dword oemsg
    push    dword stderr
    sys.write
    push    dword 2
    sys.exit

align 4
usage:
    push    dword usglen
    push    dword usg
    push    dword stderr
    sys.write
    push    dword 3
    sys.exit

align 4
global  _start
_start:
    add esp, byte 8 ; discard argc and argv[0]
    mov edx, (',' << 8) | 9

.arg:
    pop ecx
    or  ecx, ecx
    je  near .init      ; no more arguments

    ; ECX contains the pointer to an argument
    cmp byte [ecx], '-'
    jne usage

    inc ecx
    mov ax, [ecx]

.o:
    cmp al, 'o'
    jne .i

    ; Make sure we are not asked for the output file twice
    cmp dword [fd.out], stdout
    jne usage

    ; Find the path to output file - it is either at [ECX+1],
    ; i.e., -ofile --
    ; or in the next argument,
    ; i.e., -o file

    inc ecx
    or  ah, ah
    jne .openoutput
    pop ecx
    jecxz   usage

.openoutput:
    push    dword 420   ; file mode (644 octal)
    push    dword 0200h | 0400h | 01h
    ; O_CREAT | O_TRUNC | O_WRONLY
    push    ecx
    sys.open
    jc  near oerr

    add esp, byte 12
    mov [fd.out], eax
    jmp short .arg

.i:
    cmp al, 'i'
    jne .p

    ; Make sure we are not asked twice
    cmp dword [fd.in], stdin
    jne near usage

    ; Find the path to the input file
    inc ecx
    or  ah, ah
    jne .openinput
    pop ecx
    or  ecx, ecx
    je near usage

.openinput:
    push    dword 0     ; O_RDONLY
    push    ecx
    sys.open
    jc  near ierr       ; open failed

    add esp, byte 8
    mov [fd.in], eax
    jmp .arg

.p:
    cmp al, 'p'
    jne .t
    or  ah, ah
    jne near usage
    or  edx, 1 << 31
    jmp .arg

.t:
    cmp al, 't'     ; redefine output delimiter
    jne .c
    or  ah, ah
    je  near usage
    mov dl, ah
    jmp .arg

.c:
    cmp al, 'c'
    jne near usage
    or  ah, ah
    je  near usage
    mov dh, ah
    jmp .arg

align 4
.init:
    sub eax, eax
    sub ebx, ebx
    sub ecx, ecx
    mov edi, obuffer

    ; See if we are to preserve the first line
    or  edx, edx
    js  .loop

.firstline:
    ; get rid of the first line
    call    getchar
    cmp al, 0Ah
    jne .firstline

.loop:
    ; read a byte from stdin
    call    getchar

    ; is it a comma (or whatever the user asked for)?
    cmp al, dh
    jne .quote

    ; Replace the comma with a tab (or whatever the user wants)
    mov al, dl

.put:
    call    putchar
    jmp short .loop

.quote:
    cmp al, '"'
    jne .put

    ; Print everything until you get another quote or EOL. If it
    ; is a quote, skip it. If it is EOL, print it.
.qloop:
    call    getchar
    cmp al, '"'
    je  .loop

    cmp al, 0Ah
    je  .put

    call    putchar
    jmp short .qloop

align 4
getchar:
    or  ebx, ebx
    jne .fetch

    call    read

.fetch:
    lodsb
    dec ebx
    ret

read:
    jecxz   .read
    call    write

.read:
    push    dword BUFSIZE
    mov esi, ibuffer
    push    esi
    push    dword [fd.in]
    sys.read
    add esp, byte 12
    mov ebx, eax
    or  eax, eax
    je  .done
    sub eax, eax
    ret

align 4
.done:
    call    write       ; flush output buffer

    ; close files
    push    dword [fd.in]
    sys.close

    push    dword [fd.out]
    sys.close

    ; return success
    push    dword 0
    sys.exit

align 4
putchar:
    stosb
    inc ecx
    cmp ecx, BUFSIZE
    je  write
    ret

align 4
write:
    jecxz   .ret    ; nothing to write
    sub edi, ecx    ; start of buffer
    push    ecx
    push    edi
    push    dword [fd.out]
    sys.write
    add esp, byte 12
    sub eax, eax
    sub ecx, ecx    ; buffer is empty now
.ret:
    ret

　　Much of it is taken from hex.asm above. But there is one important difference: I no longer call write whenever I am outputting a line feed. Yet, the code can be used interactively.

　　I have found a better solution for the interactive problem since I first started writing this chapter. I wanted to make sure each line is printed out separately only when needed. After all, there is no need to flush out every line when used non-interactively.

　　The new solution I use now is to call write every time I find the input buffer empty. That way, when running in the interactive mode, the program reads one line from the user's keyboard, processes it, and sees its input buffer is empty. It flushes its output and reads the next line.

.loop:
    call    getchar
    not al      ; Create a negative
    call    putchar
    jmp short .loop

11.13.1 Organization of the FPU

　　The FPU consists of 8 80-bit floating-point registers. These are organized in a stack fashion──you can push a value on TOS (top of stack) and you can pop it.

　　That said, the assembly language op codes are not push and pop because those are already taken.

　　You can push a value on TOS by using fld, fild, and fbld. Several other op codes let you push many common constants──such as pi──on the TOS.

　　Similarly, you can pop a value by using fst, fstp, fist, fistp, and fbstp. Actually, only the op codes that end with a p will literally pop the value, the rest will store it somewhere else without removing it from the TOS.

　　We can transfer the data between the TOS and the computer memory either as a 32-bit, 64-bit, or 80-bit real, a 16-bit, 32-bit, or 64-bit integer, or an 80-bit packed decimal.

　　The 80-bit packed decimal is a special case of binary coded decimal which is very convenient when converting between the ASCII representation of data and the internal data of the FPU. It allows us to use 18 significant digits.

　　No matter how we represent data in the memory, the FPU always stores it in the 80-bit real format in its registers.

　　Its internal precision is at least 19 decimal digits, so even if we choose to display results as ASCII in the full 18-digit precision, we are still showing correct results.

　　We can perform mathematical operations on the TOS: We can calculate its sine, we can scale it (i.e., we can multiply or divide it by a power of 2), we can calculate its base-2 logarithm, and many other things.

　　We can also multiply or divide it by, add it to, or subtract it from, any of the FPU registers (including itself).

　　The official Intel op code for the TOS is st, and for the registers st(0)-st(7). st and st(0), then, refer to the same register.

　　For whatever reasons, the original author of nasm has decided to use different op codes, namely st0-st7. In other words, there are no parentheses, and the TOS is always st0, never just st.

80 00 00 00 00 00 01 23 45 67

67 45 23 01 00 00 00 00 00 80

11.13.2 Excursion to Pinhole Photography

　　To write meaningful software, we must not only understand our programming tools, but also the field we are creating software for.

　　Our next filter will help us whenever we want to build a pinhole camera, so, we need some background in pinhole photography before we can continue.

   D = PC * sqrt(FL)

   F = FL / D

   t * (B / A)²

11.13.3 Designing the Pinhole Software

　　We are now ready to decide what exactly we want our pinhole software to do.

100, 150, 210

What is the best pinhole diameter for the focal length of 150?

Syntax error: What
Syntax error: is
Syntax error: the
Syntax error: best

00000000150

17459765723452353453534535353530530534563507309676764423

17459765723452353453534535353530530534563507309676764423   ??? ??? ??? ??? ???

0  ??? ??? ??? ??? ???

   fmul    st0, st0
    fld1
    fld st1
    fyl2x
    frndint
    fld1
    fscale
    fsqrt
    fstp    st1

11.13.4 FPU Optimizations

　　In assembly language we can optimize the FPU code in ways impossible in high languages, including C.

　　Whenever a C function needs to calculate a floating-point value, it loads all necessary variables and constants into FPU registers. It then does whatever calculation is required to get the correct result. Good C compilers can optimize that part of the code really well.

　　It "returns" the value by leaving the result on the TOS. However, before it returns, it cleans up. Any variables and constants it used in its calculation are now gone from the FPU.

　　It cannot do what we just did above: We calculated the square of the f-number and kept it on the stack for later use by another function.

　　We knew we would need that value later on. We also knew we had enough room on the stack (which only has room for 8 numbers) to store it there.

　　A C compiler has no way of knowing that a value it has on the stack will be required again in the very near future.

　　Of course, the C programmer may know it. But the only recourse he has is to store the value in a memory variable.

　　That means, for one, the value will be changed from the 80-bit precision used internally by the FPU to a C double (64 bits) or even single (32 bits).

　　That also means that the value must be moved from the TOS into the memory, and then back again. Alas, of all FPU operations, the ones that access the computer memory are the slowest.

　　So, whenever programming the FPU in assembly language, look for the ways of keeping intermediate results on the FPU stack.

　　We can take that idea even further! In our program we are using a constant (the one we named PC).

　　It does not matter how many pinhole diameters we are calculating: 1, 10, 20, 1000, we are always using the same constant. Therefore, we can optimize our program by keeping the constant on the stack all the time.

　　Early on in our program, we are calculating the value of the above constant. We need to divide our input by 10 for every digit in the constant.

　　It is much faster to multiply than to divide. So, at the start of our program, we divide 10 into 1 to obtain 0.1, which we then keep on the stack: Instead of dividing the input by 10 for every digit, we multiply it by 0.1.

　　By the way, we do not input 0.1 directly, even though we could. We have a reason for that: While 0.1 can be expressed with just one decimal place, we do not know how many binary places it takes. We, therefore, let the FPU calculate its binary value to its own high precision.

　　We are using other constants: We multiply the pinhole diameter by 1000 to convert it from millimeters to microns. We compare numbers to 10000 when we are rounding them off to four significant digits. So, we keep both, 1000 and 10000, on the stack. And, of course, we reuse the 0.1 when rounding off numbers to four digits.

　　Last but not least, we keep -5 on the stack. We need it to scale the square of the f-number, instead of dividing it by 32. It is not by coincidence we load this constant last. That makes it the top of the stack when only the constants are on it. So, when the square of the f-number is being scaled, the -5 is at st(1), precisely where fscale expects it to be.

　　It is common to create certain constants from scratch instead of loading them from the memory. That is what we are doing with -5:

   fld1            ; TOS =  1
    fadd    st0, st0    ; TOS =  2
    fadd    st0, st0    ; TOS =  4
    fld1            ; TOS =  1
    faddp   st1, st0    ; TOS =  5
    fchs            ; TOS = -5

　　总结一下前面的所有这些优化： 将重复的值放在堆栈上！

11.13.5 pinhole──源程序

;;;;;;; pinhole.asm ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; 计算针孔照相机的若干参数
;
; 创建: 2001-6月-9日
; 更新: 2001-6月-10日
;
; Copyright (c) 2001 G. Adam Stanislav
; All rights reserved.
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

%include    'system.inc'

%define BUFSIZE 2048

section .data
align 4
ten dd  10
thousand    dd  1000
tthou   dd  10000
fd.in   dd  stdin
fd.out  dd  stdout
envar   db  'PINHOLE='  ; Exactly 8 bytes, or 2 dwords long
pinhole db  '04,',      ; Bender's constant (0.04)
connors db  '037', 0Ah  ; Connors' constant
usg db  'Usage: pinhole [-b] [-c] [-e] [-p <value>] [-o <outfile>] [-i <infile>]', 0Ah
usglen  equ $-usg
iemsg   db  "pinhole: Can't open input file", 0Ah
iemlen  equ $-iemsg
oemsg   db  "pinhole: Can't create output file", 0Ah
oemlen  equ $-oemsg
pinmsg  db  "pinhole: The PINHOLE constant must not be 0", 0Ah
pinlen  equ $-pinmsg
toobig  db  "pinhole: The PINHOLE constant may not exceed 18 decimal places", 0Ah
biglen  equ $-toobig
huhmsg  db  9, '???'
separ   db  9, '???'
sep2    db  9, '???'
sep3    db  9, '???'
sep4    db  9, '???', 0Ah
huhlen  equ $-huhmsg
header  db  'focal length in millimeters,pinhole diameter in microns,'
    db  'F-number,normalized F-number,F-5.6 multiplier,stops '
    db  'from F-5.6', 0Ah
headlen equ $-header

section .bss
ibuffer resb    BUFSIZE
obuffer resb    BUFSIZE
dbuffer resb    20      ; decimal input buffer
bbuffer resb    10      ; BCD buffer

section .text
align 4
huh:
    call    write
    push    dword huhlen
    push    dword huhmsg
    push    dword [fd.out]
    sys.write
    add esp, byte 12
    ret

align 4
perr:
    push    dword pinlen
    push    dword pinmsg
    push    dword stderr
    sys.write
    push    dword 4     ; return failure
    sys.exit

align 4
consttoobig:
    push    dword biglen
    push    dword toobig
    push    dword stderr
    sys.write
    push    dword 5     ; return failure
    sys.exit

align 4
ierr:
    push    dword iemlen
    push    dword iemsg
    push    dword stderr
    sys.write
    push    dword 1     ; return failure
    sys.exit

align 4
oerr:
    push    dword oemlen
    push    dword oemsg
    push    dword stderr
    sys.write
    push    dword 2
    sys.exit

align 4
usage:
    push    dword usglen
    push    dword usg
    push    dword stderr
    sys.write
    push    dword 3
    sys.exit

align 4
global  _start
_start:
    add esp, byte 8 ; discard argc and argv[0]
    sub esi, esi

.arg:
    pop ecx
    or  ecx, ecx
    je  near .getenv        ; no more arguments

    ; ECX contains the pointer to an argument
    cmp byte [ecx], '-'
    jne usage

    inc ecx
    mov ax, [ecx]
    inc ecx

.o:
    cmp al, 'o'
    jne .i

    ; Make sure we are not asked for the output file twice
    cmp dword [fd.out], stdout
    jne usage

    ; Find the path to output file - it is either at [ECX+1],
    ; i.e., -ofile --
    ; or in the next argument,
    ; i.e., -o file

    or  ah, ah
    jne .openoutput
    pop ecx
    jecxz   usage

.openoutput:
    push    dword 420   ; file mode (644 octal)
    push    dword 0200h | 0400h | 01h
    ; O_CREAT | O_TRUNC | O_WRONLY
    push    ecx
    sys.open
    jc  near oerr

    add esp, byte 12
    mov [fd.out], eax
    jmp short .arg

.i:
    cmp al, 'i'
    jne .p

    ; Make sure we are not asked twice
    cmp dword [fd.in], stdin
    jne near usage

    ; Find the path to the input file
    or  ah, ah
    jne .openinput
    pop ecx
    or  ecx, ecx
    je near usage

.openinput:
    push    dword 0     ; O_RDONLY
    push    ecx
    sys.open
    jc  near ierr       ; open failed

    add esp, byte 8
    mov [fd.in], eax
    jmp .arg

.p:
    cmp al, 'p'
    jne .c
    or  ah, ah
    jne .pcheck

    pop ecx
    or  ecx, ecx
    je  near usage

    mov ah, [ecx]

.pcheck:
    cmp ah, '0'
    jl  near usage
    cmp ah, '9'
    ja  near usage
    mov esi, ecx
    jmp .arg

.c:
    cmp al, 'c'
    jne .b
    or  ah, ah
    jne near usage
    mov esi, connors
    jmp .arg

.b:
    cmp al, 'b'
    jne .e
    or  ah, ah
    jne near usage
    mov esi, pinhole
    jmp .arg

.e:
    cmp al, 'e'
    jne near usage
    or  ah, ah
    jne near usage
    mov al, ','
    mov [huhmsg], al
    mov [separ], al
    mov [sep2], al
    mov [sep3], al
    mov [sep4], al
    jmp .arg

align 4
.getenv:
    ; If ESI = 0, we did not have a -p argument,
    ; and need to check the environment for "PINHOLE="
    or  esi, esi
    jne .init

    sub ecx, ecx

.nextenv:
    pop esi
    or  esi, esi
    je  .default    ; no PINHOLE envar found

    ; check if this envar starts with 'PINHOLE='
    mov edi, envar
    mov cl, 2       ; 'PINHOLE=' is 2 dwords long
rep cmpsd
    jne .nextenv

    ; Check if it is followed by a digit
    mov al, [esi]
    cmp al, '0'
    jl  .default
    cmp al, '9'
    jbe .init
    ; fall through

align 4
.default:
    ; We got here because we had no -p argument,
    ; and did not find the PINHOLE envar.
    mov esi, pinhole
    ; fall through

align 4
.init:
    sub eax, eax
    sub ebx, ebx
    sub ecx, ecx
    sub edx, edx
    mov edi, dbuffer+1
    mov byte [dbuffer], '0'

    ; Convert the pinhole constant to real
.constloop:
    lodsb
    cmp al, '9'
    ja  .setconst
    cmp al, '0'
    je  .processconst
    jb  .setconst

    inc dl

.processconst:
    inc cl
    cmp cl, 18
    ja  near consttoobig
    stosb
    jmp short .constloop

align 4
.setconst:
    or  dl, dl
    je  near perr

    finit
    fild    dword [tthou]

    fld1
    fild    dword [ten]
    fdivp   st1, st0

    fild    dword [thousand]
    mov edi, obuffer

    mov ebp, ecx
    call    bcdload

.constdiv:
    fmul    st0, st2
    loop    .constdiv

    fld1
    fadd    st0, st0
    fadd    st0, st0
    fld1
    faddp   st1, st0
    fchs

    ; If we are creating a CSV file,
    ; print header
    cmp byte [separ], ','
    jne .bigloop

    push    dword headlen
    push    dword header
    push    dword [fd.out]
    sys.write

.bigloop:
    call    getchar
    jc  near done

    ; Skip to the end of the line if you got '#'
    cmp al, '#'
    jne .num
    call    skiptoeol
    jmp short .bigloop

.num:
    ; See if you got a number
    cmp al, '0'
    jl  .bigloop
    cmp al, '9'
    ja  .bigloop

    ; Yes, we have a number
    sub ebp, ebp
    sub edx, edx

.number:
    cmp al, '0'
    je  .number0
    mov dl, 1

.number0:
    or  dl, dl      ; Skip leading 0's
    je  .nextnumber
    push    eax
    call    putchar
    pop eax
    inc ebp
    cmp ebp, 19
    jae .nextnumber
    mov [dbuffer+ebp], al

.nextnumber:
    call    getchar
    jc  .work
    cmp al, '#'
    je  .ungetc
    cmp al, '0'
    jl  .work
    cmp al, '9'
    ja  .work
    jmp short .number

.ungetc:
    dec esi
    inc ebx

.work:
    ; Now, do all the work
    or  dl, dl
    je  near .work0

    cmp ebp, 19
    jae near .toobig

    call    bcdload

    ; Calculate pinhole diameter

    fld st0 ; save it
    fsqrt
    fmul    st0, st3
    fld st0
    fmul    st5
    sub ebp, ebp

    ; Round off to 4 significant digits
.diameter:
    fcom    st0, st7
    fstsw   ax
    sahf
    jb  .printdiameter
    fmul    st0, st6
    inc ebp
    jmp short .diameter

.printdiameter:
    call    printnumber ; pinhole diameter

    ; Calculate F-number

    fdivp   st1, st0
    fld st0

    sub ebp, ebp

.fnumber:
    fcom    st0, st6
    fstsw   ax
    sahf
    jb  .printfnumber
    fmul    st0, st5
    inc ebp
    jmp short .fnumber

.printfnumber:
    call    printnumber ; F number

    ; Calculate normalized F-number
    fmul    st0, st0
    fld1
    fld st1
    fyl2x
    frndint
    fld1
    fscale
    fsqrt
    fstp    st1

    sub ebp, ebp
    call    printnumber

    ; Calculate time multiplier from F-5.6

    fscale
    fld st0

    ; Round off to 4 significant digits
.fmul:
    fcom    st0, st6
    fstsw   ax
    sahf

    jb  .printfmul
    inc ebp
    fmul    st0, st5
    jmp short .fmul

.printfmul:
    call    printnumber ; F multiplier

    ; Calculate F-stops from 5.6

    fld1
    fxch    st1
    fyl2x

    sub ebp, ebp
    call    printnumber

    mov al, 0Ah
    call    putchar
    jmp .bigloop

.work0:
    mov al, '0'
    call    putchar

align 4
.toobig:
    call    huh
    jmp .bigloop

align 4
done:
    call    write       ; flush output buffer

    ; close files
    push    dword [fd.in]
    sys.close

    push    dword [fd.out]
    sys.close

    finit

    ; return success
    push    dword 0
    sys.exit

align 4
skiptoeol:
    ; Keep reading until you come to cr, lf, or eof
    call    getchar
    jc  done
    cmp al, 0Ah
    jne .cr
    ret

.cr:
    cmp al, 0Dh
    jne skiptoeol
    ret

align 4
getchar:
    or  ebx, ebx
    jne .fetch

    call    read

.fetch:
    lodsb
    dec ebx
    clc
    ret

read:
    jecxz   .read
    call    write

.read:
    push    dword BUFSIZE
    mov esi, ibuffer
    push    esi
    push    dword [fd.in]
    sys.read
    add esp, byte 12
    mov ebx, eax
    or  eax, eax
    je  .empty
    sub eax, eax
    ret

align 4
.empty:
    add esp, byte 4
    stc
    ret

align 4
putchar:
    stosb
    inc ecx
    cmp ecx, BUFSIZE
    je  write
    ret

align 4
write:
    jecxz   .ret    ; nothing to write
    sub edi, ecx    ; start of buffer
    push    ecx
    push    edi
    push    dword [fd.out]
    sys.write
    add esp, byte 12
    sub eax, eax
    sub ecx, ecx    ; buffer is empty now
.ret:
    ret

align 4
bcdload:
    ; EBP contains the number of chars in dbuffer
    push    ecx
    push    esi
    push    edi

    lea ecx, [ebp+1]
    lea esi, [dbuffer+ebp-1]
    shr ecx, 1

    std

    mov edi, bbuffer
    sub eax, eax
    mov [edi], eax
    mov [edi+4], eax
    mov [edi+2], ax

.loop:
    lodsw
    sub ax, 3030h
    shl al, 4
    or  al, ah
    mov [edi], al
    inc edi
    loop    .loop

    fbld    [bbuffer]

    cld
    pop edi
    pop esi
    pop ecx
    sub eax, eax
    ret

align 4
printnumber:
    push    ebp
    mov al, [separ]
    call    putchar

    ; Print the integer at the TOS
    mov ebp, bbuffer+9
    fbstp   [bbuffer]

    ; Check the sign
    mov al, [ebp]
    dec ebp
    or  al, al
    jns .leading

    ; We got a negative number (should never happen)
    mov al, '-'
    call    putchar

.leading:
    ; Skip leading zeros
    mov al, [ebp]
    dec ebp
    or  al, al
    jne .first
    cmp ebp, bbuffer
    jae .leading

    ; We are here because the result was 0.
    ; Print '0' and return
    mov al, '0'
    jmp putchar

.first:
    ; We have found the first non-zero.
    ; But it is still packed
    test    al, 0F0h
    jz  .second
    push    eax
    shr al, 4
    add al, '0'
    call    putchar
    pop eax
    and al, 0Fh

.second:
    add al, '0'
    call    putchar

.next:
    cmp ebp, bbuffer
    jb  .done

    mov al, [ebp]
    push    eax
    shr al, 4
    add al, '0'
    call    putchar
    pop eax
    and al, 0Fh
    add al, '0'
    call    putchar

    dec ebp
    jmp short .next

.done:
    pop ebp
    or  ebp, ebp
    je  .ret

.zeros:
    mov al, '0'
    call    putchar
    dec ebp
    jne .zeros

.ret:
    ret

　　这段代码在形式上与我们之前看到的其他过滤器如出一辙， 只是有一处细小的区别：

我们不再假定输入的结束是全部事情的终结， 而这是 面向字符的 过滤器中的一种基本假设。

这个过滤器并不是简单地处理字符流。 它处理的是一种 语言 (当然， 只是一种非常简单的， 只包含数字的语言)。

如果没有进一步的输入了， 这可能表示两件事之一：

• 已经完成了全部工作， 而程序可以结束了。 这与之前的情况类似。

• 我们读入的最后一个字符是一个数字。 我们将其保存在 ASCII-到-浮点数转换缓冲区中。 我们需要将那个缓冲区的内容转换为数字， 并输出所得到的最后一个结果。

基于这样的原因， 我们需要修改 getchar 和 read 两个过程， 并在仍有字符时返回时将 carry flag 复位， 而在没有更多字符时， 则返回时将 carry flag 置位。

当然， 我们需要使用一些汇编语言的小技巧来完成这项工作。 看一看 getchar。 它 总会 在返回时将 carry flag 复位。

另外， 我们的主函数代码依赖于使用 carry flag 来告诉它何时退出──就是这样。

这里所采用的技巧是在 read 中。 当它收到来自系统的更多输入时， 会返回到 getchar， 后者会从输入缓冲中取走一个字符， 复位 carry flag 并返回。

但是当 read 没有从系统中获取到输入时， 它 并不会 返回到 getchar。 与此相反， 它会使用 add esp, byte 4 操作将 ESP 加 4， 并将 carry flag 置位 之后返回。

那么， 它返回到了哪里呢？ 无论什么时候， 当程序用到 call 操作时， 微处理器都会 push 返回地址， 也就是将其放到�顶 (注意并不是 FPU �， 而是内存中的系统�)。 当程序用到 ret 操作时， 微处理器会从�中 pop 返回地址， 并跳转回保存在那里的地址。

然而， 由于我们在ESP (�指针寄存器) 上加了 4， 我们实际上利用了微处理器的 健忘性： 它会忘记， 在之前是 getchar call(调用) 的 read。

而由于 getchar 从未在 call read 之前 push 过数据， 因此�顶的内容就是 call 了 getchar 时的返回地址。 如果调用者留意的话， 他会发现 call 了 getchar， 而 ret (返回) 时， 则有设置 carry flag！

　　除此之外， bcdload 这个过程也有一些问题， 它需要面对 Big-Endians 和 Little-Endians 之间的冲突。

　　在将文本转化为对应的数值时， 文本是以 big-endian 字节序保存的， 而 压缩形式的十进制数 则是 little-endian 格式。

　　要解决这个冲突， 我们首先使用 std。 然后， 使用 cld 来取消其作用： 确保在设了 std 时， 不调用任何可能会依赖于默认的 direction flag 设置的函数是非常重要的。

　　如果您完整地阅读过这一章， 那么这段代码的其余部分就比较清晰了。

　　这也应验了一句老话， 程序设计需要的是深思熟虑， 而真正的编码工作则微不足道。 一旦我们认真思考了每个细节， 那么代码基本上就是在顺理成章中一气呵成的了。

11.13.6 使用 pinhole

　　由于我们已经决定让程序 忽略 除了数字以外的任何输入 (当然在注释中的数字也会忽略)， 实际的操作就简化为 文本查询。 尽管并非 必须如此， 但至少 可以 这样做。

　　在我看来， 构造文本查询， 而非严格遵循语法， 有助于改善软件的用户体验。

　　假定我们打算制作使用 4x5 英寸胶片的针孔相机。 这种胶片的标准焦距大约是 150mm。 我们希望尽可能地 微调 焦距， 使得针孔的直径尽可能接近某个数值。 除此之外， 由于对计算机的抵触情绪和对照相机的熟悉， 并不希望输入一大串数字， 而是直接 问 一些问题。

　　这种会话大致如此：

% pinhole

Computer,

What size pinhole do I need for the focal length of 150?
150 490 306 362 2930    12
Hmmm... How about 160?
160 506 316 362 3125    12
Let's make it 155, please.
155 498 311 362 3027    12
Ah, let's try 157...
157 501 313 362 3066    12
156?
156 500 312 362 3047    12
That's it! Perfect! Thank you very much!
^D

　　我们注意到， 尽管焦距是 150， 针孔的直径却应该是 490 微米， 或 0.49 mm； 而如果希望得到与之接近的 156 mm 的焦距， 则针孔的直径则应是恰好半毫米。

11.13.7 使用脚本

　　由于选择了使用 # 标示注释的开始， 因此可以把我们的 pinhole 软件作为一种 脚本语言 来使用。

　　您可能看过 shell 脚本 的开头是类似这样的形式：

#! /bin/sh

　　...或者...

#!/bin/sh

　　...因为在 #! 后面的空格是可选的。

　　当在 UNIX 中执行以 #! 开头的文件时， 它会假定这个文件是脚本。 此时， 脚本会把脚本头一行和命令拼起来， 并尝试执行它。

　　假设现在已经把 pinhole 安装到了 /usr/local/bin/， 就可以撰写用于计算用于 120 胶卷在不同焦距时所应使用的光圈大小了。

　　这样的脚本格式类似下面这样：

#! /usr/local/bin/pinhole -b -i
# Find the best pinhole diameter
# for the 120 film

### Standard
80

### Wide angle
30, 40, 50, 60, 70

### Telephoto
100, 120, 140

　　由于 120 是一种中型尺寸的胶卷， 我们把这个文件命名为 medium。

　　接下来赋予这个文件可执行权限， 并作为程序运行：

% chmod 755 medium
% ./medium

　　UNIX 将把前述命令解释为：

% /usr/local/bin/pinhole -b -i ./medium

　　这个命令的输出结果将是：

80 358 224 256 1562    11
30  219 137 128 586 9
40  253 158 181 781 10
50  283 177 181 977 10
60  310 194 181 1172    10
70  335 209 181 1367    10
100 400 250 256 1953    11
120 438 274 256 2344    11
140 473 296 256 2734    11

　　 现在， 输入：

% ./medium -c

　　UNIX 会将前述命令作为：

% /usr/local/bin/pinhole -b -i ./medium -c

　　来执行。 这里有两个互相冲突的选项： -b 和 -c (分别表示采用 Bender 常数和 Connors 常数)。 我们在设计程序时， 假定后出现的选项优先生效 ── 这样一来， 程序将使用 Connors 常数来完成计算：

80 331 242 256 1826    11
30  203 148 128 685 9
40  234 171 181 913 10
50  262 191 181 1141    10
60  287 209 181 1370    10
70  310 226 256 1598    11
100 370 270 256 2283    11
120 405 296 256 2739    11
140 438 320 362 3196    12

　　最后我们决定使用 Bender 常数， 并将这些数值， 以使用逗号分隔的文本文件来保存：

% ./medium -b -e > bender
% cat bender
focal length in millimeters,pinhole diameter in microns,F-number,normalized F-number,F-5.6 multiplier,stops from F-5.6
80,358,224,256,1562,11
30,219,137,128,586,9
40,253,158,181,781,10
50,283,177,181,977,10
60,310,194,181,1172,10
70,335,209,181,1367,10
100,400,250,256,1953,11
120,438,274,256,2344,11
140,473,296,256,2734,11
%

11.14.1 UNIX 是受保护的

　　首先， 简而言之这是不可行的。 UNIX 是在保护模式下运行的。 只有内核和设备驱动才允许直接访问硬件。 也许某些设计不良的类 UNIX 系统会让您读取键盘扫描码， 但是通常真正的 UNIX 操作系统都不允许这样做。 而且， 即便某个版本允许您这么做， 也许下个版本就不行了， 因此您精心雕琢的软件， 很可能会沦为昨日黄花。

11.14.2 UNIX 是一种抽象

　　即使在允许您这样做的类 UNIX 系统上， 也不去尝试直接操作硬件的一个更重要原因 (当然， 除非您正在撰写设备驱动) 是：

　　UNIX 是一种抽象！

　　MS-DOS 和 UNIX 的设计哲学有一个截然相反的地方。 MS-DOS 是为单用户系统设计的， 它只在那些键盘和显示屏幕都直接插在主机上的计算机上运行， 来自用户的输入， 基本上一定来自于那个键盘， 而您程序的输出， 最终也一定会反映到那个显示器上。

　　在 UNIX 中从未提供这样的保证。 使用管道来重定向输入和输出这样的事情在 UNIX 用户看来是极为稀松平常的事情：

% program1 | program2 | program3 > file1

　　如果您撰写了 program2， 则输入并非来自键盘， 而是来自 program1 的输出。 类似地， 您的输出并不会显示到屏幕上， 而是成为 program3 的输入， 而后者的输出， 则相应地会存入 file1。

　　且慢！ 即使您能确保输入输出都来自真正的终端， 也没有任何人能保证那终端一定是 PC： 在您预期的位置可能并不是显存， 其键盘也未必会产生 PC-风格的扫描码。 它可能是一台 Macintosh， 或者其他种类的计算机。

　　现在您也许会摇头： 我的软件是用 PC 汇编语言写成的， 它如何能在 Macintosh 上运行？ 请注意， 我并不是说它要在 Macintosh 上运行， 而只是说终端可能是一台 Macintosh。

　　在 UNIX 中， 终端未必会直接连在运行您软件的计算机上， 它甚至可能在另一个大洲， 甚至在另一个星球上。 很有可能某位澳洲的 Macintosh 用户会通过 telnet 连到在北美 (或其他地方) 的 UNIX 系统上。 这样， 软件是在一台计算机上运行的， 而终端则在另一台计算机上： 如果您试图读取扫描码， 就会得到不正确的输入！

　　同样的问题也适用于任何其他硬件： 您正读取的文件， 可能位于您无权直接访问的磁盘上。 提取图像的一部照相机， 也许正在某个透过卫星连接的航天飞机上。

　　这就是为什么在 UNIX 下您不应对数据的来源和去向有任何心存侥幸的假定。 任何时候都应让系统来处理对硬件的物理访问。