Embeded开发

构建GB2312汉字库的unicode码表

乾坤一笑 — Mon, 28 Nov 2005 16:25:00 GMT

嵌入式系统总离不了处理汉字。一般汉字的处理方法是（以手机接受短信为例）：比如你收到了一封短信，该短信解码后是按照UTF-16表示，那么我们需要根据每一个汉字的unicode码，找到它在GB2312库中的位置，然后在用对应的点阵数据在屏幕上显示出来。

于是乎，必须有一种手段将unicode码和汉字字模的数据对应起来。最常用的手段是做一个unicode码表，在该数组中查找到匹配的unicode码后，用匹配的index（数组索引）值在另外一个由该index值对应的字模记录的数组中的数据去显示。
+-----------------+ 查表 +-----------------+ 同index   +-------------------+
| 汉字的unicode码 | ==> | unicode码表数组 | =======> | 汉字字模数据数组     | ==> 显示输出
+-----------------+      +-----------------+           +-------------------+
本文简要介绍一下如何生成unicode码表，其他相关的汉字处理技术不在本文的讨论范围之内。:)

用下面两个函数可以把unicode码表构造出来（*注1）：

void UnicodeToGB2312(unsigned char* pOut,unsigned short uData)
{
    WideCharToMultiByte(CP_ACP,NULL,&uData,1,pOut,sizeof(unsigned short),NULL,NULL);
    return;
}     
 
void Gb2312ToUnicode(unsigned short* pOut,unsigned char *gbBuffer)
{
    MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,gbBuffer,2,pOut,1);
    return;
}

一个简单的例子如下（随手写的一段代码，只是演示一下构造数组的过程，不要挑刺儿啊! ^_^ ）：

/*-----------------------------------------------*\
|  GB2312 unicode table constructor               |
|  author: Spark Song                             |
|  file  : build_uni_table.c                      |
|  date  : 2005-11-18                             |
\*-----------------------------------------------*/

#include <stdio.h>
#include <windows.h>


void UnicodeToGB2312(unsigned char* pOut,unsigned short uData);
void Gb2312ToUnicode(unsigned short* pOut,unsigned char *gbBuffer);
void construct_unicode_table();

int main(int argc, char *argv[])
{
	construct_unicode_table();
	return 0;
}

void construct_unicode_table()
{
    #define GB2312_MATRIX   (94)
    #define DELTA           (0xA0)
    #define FONT_ROW_BEGIN (16  + DELTA)
    #define FONT_ROW_END   (87 + DELTA)
    #define FONT_COL_BEGIN (1  + DELTA)
    #define FONT_COL_END   (GB2312_MATRIX + DELTA)
    #define FONT_TOTAL     (72 * GB2312_MATRIX)

    int i, j;
    unsigned char   chr[2];
    unsigned short  uni;
    unsigned short  data[FONT_TOTAL] = {0};
    int index = 0;
    unsigned short buf;

    //生成unicode码表
    for (i=FONT_ROW_BEGIN; i<=FONT_ROW_END; i++)
        for(j=FONT_COL_BEGIN; j<=FONT_COL_END; j++)
        {
            chr[0] = i; 
            chr[1] = j;
            Gb2312ToUnicode(&uni, chr);
            data[index] = uni; index++;
        }


   //排个序，以后检索的时候就可以用binary-search了
    for (i=0;i<index-1; i++)
        for(j=i+1; j<index; j++)
            if (data[i]>data[j])
            {
                buf = data[i]; 
                data[i] = data[j];
                data[j] = buf;
            }            
    
    //输出到STD_OUT
    printf("const unsigned short uni_table[]={\n");

    for (i=0; i<index; i++)
    {
        uni = data[i];
        UnicodeToGB2312(chr, uni);

        printf("    0x%.4X%s /* GB2312 Code: 0x%.2X%.2X ==> Row:%.2d Col:%.2d */\n", 
                uni, 
                i==index-1?" ":",",
                chr[0],
                chr[1],
                chr[0] - DELTA,
                chr[1] - DELTA
                );
    }

    printf("};\n");
    return ;
}


void UnicodeToGB2312(unsigned char* pOut,unsigned short uData)
{
    WideCharToMultiByte(CP_ACP,NULL,&uData,1,pOut,sizeof(unsigned short),NULL,NULL);
    return;
}     
 
void Gb2312ToUnicode(unsigned short* pOut,unsigned char *gbBuffer)
{
    MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,gbBuffer,2,pOut,1);
    return;
}

用vc6编译后，在dos中执行：
build_uni_table.exe > report.txt
可以得到如下的txt文件：

const unsigned short  uni_table[]={
    0x4E00, /* GB2312 Code: 0xD2BB ==> Row:50 Col:27 */
    0x4E01, /* GB2312 Code: 0xB6A1 ==> Row:22 Col:01 */
    0x4E03, /* GB2312 Code: 0xC6DF ==> Row:38 Col:63 */
    0x4E07, /* GB2312 Code: 0xCDF2 ==> Row:45 Col:82 */
... ...
    0x9F9F, /* GB2312 Code: 0xB9EA ==> Row:25 Col:74 */
    0x9FA0, /* GB2312 Code: 0xD9DF ==> Row:57 Col:63 */
    0xE810, /* GB2312 Code: 0xD7FA ==> Row:55 Col:90 */
    0xE811, /* GB2312 Code: 0xD7FB ==> Row:55 Col:91 */
    0xE812, /* GB2312 Code: 0xD7FC ==> Row:55 Col:92 */
    0xE813, /* GB2312 Code: 0xD7FD ==> Row:55 Col:93 */
    0xE814  /* GB2312 Code: 0xD7FE ==> Row:55 Col:94 */};

然后把这个生成的数组copy到项目代码中使用就okey了。hoho，其实在开发中编写代码来构造代码的机会很多，coder不用coding辅助自己开发多浪费啊～ :)

--------------------------------
注1：
关于内码转换的相关知识可参考vckbase document online上的两篇资料：
1) 吴康彬《UTF-8与GB2312之间的互换》
2) 李天助《《UTF-8与GB2312之间的互换》的改进》
-------------
乾坤一笑写于2005年11月29日转载请标明出处和原文链接

