sudo apt-get install gcc-mipsel-linux-gnu

sudo apt-get install g++-mipsel-linux-gnu

下载必要库的源码--没错是源码

libevent prce libz openssl

./configure --host=mipsel-linux-gnu 

make

make install

这样环境就完成了。

sudo dpkg-reconfigure dash 选no 关闭dash这步非常重要。

会导致bash运行出错。

2.先用原来环境编译一次

./builf.FluffOS

make

获得并备份以下5个文件：

vm/internal/compiler/grammar.autogen.y

vm/internal/applies_table.autogen.cc

vm/internal/applies_table.autogen.h

vm/internal/efuns.autogen.cc

vm/internal/efuns.autogen.h

make clean命令清除

把以上的5个备份文件复杂回原来的目录里面。

3.修改configure.h

删除

#define malloc rpl_malloc

#define realloc rpl_realloc

两行

4.修改makefile文件

CXX=g++ 改为CAA=g++

增加一项,内容为CXX=mipsel-linux-gnu-g++ 你需要的编译器

复制CXXFLAGS=的所有内容

增加一项，CAAFLAGS=内容为以上复杂的内容，修改其中-march=的内容，该为你需要的cpu型号，例如-march=mips32r2

把USE_JEMALLOC=1 改为USE_JEMALLOC=0

把@echo '#define USE_JEMALLOC 1' >> cc.h 改为@echo '#define USE_JEMALLOC 0' >> cc.h

找到并删除以下3句

@./tools/build_applies.autogen

@./tools/make_func.autogen packages/packages.autogen.fullspec

@./tools/make_grammar.sh $(CXX) $(CXXFLAGS)

找到

$(CXX) $(CXXFLAGS) -x c++ dtrace_compile.cc -o dtrace_compile

修改为

$(CAA) $(CAAFLAGS) -x c++ dtrace_compile.cc -o dtrace_compile

5.修改dtrace_compile.cc

找到64，修改为32

6.make 恭喜你完成了交叉编译

                                       --by mok 

                                        2017.8.11

使用前授权 chmod -v +x ./driver

另外自行安装必要的裤头

libpcre.so.1

libc.so.6                         libstdc++.so.6

libc6_2.19-18+deb8u10_mipsel.deb  libstdc++6_7.1.0-13_mipsel.deb

libevent-2.1.so.6

9月7日版本交叉编译问题

# @ASAN_OPTIONS="detect_leaks=0" ./tools/make_func.autogen packages/packages.autogen.fullspec

把这句注释掉就ok

                                        2017.9.18

因为reallove的帖子，我算是第一次较为仔细的看了一遍call_out()在driver中的机理，也明确了不少以前似是而非的概念。现整理如下：

1. 关于call_out()的driver级宏开关有两个（均在options.h当中）：

    a. THIS_PLAYER_IN_CALL_OUT

    该宏被define时，我们可以在被延时呼叫的函数中肆无忌惮的使用this_player()来找到call_out定义时的this_player()，反之则无法找到准确的this_player()（也就是说，可能找到一个谁，但这个“谁”应该与定义call_out时的“谁”毫无瓜葛，肯定不是我们希望的那一个就对了）

    b. CALLOUT_HANDLES

    该宏被定义时，call_out()原型变成了 int call_out(function foo,int delay, ..)，返回值是该call_out的唯一句柄，我们可以在remove_call_out()时以此为参数清理掉“这一个”而非“这一类”call_outs

2. 关于call_out的作用时机和delay的详细含义：

    已知call_out记录是以链表与delay的某个余数分类的形式进行存储的。

    call_out会在每个系统心跳（不是每个人的心跳，而是说，系统每次呼叫完所有心跳）之后进入对call_out们的处理（仔细的说，driver中call_out.c中的call_out()函数就是干这个事情的）。

    因此，就我现在阅读driver代码得到的结论，可以确定的说，call_out一定在心跳点上发作，但会有累积发作的模式。

   在解释delay之前，有几个“时间”需要说明：

   a. heart_beat()的发作时间：driver通过一个alarm/singal事件来设置hb的标志位，并在backend()的大循环当中不停检查该标志位的状态以决定是否应该触发hb，因此通常可以认为hb的发作较为准确。虽然从代码中看，在不同系统下的编译中，driver使用了alarm和ualarm两种不同方式进行按秒或按微秒级别的触发事件，但不那么精确的描述下，还是可以认为心跳的准时程度较高，更接近与真实系统时间。

   b. call_out被插入和判断是否被执行（注意不是是否进入call_out执行过程，而是进入后的“判断”），依据的是另外一个时间标记current_time。该标记在系统启动的时候被设置为当前时间的秒数（unix_time，也就是我们常看到的1239xxxxxxxx这种），其后只在系统心跳时被重置为“当前”。因此这个时间标并不总是等于真实的时间。特别是在hb大于1秒的情况下，如果以真实的秒为ticker来审视它，可能会是：0,0,0,[1,2,3],3,3,3,[4,5,6]这样的情况，即很多秒不变化，然后在同一个时间点上依次++直到追上真实时间。

    于是，关于delay有如下看法：

    a.在插入一条新的call_out时，delay看起来是从“现在”加上delay秒数后执行被呼叫函数，但这个“现在”是current_time指定的现在，hb>1sec时，他通常指的是过去。。。，因此当我们call_out(foo,3)的时候，他不一定指的是现在+3秒，而是指time()+3秒，他也不一定真的在三秒后执行。不考虑毫秒位的话，通常只有hb为1秒的时候，上面的描述才较为精确。但另外一个方面，delay的含义更倾向于秒，而不是hb。。。（我觉得我已经无法用人类的语言解释清楚这个破玩意儿了。。。。）

    b.如前述，call_out被执行一定是在hb的执行点上，具体的执行方式是：在某个HB执行点上，系统扫描小于current_time的call_out记录，然后依次执行（链表的原因，对于应该在“同一个时间点被执行的callout”，先入先执行）。然后系统对current_time++，继续上一步操作，知道current_time追赶上“现在”。

    所以说，如果你期望call_out表现比较正常，那最好把hb设为1秒（1000000微秒）；否则hb越大，callout的表现就越奇怪。hb非整秒数则会带来其他更微妙的改变。。。。

    最后，关于call_out(foo,0)这个特例。

    一般来说，我们无法期待这个东西立刻执行。他可能会在下一次hb的时候才被执行。

    之所以用“可能”，是因为这个特例还有个更奇怪的特例。该call_out本身处于另外一个call_out的呼叫函数当中。因此这个call_out进行的记录插入动作本身就是在call_out执行点上。可想而知，他立刻就被执行了！！！

    我们举两个例子来说明吧：

    我们假设hb是10个seconds。查看这样一段函数：

void test()

{

        call_out("test_callout",0);

}

void test_callout()

{

        tell_object(this_object(),sprintf("CO:%d\n",time()));

        call_out("test_callout",0);

}

当我们以某种形式执行了test()的时候，会出现什么状况呢？

首先是test()中的：call_out("test_callout",0)被执行，插入了一条记录，这个记录应当被触发的时间点是current_time+0。（我们假设current_time是333秒吧）

但考虑到hb点还没到。这个时候我们什么都看不到。

等到下一个hb点，也许作为现实时间，是337秒的时候吧（举例）。

上次插入的callout被执行了！

因此我们收到一条CO:333的显示信息（因为current_time这个时候还没++完呢）

接下来就坏掉了，因为又一个call_out("test_callout",0)被执行了！

要注意，这一条call_out插入的触发时间点依然是current_time+0，也就是333。

这时这个test_callout函数被执行完，退出，回到系统的call_out执行循环当中。

坏掉了，系统发现在333这个时间点上还有个未处理的记录（刚插进去的。。）

于是进入了死循环。。。

我们会看到系统不断刷屏CO:333

CO:333

CO:333

CO:333

。。。。

死循环下去了。

上面这个例子表明，callout 0是否立刻被执行，要看他所处的环境，不能一概而论，即时hb是1也如此。

再来一个例子：

同样hb是10seconds。

void test()

{

        call_out("test_callout",0);

}

void test_callout(){

        tell_object(this_object(),sprintf("CO:%d\n",time()));        call_out("test_callout",1);

}差别是后一个call_out的delay是1。

不详细描述了，我们得到的结果应该是类似：

系统等待发呆。。。。一次性刷屏：

CO:333

CO:334

CO:335

CO:336

CO:337

继续等待发呆个10秒。。。一次性刷屏：

CO:338

CO:339

CO:340

CO:341

CO:342

CO:343

CO:344

CO:345

CO:346

CO:347

等待。。。刷屏。。。等待。。。刷屏。。。。

————————————————

版权声明：本文为CSDN博主「回到未来望过去」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。

原文链接：https://blog.csdn.net/viviliving/article/details/100553285

       有关系统更新一直是玩家乃至于新巫师们关心的问题。比如，为何每隔15分钟大多数房间里杀死的NPC会重生？跑到别处或被玩家背到别处的NPC怎么会跑回去？为什么有的NPC跑不回去？什么有的东西会重生？为什么又有的东西只要别的玩家放在身上？等等。
　　目前主流MUDLIB都是ES系列的。从ES系列沿袭下来的更新都是通过ROOM的更新实现的。而ROOM的更新则是由MUDOS里的设置每隔一定时间（一般是15分钟）调用一次所有的有reset()函数的房间。而这个reset()函数则写在ROOM的标准继承文件里面。下面我们则来看看ROOM是如何实现房间里的生物、物品的重生或更新：
　　在写这篇文章之前，正好在网上看到darks兄写的《ROOM的结构》，于是我这篇文章的不少地方也就写得很顺畅了，有些直接引用了《ROOM》一文的一些内容。为了尊重原作者，凡是引用或出自darks兄的原文内容我都用“”与绿色标出：
　　ROOM的标准文件由于MUDLIB的不同，放在目录路径也不同，但大多情况下也就是/inherit/room/下或者与/obj/room/下两种可能而已。反正不检查一下在/include/下的globals.h，看这个文件里ROOM是定义在哪里就可以了，下面来看一看room.c的程序详解：

inherit F_DBASE;
//“这个是继承dbase标准继承，有了它，你才可使用set等函数为这个物件设定变数”（此问题日后做专题说明）。

inherit F_CLEAN_UP;
//“这个用来定时清除很久没被访问的room”，这个概念我们要在后面谈到。

static mapping doors;
//“这是一个有关房间里的门的全局变量，不是我们今天讨论的范围之内，你只要知道就行，我们在这个文件里还能找到与门相关的几个函数：”

mixed set_door(string dir, string prop, mixed data)
mixed query_door(string dir, string prop)
mapping query_doors()
string look_door(string dir)
varargs int open_door(string dir, int from_other_side)
varargs int close_door(string dir, int from_other_side)
varargs int lock_door(string dir, string key, int from_other_side)
varargs int unlock_door(string dir, string key, int from_other_side)
int check_door(string dir, mapping door)
varargs void create_door(string dir, mixed data, string other_side_dir, int status)
int valid_leave(object me, string dir)
int query_max_encumbrance() { return 100000000000; }
//设置可容纳的重量，以上这些函数大多与门有关，我们今天都一一略过，下面才是我们今天要研究的与系统房间刷新相关的函数：

object make_inventory(string file)
{
　　object ob;
　　ob = new(file);
//根据传递来的路径名，将ob复制出来
　　ob->move(this_object());
//复制出来的ob移于目的地
　　ob->set("startroom", base_name(this_object()));
　　return ob;
}
//这个函数用来产生一个房间里的物品。首先它需要别的函数在调用它的时候要传递给它一个需要产生的物件的路径。然后用new()复制出来，接着move到这个房间里，再接着给它设上startroom这个标记，这个标记就可以在这个房间定时呼叫自己房间里产生的npc可以使用return_home()这个函数时，正确回到原来的地方。

