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 Collection 中有 GNU Pascal Compiler (GPC) 和 Free Pascal Compiler，分别在 lang/gpc 和 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 中还有一个它的图形 前端 (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 上可以用 the 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的开发者， 请发送给我们任何你能想到的与之相关的说明，想法，问题等等。

　　Michael C. Wu 将会维护I18N的工作，主页在 http://www.FreeBSD.org/~keichii/i18n/index.html。 请同时阅读BSDCon2000 I18N的由Clive Lin，Chia-Liang Kao和Michael C.Wu 在http://www.FreeBSD.org/~keichii/papers/ 提出的文章。

4.1.2 Perl 和 Python

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

　　在旧的FreeBSD版本中，Perl会给出一些没有在你的系统中安装了本地宽 字符的警告。你可以在你的shell中设置环境变量LD_PRELOAD为 /usr/lib/libxpg4.so。

　　在基于sh的shell中:

LD_PRELOAD=/usr/lib/libxpg4.so

　　在基于C-sh的shell中:

setenv LD_PRELOAD /usr/lib/libxpg4.so