从windows到linux -- 编程篇 -- cygwin(在win中开发linux程序）

乾坤一笑 — Sun, 21 Aug 2005 04:58:00 GMT

偶去年写的一篇文章，放在CSDN blog（偶早已经不维护）锈掉了。收藏在这里吧，也算记录了偶以前的学习历程。

从windows到linux -- 编程篇 -- cygwin（在win中开发linux程序）
乾坤一笑[smileonce] 2004-7-23

很多用windows的朋友不习惯于用linux的开发环境。虽然很乐意尝试一下，但是往往怕linux系统打乱了自己的正常生活：1〉装linux系统把windows系统给搞坏了，导致自己无法正常生活；2>linux开发上手太难，写出第一个helloworld不亚于java的难度，环境配置摸不着头脑。对于此，我的看法是：路不管平还是陡，终归你要走的，如果你愿意投入到linux开发的社群中来，不会安装linux系统，不会配置工作环境是不能想象的。(事实上，确实要了解很多东西的原理，不然很难排错：诸如，硬盘引导器的引导原理、分区结构原理及linux分区结构和文件系统、环境变量的设置、种类繁多的压缩包安装包的解压安装方法、用户管理权限管理等常用命令、以至于驱动安装系统中文化等等异常琐碎的东东)。

本文试图跳过这个难走的步骤，启用一个win环境下的linux仿真器（和linux下面的命令行开发环境基本一致），用短短的20分钟的时间，教你做出一个纯正的linux下gcc编译的helloworld。就象是买点心前先尝尝味道，不也是一件很愉快的事情么？(注：cygwin事实上不仅有此模拟功能，它也是移植unix<-->win程序的一个很有效的工具，也有人用它来做嵌入式系统开发)

一、cygwin是什么？
这个问题你最好google一下"cygwin的历史",或许能够获得更为详尽的答案。简而言之，cygwin是一个在windows平台上运行的linux模拟环境，是cygnus solutions公司开发的自由软件（该公司开发了很多好东西，著名的还有eCos，不过现已被Redhat收购）。插一句废话，很多朋友不明白linux和unix的区别和联系，在此也简要介绍一下。UNIX是一个注册商标，是要满足一大堆条件并且支付可观费用才能够被授权使用的一个操作系统;linux是unix的克隆版本，是由其创始人Linus和诸多世界知名的黑客手工打造的一个操作系统。为什么linux和unix之间有很多软件可以很轻松的移植？因为linux也满足POSIX规范,所以在运行机制上跟unix相近。
以下引用网上的一段话（出处：http://blog.csdn.net/glock18/archive/2004/07/10/38275.aspx），
用于说明cygwin的工作机制：cygnus当初首先把gcc，gdb，gas等开发工具进行了改进，使他们能够生成并解释win32的目标文件。然后，他们要把这些工具移植到windows平台上去。一种方案是基于win32 api对这些工具的源代码进行大幅修改，这样做显然需要大量工作。因此，他们采取了一种不同的方法——他们写了一个共享库(就是cygwin dll)，把win32 api中没有的unix风格的调用（如fork,spawn,signals,select,sockets等）封装在里面，也就是说，他们基于win32 api写了一个unix系统库的模拟层。这样，只要把这些工具的源代码和这个共享库连接到一起，就可以使用unix主机上的交叉编译器来生成可以在windows平台上运行的工具集。以这些移植到windows平台上的开发工具为基础，cygnus又逐步把其他的工具（几乎不需要对源代码进行修改，只需要修改他们的配置脚本）软件移植到windows上来。这样，在windows平台上运行bash和开发工具、用户工具，感觉好像在unix上工作。关于cygwin实现的更详细描述，请参考http://cygwin.com/cygwin-ug-net/highlights.html

二、cygwin的安装。
cygwin的安装文件很容易通过google找到。目前国内的网站上有“网络安装版”和"本地安装版"两种。标准的发行版应该是网络安装版。两者并无大不同，下面介绍一下安装的过程。

step1. 下载后，点击安装文件(setup.exe)进行安装，第一个画面是GNU版权说明，点"下一步(N)—>"，
进入安装模式选择画面。

step2. 安装模式有"Install from Internet"、"Download form Internet"、
"Install from Local Directory" 三种。"Install form Internet"就是直接从internet上装，适用于网速较快的情况。如果你和我一样网速不是很快，或者说装过之后想把下载的安装文件保存起来，下次不再下载了直接安装，就应该选择"Download form Internet"，下载安装的文件（大约40M左右）。
事实上，所谓的"本地安装版"，也是别人从网上下载全部文件后打的包(适用于中国国情嘛^_^)

step3. 接下来是选择安装目的路径和安装源文件所在的路径，之后就进入了选择安装包所在的路径。
注意了阿，这里可是重头戏。我第一安装的时候就是没有看清这一步，结果没有把gcc装进去，导致没法编译文件。
   + All Default
      + Admin Default
       ....
      + Devel   Default
      + Editors Default
      ....
如上图所示，你在这个TreeView的某个节点上双击，就可以改变它的状态，如Default、Install、Uninstall、Reinstall四种状态。默认的都是Default状态，很多工具的默认状态都是不安装。
在这里我选择了在All这一行上后面的Default上点Install，全部安装，以免后患。（注意：这里的树形控件和win下面的不同，你试试点在All上点和在All这一行后面的Default上点，会有不同的响应）

step4. 点下一步，安装成功。它会自动在你的桌面上建立一个快捷方式。

好了，下面就开始我的linux旅程了。双击cygwin的快捷方式进入系统。
首先介绍几个简单的linux命令。
pwd   显示当前的路径
cd    改变当前路径，无参数时进入对应用户的home目录
ls    列出当前目录下的文件。此命令有N多参数，比如ls -al
ps    列出当前系统进程
kill 杀死某个进程
mkdir 建立目录
rmdir 删除目录
rm    删除文件
mv    文件改名或目录改名
man   联机帮助
less 显示文件的最末几行

由于linux下面的命令大多都有很多参数，可以组合使用。所以，每当你不会或者记不清楚改用那个参数，那个开关的时候，可以用man来查找，比如，我想查找ls怎么使用，可以键入
$ man ls
系统回显信息如下：
LS(1)                          FSF                          LS(1)
NAME
       ls - list directory contents
SYNOPSIS
       ls [OPTION]... [FILE]...
DESCRIPTION
       List information about the FILEs (the current directory by
       default). Sort entries alphabetically if none of -cftuSUX
       nor --sort.
       -a, --all
             do not hide entries starting with .
       -A, --almost-all
             do not list implied . and ..
       -b, --escape
             print octal escapes for nongraphic characters
       --block-size=SIZE
             use SIZE-byte blocks
:
很全是吧，嘿嘿。

好了，多说无意，让我们来写一个hello world程序。
# cd
进入了/home/administrator目录，我当前的登陆帐号是administrator

# mkdir source
建立一个叫做source的子目录

# cd source
进入 /home/administrator/source

# vim hello.c

   启动vim编辑器，来编写程序。好了，现在有必要简要介绍一下vim。
在linux界，有两大编辑器最有历史。其一是vi，其二是emacs。vi现在已经演化成了vim，比当前的vi更为强大。vim和emacs是两种截然不同的东西，vim强调用简洁的命令来完成功能，无论是查找、替换、
正则表达式匹配、编译、链接、排错、函数间跳转等等等等都在命令行中完成，并且它把方向键也集成在了hjkl四个键之上，可以说，用了vim基本上可以不用鼠标了:p emacs则是在功能强大上做文章，版本控制、模拟多种编辑环境、对文本进行各种操作，可谓之一个强大的文本处理系统。emacs是用诸如Ctrl+Alt+K 之类的组合键来控制的；vim则是用se(set 的缩写)等简洁命令来控制的。
   由于cygwin中只提供了vim(能不能自己装emacs我还没有试过)，我们就先体验一下vim吧:p
vim加载文本文件后分为命令模式和插入模式两种。插入模式，顾名思义就是输入编辑文本；命令模式，则是输入各种vim的控制命令，常用的有：
   i 进入编辑模式
   h 左移
   j 下移
   k 上移
   l 右移
   w 存盘
   q 退出
   ！强调执行

有些命令是可以组合使用的，如果你修改了某个文件，想存盘退出，则可以使用wq；如果你想放弃存盘，直接退出则可以使用q! 好了大家体验一下吧，记住：从编辑模式退回命令模式按"Esc"，再按":"，在输入指令，从命令模式进入编辑模式用i，初次使用vim肯定很难受，嘿嘿，不过用多了就习惯了，确实很省劲。

我们编辑hello.c文件，输入：
#include <stdio.h>

int main(void) {
printf( "Hello World!");
}
然后，输入wq命令退到命令行。
输入编译指令：
# gcc hello.c -o hello
编译成功后可以看一下
# ls
看到hello.exe了吧，嘿嘿。
好，让我们运行看看。
# ./hello
效果如何？不错吧？ :)