void reset()
{
　　mapping ob_list, ob;
　　string *list;
　　int i,j;

　　set("no_clean_up", 0);
//“这个标记为零，即允许系统到了规定时间将这个文件扫出内存，那么这个文件内的所有东西都会消失。由于room标准继承有这句，似乎发现只要继承它的房间文件无论写为0/1都是无效的，因为都会在这里被清除成零。”

　　ob_list = query("objects");
//先取出一个这个房间初始设定的objects的映射集
　　if( !mapp(ob_list) ) return;
//如果这个房间初始时就没有设定有生物物品，就说明根本无需要刷新，因此到此返回。

　　if( !mapp(ob = query_temp("objects")) )
　　ob = allocate_mapping(sizeof(ob_list));
//程序到后面才可看到ob = query_temp("objects")是如何出来的，在这里，我们先不管，你只要知道，如果是一个刚刚编译进内存的房间，是不会有ob这个映射集的，因此需要用allocate_mapping按照ob_list的多少为这个新设定的映射集ob分配内存大小。

　　list = keys(ob_list);
//从ob_list映射中取出关键字组成一个新数组。

　　for(i=0; i<sizeof(list); i++)
//开始循环检查这个数组里的每一项
　　{
　　　　if( undefinedp(ob[list[i]])
　　　　　　&& intp(ob_list[list[i]])
　　　　　　&& ob_list[list[i]] > 1 )
　　　　　　ob[list[i]] = allocate(ob_list[list[i]]);
//如果房间里曾经定义了要产生物品，并且数量不止一个的话，就要进行ob[list[i]]这个物件数组的内存分配

　　　　switch(ob_list[list[i]])
　　　　{
　　　　case 1:
//举例一个文件里：set("objects",(["/d/city/npc/bing":1]));，那么在这里，也就是ob_list[list[i]]这个值取出是1

　　　　　　if( !ob[list[i]] )
　　　　　　　　ob[list[i]] = make_inventory(list[i]);
//如果这一个对象已经不在了（玩家理解的就是被杀死了或被当作任务送掉了，巫师的理解就是被destruct了），就使用make_inventory()函数再重新制造一个放进来。这里注意了，仁去递过去的list[i]就是这一项物品的路径名，正因为有了路径名，make_inventory()函数才能正确制造出新的来。

　　　　　　if( environment(ob[list[i]]) != this_object())
//反之如果还存在，但它目前所处之地却不是目前的这个房间

　　　　　　{
　　　　　　　　if(ob[list[i]]->is_character()
　　　　　　　　　　&&!ob[list[i]]->return_home(this_object()))
　　　　　　　　add("no_clean_up",1);
//这句判断该物体如果是生物，就呼叫生物的return_home()叫它回来，如果这个NPC不能回来并且返回值是0的话，就会给这个房间增加一次no_clean_up的记号，程序的原作者之所以要在这里增加房间的no_clean_up记号，估计它的意思就是不想让系统在房间不能成功召回自己的NPC的情况下清除它，因为它想在以后的刷新中再把它呼叫回来。但是实际上，大家注意到前面的程序了吧，只要产生了下一次呼叫reset()时，前面就会把no_clean_up设为0，因此这段ES的源程有些莫名其妙，但大家居然都没人改，也是怪事。

　　　　　　}
　　　　　　break;
　　　　　　default:
//除此之外，也就是物件不止一个的话，举例相当于文件里：set("objects",(["/d/city/npc/bing":2]))或者3,4....这类的情况

　　　　　　for(j=0; j<ob_list[list[i]]; j++)
　　　　　　{
　　　　　　　　if( !objectp(ob[list[i]][j]) )
　　　　　　　　{
　　　　　　　　　　ob[list[i]][j] = make_inventory(list[i]);
　　　　　　　　　　continue;
　　　　　　　　}
　　　　　　　　if( environment(ob[list[i]][j]) != this_object())
　　　　　　　　{
　　　　　　　　　　if(ob[list[i]][j]->is_character()
　　　　　　　　　　&&!ob[list[i]][j]->return_home(this_object()) )
　　　　　　　　　　add("no_clean_up", 1);
　　　　　　　　}
　　　　　　}
//这里其实与物件只有一个是一样的，只是因为相同的物品不止一个，需要进行几次的循环判断而已。

　　　　 }
　　}
　　set_temp("objects", ob);
//看到这里，知道这个函数里ob映射集是如何来的了吧，实际上ob_list就是代表的这个房间里的的query("objects")，是一个字符串内容的映射集，而ob就是代表的这个房间里的query_temp("objects")它实际上一个object型的映射集。
}

　　reset()函数结束了，其实在ROOM里，除了这两个函数，还有一个在一开始编译进内存后进行首次调用reset()函数的setup()函数之外，其它的函数都是有关门的，都是可以去掉并影响房间的主要功能的，ROOM标准继承的最主要功能就是定时检查自己房间里的物品是否还在？是否需要更新等等。而这个定时则就是由MUDOS定义并按时呼叫房间里的reset()，这个时间绝大多数被定义为十五分钟。
　　我们通过上面的程序详解可以看出，当一个房间被编译成功进入内存之后，那么这个房间就将自身产生出来的各个物体（假如它有的话）记入一个query_temp("objects")的物件映射变量中，这个变量与我们写程序里的query("objects")是一一对应的，只不过query("objects")里记的是这此物件的
文件路径，而query_temp("objects")里记的是这些具体的物件。关于这两个映射的区别，有兴趣的新巫师可以找一个有很多NPC的房间按下面分别call两次，看看区别：
call here->query("objects")
call here->query_temp("objects")

　　在reset()被调用时，程序就会循环地一个个地查找这些物件是否还在MUD中？如果这些物件都已经不存在了，那么，reset()函数就会通过呼叫make_inventory()函数将其再次制造出来，也就是我们看到了，更新时间一到，很多被杀死的NPC，用掉的东西都会在原处产生出来。
　　而如果这些物件都还在MUD中，就会检查它们是否还在原处？如果不在的话，只要是生物，就呼叫它的return_home()函数（这个函数在所有NPC的标准继承
/inherit/char/npc.c里），叫它回来。并且要把这个房间作为参数传递过去，否则NPC会回不来。如果不是生物只得作罢（这就是房间产生出的物品如果被某一玩家放在身上，就再也不能重生的原因）。那么下面我们就来看一下npc.c里的return_home()函数：

int return_home(object home)
//注意，括号里的home就是呼叫它回家的那个房间，当时是叫this_object()
{
　　if( !environment()|| environment()==home ) return 1;
//再次检查：是否在一个存在的环境里？是否已经回来了？如果是，则什么也不做，返回！
　　if( !living(this_object())|| is_fighting()) return 0;
//如果NPC处于昏迷或战斗状态，则不回来，返回值是0,综合room.c，原房间会增加no_clean_up记号;
　　message("vision", this_object()->name() + "急急忙忙地离开了。\n",environment(), this_object());
　　return move(home);
}

　　谈到这里，大家可以发现，所谓房间的更新，实际上只是房间里的物体进行更新，这个房间没有任的变化。也就是说，如果在房间更新的时候，我们站在这个房间里，或者我们扔了一个不属于任何房的物品在这个房间里，都不会受到影响，这些物品与我们在更新前后都不会消失。这个与我们巫师进update here是本质性的两回事（updata here就是更新了房间）。

　　那么，有时有的玩家就会说，我曾得到一个很好的宝物，离线不能保存，我就把它扔在一个很少有去的地方，结果，每次再去连线再去找的时候，大多数时候都找不到，不会是被别人捡去吧？这里就及到另一个概念：MUD里的资源清除。
　
　　大家知道，在LPMUD里，所有的程序都必须装载进内存里才会工作。因此，MUD的内存资源便就是最主要的资源。更合理地分配和使用内存便成为一个MUD效率高低的体现。
　　MUDOS为了节约内存的耗用，对于每一个占用内存的对象，包括是房间、物品、人物、指令等等，如果相当长的时间内没有被其它程序参考到（参考的含义：就是包括别人进入、看到、或者使用到这个房间、物品、或指令，还包括各个程序等等）的话，也就是这个对象很长时间没有活动了，MUDOS就会调用这个对象的clean_up()函数（由于大多数的程序都会继承这个函数标准文件），如果该函数返回1，则下次同样情况还会调用该对象的clean_up；如果返回0，则永远不再调用。那么，我们就来看一下/feature/下面的clean_up.c文件，这个文件只有一个函数：

int clean_up()
{
　　object *inv;
　　int i;

　　if( !clonep() && this_object()->query("no_clean_up") )
　　　　return 1;
//如果这个对象不是clone出来并且有"no_clean_up"记号的，则返回1（返回1的含义上面说过了）

　　if(interactive(this_object())) return 1;
//如果对象是互动物件，比如玩家，就返回1

　　if(environment()) return 1;
//如果对象处在一个环境里，也返回1

　　inv = all_inventory();
//取出这个对象里面所有的物件
　　for(i=sizeof(inv)-1; i>=0; i--)
　　if(interactive(inv[i])) return 1;
//循环检查这些物件，只要其中有一个互动物件，就返回1

　　destruct(this_object());
　　return 0;
//全部检查完了后，就决定正式摧毁自身，释放出这个对象所占用的内存，并返回0
}

　　我们再次复习一下clean_up()函数返回1的含义，如果clean_up()函数返回1，则MUDOS在这一次的调用时不会做其的任何举动，但到了下一次想调用的时间里，还将再次调用这个对象的clean_up()函数。那么从这可以看出，有以下四种情况不会将其清除出内存：
一、非clone出来并且有no_clean_up参数的对象；
二、玩家永远不会
三、处于一个还存在的环境里
四、自己里面存在着玩家
　　也就是MUDOS定时摧毁内存不需要的对象是由外向内的，比如一个房间，系统只要检查这个房间里没有no_clean_up参数、里面没有玩家就可清除它，而房间里的物品、NPC都会因环境的不存在而消失。这个清除的定时时间一般都为两个小时。当然要视不同的MUDOS里的设置而看的。
　　再说一点题外话，如果一个房间长时间没有玩家走进来，当然会被MUDOS清出内存，而突然又有玩家进来呢？很简单，它会在一瞬间被编译进内存，进入一个已经存在在内存里的房间与进入一个刚刚编译出来进入内存的房间对于我们的玩家来说，是察觉不出它们之间的差异的。　  

    本文介绍了 MudOS中使用的散 列函数，并对包装了散列函数的散 列表寻址操作做了一个简单的分析，最后模拟MudOS中object hash table实现了一个简 化的散列表。

    在MudOS中，散列 表的应用非常广泛，可以说凡是用到查找的地方都用到了散列（hash table），散列的好处在于它的 效率，理想状态下，搜索、插入、删除操作的时间均为O(1)，在应用中，虽然达不到这样的理想状态，但相 比于其它数据结构来说，hash table的优势还是很明显的。在非理想状态下，不可避免的会遇到碰撞 问题（collision），MudOS源码中处理碰撞 所采用的方法是使用链表散列。

散列函数（hash function）

    在最新发布的MudOS源码（v22.2b14）中，散列函数（hash function）定义于hash.c：

/* hash.c */

/*

** A simple and fast generic string hasher based on Peter K.  Pearson's

** article in CACM 33-6, pp. 677.

*/

#define EDIT_SOURCE

#define NO_SOCKETS

#define NO_OPCODES

#include "std.h"

static int T[] =

{

    1, 87, 49, 12, 176, 178, 102, 166, 121, 193, 6, 84, 249,  230, 44, 163,

    14, 197, 213, 181, 161, 85, 218, 80, 64, 239, 24, 226,  236, 142, 38, 200,

    110, 177, 104, 103, 141, 253, 255, 50, 77, 101, 81, 18,  45, 96, 31, 222,

    25, 107, 190, 70, 86, 237, 240, 34, 72, 242, 20, 214, 244, 227, 149, 235,

    97, 234, 57, 22, 60, 250, 82, 175, 208, 5, 127, 199, 111,  62, 135, 248,

  174, 169, 211, 58, 66, 154, 106, 195, 245, 171, 17, 187,  182, 179, 0, 243,

 132, 56, 148, 75, 128, 133, 158, 100, 130, 126, 91, 13, 153,  246, 216, 219,

    119, 68, 223, 78, 83, 88, 201, 99, 122, 11, 92, 32, 136,  114, 52, 10,

    138, 30, 48, 183, 156, 35, 61, 26, 143, 74, 251, 94, 129,  162, 63, 152,

    170, 7, 115, 167, 241, 206, 3, 150, 55, 59, 151, 220, 90,  53, 23, 131,

    125, 173, 15, 238, 79, 95, 89, 16, 105, 137, 225, 224,  217, 160, 37, 123,

    118, 73, 2, 157, 46, 116, 9, 145, 134, 228, 207, 212, 202, 215, 69, 229,

    27, 188, 67, 124, 168, 252, 42, 4, 29, 108, 21, 247, 19,  205, 39, 203,

 233, 40, 186, 147, 198, 192, 155, 33, 164, 191, 98, 204, 165, 180, 117, 76,

    140, 36, 210, 172, 41, 54, 159, 8, 185, 232, 113, 196,  231, 47, 146, 120,

    51, 65, 28, 144, 254, 221, 93, 189, 194, 139, 112, 43, 71, 109, 184, 209,

};

INLINE int

hashstr P3(char *, s,           /* string to hash */

                  int, maxn,      /* maximum number of chars to consider */

                  int, hashs)

{

    register unsigned int h;

    register unsigned char *p;

    h = (unsigned char) *s;

    if (h) {

       if (hashs > 256) {

           register int oh = T[(unsigned char) *s];

           for (p = (unsigned char *) s + 1; *p

                     && p <= (unsigned char *) s + maxn; p++) {

              h = T[h ^ *p];

              oh = T[oh ^ *p];

           }

           h |= (oh << 8);

       } else

           for (p = (unsigned char *) s + 1; *p

                     && p <= (unsigned char *) s + maxn; p++)

              h = T[h ^ *p];

    }

    return (int) (h % hashs);

}

/*

 * whashstr is faster than hashstr, but requires an even  power-of-2 table size

 * Taken from Amylaars driver.

 */

INLINE int

whashstr P2(char *, s, int, maxn)

{

    register unsigned char oh, h;

    register unsigned char *p;

    register int i;

       if(!s)return 0;

    if (!*s)

              return 0;

    p = (unsigned char *) s;

    oh = T[*p];

    h = (*(p++) + 1) & 0xff;

    for (i = maxn - 1; *p && --i >= 0; ) {

              oh = T[oh ^ *p];

              h = T[h ^ *(p++)];

    }

    return (oh << 8) + h;

}

注释中说明这两个函数基于Pearson发表的一篇 文章，这篇文章发表于Communications of the ACM archive Volume 33,  Issue 6 (June 1990)，文章题目是: Fast hashing of  variable-length text strings。whashstr函数取自于Amylaars driver——另一个mud driver？ 这个函数比第一个函数hashstr速度要快一点，因此在MudOS中 全部采用whashstr函数来实现散列表。

我并没有找到Pearson的那篇文章，对于数组T[]的产生也就无从得知，在查找资料（参 考资料3）时找到另一个产生的T的算法和一个散列函数：

  -- use an array of 256 1-byte values

  ub1 x[0..255];

  -- fill it with the values 0 to 255 in some  pseudorandom order

  -- (this is derived from the alleged RC4)

  { for i in 0..255 do

    { x[i] := i;

    }

  }

  k=7;

  { for j in 0..3 do

    { for i in 0..255 do

      { s = x[i];

        k = (k + s) mod 256;

        x[i] = x[k];

        x[k] = s;

      }

    }

  }

  -- use the length of the message to initialize the  hash

  -- XXX can be 0, or some constant, or some argument

  hash := (XXX+len) mod 256;

  -- hash the characters in the message one byte at a  time

  {for i in 0..len-1 do

{hash := (hash +  message[i]) mod 256;  hash := x[hash];}}

将生成T的算法写成c函数：

void gen_T(int* vec)

{

       int i, j, s, k = 7;

       for (i = 0; i < 256; ++i)

       {

              vec[i] = i;

       }

       for (j = 0; j < 4; ++j)

       {

              for (i = 0; i < 256; ++i)

              {

                     s = vec[i];

                     k = (k + s) % 256;

                     vec[i] = vec[k];

                     vec[k] = s;

              }

       }

}

于是，我们有 了另一个散列函数：

static int simulate_T[] =

{

        49,118,63,252,13,155,114,130,137,40,210,62,219,246,136,221,

        174,106,37,227,166,25,139,19,204,212,64,176,70,11,170,58,

        146,24,123,77,184,248,108,251,43,171,12,141,126,41,95,142,

        167,46,178,235,30,75,45,208,110,230,226,50,32,112,156,180,

        205,68,202,203,82,7,247,217,223,71,116,76,6,31,194,183,

        15,102,97,215,234,240,53,119,52,47,179,99,199,8,101,35,

        65,132,154,239,148,51,216,74,93,192,42,86,165,113,89,48,

        100,195,29,211,169,38,57,214,127,117,59,39,209,88,1,134,

        92,163,0,66,237,22,164,200,85,9,190,129,111,172,231,14,

        181,206,128,23,187,73,149,193,241,236,197,159,55,125,196,60,

        161,238,245,94,87,157,122,158,115,207,17,20,145,232,107,16,

        21,185,33,225,175,253,81,182,67,243,69,220,153,5,143,3,

        26,213,147,222,105,188,229,191,72,177,250,135,152,121,218,44,

        120,140,138,28,84,186,198,131,54,2,56,78,173,151,83,27,

        255,144,249,189,104,4,168,98,162,150,254,242,109,34,133,224,

        228,79,103,201,160,90,18,61,10,233,91,80,124,96,244,36           

};

int simulate_hashstr(char * s, int len)

{

       int h = len % 256;

       for (int i = 0; i < len; ++i)

       {

              h = (h + s[i]) % 256;

              h = simulate_T[h];

       }

       return h;

}

显然，这个散 列函数生成的值在0~255之间。

处理字符串的散列函数还有很多，详见参 考资料3。

使用散列函数寻址

       在MudOS源码（v22.2b14）中，定义了5个宏或函数分别处理应用中的各个散列表的寻址操作，这些宏包装了whashstr函数以方便使用：

1.          

/* lex.h */

#define DEFHASH 64

#define defhash(s) (whashstr((s), 10) & (DEFHASH - 1))

2.          

/* lex.c */

#define IDENT_HASH_SIZE 1024

#define IdentHash(s) (whashstr((s), 20) & (IDENT_HASH_SIZE - 1))

3.        

/* object.c */

/* CFG_LIVING_HASH_SIZE定义于 options.h

   #define CFG_LIVING_HASH_SIZE     256 */

INLINE_STATIC int hash_living_name P1(char *, str)

{

    return whashstr(str, 20) & (CFG_LIVING_HASH_SIZE - 1);

}

4.         

/* otable.c */

#define ObjHash(s) whashstr(s, 40) & otable_size_minus_one

5.         

/* stralloc.c */

#define StrHash(s) (whashstr((s), 20) & (htable_size_minus_one))

    对于1、2、3，参数和 函数功能已经很明显：萃取（extract）低位字节作为被评估（evaluated） 的字符串所在散列表的位置，对应的散列表的大小为DEFHASH，IDENT_HASH_SIZE，CFG_LIVING_HASH_SIZE，由于使用的“&” 操作（按位与）来萃取低位字节，因此，需要将这些散列表的大小置为2的指数。

    对于第4个宏，参数otable_size_minus_one在 otable.c中 被赋值。

/* otable.c */

/*

 * hash table - list of pointers to heads of object chains.

 * Each object in chain has a pointer, next_hash, to the next object.

 */

static object_t **obj_table = 0;

void init_otable()

{

    int x, y;

    /* ensure that  otable_size is a power of 2 */

    y = OTABLE_SIZE;

    for (otable_size = 1; otable_size < y; otable_size *= 2)

       ;

    otable_size_minus_one = otable_size - 1;

    obj_table = CALLOCATE(otable_size, object_t *,

                       TAG_OBJ_TBL, "init_otable");

    for (x = 0; x < otable_size; x++)

       obj_table[x] = 0;

}

    宏OTABLE_SIZE的功能为存储配置文件中object table size的值，在MudOS启动时，在main函数里调用读取配置文件的函数，对OTABLE_SIZE进 行赋值，在init_otalbe函数中将这个值调整为2的 指数，并将这个值赋给otable_size_minus_one。

    对于第5个宏，htable_size_minus_one的 赋值过程与otable_size_minus_one大同小异。但是在查看某个mudlib的配置文件时发现下面的问题：

/* 取自config.xxx */

# Define  the size of the shared string hash table.  This number should

# a prime, probably between 1000 and 30000; if you set it to about 1/5

# of the  number of distinct strings you have, you will get a hit ratio

# (number  of comparisons to find a string) very close to 1, as found strings

# are  automatically moved to the head of a hash chain.  You will never

# need  more, and you will still get good results with a smaller table.

hash table size : 7001

    注释中（以#开头的语句），说明hash table size必须为质数（prime），然而源代 码中却需要保证这个值为2的指数。我想出现前后矛盾的原因大概和MudOS版 本差异有关：比较早的版本使用的是hashstr 函数 ，这个函数在后续的寻址操作中用的是“%” 求模运算，而使用质数作为hash table的大小在解决碰撞的效率上要好些（猜测如此，未经求证），因此这些mudlib的config文件就一直沿用这些传统；目前比较新的MudOS版本采用的是whashstr 函数，其后续的寻址操作——正如之前介绍的，用的是“&”按位与运算，这 必然要求hash table的大小必须为2的指数。

散列表的实现

    有了前面分析的散列函数和宏，本文将以object table为 例，来实现一个hash table，object table实 现的源码参见最新发布的MudOS源码 （v22.2b14）中的otable.c。下面这些代码与源码有差异，这么做的 原因是为了不牵涉到具体应用，而仅仅是单纯的实现一个hash table。

/* hashtable.h */

#if !defined(_HASH_TABLE_H_)

#define _HASH_TABLE_H_

#define STRING_SIZE 64

typedef struct object_s {

       char name[STRING_SIZE];

       struct object_s *next_hash;

       char value[STRING_SIZE];

} object_t;

void init_otable();

void clear_otable();

void enter_object_hash(object_t *);

void remove_object_hash(object_t *);

object_t *lookup_object_hash(char *);

void dump();

#endif     // _HASH_TABLE_H_

/* hashtable.c */

#include "stdafx.h"

#include "stdlib.h"

#include "stdio.h"

#include "string.h"

#include "hashtable.h"

#define BUCKET_SIZE 256    

static int otable_size;

static int otable_size_minus_one;

int whashstr(char *, int);

#define ObjHash(s) whashstr((char *)s, 40) & otable_size_minus_one

/*

* hash table - list of  pointers to heads of object chains.

* Each object in chain  has a pointer, next_hash, to the next object.

*/

static object_t **obj_table = 0;

void init_otable()

{

    int y;

    /* ensure that  otable_size is a power of 2 */

    y = BUCKET_SIZE;

    for (otable_size = 1; otable_size < y; otable_size *= 2)

              ;

    otable_size_minus_one = otable_size - 1;

       /* by using calloc,  each element in obj_table is initialized to 0 */

    obj_table = (object_t **)calloc(otable_size, sizeof(object_t *));

}

void clear_otable()

{

       int i;

       free(obj_table);

       for (i = 0; i < BUCKET_SIZE; ++i) {

              obj_table[i] = 0;

       }

}

/* A global. */

static int h;

/*

* Looks for obj in  table, moves it to head.

*/

object_t *find_obj_n(char * s)

{

    object_t *curr, *prev;

    h = ObjHash(s);

    curr = obj_table[h];

    prev = 0;

    while (curr) {

              if (!strcmp(curr->name, s)) {      /* found it */

                     if (prev) {             /* not at head of list */

                            prev->next_hash = curr->next_hash;

                            curr->next_hash = obj_table[h];

                            obj_table[h] = curr;

                     }

                     return (curr);  /* pointer to object */

              }

              prev = curr;

              curr = curr->next_hash;

    }

    return (0);                   /* not  found */

}

/*

* Add an object to the  table - can't have duplicate names.

*/

void enter_object_hash(object_t * ob)

{

    object_t *s;

    s = find_obj_n(ob->name); /* This sets h */

    ob->next_hash = obj_table[h];

    obj_table[h] = ob;

    return;

}

/*

* Remove an object from the table - generally called when it

* is removed from the  next_all list - i.e. in destruct.

*/

void remove_object_hash(object_t * ob)

{

    object_t *s;

    s = find_obj_n(ob->name); /* this sets h, and  cycles the ob to the front */

    obj_table[h] = ob->next_hash;

    ob->next_hash = 0;

    return;

}

/*

* Lookup an object in  the hash table; if it isn't there, return null.

* This is only  different to find_object_n in that it collects different

* stats; more finds are actually done than the user ever asks for.

*/

object_t *lookup_object_hash(char * s)

{

    return find_obj_n(s);

}

/*

* Display the sum of  elements in obj_table.

*/

void dump()

{

       int i, count;

       object_t * curr;

       for (i = 0; i < BUCKET_SIZE; ++i) {

              count = 0;

              curr = obj_table[i];

              while (curr) {

                     ++count;

                     curr = curr->next_hash;

              }

              printf("%d\n", count);

       }

}

/* Hash function. */

static int T[] =

{

    1, 87, 49, 12, 176, 178, 102, 166, 121, 193, 6, 84, 249, 230, 44, 163,

              14, 197,  213, 181, 161, 85, 218, 80, 64, 239, 24, 226, 236, 142, 38, 200,

              110, 177, 104, 103, 141, 253, 255, 50, 77, 101, 81, 18, 45, 96, 31, 222,

              25, 107,  190, 70, 86, 237, 240, 34, 72, 242, 20, 214, 244, 227, 149, 235,

              97, 234,  57, 22, 60, 250, 82, 175, 208, 5, 127, 199, 111, 62, 135, 248,

              174, 169, 211, 58, 66, 154, 106, 195, 245, 171, 17, 187, 182, 179, 0, 243,

              132, 56,  148, 75, 128, 133, 158, 100, 130, 126, 91, 13, 153, 246, 216, 219,

              119, 68,  223, 78, 83, 88, 201, 99, 122, 11, 92, 32, 136, 114, 52, 10,

              138, 30,  48, 183, 156, 35, 61, 26, 143, 74, 251, 94, 129, 162, 63, 152,

              170, 7,  115, 167, 241, 206, 3, 150, 55, 59, 151, 220, 90, 53, 23, 131,

              125, 173, 15, 238, 79, 95, 89, 16, 105, 137, 225, 224, 217, 160, 37, 123,

              118, 73,  2, 157, 46, 116, 9, 145, 134, 228, 207, 212, 202, 215, 69, 229,

              27, 188,  67, 124, 168, 252, 42, 4, 29, 108, 21, 247, 19, 205, 39, 203,

              233, 40,  186, 147, 198, 192, 155, 33, 164, 191, 98, 204, 165, 180, 117, 76,

              140, 36,  210, 172, 41, 54, 159, 8, 185, 232, 113, 196, 231, 47, 146, 120,

              51, 65,  28, 144, 254, 221, 93, 189, 194, 139, 112, 43, 71, 109, 184, 209,

};

int whashstr(char * s, int maxn)

{

    register unsigned char oh, h;

    register unsigned char *p;

    register int i;

       if(!s)return 0;

    if (!*s)

              return 0;

    p = (unsigned char *) s;

    oh = T[*p];

    h = (*(p++) + 1) & 0xff;

    for (i = maxn - 1; *p && --i >= 0; ) {

              oh = T[oh ^ *p];

              h = T[h ^ *(p++)];

    }

    return (oh << 8) + h;

}

这份代码实现了一个hashtable的基本操作：插入，删除，查找。为了测试这个hashtable， 我写了一份非常简单的测试代码，测试数据取自于http://www.graphcomp.com/info/mud/mudos/History_MudOS.html，为了简化代码，我用python对这篇文章进行 了一下处理，首先保存这篇文章的内容为: history_mudos.txt，我把它存放在E盘根目录，python处理源码如下：

#  preread.py

import re

def foo  ():

    rex =  re.compile('[A-Za-z0-9]+')

    f =  open('e:\out.txt','w')

    for  line in open('e:\histroy_mudos.txt','r'):

         for word in rex.findall(line):

            f.write(word)

            f.write('\n')

在python控 制台下运行这些代码，获得处理过的文件out.txt，out.txt中 将包含history_mudos.txt中的所有单词，每个单词按行排列。有了经过预处理的out.txt，编写测试代码就简单得多了，为了更加简化操作，下面的代码将使用c++来 编写：

/* main.cpp */

#include <iostream>

#include <fstream>

#include

#include <string>

#include <vector>

#include <set>

#include "hashtable.h"

using namespace std;

static vector<object_t *> ob_table;

struct constructor {

       operator () (const string& str)

       {

              object_t * pob = new object_t;

              strcpy(pob->name, str.c_str());

              strcpy(pob->value, strupr(const_cast<char*>(str.c_str())));

              pob->next_hash = 0;

              ob_table.push_back(pob);

       }

};

struct destructor {

       operator () (object_t * pob)

       {

              delete pob;

              pob = 0;

       }

};

struct ob_inserter {

       operator () (object_t * pob)

       {

              enter_object_hash(pob);

       }

};

void create()

{

       ifstream infile;

       string str;

       infile.open("E:\\out.txt");

       set<string> word_set;

       while (getline(infile, str)) {

              word_set.insert(str);

       }

       for_each(word_set.begin(), word_set.end(), constructor());

       infile.close();

       init_otable();

       for_each(ob_table.begin(), ob_table.end(), ob_inserter());

}

void clear()

{

       for_each(ob_table.begin(), ob_table.end(), destructor());

       clear_otable();

}

void lookup(char* s)

{

       object_t * pob = lookup_object_hash(s);

       if (pob)

              cout << pob->value << endl;

}

int main(void)