okey，现在玩一个C++的hello world，
# vim world.cpp
输入：
#include <iostream>
using namespace std;

void main() {
cout << "Hello World!";
}
编译C++程序要用g++
# g++ world.cpp -o world
运行一下哈，
# ./world

如何，效果不错吧？诸位都是高手，走到这步应该编些简单程序都不成问题了吧:p
好了，关于如何编写makefile文件，如何用gdb下次再说了。

-------------
乾坤一笑写于2004年7月23日转载请标明出处和原文链接

解惑：sizeof(联合)这个值是怎么计算的

乾坤一笑 — Mon, 08 Aug 2005 14:13:00 GMT

[不要只做技术]在论坛上问如下代码结果为什么是24?

union DATE
{
    char a;
    int i[5];
    double b;
};

DATE max;

cout<< sizeof(max) << endl;

这个问题很好回答，并且我把这个问题归结于基本概念题（就是入门书必须介绍的）。我想一般来说，做过内存管理的，对这个语言特性肯定不会陌生。

摘几句The C Programming Language里面讲述这个问题的原话，以说明读书还是必要的：
①联合就是一个结构，②它的所有成员相对于基地址的偏移量都为0,③此结构空间要大到足够容纳最“宽”的成员，④并且，其对齐方式要适合于联合中所有类型的成员。

怕有的兄弟还不明白，特附图一个帮助理解：

char a;

int i[5];

double b;

该结构要放得下int i[5]必须要至少占4×5=20个字节。如果没有double的话20个字节够用了，此时按4字节对齐。但是加入了double就必须考虑double的对齐方式，double是按照8字节对齐的，所以必须添加4个字节使其满足8×3=24,也就是必须也是8的倍数，这样一来就出来了24这个数字。综上所述，最终联合体的最小的size也要是所包含的所有类型的基本长度的最小公倍数才行。（这里的字节数均指winnt下的值，平台、编译器不同值也有可能不同。）

联合在存储分配的时候用的机会最多，因为很少有像存储分配这样需要给多种不同类型的变量分配空间而又打算尽可能的节约内存的，这很适合联合的特性。上述对齐的方式有个很有趣的用法也就常在存储分配里面使用。（下面依旧用The C Programming Language中的例子作答）

typedef long Align;

union header {
    struct {
        union header *ptr;
        unsigned size;
    } s;
    Align x;
}

这里的Align有什么用？作用只有一个，就是强迫分配的结构体按long的长度对齐。

爱书吧，它是知识的源泉！～～

-------------
乾坤一笑写于2005年8月8日转载请标明出处和原文链接

第三方C代码移植过程中的typedef重复定义问题

乾坤一笑 — Sat, 06 Aug 2005 07:21:00 GMT

楔子：
本文主要描述了把第三方代码移植到某一目标平台过程中所发生的typedef重复定义的问题。之所以要写这个问题，原因有三：1>这个问题是一个移植代码过程中经常遇到的老大难问题2>我还没有完全（或者说完美的）解决这个问题3>想得到诸位高手的点拨。

首先要看看下面的原始代码（为了突出重点，我简化了代码结构。实际代码要复杂的多）：
a.c和a.h代表主开发平台的代码，下面简称为A平台代码；b.c和b.h代表要移植到A平台的第三方的代码，下面简称为B代码。

<代码片断I>

//filename: b.h
#ifndef B_H
#define B_H

typedef long INT32;

void b_bar(INT32 num);

#endif //B_H

//filename: b.c

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

void b_bar(INT32 num)
{
	printf("b_bar trace: %d\n", num);
}

//filename: a.h
#ifndef A_H
#define A_H

typedef short INT32;

void a_foo(INT32 num);

#endif //A_H

//filename: a.c
#include <stdio.h>
#include "a.h"

void a_foo(INT32 num)
{
	printf("a_foo trace: %d\n", num);
}

int main()
{
	INT32 abc=100;
	a_foo(abc);
}

源代码中A代码和B代码中并无任何瓜葛。A代码和B代码中都定义了一个叫做INT32的类型，但是在A代码中INT32是以short为原型的，就是说A代码中所有使用INT32的类型都是期望使用short的。同理，B代码中的所有使用INT32类型的地方都是期望使用long的。因此，我们只要在移植过程中保证A代码和B代码中的类型定义都满足自己原始的期望，那么这个移植过程中类型定义就是成功的，代码运行起来也就会很稳定；反之，移植的代码就存在着极大的风险。

现在进入正题。我们想在a.c中使用B代码中的b_bar()这个函数，常规的方法是这样的：
<代码片断II>

//filename: a.c
#include <stdio.h>
#include "a.h"

//////// Add this include sentence,We want use B 's declare
#include "b.h" 

void a_foo(INT32 num)
{
	printf("a_foo trace: %d\n", num);
}

void a_xxx(INT32 num)  ///////// Add this function
{
	printf("a_xxx trace: %d\n", num);
	b_bar(num);   ///////// Call b_bar() function
}

int main()
{
	INT32 abc=100;
	a_foo(abc); 
	a_xxx(abc);  ///////// Use a_xxx() function
}

但是，我们代码如果这么使用的话，就会出错。错误的原因大概是：redefinition; different basic types。重复定义，不一致的基本类型。因为A代码和B代码中都定义了INT32这个类型。

那么我们应该如何搞定？有大概三种方法来解决这个问题，我们一一来看。

一、extern声明法
这种方法的基本思想是讲问题由编译阶段推迟到链接阶段。我一般会优先使用这种方法，代码如下：
<代码片断III>

//filename: a.c
#include <stdio.h>
#include "a.h"

///Use extern declare instead of include sentence, and use long instead of INT32
extern void b_bar(long num);

void a_foo(INT32 num)
{
	printf("a_foo trace: %d\n", num);
}

void a_xxx(INT32 num)  ///////// Add this function
{
	printf("a_xxx trace: %d\n", num);
	b_bar(num);   ///////// Call b_bar() function
}

int main()
{
	INT32 abc=100;
	a_foo(abc); 
	a_xxx(abc);  ///////// Use a_xxx() function
}

如上面代码所示，我不再在A代码里面include B代码的.h文件，这样就避免了typedef的重复定义。同时，我修改了extern的b_bar()的声明，使其使用C语言基本类型long，这样就满足了B代码的原始期望，B代码运行起来就不会有错。通过extern，将问题推迟到链接期，链接的过程中是以原始类型为基准的，所以链接起来也不会出错。基本上就解决了这个问题。
方法一的缺点：1>修改extern的B代码的声明中的类型为基本类型，看起来代码不是很优雅；2>如果A代码中多处使用B代码，或者要使用B代码中的多个函数，大量的extern将使代码看起来非常的恶心。

二、统一typedef法
我所使用的X公司的源代码实际上也是有好几个部分拼接而成的，每个部分都有自己的typedef。它的代码中通过如下方法来规避typedef重复定义的问题：

<代码片断IV>

//filename: b.h
#ifndef B_H
#define B_H

#ifndef A_H
typedef long INT32;
#endif

void b_bar(INT32 num);

#endif //B_H

修改b.h，而b.c、a.h 使用代码片断1的，a.c使用代码片断2的。
这样一来，B代码在b.h进行typedef的时候，如果检测到目前代码中已经存在了INT32这个定义，就不在进行这个定义了，就使用现存的INT32这个定义。这样一来，其实B代码在使用short来替代INT32,而不是它的原始期望中的long。我个人认为，这会导致B代码中的某些实现不稳定、出错。所以在移植第三方代码过程中，我绝对不推荐这种用法。（这是开讨论会中争议最大的地方，如果你有金砖，千万不要吝惜，拍过来吧～～让暴风雨来的更猛烈些吧）

三、类型适配法
这段文字已经不是再解决上面的问题了，纯粹是做为一种引申的思路而已。某些公司的代码会提供自己名字前缀的typedef，如ABC公司的类型定义就是ABC_INT32，而XXX公司的类型定义就是XXX_INT32。这样就能保证自己的类型定义总是在自己内部使用，而不至于引起冲突来。

<代码片断V>

//filename: b.h
#ifndef B_H
#define B_H

typedef long B_INT32;

void b_bar(B_INT32 num);

#endif //B_H

//filename: b.c

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

void b_bar(B_INT32 num)
{
	printf("b_bar trace: %d\n", num);
}

修a.h 使用代码片断1的，a.c使用代码片断2的。
这样就不会在A代码和B代码之间引起类型定义冲突了。如果类型定义复杂了，有可能在A和B之间要进行强制类型转换，这点的确不爽。不过一般B代码会引入一个类型适配层，用typedef来把A和B之间的类型建立等价关系，这样就一点问题也没有了。

//filename: b_type_adapt.h
typedef B_INT32 A_INT;
typedef B_UINT32 A_UINT;

在A代码中使用B代码的时候就include这个b_type_adapt.h，这样A就能正确识别出B的类型来。问题就完全解决了。

总结：遗憾的是，有很多公司的代码都不是按照方法3来做的，它们都认为自己比较牛，自己应该定义原始类型，％^&（×）#％￥^&…… 唉，就苦了我们porting engineer了。因为是做porting，所以我不能把B中的typedef的类型做个全文替换，这样以后升级B代码就更头疼了。唉，这年头混口饭吃不容易阿～～
-------------
乾坤一笑写于2005年8月6日转载请标明出处和原文链接

为什么不常见include .c文件

乾坤一笑 — Tue, 26 Jul 2005 14:02:00 GMT

今天有人问我： #include能不能include一个（多个.c文件）？
偶的回答是：从理论上讲可以，但是不推荐。

为什么经常见到include .h文件而不是include .c文件？或者说include是不是就是为包含.h文件设定的语法？这个问题的答案偶不知道，没有见有文档记载、说明这个问题。不过从语法角度讲，include的意思就是从当前位置包含另外一个文件，就象宏替换一样把当前行用另外一个文件的整个内容替换掉。

从这点讲，include .c文件是可行的，c编译器完全能够正常处理。但是为什么不常见include .c文件？我想从两个方面可以得到一点解释。一就是，从设计角度上讲，源代码区分为.h和.c文件，是为了接口与实现的分离，实际上两者没什么本质的差别。.h文件提供接口，.c文件提供具体的实现，两者可以一一对应，也可以不一一对应，没有强制要求。一个.c文件做为一个模块的实现，有可能要跟其他的模块打交道，这个时候就需要include其他模块的接口(其他模块的.h文件)；而包含其他模块的实现(.c文件)是没有意义的、危险的。二就是从编译角度上来讲，make对同名的.h和.c之间提供隐讳规则的支持，就是说在makefile中不必显式指定一个.c文件依赖于同名的.h文件，就能达到显示指定这一依赖规则的作用。

这个规则的副作用就是，如果.c文件中包含了另外的.c文件，除非在Makefile中显示指定这种依赖规则，否则make不会自动添加这种依赖关系。这样，很多时候被包含的.c文件改变了，原本需要重新编译的模块得不到重新编译(除非你手动删除对应的.obj或者执行rebuild)，这样的话对工程管理和排错都造成了很大的障碍。

所以，我们不应该在项目中include .c文件，这样使用者出于直觉很难想到这里会有问题，增加了排错的难度。前几天偶移植一个国际知名大公司的代码就遇到了这个问题，耗费了半天的时间查看了全部的源码和makefile才发现了这个不常见编译现象。当然，那个公司的代码之所以这么做，是他认为这些代码已经很成熟了，不需要修改和反复重新编译。但它的做法确实对我的调试造成了很大的障碍。

－－－－－
谢谢[满头大汗]的提醒，偶又做了改动：删除线都是写的不对的内容。补充的是：即便是include了.c文件，如果修改Makefile，也能完成其依赖关系。这个帖子放的久了，就不删掉了。

－－－－－ GNU Make Document 中的相关章节－－－－－