{

       create();

       lookup("the");

       lookup("history");

       lookup("of");

       lookup("MudOS");

       dump();

       clear();

}

编译运行，结果如下：

THE

OF

MUDOS

dump函数统计个数见下图，总共651个点，对于散列大 小为256而言，这样的分布还是满足要求的。

结果证明这份hash table的实现代码是正确的。

参考资料：

[1]    Sartaj  Sahni. Data Structures, Algorithms, and Applications in C++

[2]    侯捷. 《STL源码分析》

[3]    http://burtleburtle.net/bob/hash/index.html

[4]    http://www.mudos.org/

/****************************************************************************
 * EVERY time you change ANYTHING in this file, RECOMPILE from scratch.     *
 * (type "make clean" then "make" on a UNIX system) Failure to do so may    *
 * cause the driver to behave oddly.                                        *
 ****************************************************************************/

/* NOTES: Many of the configurable options are now set in the runtime config.
 *
 * This file only contain a list of default settings, for quick diffing .
 * See detailed explaination from 'local_options.README'
 */

#ifndef _LOCAL_OPTIONS_H_
#define _LOCAL_OPTIONS_H_

/****************************************************************************
 *                              COMPAT                                      *
 ****************************************************************************/
#undef COMPAT_32
#undef NO_ADD_ACTION
#undef NO_SNOOP
#undef NO_ENVIRONMENT
#undef NO_WIZARDS
#undef NO_SHADOWS
#define NO_LIGHT
#undef PRIVS
#undef SENSIBLE_MODIFIERS

/****************************************************************************
 *                              BEHAVIOR                                    *
 ****************************************************************************/
#define OLD_ED
#undef ED_INDENT_CASE
#define ED_INDENT_SPACES 4
#undef RECEIVE_ED
#define RESTRICTED_ED

#define DEFAULT_PRAGMAS PRAGMA_WARNINGS + PRAGMA_SAVE_TYPES + PRAGMA_ERROR_CONTEXT + PRAGMA_OPTIMIZE
#define SAVE_EXTENSION ".o"
#define SAVE_GZ_EXTENSION ".o.gz"

#undef USE_ICONV
#undef IPV6
#undef DTRACE

/****************************************************************************
 *                              PACKAGES                                    *
 ****************************************************************************/
#undef CUSTOM_CRYPT
#define PACKAGE_ASYNC
#define PACKAGE_COMPRESS
#define PACKAGE_CONTRIB
#define PACKAGE_CORE
#undef PACKAGE_CRYPTO

#undef PACKAGE_DB
#ifdef PACKAGE_DB
#define USE_MYSQL 1
#undef USE_POSTGRES
#undef USE_SQLITE3
#endif

#define PACKAGE_DEVELOP
#undef PACKAGE_DWLIB
#define PACKAGE_EXTERNAL
#define PACKAGE_MATH
#undef PACKAGE_MATRIX
#define PACKAGE_MUDLIB_STATS
#define PACKAGE_OPS
#undef PACKAGE_PARSER
#define PACKAGE_PCRE
#define PACKAGE_SHA1
#define PACKAGE_SOCKETS
#define PACKAGE_TRIM
#undef PACKAGE_THREAD

#define PACKAGE_UIDS
#ifdef PACKAGE_UIDS
#define AUTO_SETEUID
#undef AUTO_TRUST_BACKBONE
#endif

#endif /* _LOCAL_OPTIONS_H_ */

#ifndef _OPTIONS_H_
#define _OPTIONS_H_

/*
 * YOU SHOULD NOT MODIFY THIS FILE DIRECTLY.
 *
 * Do 'cp options.h local_options' and edit that instead.
 *
 */

/****************************************************************************
 * EVERY time you change ANYTHING in this file, RECOMPILE from scratch.     *
 * (type "make clean" then "make" on a UNIX system) Failure to do so may    *
 * cause the driver to behave oddly.                                        *
 ****************************************************************************/

/* NOTES:
 * Many of the configurable options are now set via the configuration file
 *  that is specified as the first argument to the driver.
 * See port.h for those #defines related to portability (compatibility) if
 *  you have problems compiling on your system.
 * Removing an efun from func_spec.c usually removes most, if not all,
 *  of the code associated with it.
 * Note that anything defined in this file is also visible to LPC files
 * surrounded by __.  So #define FOO in this file defines __FOO__ for
 * all LPC files.  This allows code like:
 *
 * #ifdef __SENSIBLE_MODIFIERS__
 * ...
 */

/****************************************************************************
 *                              MALLOC                                      *
 *                             --------                                     *
 * For performance reasons, LP drivers have a variety of memory allocation  *
 * packages.  If you don't care, use the default one on your system:        *
 * #define SYSMALLOC, #undef the others.                                    *
 ****************************************************************************/

/* You must choose exactly one of these malloc packages:
 *     ~~~~
 * SYSMALLOC:
 *   * Built-in system malloc.
 *   * No statistics.
 *   * SYSMALLOC incurs no additional CPU or memory overhead.
 *
 * MALLOC64
 *   * Wodan's malloc, uses system malloc for small allocations and spreads
 *   * large allocations through the 64 bit memory space
 *   * won't work on 32 bit systems.
 * MALLOC32
 *   * fixes realloc by always doing a malloc/memcpy/free instead, try this
 *   * if you use more memory than expected (or MALLOC64 on a 64bit system).
 */
#undef SYSMALLOC
#define MALLOC64
#undef MALLOC32

/****************************************************************************
 *                          COMPATIBILITY                                   *
 *                         ---------------                                  *
 * The MudOS driver has evolved quite a bit over the years.  These defines  *
 * are mainly to preserve old behavior in case people didn't want to        *
 * rewrite the relevant portions of their code.                             *
 *                                                                          *
 * In most cases, code which needs these defines should be rewritten when   *
 * possible.  The 'Compat status' field is designed to give an idea how     *
 * likely it is that support for that option will be removed in the near    *
 * future.  Certain options are fairly easy to work around, and double      *
 * the size of the associated code, as well as the maintenance workload,    *
 * and can make the code significantly more complex or harder to read, so   *
 * supporting them indefinitely is impractical.                             *
 *                                                                          *
 * WARNING: If you are using software designed to run with the MudOS driver *
 *          it may assume certain settings of these options.  Check the     *
 *          instructions for details.                                       *
 ****************************************************************************/

/* explode():
 *
 * The old behavior (#undef both of the below) strips any number of
 * delimiters at the start of the string, and one at the end.  So
 * explode("..x.y..z..", ".") gives ({ "x", "y", "", "z", "" })
 *
 * SANE_EXPLODE_STRING strips off at most one leading delimiter, and
 * still strips off one at the end, so the example above gives
 * ({ "", "x", "y", "", "z", "" }).
 *
 * REVERSIBLE_EXPLODE_STRING overrides SANE_EXPLODE_STRING, and makes
 * it so that implode(explode(x, y), y) is always x; i.e. no delimiters
 * are ever stripped.  So the example above gives
 * ({ "", "", "x", "y", "", "z", "", "" }).
 */
#define SANE_EXPLODE_STRING
#undef REVERSIBLE_EXPLODE_STRING

/* NO_LIGHT: define this to disable the set_light() and driver maintenance
 *   of light levels in objects.  You can simulate it via LPC if you want...
 *
 * Compat status: Very dated, easy to simulate, and gross.
 */
#define NO_LIGHT

/* NO_ADD_ACTION: define this to remove add_action, commands, livings, etc.
 * process_input() then becomes the only way to deal with player input.
 *
 * Compat status: next to impossible to simulate, hard to replace, and
 * very, very widely used.
 */
#undef NO_ADD_ACTION

/* NO_SNOOP: disables the snoop() efun and all related functionality.
 */
#undef NO_SNOOP

/* NO_ADD_ACTION: define this to remove add_action, commands, livings, etc.
   process_input() then becomes the only way to deal with player input. */

/* NO_ENVIRONMENT: define this to remove the handling of object containment
 * relationships by the driver
 *
 * Compat status: hard to simulate efficiently, and very widely used.
 */
#undef NO_ENVIRONMENT

/* NO_WIZARDS: for historical reasons, MudOS used to keep track of who
 * is and isn't a wizard.  Defining this removes that completely.
 * If this is defined, the wizardp() and related efuns don't exist.
 *
 * Also note that if it is not defined, then non-wizards are always put
 * in restricted mode when ed() is used, regardless of the setting of
 * the restrict parameter.
 *
 * Compat status: easy to simulate and dated.
 */
#undef NO_WIZARDS

/* OLD_ED: ed() efun backwards compatible with the old version.  The new
 * version requires/allows a mudlib front end.
 *
 * Compat status: Easily simulated.
 */
#define OLD_ED

/* In ed auto-indent,
 * 1) does the case line get indented after the switch() ?
 * 2) How far do we indent? (this can also be set in the mudlib)
 */
#undef ED_INDENT_CASE
#define ED_INDENT_SPACES 4

/* SENSIBLE_MODIFIERS:
 * Turning this on changes a few things, which may break old code:
 *
 * (1) 'static' is not recognized; either 'nosave' or 'protected' must
 *     be used instead.
 * (2) The old meaning of 'public' is no longer allowed.  Explicit
 *     functions must be defined at each level to allow access to
 *     privately inherited functions.
 * (3) 'public' now means the default visibility.  Previously there was
 *     no keyword that meant this (before you ask, 'public' meant something
 *     else, and if you don't know that, you probably don't have any reason
 *     to care about the old meaning).
 */
#undef SENSIBLE_MODIFIERS

/* SANE_SORTING: Use system provided fastest sorting routine for various
 * sorting, including sort_array EFUN.
 *
 * This replace the old internal version qsort which only sorts to one
 * direction repetitively. so following LPC code:
 *
 *    sort_array(({4,3,2,1}), (: -($1<$2) :));
 *
 * can still return ({1,2,3,4}), even though it only returns -1 and 0.
 *
 * It is recommended to fix your LPC code to not rely on this behavior.
 *
 * Your LPC code should return 1, 0, -1 for situation where first argument
 * is less than, equal to, or greater than the second argument. This will
 * will work with both implementation.
 *
 * Old code should work fine with this added, easy to inspect by searching
 * for sort_array.
 */
#define SANE_SORTING

/* WARN_TAB: Some versions of the editor built in indent function use
 *   tabs for indenting. This options turns on a warning message for
 *   files indented with tabs instead of spaces.
 */
#undef WARN_TAB

/* WOMBLES: don't allow spaces between start/end of array/mapping/functional
 * token chars so ({1,2,3}) still works, but ( { 1 , 2 , 3 } ) doesn't
 * and ({ 1 , 2 , 3 }) does.*/
#undef WOMBLES

/* CALL_OTHER_TYPE_CHECK: enable type checking for call_other()
 * (-> operator on objects)
 */
#undef CALL_OTHER_TYPE_CHECK

/* CALL_OTHER_WARN, make it warning instead of errors */
#undef CALL_OTHER_WARN

/****************************************************************************
 *                           MISCELLANEOUS                                  *
 *                          ---------------                                 *
 * Various options that affect the way the driver behaves.                  *
 *                                                                          *
 * WARNING: If you are using software designed to run with the MudOS driver *
 *          it may assume certain settings of these options.  Check the     *
 *          instructions for details.                                       *
 ****************************************************************************/

/*
 * Define this in order to use Fermat@Equilibria's MD5 based crypt() instead
 * of the operating system's.  It has the advantage of giving the same value
 * on all architectures, and being stronger than the standard UNIX crypt().
 *
 * Consider use PACKAGE_CRYPTO instead.
 */
#undef CUSTOM_CRYPT

/*
 * Some minor tweaks that make it a bit easier to run code designed to run
 * on LPmud 3.2/3.2.1.  Currently has the following effects:
 *
 * . m_indices() and m_values() are synonyms for keys() and values(),
 *   respectively
 * . map_delete() returns it's first argument
 * . inherit_list() means deep_inherit_list(), not shallow_inherit_list()
 * . heart_beat_info() is a synonym for heart_beats()
 */
#undef COMPAT_32

/* MUDLIB_ERROR_HANDLER: If you define this, the driver doesn't do any
 *   handling of runtime errors, other than to turn the heartbeats of
 *   objects off.  Information about the error is passed in a mapping
 *   to the error_handler() function in the master object.  Whatever is
 *   returned is put in the debug.log.
 *
 * A good mudlib error handler is one of the best tools for tracking down
 * errors.  Unfortunately, you need to have one.  Check the testsuite or
 * other libs for an example.
 */
#define MUDLIB_ERROR_HANDLER

/* CONFIG_FILE_DIR specifies a directory in which the driver will search for
 *   config files by default.  If you don't wish to use this define, you may
 *   always specify a full path to the config file when starting the driver.
 */
#define CONFIG_FILE_DIR "/home/atuin/bin"

/* DEFAULT_PRAGMAS:  This should be a sum of pragmas you want to always
 * be on, i.e.
 *
 * #define DEFAULT_PRAGMAS PRAGMA_STRICT_TYPES + PRAGMA_SAVE_TYPES
 *
 * will make every LPC file behave as if it had the lines:
 * #pragma strict_types
 * #pragma save_types
 *
 * for no default pragmas:
 * #define DEFAULT_PRAGMAS 0
 *
 * If you don't know what these are, 0 is a good choice.
 *
 * Supported pragmas:
 * PRAGMA_STRICT_TYPES: enforces strict type checking
 * PRAGMA_WARNINGS:     issues warnings about various dangerous things in
 *                      your code
 * PRAGMA_SAVE_TYPES:   save the types of function arguments for checking
 *                      calls to functions in this object by objects that
 *                      inherit it.
 * PRAGMA_OPTIMIZE:     make a second pass over the generated code to
 *                      optimize it further.
 * PRAGMA_ERROR_CONTEXT:include some text telling where on the line a
 *                      compilation error occured.
 */
#define DEFAULT_PRAGMAS PRAGMA_SAVE_TYPES + PRAGMA_ERROR_CONTEXT

/* NO_RESETS: completely disable the periodic calling of reset() */
#undef NO_RESETS