4.12 自动生成依赖
在为一个程序编写的makefile文件中，常常需要写许多仅仅是说明一些OBJ文件依靠头文件的规则。例如，如果‘main.c’通过一条#include语句使用‘defs.h’，您需要写入下的规则：
main.o: defs.h
您需要这条规则让make知道如果‘defs.h’一旦改变必须重新构造‘main.o’。由此您可以明白对于一个较大的程序您需要在makefile文件中写很多这样的规则。而且一旦添加或去掉一条#include语句您必须十分小心地更改makefile文件。
为避免这种烦恼，现代C编译器根据原程序中的#include语句可以为您编写这些规则。如果需要使用这种功能，通常可在编译源程序时加入‘-M’开关，例如，下面的命令：
cc -M main.c
产生如下输出：
main.o : main.c defs.h
这样您就不必再亲自写这些规则，编译器可以为您完成这些工作。
注意，由于在makefile文件中提及构造‘main.o’，因此‘main.o’将永远不会被隐含规则认为是中间文件而进行搜寻，这同时意味着make不会在使用它之后自动删除它；参阅隐含规则链。
对于旧版的make程序，通过一个请求命令，如‘make depend’，利用编译器的特点生成依赖是传统的习惯。这些命令将产生一个‘depend’文件，该文件包含所有自动生成的依赖；然后makefile文件可以使用include命令将它们读入（参阅包含其它makefile文件）。
在GNU make中，重新构造makefile文件的特点使这个惯例成为了过时的东西――您永远不必具体告诉make重新生成依赖，因为GNU make总是重新构造任何过时的makefile文件。参阅Makefile文件的重新生成的过程。
我们推荐使用自动生成依赖的习惯是把makefile文件和源程序文件一一对应起来。如，对每一个源程序文件‘name.c’有一名为‘name.d’的makefile文件和它对应，该makefile文件中列出了名为‘name.o’的OBJ文件所依赖的文件。这种方式的优点是仅在源程序文件改变的情况下才有必要重新扫描生成新的依赖。
这里有一个根据C语言源程序‘name.c’生成名为‘name.d’依赖文件的格式规则：
%.d: %.c
        set -e; $(CC) -M $(CPPFLAGS) $< \
                  | sed 's/$$*$\.o[ :]*/\1.o $@ : /g' > $@; \
                [ -s $@ ] || rm -f $@
关于定义格式规则的信息参阅定义与重新定义格式规则。‘-e’开关是告诉shell如果$(CC)命令运行失败（非零状态退出）立即退出。正常情况下，shell退出时带有最后一个命令在管道中的状态（sed）,因此make不能注意到编译器产生的非零状态。
对于GNU C编译器您可以使用‘-MM’开关代替‘-M’，这是省略了有关系统头文件的依赖。详细内容参阅《GNU CC使用手册》中控制预处理选项。
命令Sed的作用是翻译（例如）：
main.o : main.c defs.h
到：
main.o main.d : main.c defs.h
这使每一个‘.d’文件和与之对应的‘.o’文件依靠相同的源程序文件和头文件，据此，Make可以知道如果任一个源程序文件和头文件发生变化，则必须重新构造依赖文件。
一旦您定义了重新构造‘.d’文件的规则，您可以使用使用include命令直接将它们读入，（参阅包含其它makefile文件），例如：
sources = foo.c bar.c
include $(sources:.c=.d)
（这个例子中使用一个代替变量参照从源程序文件列表‘foo.c bar.c'翻译到依赖文件列表‘foo.d bar.d'。详细内容参阅替换引用。）所以，‘.d’的makefile文件和其它makefile文件一样，即使没用您的任何进一步的指令，make同样会在必要的时候重新构建它们。参阅Makefile文件的重新生成过程。

-------------
乾坤一笑写于2005年7月26日转载请标明出处和原文链接

小议char *和C语言的字符串

乾坤一笑 — Sat, 25 Jun 2005 18:20:00 GMT

前几天和清风雨交谈strncpy()函数的时候，他认为“如果一个函数有一个char * str的参数，那么str一定是一个字符串”，而我对此不以为然。难得到了周末，抽得出功夫,谈谈我对char *含义的认识,与大家共同讨论一下。

C语言是开发操作系统的首选语言，在很多方面都能从C代码中看到机器的固有性质。比如,PASCAL语言的数组索引是从1开始计数，而C语言就是从0开始计数。从0开始计数不太符合一般人的正常思维模式，但是为什么C语言要采用这种设计方式呢？因为C语言最初主要是为操作系统开发人员和编译器设计人员设计的——对于经常需要考察内存地址的开发人员，偏移量的概念在他们脑子里面根深蒂固。要把100个int型的整数放在从地址0x0000开始的一段内存中，如果系统是按Byte编址的，那么第100个元素(其数组索引为99)的要放入的地址必然是：0x0000 + sizeof(int) * 99，而不是乘以100，所以索引以0开始是很有好处的。(C语言的底层特性请参考P.V.D.L的《Expert C Programming——Deep C Secrets》，中文版《C专家编程》)

同样而言，C语言对所谓字符串的处理也和其他语言不同。(参见拙著《我用错了strcat() 》文后的评论) 它同样体现了便于系统设计的特点。例如unix系统总是把设备都映射为文件，对I/O流、光驱、硬盘、modem的访问最终都转换为了对文件的处理。而文件，也可以看作是一个长长的字符数组(文件以EOF结尾)。C语言没有专门定义字符串数据类型(如其他语言中的string)，它用以'\0'结尾的字符数组来表示一个逻辑意义上的字符串。C语言用一些对于字符数组的处理函数(特别是对以'\0'结尾的字符数组的处理函数)来处理所谓的以'\0'结尾的字符串，并把他们放在string.*、stdio.*等一些标准库文件中。string这个字眼也就对人造成了某些误解，好像是C语言中定义了字符串这种类型一样。其实C语言只定义了char、int、float、void、poiner这几种基本类型，这正是C语言简洁之处。至于所谓的字符串，只是对字符数组的一种特殊应用而已。

由于没有了“字符串类型”，“传char *参数就是传一个字符串进来”之说自然也不攻自破。那么char *真正的含义是什么？我们不妨用大家最熟悉的int来对比一下。

#include <stdio.h>

int main(int argc, char *argv[])
{    
    int b[3] = { 17, 18, 19 };
    int a = 5;
    int d = 2103157716; 

    int * i; // pay attention to this variable

    i = b;
    printf("%d \n", *i);  // i points to a array, *i gets the first number of the array, 
                          // *i does not get the all elements of the array.
    
    i = b + 1;            // okey, i can get whichever element of the array.
    printf("%d \n", *i);

    printf("Int size: %d \n", sizeof(int));
    printf("Address0: %#x \n", i); // if i++, the value of i add by sizeof(int)
    i++;
    printf("Address1: %#x \n", i);
   

    i = &a;               // i also can point to a int variable. as i is a pointer, we shoule 
    printf("%d \n", *i);  // use & to get the address of a.


    printf("%#x \n", d);  // I use a big number to prove that int * is only a pointer,
    i = &d;               // which is not tightness to int type.
    printf("%#x \n", *((unsigned char*)i));    
    
 return 0;
}

代码中的int * i就是我们关注的焦点。它是一个指向int指针。也就是说：i指向一个内存地址，从这个地址开始存储了一个数据。int * i中的int标明应该使用int类型（长度为sizeof(int)个字节）来从这个地址取数据，也就是说要一次取sizeof(int)个byte的数据来拼成最后的结果。最后一个例子也证明了这一点：如果我们强制用unsigned char的大小的数据类型来对这个地址操作，就只能取出数据的一部分。反过来说，如果用较大数据类型来取实际存储较小数据类型的数据，就有可能越界操作内存，取回一些杂乱的内容或导致系统崩溃。int b[]这个数组，标明有一组数，放在以&b开始地址的内存空间内，每个元素占用了sizeof(int)个byte的内存单元；如果有类似于i=&b;i++;的操作，i的值就每次递增sizeof(int)而不是1，这样确保了i每次都能恰好取回一个正确的int。

同理，char * c也是如此。如果我们定义了一个char *的变量c，那么c也只不过是一个指向内存中某个地址的指针而已。之所以标明它是char *的类型，就是说要以sizeof(char)为单位去内存中取数。所以，我们应该称呼char * c为指向char类型的指针——而不是说c就是字符串。为什么传一个char *指针给printf(),strlen()之类的函数，它就能把它当作一个字符串来处理呢？没错，我们不是定义了'\0'来表示一个"字符串"的终结么？我们只需从起始地址不断累加，遍历字符数组的每一个元素，直到找到一个'\0'为止，就算是处理一个字符串了——从起始地址到'\0'为止的字符数组元素构成一个“字符串”，这就是C语言设计字符串的原理。

所以，当一个函数要求传入一个char *的参数，并不一定这个参数就一定是字符串(以'\0'结尾的字符数组)，char *只是一个字符指针而已,它仅仅提供了一个内存地址和每次遍历元素的偏移量而已。究竟函数对传入的参数有什么要求，还要视函数的具体实现而定。(我想ANSI C应该对参数有所要求和规定，可惜偶没有ANSI C文件，无法参考。 )C语言一般约定是用char * str来表示以'\0'结尾的字符数组，但是由于某些实现上的效率的考虑，往往没有严格遵守这个约定。C语言的设计理念中没有强调使用者一定要使用遵守这个约定，不遵守这个约定也不违背C语言的基本语法规则。这或许可以看作是C语言和创造和使用它的黑客群体崇尚自由的一种特色、一种精神文化吧。

小练习：
1)参照上面int *的例子来编写一个类似代码验证一下char *是否也有类似特性。
2)C语言这么设计字符串会在那些方面的处理上有为难之处。
3)考察C语言标准库函数中，有那些函数传入char*的参数是一定要求以'\0'结尾的，那些函数对char *参数不做这个检查。

-------------
乾坤一笑写于2005年6月26日转载请标明出处和原文链接

用Makefile打补丁——自动化构建

乾坤一笑 — Sat, 18 Jun 2005 08:07:00 GMT

make和Makefile一向被用来编译、连接代码，这已经成为了思维的定势。如果能够突破这个定势，就会发现make原来还有很多妙用。

Makefile其根本原理就是利用文件时间比较来触发一个动作。比如：

file_a.obj : file_a.c
    gcc file_a.c - o file_a.obj

这就是一个最简单的应用。make读到这段代码时，会去比较file_a.obj和file_a.c的日期，如果file_a.c比file_a.obj还要新（就是时间晚，如2005-05-09 20:03:43 就比2003-12-07 04:03:12要新），这时候就会触发下面一行的动作。用gcc去编译file_a.c，从而重新生成file_a.obj，这就是项目编译中所做的事，通过比较时间，只编译需要编译的部分，这样比较高效、节约时间。

我们也可以利用make的原理来打patch，效果很好。比如我的项目中平台会自动生成一个ori_font.c的文件，上面是平台提供的字库。而我不需要这个字库，我要替换掉其中这个文件中字库相关的一部分内容。于是我写了一个小程序 replace_fonts.exe，通过执行replace_fonts ori_font.c pt_font.c就可以把ori_font.c给替换掉。但是汉字是很多的，这个文件也非常大。所以我不想每次编译之前都替换这个文件，我只需要在平台重新生成代码后（平台更新了ori_font.c），我才使用replace_fonts，然后再编译工程即可。于是make可以帮我这个忙。

首先我写一个Makefile:

#rpfonts.mak
#for replacing fonts res

fonts.obj : fonts.c
   replace_fonts ori_font.c pt_font.c

然后把它加入我build工程的批处理文件中：

rem build_prj.bat

gnumake -f rpfonts.mak
gnumake -f prj.mak

Okey，我只需像平常一样执行build_prj.bat就好了，它会在需要替换字体的时候自动给偶替换的。嘻嘻，是不是很方便呢？:p

-------------
乾坤一笑写于2005年6月18 日转载请标明出处和原文链接

用宏也不见得效率高——max宏使用方法说明

乾坤一笑 — Sat, 18 Jun 2005 07:44:00 GMT

很多人认为使用宏，在预处理时候就完成了宏替换，消除了函数调用的代价，因此效率很高。其实也不见得。比如max宏一般是这样定义的：

#define max(a,b) ((a)>(b)?(a):(b))

使用它来比较两个看不出什么问题，我们不妨用它来比较一下a, b, c, d的大小：
max(a, max(b, max(c, d)))
宏替换后的结果是这样的：
((a)>(((b)>(((c)>(d)?(c):(d)))?(b):(((c)>(d)?(c):(d)))))?(a):(((b)>(((c)>(d)?(c):(d)))?(b):(((c)>(d)?(c):(d))))))
够晕够复杂吧？

如果这样用试试看：
max(max(a, b), max(c, d))
同样还是使用三次max宏，但是效果就大大不同了：
((((a)>(b)?(a):(b)))>(((c)>(d)?(c):(d)))?(((a)>(b)?(a):(b))):(((c)>(d)?(c):(d))))

看样子是短了点了，可是也不见得效率高！其实还真不如这样搞：

max_num = a;
if (max_num<b) max_num = b;
if (max_num<c) max_num = c;
if (max_num<d) max_num = d;

这样做又清爽又直观难道不好么？所以，兵器有多种，如何发挥作用还在于用的人。:p

该方法在Andrew Koenig的《C陷阱与缺陷》中有提到。

我用错了strcat()

乾坤一笑 — Sat, 18 Jun 2005 03:14:00 GMT