/* LAZY_RESETS: if this is defined, an object will only have reset()
 *   called in it when it is touched via call_other() or move_object()
 *   (assuming enough time has passed since the last reset).  If LAZY_RESETS
 *   is #undef'd, then reset() will be called as always (which guaranteed that
 *   reset would always be called at least once).  The advantage of lazy
 *   resets is that reset doesn't get called in an object that is touched
 *   once and never again (which can save memory since some objects won't get
 *   reloaded that otherwise would).
 */
#undef LAZY_RESETS

/* RANDOMIZED_RESETS: if this is defined, the reset() will be called in randomized
 *   time interval. The interval vary from TIME_TO_RESET/2 to TIME_TO_RESET-1 .
 *   if this is undefined, the reset() will be called among all objects at the same time,
 *   with the interval as TIME_TO_RESET
*/
#undef RANDOMIZED_RESETS

/* SAVE_EXTENSION: defines the file extension used by save_object().
 *   and restore_object().  Some sysadmins run scripts that periodically
 *   scan for and remove files ending in .o (but many mudlibs are already
 *   set up to use .o thus we leave .o as the default).
 */
#define SAVE_EXTENSION ".o"

/* NO_ANSI: define if you wish to disallow users from typing in commands that
 *   contain ANSI escape sequences.  Defining NO_ANSI causes all escapes
 *   (ASCII 27) to be replaced with a space ' ' before the string is passed
 *   to the action routines added with add_action.
 *
 * STRIP_BEFORE_PROCESS_INPUT allows the location where the stripping is
 * done to be controlled.  If it is defined, then process_input() doesn't
 * see ANSI characters either; if it is undefined ESC chars can be processed
 * by process_input(), but are stripped before add_actions are called.
 * Note that if NO_ADD_ACTION is defined, then #define NO_ANSI without
 * #define STRIP_BEFORE_PROCESS_INPUT is the same as #undef NO_ANSI.
 *
 * If you anticipate problems with users intentionally typing in ANSI codes
 * to make your terminal flash, etc define this.
 */
#define NO_ANSI
#define STRIP_BEFORE_PROCESS_INPUT

/* OPCPROF: define this if you wish to enable OPC profiling. Allows a dump
 *   of the # of times each efun is invoked (via the opcprof() efun).
 */
#undef OPCPROF

/* OPCPROF_2D: define this if you wish to enable 2-D OPC profiling. Allows a
 *   dump of the # of times each *pair* of eoperators is invoked.
 *
 * You can't use this and OPCPROF at the same time.
 */
#undef OPCPROF_2D

/* THIS_PLAYER_IN_CALL_OUT: define this if you wish this_player() to be
 *   usable from within call_out() callbacks.
 */
#define THIS_PLAYER_IN_CALL_OUT

/* CALLOUT_LOOP_PROTECTION: If this is defined, all new zero-delay call_outs
 * added while already processing call_outs will run under a single evaluation
 * cost allotment.  In the event of an infinite loop, the eval timer will
 * expire and a "Maximum evaluation cost" error will be thrown.
 *
 * If this option is undefined, all call_outs (including zero-delay ones added
 * by another call_out) will be given a full evaluation time budget.  Unless
 * the mudlib takes steps to protect against loops by overriding call_out()
 * with a sefun, an infinite loop will hang the driver, requiring it to be
 * killed and restarted.
 *
 * Old code should work fine with this added.
 */
#define CALLOUT_LOOP_PROTECTION

/* FLUSH_OUTPUT_IMMEDIATELY: Causes output to be written to sockets
 * immediately after being generated.  Useful for debugging.
 */
#undef FLUSH_OUTPUT_IMMEDIATELY

/* PRIVS: define this if you want object privileges.  Your mudlib must
 *   explicitly make use of this functionality to be useful.  Defining this
 *   this will increase the size of the object structure by 4 bytes (8 bytes
 *   on the DEC Alpha) and will add a new master apply during object creation
 *   to "privs_file".  In general, privileges can be used to increase the
 *   granularity of security beyond the current root uid mechanism.
 *
 * [NOTE: for those who'd rather do such things at the mudlib level, look at
 *  the inherits() efun and the 'valid_object' apply to master.]
 */
#undef PRIVS

/* INTERACTIVE_CATCH_TELL: define this if you want catch_tell called on
 *   interactives as well as NPCs.  If this is defined, user.c will need a
 *   catch_tell(msg) method that calls receive(msg);
*/
#undef INTERACTIVE_CATCH_TELL

/* RECEIVE_ED: define this if you want normal ed output to go to a
     receive_ed() apply in the player ob.  Some errors still go directly
     to output.  Useful for post-processing (perhaps colorizing?) ed
     output. Prototype:  mixed receive_ed(string txt, string fname);
     If fname, return a string that ed will output, 0 to let ed handle
     the output in the default way, or 1 to handle the output yourself.
     If fname == 0, output is help text and you may return any of the above
     or an array of strings that will be more'ed.
*/
#undef RECEIVE_ED

/* RESTRICTED_ED: define this if you want restricted ed mode enabled.
 */
#define RESTRICTED_ED

/* NO_SHADOWS: define this if you want to disable shadows in your driver.
 */
#undef NO_SHADOWS

/* SNOOP_SHADOWED: define this if you want snoop to report what is
 *   sent to the player even in the event that the player's catch_tell() is
 *   shadowed and the player may not be seeing what is being sent.  Messages
 *   of this sort will be prefixed with $$.
 */
#undef SNOOP_SHADOWED

/* RECEIVE_SNOOP: define this if you want snoop text to be sent to
 *   the receive_snoop() function in the snooper object (instead of being
 *   sent directly via add_message()).  This is useful if you want to
 *   build a smart client that does something different with snoop messages.
 */
#define RECEIVE_SNOOP

/* PROFILE_FUNCTIONS: define this to be able to measure the CPU time used by
 *   all of the user-defined functions in each LPC object.  Note: defining
 *   this adds three long ints (12 bytes on 32-bit machines) to the function
 *   header structs.  Also note that the resolution of the getrusage() timer
 *   may not be high enough on some machines to give non-zero execution
 *   times to very small (fast) functions.  In particular if the clock
 *   resolution is 1/60 of a second, then any time less than approxmately 15k
 *   microseconds will resolve to zero (0).
 */
#undef PROFILE_FUNCTIONS

/****************************************************************************
 *                              PACKAGES                                    *
 *                              --------                                    *
 * Defining some/all of the following add certain efuns, and sometimes      *
 * add/remove code from the driver.                                         *
 *                                                                          *
 * if PACKAGE_XYZZY is defined here, then the code in packages/xyzzy.c      *
 * and the efuns in packages/xyzzy_spec.c will be added to the driver.      *
 ****************************************************************************/

/* various miscellaneous efuns */
#define PACKAGE_CONTRIB

/* efuns that are only of use to those that know something about driver
   internals */
#define PACKAGE_DEVELOP

/* PACKAGE_MATH: determines whether or not the math efuns (for floats) are
   included.
 */
#define PACKAGE_MATH

/* PACKAGE_MATRIX: determines whether or not the 3d graphics efuns (for floats)
 *   are included - see packages/matrix.spec for a list.
 */
#undef PACKAGE_MATRIX

/* PACKAGE_MUDLIB_STATS: define this to enable domain and author stats
 *   maintenance by the driver.  These mudlib stats are more domain
 *   based than user based, and replaces the traditional wiz_list stats.
 */
#define PACKAGE_MUDLIB_STATS

/* PACKAGE_SOCKETS: define this to enable the socket efunctions.  This
 *   causes HAS_SOCKETS to be defined for all LPC objects.
 */
#define PACKAGE_SOCKETS

/* PACKAGE_PARSER: Natural language parsing efuns for interactive fiction
 *   type applications
 */
#undef PACKAGE_PARSER

/* PACKAGE_EXTERNAL: Allows the driver to exec() commands specified in the
 * config file.
 */
#define PACKAGE_EXTERNAL

/* NUM_EXTERNAL_CMDS: the number of external commands supported */
#ifdef PACKAGE_EXTERNAL
#define NUM_EXTERNAL_CMDS 100
#endif

/* PACKAGE_DB: efuns for external database access using msql */
#undef PACKAGE_DB

/* If PACKAGE_DB is defined above, you must pick ONE of the following supported
 * databases
 */
#ifdef PACKAGE_DB
#undef USE_MSQL
#define USE_MYSQL 1
#undef USE_POSTGRES
#undef USE_SQLITE3
#endif

/*PACKAGE_ASYNC: adds some efuns for asyncronous IO */
#define PACKAGE_ASYNC

/*PACKAGE_SHA1: adds a function to calculate the sha1 hash of a string sha1(string).  Use PACKAGE_CRYPTO instead if possible. */
#define PACKAGE_SHA1

/*PACKAGE_CRYPTO: adds a function that does multiple hash types hash(hash, string), needs openssl lib and includes and -lssl in system_libs*/
#undef PACKAGE_CRYPTO

/*
  PACKAGE_TRIM: efuns for remove leading / trailing whitepsaces (or chars in provided charset)
  Functions:
    - trim: Remove leading and trailing whitespaces (or in provided charset).
      Example:
        - "    my test   " : "my test"
    - ltrim: Remove leading whitespaces (and others).
      Example:
        - "    my test   " : "my test   "
    - rtrim: Remove trailing whitespaces (and others).
      Example:
        - "    my test   " : "    my test"

  Characters that remove by default: isspace() == 1, which is:
    ' ' (0x20)  space (SPC)
    '\t'  (0x09)  horizontal tab (TAB)
    '\n'  (0x0a)  newline (LF)
    '\v'  (0x0b)  vertical tab (VT)
    '\f'  (0x0c)  feed (FF)
    '\r'  (0x0d)  carriage return (CR)
 */
#define PACKAGE_TRIM

/*PACKAGE DWLIB: some discworld mudlib simuls coded in C (well just one right
  now) */

#undef PACKAGE_DWLIB

/****************************************************************************
 *                            UID PACKAGE                                   *
 *                            -----------                                   *
 * UIDS are the basis for some mudlib security systems.  Basically, they're *
 * preserved for backwards compatibility, as several ways of breaking       *
 * almost any system which relies on them are known.  (No, it's not a flaw  *
 * of uids; only that b/c of the ease with which LPC objects can call       *
 * each other, it's far too easy to leave holes)                            *
 *                                                                          *
 * If you don't care about security, the first option is probably what you  *
 * want.                                                                    *
 ****************************************************************************/

/*
 * PACKAGE_UIDS: define this if you want a driver that does use uids.
 *
 */
#define PACKAGE_UIDS

#ifdef PACKAGE_UIDS
/* AUTO_SETEUID: when an object is created it's euid is automatically set to
 *   the equivalent of seteuid(getuid(this_object())).  undef AUTO_SETEUID
 *   if you would rather have the euid of the created object be set to 0.
 */
#define AUTO_SETEUID

/* AUTO_TRUST_BACKBONE: define this if you want objects with the backbone
 *   uid to automatically be trusted and to have their euid set to the uid of
 *   the object that forced the object's creation.
 */
#undef AUTO_TRUST_BACKBONE
#endif

/*************************************************************************
 *                       FOR EXPERIENCED USERS                           *
 *                      -----------------------                          *
 * Most of these options will probably be of no interest to many users.  *
 *************************************************************************/

/* USE_32BIT_ADDRESSES: Use 32 bits for addresses of function, instead of
 * the usual 16 bits.  This increases the maximum program size from 64k
 * of LPC bytecode (NOT source) to 4 GB.  Branches are still 16 bits,
 * imposing a 64k limit on catch(), if(), switch(), loops, and most other
 * control structures.  It would take an extremely large function to hit
 * those limits, though.
 *
 * Overhead: 2 bytes/function with LPC->C off.  Having LPC->C on forces
 * this option, since it needs 4 bytes to store the function pointers
 * anyway, and this setting is ignored.
 */
#undef USE_32BIT_ADDRESSES

/* HEARTBEAT_INTERVAL: define heartbeat interval in seconds.
 */
#define HEARTBEAT_INTERVAL 2

/* LARGEST_PRINTABLE_STRING: defines the size of the vsprintf() buffer in
 *   comm.c's add_message(). Instead of blindly making this value larger,
 *   your mudlib should be coded to not send huge strings to users.
 */
#define LARGEST_PRINTABLE_STRING 8192

/* MESSAGE_BUFFER_SIZE: determines the size of the buffer for output that
 *   is sent to users.
 */
#define MESSAGE_BUFFER_SIZE 4096

/* TRACE: define this to enable the trace() and traceprefix() efuns.
 *   (keeping this undefined will cause the driver to run faster).
 */
#define TRACE

/* TRACE_CODE: define this to enable code tracing (the driver will print
 *   out the previous lines of code to an error) eval_instruction() runs about
 *   twice as fast when this is not defined (for the most common eoperators).
 */
#undef TRACE_CODE

/* GET_CHAR_IS_BUFFERED: Normally get_char() is unbuffered.  That is, once
 * a character is received for get_char(), anything else is in the input
 * stream is immediately thrown away.  This can be very undesirable, especially
 * if you're calling get_char() again from the handler from the previous call.
 * Define this if you want get_char() to be buffered.  In this case, the buffer
 * will only get flushed if get_char() is not called from the first get_char()'s
 * LPC callback handler.
 */
#undef GET_CHAR_IS_BUFFERED

/* PACKAGE_COMPRESS: Enable MCCP support and compressed save files
   SAVE_GZ_EXTENSION: save extension for compressed files
 */
#define HAVE_ZLIB
#define PACKAGE_COMPRESS
#define SAVE_GZ_EXTENSION ".o.gz"

/* USE_ICONV: Use iconv to translate input and output from/to the users char
 * encoding
 */
#undef USE_ICONV

/* HAS_CONSOLE: If defined, the driver can take the argument -C
 *   which will give the driver an interactive console (you can type
 *   commands at the terminal.)  Backgrounding the driver will turn off
 *   the console, but sending signal SIGTTIN (kill -21) to the driver can
 *   turn it back on.  Typing 'help' will display commands available.
 *   The intent is to allow the inspection of things that are difficult
 *   to inspect from inside the mud.
 */
#define HAS_CONSOLE

/* IPV6: Use IP version 6 instead of 4, for most people the only difference
 * will be that numerical IP addresses get ::ffff: added in front.*/
#undef IPV6

/* static user space dtrace probes, try them if you have dtrace! */
#undef DTRACE

/* use POSIX timers for eval_cost.
 *
 * Old code should works fine with this added.
 */
#define POSIX_TIMERS

/*
  REVERSE_DEFER:

  If not defined executes defer functions in LIFO mode.

  If defined executes defer functions in FIFO mode.
*/
#undef REVERSE_DEFER

#endif /* _OPTIONS_H */

/* options.h配置详细选项
—————————————————————————-
将 MudOS 下载解压以后可以在相应目录的根目录中找到 options.h 这个文件。如果修
 改了这个文件，那么每次都需要重新编译 MudOS 才能生效。重新编译之前，请执行 ma
 ke clean 一下。
 下面的 options.h 来自 MudOSv22.2b10，MudOS作者推荐在修改options.h 之前，先将
 它备份成 local_options。新的特性将会自动对比local_options并且在编译的时候告知
 。文中的选项定义并非最原始的定义。此文只是为了说明各个选项的大致含义。
options.h: defines for the compile-time configuration of the MudOS driver
 */

#ifndef _OPTIONS_H_
 #define _OPTIONS_H_

/****************************************************************************
如果你对自己的系统不熟悉，请使用缺省的定义 SYSMALLOC，同时将其它的undef掉。
 你必须选择下面的其中一种定义，并且将其它的定义undef掉。
SYSMALLOC: 缺省选项，没有额外的系统开支，没有统计能力。
SMALLOC:速度比较快，但是开销相对大一些。
BSDMALLOC:速度更快，开销比较大。
****************************************************************************/

#define SYSMALLOC
 #undef SMALLOC
 #undef BSDMALLOC

/****************************************************************************
 WRAPPEDMALLOC:这个附加定义可以换来有限的统计能力，并且不会增加太多的系统开销。
DEBUGMALLOC:系统花费比较折中
****************************************************************************/
 #undef WRAPPEDMALLOC
 #undef DEBUGMALLOC

/****************************************************************************
如果没有定义SMALLOC，请不要使用下面这个定义。
****************************************************************************/
 #undef SBRK_OK

/****************************************************************************
如果没有定义 BSDMALLOC or SMALLOC ，请不要使用下面这个定义
****************************************************************************/
 #undef DO_MSTATS

/****************************************************************************
 DEBUGMALLOC定义的附加定义，用来强化DEBUGMALLOC，但是需要更多的开销。
set_malloc_mask(int) and debugmalloc(string,int)等efuns将可以被使用。
****************************************************************************/
 #undef DEBUGMALLOC_EXTENSIONS

/****************************************************************************
同上，是用来调试的良好定义，check_memory() efun将可以被使用。
****************************************************************************/
 #undef CHECK_MEMORY

/****************************************************************************
兼容性定义选项：
 由于MudOS发展了很多年，所以历代MudOS为了保证原有的Lib可以不修改就被移植到新的
OS上面，增加了这些兼容性选项。如果你是根据OS撰写Lib的人，可以定义一些优化的选
 项来设计自己的Lib，而不必考虑重写的问题。
 以前的MudOS使用status这样子的定义词，这是很老的定义了，对于新的Lib设计而言，
 这个定义毫无用处。
****************************************************************************/
 #undef HAS_STATUS_TYPE

/****************************************************************************
 explode()选项，这个根据个人的习惯来定义吧
 如果不定义下面两个选项， explode(“..x.y..z..”, “.”) 的结果是 ({ “x”, “y”, “”
, “z”, “” })
如果定义SANE_EXPLODE_STRING 选项，其结果将是({ “”, “x”, “y”, “”, “z”, “” })
如果定义 REVERSIBLE_EXPLODE_STRING 选项，其结果将是 ({ “”, “”, “x”, “y”, “”,
“z”, “”, “” })
 ****************************************************************************/
 #define SANE_EXPLODE_STRING
 #undef REVERSIBLE_EXPLODE_STRING

/****************************************************************************
这个选项用来确定call_other的行为，但是这个选项对于系统毫无好处可言。
****************************************************************************/
 #undef CAST_CALL_OTHERS

/****************************************************************************
如果定义了下面这个选项，那么任何传往非交互式物件（比如npc）的信息前面都会被加
 上’]'符号，这个也不是非常需要，而且很容易被模拟出来。
****************************************************************************/
 #undef NONINTERACTIVE_STDERR_WRITE

/****************************************************************************
如果定义下面这个选项，你将不能使用set_light()这样的efuns函数，不过没有关系，
 这个函数是在太落伍了，这个功能非常容易被模拟出来。
****************************************************************************/
 #define NO_LIGHT

/****************************************************************************
嗯，下面这个选项，是非常重要的选项，如果你定义了，那么意味着你将不能使用add_
 action, commands, livings等等这些相关的efuns，而不得不使用 process_input() 这
 样的函数来定义物件所有的动作。这将是非常难堪的工作。所以保持add_action还是非
 常有用的。
****************************************************************************/
 #undef NO_ADD_ACTION

/****************************************************************************
定义下面这个选项，将不能使用和snoop相关的函数，如果你认为没有snoop也没有关系
 ，可以定义这个选项来保护一些隐私。
****************************************************************************/
 #undef NO_SNOOP

/****************************************************************************
这个选项和add_action一样要命，除非你立志只做一个聊天室，那么可以定义这个选项
 ，否则，你的工作将会非常的麻烦。
****************************************************************************/
 #undef NO_ENVIRONMENT

/****************************************************************************
由于历史原因，定义wizard来管理Mud的运作，但是现在好像不是非常重要了。
 如果定义了, wizardp() 和 related efuns 将不存在
 如果没有定义，在使用ed()时也受限制，设置的限制参数无效
 而且这个定义非常容易模拟出来。
****************************************************************************/
 #undef NO_WIZARDS

/****************************************************************************
下面的选项只是为了保持兼容性问题，对于大多数的LPmud而言，这个选项毫无用处。尤
 其是一个新的Lib撰写。
****************************************************************************/
 #undef OLD_TYPE_BEHAVIOR

/****************************************************************************
定义下面这个选项，将意味着对于一个string或者buffers而言可以使用负数的index。
 对于一个新Lib撰写，这个属性不是非常重要。
****************************************************************************/
 #undef OLD_RANGE_BEHAVIOR

/****************************************************************************
这个定义选项主要是为了保持向后兼容，对于新的Lib而言，没什么用处。重新习惯一个
 方式，并不是非常困难的，而且，ed()对于大多数习惯使用工具撰写的人们而言，意义
 不大。
****************************************************************************/
 #define OLD_ED

/****************************************************************************
下面这个选项比较重要，对于新的Lib撰写或者以前没有接触过LPC的人来说，这个定义
 可以按照喜好来定。
(1) ‘static’ 将不再使用，而是用 ‘nosave’ 或者 ‘protected’ 代替了它。.
 (2) ‘public’ 含义发生了变化，外部函数必须在任何一级的继承中被声明。现在publi
 c意味着是明显可见的。
****************************************************************************/
 #define SENSIBLE_MODIFIERS

/****************************************************************************
下面的选项定义会改变MudOS的一些行为。这些对于Lib撰写，是比较重要的。
 定义下面这个选项，将使用MD5加密法代替系统缺省的crypt()加密法。
****************************************************************************/
 #undef CUSTOM_CRYPT

/****************************************************************************
下面这个选项只是为了一些兼容性问题。定义以后，某些efuns含义会有所变化，但是没
 有实质的区别。
****************************************************************************/
 #undef COMPAT_32

/****************************************************************************
允许统计的时候包含字符串分配，不定义可以是字符串处理更快，但字符串统计将被忽略。
****************************************************************************/
 #define STRING_STATS

/****************************************************************************
同上，数组统计。
****************************************************************************/
 #define ARRAY_STATS

/****************************************************************************
这是比较有用的选项，用来生成log文件。
****************************************************************************/
 #define LOG_CATCHES

/****************************************************************************
这个类似上面得选项，可以生成有用的调试文档。
****************************************************************************/
 #define ARGUMENTS_IN_TRACEBACK

/****************************************************************************
同上，对于新Lib撰写非常有用。
****************************************************************************/
 #define LOCALS_IN_TRACEBACK

/****************************************************************************
通过error_handler()来处理错误，非常有用的选项。
****************************************************************************/
 #define MUDLIB_ERROR_HANDLER

/****************************************************************************
下面得选项，可以详细定义，当然也可以通过配置config.cfg这样的文件来设置。
****************************************************************************/
 #ifndef LATTICE
 #define CONFIG_FILE_DIR “/u/tim/COMP/bin”
#else
 #define CONFIG_FILE_DIR “etc:”
#endif

/****************************************************************************
下面的选项将会对整个Lib撰写起到作用。对于新的Lib撰写，建议选择比较严格的方式
 。而如果想保持兼容，建议选择常规的设定。
 这些设定　其实等同于使用 #pragma　来定义。
 如果你不太明白，使用 #define DEFAULT_PRAGMAS 0　是一个比较好的选择。
PRAGMA_STRICT_TYPES: 强制执行严格的书写规则，这个估计是以前议论最多的问题，
 事实上，对于新Lib，这几乎不是问题。
PRAGMA_WARNINGS: 对不合法代码进行警告。非常有用。
PRAGMA_SAVE_TYPES: 呼叫以后保存函数情况
PRAGMA_SAVE_BINARY: 二进制代码保存，可以降低系统负担。
PRAGMA_OPTIMIZE: 代码优化
PRAGMA_ERROR_CONTEXT:错误报告
****************************************************************************/
 #define DEFAULT_PRAGMAS PRAGMA_SAVE_BINARY + PRAGMA_WARNINGS + PRAGMA_ERROR_CONTEXT

/****************************************************************************
对于没有使用的变量声明或者缺少的参数进行报告
****************************************************************************/
 #define SUPPRESS_ARGUMENT_WARNINGS

/****************************************************************************
这是重要的设定，为了保证系统拥有reset()，请不要定义这个选项。
 除非不想系统拥有reset()。
****************************************************************************/
 #undef NO_RESETS

/****************************************************************************
看名字就知道，如果定义了，reset()将变得比较懒惰，你不碰它，它不呼叫。对于大多
 数需要刷新时间的LPmud而言，还是不要定义的好。
****************************************************************************/
 #undef LAZY_RESETS

/****************************************************************************
存盘文件的缺省后缀名。
****************************************************************************/
 #define SAVE_EXTENSION “.o”

/****************************************************************************
下面两个选项使用来控制ansi的用户输入的，这个比较容易模拟出来，因为自由的ansi
输入可能会导致一些显示错误。
****************************************************************************/
 #define NO_ANSI
 #define STRIP_BEFORE_PROCESS_INPUT

/****************************************************************************
笔者水平有限，不知道OPC是什么东西。只知道定义以后，可以用一个opcprof()函数来
 统计外部函数调用的情况。下面得选项稍有不同，一次只能定义其中的一个。
****************************************************************************/
#undef OPCPROF
#undef OPCPROF_2D

/****************************************************************************
当这个选项定义以后，当发生crash的时候，master.c中定义的crash()将被呼叫。
****************************************************************************/
 #define TRAP_CRASHES

/****************************************************************************
可以在call_outs中使用this_player()
 ****************************************************************************/
 #define THIS_PLAYER_IN_CALL_OUT

/****************************************************************************
这个定义是比较有用的，定义以后，call_out将产生一个int序列，这个序列可以方便的
 被find_call_out()和remove_call_out()调用。这是一个效率极高的处理方式。原来使
 用name来处理的方式相对比较低效。唯一的代价是些许系统开销。
****************************************************************************/
 #define CALLOUT_HANDLES

/****************************************************************************
调试非常有用，一般情况下不需要。
****************************************************************************/
 #undef FLUSH_OUTPUT_IMMEDIATELY

/****************************************************************************
这个定义允许在Lib中给与一些object以特权，除非你非常了解这个定义对于你所要撰写
 的Lib的用处，不然的话，不要定义这个。
****************************************************************************/
 #undef PRIVS

/****************************************************************************
下面这个定义可以使互动物件也适用catch_tell()，当然你就必须在user.c中写入catc
 h_tell()来处理receive(msg)。
****************************************************************************/
 #undef INTERACTIVE_CATCH_TELL

/****************************************************************************
受限制的ed模式
****************************************************************************/
 #define RESTRICTED_ED

/****************************************************************************
使用下面这个定义，你就不能在想要撰写的Lib中使用shadow，而shadow往往非常有用，
 所以除非你明确知道不需要，不然不要定义这个选项。
****************************************************************************/
 #undef NO_SHADOWS

/****************************************************************************
定义下面这个，可以snoop shadowed object，因为shadowed object可能不知道送过来
 的msg。
****************************************************************************/
 #undef SNOOP_SHADOWED

/****************************************************************************
这是一个有趣的定义，可以让你监听snooper的msg，也许利用起来比较有趣。当然也可
 以不定义它。
****************************************************************************/
 #define RECEIVE_SNOOP

/****************************************************************************
这不是一个非常准确的定义，如果你想知道物件调用函数的时候，使用了多少时间，可
 以用这个试试。不过不要对它的准确性基于太多的希望。
****************************************************************************/
 #define PROFILE_FUNCTIONS

/****************************************************************************
‘buffer’这个类型定义的选择，按所要撰写的Lib而定，如果你可能要用到这种变量定义
 ，就不要定义这个选项。
****************************************************************************/
 #undef NO_BUFFER_TYPE

/****************************************************************************
设置 pragma　’save_binary’　的有效性。
 使用这个选项，可以是Lib运行速度有所提高，并且降低系统的开销。代价就是将占用更
 多的硬盘空间。
****************************************************************************/
 #define BINARIES