估计如果我一直在Windows下写程序、用VC写程序，绝对不会因为这一个小小的函数来写一篇blog。因为就算是出了差错，也在debug中随手改过来了，一点感觉和印象都没有。但是我是在做嵌入式开发，情形就不同了，我需要在Windows上用编辑器(SourceInsight或者ultraedit)写出源码，用编译器进行交叉编译，再烧到目标板上去看效果。这样一组操作的周期大概需要20分种左右(如果都先clean再build的话需要2个小时左右)。而平时的调试不仅没有VC这种IDE式的debug工具，就是连gdb这种console的单步调试工具也没有。一般没有致命错误，我是绝对不会动用JTAG之类的核子武器的，我会用Trace宏讲要看到的运行时信息打印到串口，当然更多的情况下，是用肉眼去判断。(不然完成一个项目估计1～2年是做不完了)——在这种情况下，如果概念不清、思路不清、库函数的细节不清楚，就会挂了。我这次用strcat()这个函数犯的错误就是个很好的例子。

好了，大家先看看这个程序，你能发现其中的bug吗？

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
    #define MAX (100)
    #define START (10000)

    char buf[512], tmp[32];
    int a[MAX];
    int count = 0;
    int i;

    printf("%d %d %d \n",a[0],a[1],a[2]);
    //initialize an array for testing
    for ( i = START; i<START + MAX; ++i)
    {
        a[i - START] = i;
    }
  
    for ( i=0; i<MAX; ++i)
    {
        sprintf(tmp, "0x%.4X,", i);
        
        strcat(buf, tmp);
        if (count++ == 9)
        {
            //print result, output to standard io stream for samulation.
            printf("%s\n", buf);
            buf[0] = '\0';
            count = 0;
        }
        
    }
 
 return 0;
}

嘿嘿，这个bug可不简单，它会导致偶的系统驱动层的所有实体全部崩溃掉。偶是用的世界著名的A公司的OS，这个OS很多公司都在用。这段代码是偶写的代码的一个简化版。a[]这个数组是显示的缓冲区，我需要将它的内容trace到串口。因为a[]中的数据量很大，如果我极为频繁的访问串口的话，会导致串口阻塞，trace数据丢失，看不到我要看的数据。所以我把数据分了组，用strcat()来合并数据，一组一组的往串口发。

好了，背景介绍完了。看出bug了没有？如果没有看出来，我就要公布答案了! :)

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
    #define MAX (100)
    #define START (10000)

    char buf[512], tmp[32];
    int a[MAX];
    int count = 0;
    int i;

    printf("%d %d %d \n",a[0],a[1],a[2]);
    //initialize an array for testing
    for ( i = START; i<START + MAX; ++i)
    {
        a[i - START] = i;
    }

    buf[0] = '\0'; ////////////////////////////////////////// here !
   
    for ( i=0; i<MAX; ++i)
    {
        sprintf(tmp, "0x%.4X,", i);
        
        strcat(buf, tmp);
        if (count++ == 9)
        {
            //print result, output to standard io stream for samulation.
            printf("%s\n", buf);
            buf[0] = '\0';
            count = 0;
        }
        
    }
 
 return 0;
}

问题的关键在于传递给strcat(dst,src)的两个参数都要是以'\0'结尾的。而我第一次传递给strcat()的第一个参数buf[]没有初始化，导致了buf的内容都非0，从而引起缓冲区溢出的错误。

先看看vc6.0中strcat的实现：

char * __cdecl strcat (
        char * dst,
        const char * src
        )
{
        char * cp = dst;

        while( *cp )
                cp++;                   /* find end of dst */

        while( *cp++ = *src++ ) ;       /* Copy src to end of dst */

        return( dst );                  /* return dst */

}

在find end of dst这一步，程序会从dst的起始地址开始，去找一个'\0'，并且只有找到这个'\0'，代码才会结束。Okey，问题明了了。由于我没有初始化buf[]，而系统随便分配一块内存给它，里面可能还不为0，它就不停的跑下去了。就算它停了下来，第二步的copy src to end of dst也会接着写下去，如果此刻超出了buf的范围，就会把src中的内容写到不该写的位置上去，这样就破坏了其他的进程的代码和数据，系统就崩溃掉了。

反过来想，当系统崩溃的时候，又有谁一下子能想到是buf没有初始化引起的呢？:) 值得一提的是，这段代码在Mingw上不初始化buf也不会出错的，就是说，由于编译器实现不同，可能MingW在分配buf的时候已经替它做了初始化。所以在MingW上编译我们第一段代码，它也跑的很好，不会出错。但是如果你来做移植工作，把MingW上的一个工程移植到其他平台，系统就挂掉了，再也跑不起来，你能查到这个由于strcat()参数没有初始化的bug么？

呵呵，所以coder的责任重大，不写代码没什么问题，如果写了错误的代码就会给维护的人员造成很大的压力了。所以，一个好的coder平时就要对自己有至少两点要求：第一，要对库函数实现有清晰的认识，最好能了解几种不同实现的代码，要知道他们的实现原理，知其然并且知其所以然；第二，平时工作就要多用几种不同的编译器，这样才好及时的发现不能跨平台的问题，及时去解决。Coder任重而道远，虽不能妄自尊大，也不要妄自菲薄呀！:)

----------------------------------------
吃完饭回来，再补充两句：不要以为strcat()不作边界检查、或者不强制初始化是C语言的不足。没有任何一个有实用价值的操作系统实现会去强制执行边界检查或者缓冲区溢出的错误的，不然它在市场上就没有竞争力。以下给出几种strcat的实现，希望有参考价值：

Linux 0.11的实现：

//////// Linux 0.11 ///////////
extern inline char * strcat(char * dest,const char * src)
{
__asm__("cld\n\t"
 "repne\n\t"
 "scasb\n\t"
 "decl %1\n"
 "1:\tlodsb\n\t"
 "stosb\n\t"
 "testb %%al,%%al\n\t"
 "jne 1b"
 ::"S" (src),"D" (dest),"a" (0),"c" (0xffffffff));
return dest;
}

Linux 2.4.26的实现：

///// LINUX 2.4.26 /////

#ifndef __HAVE_ARCH_STRCAT
/**
 * strcat - Append one %NUL-terminated string to another
 * @dest: The string to be appended to
 * @src: The string to append to it
 */
char * strcat(char * dest, const char * src)
{
 char *tmp = dest;

 while (*dest)
  dest++;
 while ((*dest++ = *src++) != '\0')
  ;

 return tmp;
}
#endif

GNU glibc的实现：

/* Copyright (C) 1991, 1997, 2003 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#include <string.h>
#include <memcopy.h>

#undef strcat

/* Append SRC on the end of DEST.  */
char *
strcat (dest, src)
     char *dest;
     const char *src;
{
  char *s1 = dest;
  const char *s2 = src;
  reg_char c;

  /* Find the end of the string.  */
  do
    c = *s1++;
  while (c != '\0');

  /* Make S1 point before the next character, so we can increment
     it while memory is read (wins on pipelined cpus).  */
  s1 -= 2;

  do
    {
      c = *s2++;
      *++s1 = c;
    }
  while (c != '\0');

  return dest;
}
libc_hidden_builtin_def (strcat)