/****************************************************************************
允许定义数组变量，关键字array。比如 int array x = ({…});
不过估计这样定义也不会有人反对 int *x = ({});
定义这个选项与否，主要是看是不是习惯使用array这个声明，如果你来自C或者java，
 也许会喜欢的。
****************************************************************************/
 #define ARRAY_RESERVED_WORD

/****************************************************************************
这个同上，关键字ref。按照Lib撰写人的习惯来定义比较好。
****************************************************************************/
 #define REF_RESERVED_WORD

/****************************************************************************
扩充包是可选配件
 如果你定义了PACKAGE_XYZZY，那么你可以参看 packages/xyzzy.c　中的函数来确定可
 以使用哪些efuns。
 确定使用哪些扩充包，主要取决于提供的efuns是否是需要的。

****************************************************************************/

/****************************************************************************
这个扩充包的函数还是非常有用的，比如query_ip_port() repeat_string()等等。

****************************************************************************/

#define PACKAGE_CONTRIB

/****************************************************************************
下面这个包主要用来了解driver内部的信息。
****************************************************************************/
 #define PACKAGE_DEVELOP

/****************************************************************************

****************************************************************************/
 #define PACKAGE_MATH

/****************************************************************************
这个是图像处理包，不过，笔者也没用过。
****************************************************************************/
 #undef PACKAGE_MATRIX

/****************************************************************************
这个包的函数用来了解Mudlib的数据，比较实用。
****************************************************************************/
 #undef PACKAGE_MUDLIB_STATS

/****************************************************************************
呵呵，这个当然非常有用了。
****************************************************************************/
 #define PACKAGE_SOCKETS

/****************************************************************************
这个用处不大，尤其是中文使用者，呵呵
****************************************************************************/
 #undef PACKAGE_PARSER

/****************************************************************************
这个也没什么大的用处。允许driver在config文件里exe()命令清单
****************************************************************************/
 #undef PACKAGE_EXTERNAL

/****************************************************************************
外部扩展指令支持的数目
****************************************************************************/
 #ifdef PACKAGE_EXTERNAL
 #define NUM_EXTERNAL_CMDS
 #endif

/****************************************************************************
数据库支持包，想用数据库mysql的Lib撰写者比较有用，
****************************************************************************/
 //#define PACKAGE_DB
 #undef PACKAGE_DB
 /****************************************************************************
如果PACKAGE_DB被定义，必须选择下面中的一个来支持数据库
****************************************************************************/
 #ifdef PACKAGE_DB
 #define USE_MSQL 1 /* MiniSQL, it’s small; it’s free */
 #undef USE_MYSQL 2 /* MySQL, bigger; it’s free */
 #define DEFAULT_DB USE_MSQL /* default database */
 #endif

/****************************************************************************
　　UID，就是用户有效识别码，国内的LPMud大多基于 wizard 以及 uid 系统，如果不
 是新Lib的撰写者，这个是比较有用的。如果你拥有了自己的理念，可以不使用这些定义
 。从MudOS开发者来看，他们也没有明确说不需要这些。虽然本人倒是比较喜欢放弃这些
 设定，但是这些设定的存在，确实可以方便很多的处理。
 如果你打算使用UID，那就定义下面这个选项。
****************************************************************************/
 #define PACKAGE_UIDS

/****************************************************************************
自动设定UID，那就不需要每次都seteuid(getuid(this_object()))。如果需要seteuid
 (0)，那么不要定义这个，比如现在大多数的Lib。
****************************************************************************/
 #define AUTO_SETEUID

/****************************************************************************
 backbone这个设定是被自动认可的。
****************************************************************************/
 #define AUTO_TRUST_BACKBONE

/****************************************************************************
下面这些设定，一般情况下，不需要做出大的调整。
 资源问题，使用32位地址。
****************************************************************************/
 #undef USE_32BIT_ADDRESSES

/****************************************************************************
心跳时间，这里是一秒。
****************************************************************************/
 #define HEARTBEAT_INTERVAL 2000000

/****************************************************************************
 call_out的设定
****************************************************************************/
 #define CALLOUT_CYCLE_SIZE 64

/****************************************************************************
信息暂存设定
****************************************************************************/
 #define LARGEST_PRINTABLE_STRING 8192

/****************************************************************************
输出信息buffer设定
****************************************************************************/
 #define MESSAGE_BUFFER_SIZE 65536

/****************************************************************************
定义call_other cache的bits number
 6 64 1k
 8 256 4k
 10 1024 16k
 12 4096 64k
 14 16384 256k
 16 65536 1M
 ****************************************************************************/
 #define APPLY_CACHE_BITS 12

/****************************************************************************
 call_other的cache统计
****************************************************************************/
 #define CACHE_STATS

/****************************************************************************
不定义可以快一点。
****************************************************************************/
 #undef TRACE

/****************************************************************************
 LPC->C的编译
****************************************************************************/
 #undef LPC_TO_C

/****************************************************************************
看系统而定，一般不需要定义。
****************************************************************************/
 #undef RUNTIME_LOADING

/****************************************************************************
这个定义以后，允许被跟踪执行。
****************************************************************************/
 #undef TRACE_CODE

/****************************************************************************
缺省设定是32，主要关系到 heart_beat 的系统开销。
****************************************************************************/
 #define HEART_BEAT_CHUNK 64

/****************************************************************************
一般情况下，get_char不是bufferd。所以不太必要定义这个选项。
****************************************************************************/
 #undef GET_CHAR_IS_BUFFERED

/****************************************************************************
字符串定义。
****************************************************************************/
 #define SMALL_STRING_SIZE 100
 #define LARGE_STRING_SIZE 1000

/****************************************************************************
指令buffer定义。
****************************************************************************/
 #define COMMAND_BUF_SIZE 2000

/****************************************************************************
呵呵，如果dbase深度超过了25就会溢出，这个设定就是这里定义的。当年最常见的一个
 当机bug就是set指令的dbase溢出导致的。
****************************************************************************/
 #define MAX_SAVE_SVALUE_DEPTH 50

/****************************************************************************
 25个局部变量调用，对于一个函数来说，应该是够了。数数COMBAT_D中的attack()函数
 用到了几个局部变量。本人曾经定义超过25个变量，结果导致出错，但是那个时候不知
 道为什么，虽然预感到这一点，可以在mud配置文件中定义。
****************************************************************************/
 #define CFG_MAX_LOCAL_VARIABLES 100
 #define CFG_EVALUATOR_STACK_SIZE 2000
 #define CFG_MAX_CALL_DEPTH 100

/****************************************************************************
下面定义的必须选择 4, 16, 64, 256, 1024, 4096 中的一个数字
****************************************************************************/
 #define CFG_LIVING_HASH_SIZE 1024

/****************************************************************************
 NEXT_MALLOC_DEBUG: define this if using a NeXT and you want to enable
 the malloc_check() and/or malloc_debug() efuns. Run the ‘man malloc_debug’
command on the NeXT to find out what the arguments to malloc_debug(int)
 mean. The malloc_check() efun calls the NeXT NXMallocCheck() system
 call which does a consistency check on malloc’s data structures (this
 consistency check is done at each malloc() and free() for certain
 malloc_debug() levels). A non-zero return value indicates there was
 a consistency problem. For those NeXT users wanting a bit more
 performance out of malloc, try defining NEXT_MALLOC_DEBUG and calling the
 malloc_debug(-1) efun (with an arg of -1). This will turn all
 malloc debugging off and call malloc_singlethreaded() which the NeXT
 malloc man page claims can make NeXT system malloc 10% to 15% faster.

[NOTE: This #define has no affect on the driver if not using the
 NeXTSTEP OS.]

Warning: if you use a NeXT and define NEXT_MALLOC_DEBUG, be sure to
 protect the use of the malloc_check() and malloc_debug() efuns
 since setting certain debug levels can cause malloc() and free()
 to become _very_ slow (protect efuns by using simul_efuns and
 valid_override).

[NOTE: malloc_debug(6) is a good compromise between efficiency and
 completeness of malloc debugging (malloc/free will be about half as fast).]
 ****************************************************************************/
 #define NEXT_MALLOC_DEBUG

#endif

编译V14的时候编译DB
 option.h修改下列配置
#define PACKAGE_DB
 #ifdef PACKAGE_DB
 #undef USE_MSQL /* MiniSQL, it’s small; it’s free */
 #define USE_MYSQL 2 /* MySQL, bigger; it’s free */
 #define DEFAULT_DB USE_MYSQL /* default database */
 #endif

修改 db.h 头文件：
 将 24 行至 37 行注释掉，紧接着写上你自己的 MySQL 头文件的位置，
find / -name mysql.h 就找到了！
 例如在 /usr/local/mysql/include/mysql.h
就写上：
#include “/usr/local/mysql/include/mysql.h”

在源代码目录里的 system_libs 文件里加上 mysql 连接库的位置，
 例如在 /usr/local/mysql/lib
就加上：
-L/usr/local/mysql/lib -lmysqlclient

// File : /include/ansi.h 
// 这是MUDLIB的标准颜色设置，由Jjgod汉化 

#define ESC "" 
#define CSI ESC + "[" 

#define BLK ESC+"[30m"  
#define RED ESC+"[31m"  
#define GRN ESC+"[32m"  
#define YEL ESC+"[33m"  
#define BLU ESC+"[34m"  
#define MAG ESC+"[35m"  
#define CYN ESC+"[36m"  
#define WHT ESC+"[37m"  

#define HIR ESC+"[1;31m"  
#define HIG ESC+"[1;32m"  
#define HIY ESC+"[1;33m"  
#define HIB ESC+"[1;34m"  
#define HIM ESC+"[1;35m"  
#define HIC ESC+"[1;36m"  
#define HIW ESC+"[1;37m"  

#define HBRED ESC+"[41;1m"  
#define HBGRN ESC+"[42;1m"  
#define HBYEL ESC+"[43;1m"  
#define HBBLU ESC+"[44;1m"  
#define HBMAG ESC+"[45;1m"  
#define HBCYN ESC+"[46;1m"  
#define HBWHT ESC+"[47;1m"  

#define BBLK ESC+"[40m"  
#define BRED ESC+"[41m"  
#define BGRN ESC+"[42m"  
#define BYEL ESC+"[43m"  
#define BBLU ESC+"[44m"  
#define BMAG ESC+"[45m"  
#define BCYN ESC+"[46m"  
// #define BWHT ESC+"[47m"  

#define NOR ESC+"[2;37;0m"  

#define BOLD ESC+"[1m"  
#define CLR ESC+"[2J"  
#define HOME ESC+"[H"  
#define REF CLR+HOME  
#define BIGTOP ESC+"#3"  
#define BIGBOT ESC+"#4"  
#define SAVEC ESC+"[s"  
#define REST ESC+"[u"  
//#define REVINDEX ESC+"M"  
#define SINGW ESC+"#5"  
#define DBL ESC+"#6"  
#define FRTOP ESC+"[2;25r"  
#define FRBOT ESC+"[1;24r"  
#define UNFR ESC+"[r"  
#define BLINK ESC+"[5m"  
#define U ESC+"[4m"  
#define REV ESC+"[7m"  
#define HIREV ESC+"[1,7m"  