VC 7.1的实现：

        page    ,132
        title   strcat - concatenate (append) one string to another
;***
;strcat.asm - contains strcat() and strcpy() routines
;
;       Copyright (c) Microsoft Corporation. All rights reserved.
;
;Purpose:
;       STRCAT concatenates (appends) a copy of the source string to the
;       end of the destination string, returning the destination string.
;
;*******************************************************************************

        .xlist
        include cruntime.inc
        .list


page
;***
;char *strcat(dst, src) - concatenate (append) one string to another
;
;Purpose:
;       Concatenates src onto the end of dest.  Assumes enough
;       space in dest.
;
;       Algorithm:
;       char * strcat (char * dst, char * src)
;       {
;           char * cp = dst;
;
;           while( *cp )
;                   ++cp;           /* Find end of dst */
;           while( *cp++ = *src++ )
;                   ;               /* Copy src to end of dst */
;           return( dst );
;       }
;
;Entry:
;       char *dst - string to which "src" is to be appended
;       const char *src - string to be appended to the end of "dst"
;
;Exit:
;       The address of "dst" in EAX
;
;Uses:
;       EAX, ECX
;
;Exceptions:
;
;*******************************************************************************

page
;***
;char *strcpy(dst, src) - copy one string over another
;
;Purpose:
;       Copies the string src into the spot specified by
;       dest; assumes enough room.
;
;       Algorithm:
;       char * strcpy (char * dst, char * src)
;       {
;           char * cp = dst;
;
;           while( *cp++ = *src++ )
;                   ;               /* Copy src over dst */
;           return( dst );
;       }
;
;Entry:
;       char * dst - string over which "src" is to be copied
;       const char * src - string to be copied over "dst"
;
;Exit:
;       The address of "dst" in EAX
;
;Uses:
;       EAX, ECX
;
;Exceptions:
;*******************************************************************************


        CODESEG

%       public  strcat, strcpy      ; make both functions available
strcpy  proc
        push    edi                 ; preserve edi
        mov     edi,[esp+8]         ; edi points to dest string
        jmp     short copy_start

strcpy  endp

        align   16

strcat  proc

        .FPO    ( 0, 2, 0, 0, 0, 0 )

        mov     ecx,[esp+4]         ; ecx -> dest string
        push    edi                 ; preserve edi
        test    ecx,3               ; test if string is aligned on 32 bits
        je      short find_end_of_dest_string_loop

dest_misaligned:                    ; simple byte loop until string is aligned
        mov     al,byte ptr [ecx]
        add     ecx,1
        test    al,al
        je      short start_byte_3
        test    ecx,3
        jne     short dest_misaligned

        align   4

find_end_of_dest_string_loop:
        mov     eax,dword ptr [ecx] ; read 4 bytes
        mov     edx,7efefeffh
        add     edx,eax
        xor     eax,-1
        xor     eax,edx
        add     ecx,4
        test    eax,81010100h
        je      short find_end_of_dest_string_loop
        ; found zero byte in the loop
        mov     eax,[ecx - 4]
        test    al,al               ; is it byte 0
        je      short start_byte_0
        test    ah,ah               ; is it byte 1
        je      short start_byte_1
        test    eax,00ff0000h       ; is it byte 2
        je      short start_byte_2
        test    eax,0ff000000h      ; is it byte 3
        je      short start_byte_3
        jmp     short find_end_of_dest_string_loop
                                    ; taken if bits 24-30 are clear and bit
                                    ; 31 is set
start_byte_3:
        lea     edi,[ecx - 1]
        jmp     short copy_start
start_byte_2:
        lea     edi,[ecx - 2]
        jmp     short copy_start
start_byte_1:
        lea     edi,[ecx - 3]
        jmp     short copy_start
start_byte_0:
        lea     edi,[ecx - 4]
;       jmp     short copy_start

;       edi points to the end of dest string.
copy_start::
        mov     ecx,[esp+0ch]       ; ecx -> sorc string
        test    ecx,3               ; test if string is aligned on 32 bits
        je      short main_loop_entrance

src_misaligned:                     ; simple byte loop until string is aligned
        mov     dl,byte ptr [ecx]
        add     ecx,1
        test    dl,dl
        je      short byte_0
        mov     [edi],dl
        add     edi,1
        test    ecx,3
        jne     short src_misaligned
        jmp     short main_loop_entrance

main_loop:                          ; edx contains first dword of sorc string
        mov     [edi],edx           ; store one more dword
        add     edi,4               ; kick dest pointer
main_loop_entrance:
        mov     edx,7efefeffh
        mov     eax,dword ptr [ecx] ; read 4 bytes

        add     edx,eax
        xor     eax,-1

        xor     eax,edx
        mov     edx,[ecx]           ; it is in cache now

        add     ecx,4               ; kick dest pointer
        test    eax,81010100h

        je      short main_loop
        ; found zero byte in the loop
; main_loop_end:
        test    dl,dl               ; is it byte 0
        je      short byte_0
        test    dh,dh               ; is it byte 1
        je      short byte_1
        test    edx,00ff0000h       ; is it byte 2
        je      short byte_2
        test    edx,0ff000000h      ; is it byte 3
        je      short byte_3
        jmp     short main_loop     ; taken if bits 24-30 are clear and bit
                                    ; 31 is set
byte_3:
        mov     [edi],edx
        mov     eax,[esp+8]         ; return in eax pointer to dest string
        pop     edi
        ret
byte_2:
        mov     [edi],dx
        mov     eax,[esp+8]         ; return in eax pointer to dest string
        mov     byte ptr [edi+2],0
        pop     edi
        ret
byte_1:
        mov     [edi],dx
        mov     eax,[esp+8]         ; return in eax pointer to dest string
        pop     edi
        ret
byte_0:
        mov     [edi],dl
        mov     eax,[esp+8]         ; return in eax pointer to dest string
        pop     edi
        ret

strcat  endp

        end

-------------
乾坤一笑写于2005年6月18 日转载请标明出处和原文链接

Makefile的缺陷

乾坤一笑 — Sun, 12 Jun 2005 05:29:00 GMT

难得星期天能休息一下，就翻了翻书，一翻书不当紧，马上就遇到了个好难的课后练习题。这个难题平时工作也遇到过，一直没空研究（托词，其实是本人水平有限，难以解决）。于是乎，就放在blog上，请大家一起帮忙解决一下吧:p

Unix的make功能使程序员可以描述好一个程序的不同编译单位之间的依赖关系。如果文件A依赖于文件B，而文件B修改了，make就会推断出A必须重新编译，因为B的任何改变都可能影响到A生成的代码。这种依赖性管理的精确度如何？在什么情景中它会导致一些不必要的工作？在什么情景中它可能没有去编译某些应该编译的东西？（就是“多做之过”和“少作之过”）