　　上面就是经过我汉化的的ansi.h文件了，其中有些实在太难译，所以我只好把原来的留了下来。认真看过上面 的这些，就应该基本明白常用的ANSI颜色怎么用了，所以说，如果不#include ，照样也可以用彩色， 你只需要在用的前面加上[1;33m这样就行了，这些都很简单，我就不赘述了。这篇文章要谈的重点，其实是一个A NSI COLOR于zMUD的协调问题。 
　　基本上绝大多数的MUD玩家都是使用zMUD为客户端软件的，所以你的程序在zMUD中的显示效果就尤为重要了。问题其实是出现在了在ANSI颜色的使用上，zMUD和标准的ANSI定义出现了分歧，这种分歧是在zMUD 4.62汉化版后产生的，zMUD的4.62英文版都应该尚无此问题，但正是因为以前没有问题后来才出现了问题。你听到这里是不是越来越不明白？那好，我们还是从源头说起吧。下面的“原先”，就是指zMUD 4.62 英文版及以前的。 
　　看过上面的定义就应该清楚[1;xxm这样的定义，也就是HIX这样的定义中，那个"1;"或者"HI"什么的，是表示粗体的意思，原先的注释中说得清清楚楚的，而原先的YEL，也就是[33m，大概是这种亮度，而倘若变成了HIY或者说[1;33m的话，就应该是这样了，这才是标准的用法，而zMUD对中文字体的支持还是不大完善，一般来说就是使用宋体，假如出现了粗体，也会在屏幕上划得斑驳陆离，本来是这一行的字，滑到了下面几行去，非常的有碍观瞻。 
    所以以zMUD4.62英文版为预览工具来写的程序一般是不用HIY而是就用YEL的，因为这样颜色也够亮，显示也没有问题，一切都很好。 
　　但到了4.62汉化版以后，就破坏了这个格局。在这个版本以后的所有zMUD，基本上都是将[1;也就是HI默认解释为高亮，而原来的YEL什么的，就变得很是暗淡了，比如此版本以后的YEL，显示出来是这样，而HIY呢，就是这样了，因为始终不出现粗体，所以自然也没有显示的问题。而在原来的那种环境下开发出来的程序可就惨了，像我的模拟华附，整个MUD的颜色都显得十分暗淡，自然很不具亲和力了。 
　　本身问题是很容易解决的，只要调整一下zMUD的设置就可以了，但问题在于有关颜色的zMUD设置由特别难调整（差不多每个版本我的试过），造成了本身正常的设置还要迁就不正常的设置了，绝大部分的玩家都不会去调整。因此的你的MUD如果要使用Ansi颜色就要考虑这个兼容性问题了。
　　所以呢，因为绝大部分的MUD玩家使用的都是zMUD 4.62中文版以上的，我建议还是统一使用“HIX”这种好一点，玩家看起来颜色比较鲜亮，同时也没有粗体显示不清的问题。低亮度的颜色就少用一些吧，当然，假如你已经全部使用了低亮度或者高亮度，想转换的话，也可以通过改ansi.h来实现，这比较简单，就不用我说了吧。 
　　其实ansi.h还是有很多没有普遍使用的妙处的，这就有待各位自己去发现了。

背景知识，分享一下，供武侠mud做任务参考用

1092年，《天龙八部》故事开始。秋季，段誉参加无量剑比斗。后结识钟灵、木婉清等。
《〈天龙八部〉释名》：“本书故事发生于北宋哲宗元佑、绍圣年间，公元一○九四年前后。”《天龙八部》第6章：“是时北宋汴梁哲宗天子在位，年岁尚幼，太皇太后高氏垂帘听政。……保定帝在位十一年，改元三，曰保定、建安、天佑，其时正当天估年间，四境宁静，国泰民安。”按北宋哲宗元佑为1086—1093年，而大理天佑元年为公元1090年，则故事开始时约在1090年或稍晚。

1093年，年初，段誉为鸠摩智所擒，三月中被掳至江南。于无锡与乔峰结拜。
第11章《向来痴》：“他虽无处世经历，但这二十余日来，对此事早已深思熟虑，想明白了其中关窍……自此一路向东，又行了二十余日，段誉听着途人的口音，渐觉清雅绵软，菜肴中也没了辣椒。……这时正是三月天气，杏花夹径，绿柳垂湖，暖洋洋的春风吹在身上，当真是醺醺欲醉。”
本年，乔峰为查明身份，离杏子林后先后赴少林、聚贤庄、雁门关、信阳，后，因中马夫人计，于小镜湖误杀阿朱，伤心离中原而出关。

1094年，二月初八，擂鼓山珍珑棋会，虚竹得无涯子功力，此后辗转得遇天山童姥、李秋水，终成天山灵鹫宫之主。
29章：“段誉接过一看，见帖上写着四行字道：‘苏星河奉请天下精通棋艺才俊，于二月初八日驾临河南擂鼓山天聋弈棋。’”

本年，六月十五，少林寺大会。萧远山、慕容博现身，后被无名僧点化，皈依佛门。
40章：“各人都接到丐帮帮主庄聚贤的英雄帖，说道少林寺和丐帮向来并峙中原，现庄聚贤新任丐帮帮主，意欲立一位中原的武林盟主，并定下若干规章，以便同道一齐遵守，定六月十五亲赴少林寺，与玄慈方丈商酌。”

本年，八月中秋，西夏招驸马，虚竹寻得梦姑。
40章：“公冶乾颇识诸国文字，从头至尾看了一遍，说道：‘果然是西夏国王招驸马的榜文。文中言道：西夏国文仪公主年将及笄，国王要征选一位文武双全、俊雅英伟的未婚男子为驸马，定放今年八月中秋起选拔，不论何国人士，自信为天下一等一人才者，于该日之前投文晋谒，国王皆予优容接见。即令不中驸马之选，亦当量才录用，授以官爵，更次一等者赏以金银……’”
本年十月，段正淳及其情侣殒于曼陀山庄。
本年，北宋哲宗元佑九年，太皇太后驾崩，哲宗改元绍圣。耶律洪基伺机征宋，为萧峰所阻。萧自尽，《天龙八部》结束。

1115年，北宋政和五年，黄裳刻道藏。数年后成武功高手。
《射雕英雄传》后记：“《射雕英雄传》中所说的黄裳真有其人。近人陈国符先生《道藏源流考》中考证宋徽宗访求天下道教遗书刻板的经过颇详。徽宗于政和三年下诏天下访求道教仙经，所获甚众。政和五年设经局，敕道士校定，送福州闽县，由郡守黄裳役工镂板。所刊道藏称为《政和万寿道藏》，共五百四十函，五千四百八十一卷。”
黄裳，字晟仲，人称演山先生，福建延平人，高宗建炎三年（1042—1129）卒，年八十七。
独孤求败（1100？－1170年），生年不详，死于公元1170年


1180——1190年间，某年中秋，少林寺武功考校中，火工头陀击毙达摩堂首座苦智禅师，寺中内讧，罗汉堂首座苦慧禅师忿而出走开创西域少林。
详见《倚天屠龙记第2章。文中时间为郭襄19岁游少林，其时为1263年，而“七十余年前”则在1180——1190年间。


1200年，首次华山论剑。

1204年，《射雕》故事开始。

1205年，郭靖出生。

1223年，中秋嘉兴烟雨楼之会，郭靖18岁。穆念慈怀杨过。

1224年，杨过出生。
《射雕》中农历七月十五日是丐帮君山大会，而郭靖和黄蓉在七天后（即七月二十二日）至铁掌峰并见到杨康、穆念慈。穆念慈正是在此期间有了杨过。以正常十月怀胎计算，杨过生于次年农历五月间。

  1225年，郭靖、黄蓉南下途经江西上饶，救穆念慈，为杨过起名。成吉思汗逝世。二次华山论剑。《射雕英雄传》结束。

1238年，杨过14岁，被郭靖、黄蓉夫妇收留。以不见容于桃花岛，被郭靖送往终南山重阳宫学艺。其后机缘巧合，入古墓结识小龙女。此时小龙女20岁。

1242年，杨过18岁，在古墓生活3年有余。后与龙出秘道，在终南山学习王重阳留下的《九阴真经》。

1243年，杨过19岁，先后结识陆无双与程英，并于华山见到洪七公与欧阳峰。

1244年，郭襄出生。杨过20岁，与小龙女分别于绝情谷。
1246年，张君宝（三丰）出生。
《倚天屠龙记》第3章：……一路上虽然桃红柳绿，春色正浓，他却也无心赏玩，心中默默计算：‘今日三月廿四，到四月初九还有一十四天，须得道上丝毫没有耽搁，方能及时赶到武当山，祝贺恩师他老人家九十岁大寿。’”
1259年，襄阳大战，郭襄16岁。《神雕侠侣》结束。
《神雕侠侣》第39章：“自蒙古和宋军交锋以来，从未有如此大败，而一国之主丧于城下，更是军心大沮。蒙古大汗之位并非父死子袭，系由皇族王公、重臣大将会议拥立。蒙哥既死，其弟七王子阿里不哥在北方蒙古老家被得王公拥戴而为大汗。忽必烈得讯后领军北归，与阿里不哥争位，兄弟各率精兵互斗。最后忽必烈得胜，但蒙古军已然大伤元气，无力南攻，襄阳城得保太平。直到一十三年后的宋度宗咸淳九年，蒙古军始再进攻襄阳。”按，南宋度宗咸淳九年为公元1273年。
1263年，郭襄19岁，游历少林，结识何足道。张君宝逃出少林寺。
《倚天屠龙记》第1章：“郭襄自和杨过、小龙女夫妇在华山绝顶分手后，三年来没得到他二人半点音讯。”
1285年，南宋淳佑五年，郭襄40岁，创立峨眉派。
1336年，《倚天屠龙记》新故事开始。
《倚天屠龙记》第3章：“这一年是元顺帝至元二年，宋朝之亡至此已五十余年。”
1346年，张无忌9岁，随父母自冰火岛返回中原。
《倚天屠龙记》第8章 穷发十载始归航。
1348年，张无忌11岁，下随张三丰下武当山求医。
《倚天屠龙记》第18章：“他瞧着这位相别九年的六师叔时，只见他满脸风尘之色，两鬓微见斑白，想是纪晓芙之死于他心灵有极大打击。”
1352年，张无忌15岁，被困昆仑仙境，得《九阳真经》。
《倚天屠龙记》第17章：“他进来时十五岁，身子尚小，出去已是二十岁，长大成人，却钻不过那狭窄的洞穴了。他吸一口气，运起了缩骨功，全身骨骼挤拢，骨头和骨头之间的空隙缩小，轻轻易易的便钻了过去。”
1357年，张无忌20岁，习得九阳神功，解光明顶之围，任明教教主。

1358年，韩林儿死。张无忌归隐。《倚天屠龙记》结束。

1428年左右，日月神教夜袭武当山。
《倚天屠龙记》结束时张无忌21岁，杨不悔约16岁。两人的影响力比较合理的估计是70年左右（误差不超过10年），此时张无忌超过90岁，杨也年过八旬。而《倚天屠龙记》中少林大会上，殷梨亭下场斗周芷若时，杨不悔已怀孕。武当七侠的后辈中最杰出的宋青书已死，则殷杨之后人很有可能继承武当衣钵或杨逍武功，凭与张无忌的关系或许还可能得张真传，实力也不容小视。故此，不仅需要张无忌、杨不悔等人老迈或身故，而且要待其直系徒弟或子嗣的影响力衰减时，日月神教才可能发动攻击。

1484年，华山派气宗、剑宗决战于玉女峰，气宗胜出，剑宗高手伤亡殆尽。此后五年内，岳不群继任华山派掌门。
《笑傲江湖》第9回：“岳不群在石上坐下，缓缓的道：‘二十五年之前，本门功夫本来分为正邪两途。’”《笑傲江湖》第11回：“那封不平大声道：‘你篡夺华山派掌门之位，已二十多年啦，到今天还做不够？应该让位了罢？’师父笑道：‘各位大动阵仗的来到华山，却原来想夺在下这掌门之位。那有甚么希罕？封兄如自忖能当这掌门，在下自当奉让。’那封不平道：‘当年你师父凭着阴谋诡计，篡夺了本派掌门之位，现下我已禀明五岳盟主左盟主，奉得旗令，来执掌华山一派。’”又：“岳不群道：‘成兄，你们“剑宗”一支，二十五年前早已离开本门，自认不再是华山派弟子，何以今日又来生事？倘若你们自认功夫了得，不妨自立门户，在武林中扬眉吐气，将华山派压了下来，岳某自也佩服。今日这等噜唆不清，除了徒伤和气，更有何益？’” 


令狐冲慢慢坐了下来，道：“我是个无父无母的孤儿，十五年前蒙恩师和师母收录门下，那时小师妹还只三岁，我比她大得多，常常抱了她出去采野果、捉兔子。我和她是从小一块儿长大的。师父师母没儿子，待我犹似亲生儿子一般，小师妹便等于是我的妹子。”

第三十章  密议
1509年，《笑傲江湖》故事开始。春，福威镖局为青城派灭门。令狐冲约25岁，被罚面壁一年。
《笑傲江湖》第1回：“林震南忽道：‘娘子，你今年三十九岁罢？’王夫人啐道：‘呸！这当儿还来问我的年纪？我是属虎，你不知道我几岁吗？’林震南道：‘我发帖子出去，便说是给你做四十岁的大生日……’王夫人道：‘为甚么好端端给我添上一岁年纪？我还老得不够快么？’”王夫人属虎，在《笑傲江湖》开始时39岁，可见当年为蛇年。正德年间共有两个蛇年，即正德四年和正德十六年。据金庸新修订版的介绍，故事发生在明正德年间。而正德十六年正德皇帝就驾崩了，可排除正德十六年为故事发生第一年的可能。如此则《笑傲江湖》故事发生的第一年为正德四年即公元1509年。

1510年，夏，令狐冲结识向问天，以营救任我行被囚梅庄地牢。十二月十五聚群雄围少林。
1511年，三月十五，五岳剑派并派。日月神教归还武当书剑。
1514年，令狐与盈盈成亲。
1515年，暮春，《笑傲江湖》故事结束。

1563年，《侠客行》故事发生。
《侠客行》13章中石清言道：“那是三十年前的事了，他二人那时尚是少年。各门派帮会的首脑接到铜牌请柬之人依约前往，自是无事，否则他这一门派或是帮会不免大祸临头，当时便问：‘到底去是不去？’最先接到铜牌请柬的，是川西青城派掌门人旭山道长。他长笑之下，将两块铜牌抓在手中，运用内力，将两块铜牌熔成了两团废铜。这原是震烁当时的独步内功……”《笑傲江湖》中青城派几乎全军覆没，但《侠客行》故事发生的30年前青城派又出现了顶尖高手旭山道长。余沧海之徒皆以“人”字排行，旭山道长当是其徒孙辈，当在《笑傲江湖》结束后二三十年。所以《侠客行》当在《笑傲江湖》后约五六十年，即明代后期隆庆万历年间（1563—1620）。《侠客行》第19章：“……只见簿面上写着‘河北通州聂家拳‘七字，打开簿子，第一行触目惊心，便是‘庚申五月初二，聂宗台在沧州郝家庄奸杀二命，留书嫁祸于黑虎寨盗贼’，第二行书道：‘庚申十月十七，聂宗峰在济南府以小故击伤刘文质之长子，当夜杀刘家满门一十三人灭口。’” 明末的庚申年有1560年和1620年。而1620年华山派已有穆人清等高手，故此“庚申”只能是1560年。第19章：“……姓白的倘若早得几年见了这本帐簿，侠客岛就是对他手下留情，姓白的也要杀他全家。”从白自在之言可知，聂氏灭门在几年前，则《侠客行》故事发生在1560—1570年间。而第20章记载转年有闰二月。查此段时间仅1564年有闰二月。则《侠客行》发生于前一年即1563年。


1633年，《碧血剑》故事开始，袁承志10岁。

1643年，袁承志20岁，初下华山。
《碧血剑》第3回：“这时已是崇祯十六年，袁承志也已二十岁了。这十年之间，袁承志所练华山本门的拳剑内功，与日俱深，天下事却已千变万化，眼下更是如沸如羹，百姓正遭逢无穷无尽的劫难。”

1644年，崇祯十七年三月，李自成攻陷北京。明朝灭亡。

本年四月，华山弟子集会，《碧血剑》结束。
《碧血剑》第19回：“袁承志见封皮上写着‘字谕诸弟子’字样，认得是师父笔迹，先作了一揖，然后恭恭敬敬的接过来，抽出信纸，见信上写道：‘吾华山派历来门规，不得在朝居官任职。今闯王大业克就，吾派弟子功成身退，其于四月月圆之夕，齐集华山之巅。’下面签着个‘清’字。”