IT博客-Martin Ding's Garden Plot-随笔分类-Project Management

[转]广为流传的一个关于项目管理的通俗讲解

Martin — Fri, 21 Apr 2006 10:01:00 GMT

From: http://www.cnitblog.com/Raistlin/archive/2005/12/19/5568.html

想首先问大家一个问题：你觉得中国人聪明还是美国人聪明？
我见过最好的回答是美籍华人。
我们说美国人很愚蠢，为什么呢？
你们都考过T或G吧，他们经常会出这么一道题1/3+1/2=？
50%的人回答是2/5，这可是美国研究生入学考试的试题呀！
通常在这个问题之前还有一个1/2+1/2=？为什么？
他们怕太难了，先给个容易的热身一下。
我在美国的时候见过很多的PHD，对于美国人来说if...else...是逻辑，而if...if...else...就成了哲学，也是美国这么多哲学博士的原因：）
我们说美国人很愚蠢，那我们为什么还要学习他们呢？这个问题稍候我们会回答。
再问一个问题：如果你刚买了一个豪华的房子，可你三岁的儿子把整个墙壁上都写上“我爱长城永不到，我爱北京天安门”，你该怎么做？
有的女孩子说暴打，呵呵，这个答案从女生的嘴里说出来还是比较少见。
美国人怎么办？
他们会对孩子说：“你老人家真有绘画的天赋，简直就是毕加索的毕加索，你这一幅画至少能卖100万美金”你们知道美国人喜欢钱，用金钱来量化一定是效果明显。
但显而易见，您老人家把画画在墙壁上是不能永久保存的，所以我明天给你买一个画布，你就尽情的画吧。否则我们要损失多少个毕加索呀！
于是我们就可以看见我们的小宝贝在画布上快乐的滚来滚去。墙面也干净了。
中国人很聪明，从大家就可以看出来，但中国人聪明做工作就有了聪明的做法，他们往往是每个项目都是按照自己的见解来做。
而美国人如何来操作呢，他们就象洗澡，会在面前挂一张纸，上面写着先洗头，再洗耳朵，再细脸，，，这样做事情就有了一定的流程，渐渐的就形成了一套体系。
所以这也是我们今天来探讨项目管理的目的所在。
项目管理分九个知识领域，分别是成本管理、质量管理、时间管理、范围管理、人力资源管理、沟通管理、风险管理、采购管理和整体管理。
其中时间，质量和成本管理构成了三角形
大家在纸上画一个三角形
在各个边上标上时间、质量、成本（等边三角形）
任何一方的移动必定带动其他的变形，如果时间缩短，怎么样？就是我们常说的“献礼工程”，同时必定会影响质量和成本。问大家一个问题，这个三角形中间是什么东东？
对，是范围管理，也就是我们说的项目范围。这也就是我们常说的项目“项目管理三角形”
下面介绍一下项目管理的“项目管理三角形“
项目三角形中的成本，主要来自于所需资源的成本，自然也包括人力资源的成本。这个相信很好理解。
为了缩短项目时间，就需要增加项目成本（资源）或减少项目范围；
为了节约项目成本（资源），可以减少项目范围或延长项目时间；
如果需求变化导致增加项目范围，就需要增加项目成本（资源）或延长项目时间
通过“项目管理三角形“我们了解了项目成本、时间，质量和范围的简单定义。
我们说一个项目经理有多少时间是用来做沟通的工作的？
应该不少于75%的时间是用来沟通的，所以项目管理将项目沟通管理单独列了出来。
所有这些领域都有一个主线就是项目的整体管理来统一的。
由于时间的限制我们不详细讨论其他的知识领域，因为今天是入门的，哈哈
另外项目管理除了九个知识领域，还应该了解5个过程组
5个过程组就是：启动，计划，执行，控制，收尾。
这5个过程组贯穿于每个知识领域的始终，你们了解吗？
举个例子字来说：
某人（比喻）好不容易找了个女朋友，为了增进进一步的距离，他想来个欧亚8日游，于是他把自己多年的积蓄——3万元，一次性投入。
但在旅游过程中，他的MM看上了另外一个帅哥，于是人财两空，说明什么问题？
说明他的项目启动的时候就出现了问题，没有很好的做市场调研，结果过程就没有办法控制。
根据PMI的解释，接单之后项目自然转入启动阶段
于是他刻苦的工作，终于又攒了3万，这次他不和美女旅游了，考虑到自己的费用，他请这个姑娘看了场电影。
于是他带这个这个姑娘看了——《第一滴血》
看的那叫爽，姑娘看的也很爽，看看完后她觉得这个家伙有暴力倾向，于是又分手。说明什么问题？
对，没有进行有效的需求调查，也就是在计划的时候没有明确的需求定义。
于是他下次的时候知道了姑娘爱看歌舞剧，于是他就请一个靓女看了《天鹅湖》，可是以外有发生了——
进去后发现座位不在一起，等他们把位子换到一起的时候歌舞剧结束了，这说明什么？
对，说明没有很好的执行，起码在执行过程中没有进行有效的监督。
其他的过程不一一解释，我在这里强调的是收尾的重要性。
我们往往非常注重合同性收尾，却总是忽略管理性收尾。什么是管理性收尾呢？
某人同志吸取了所有的经验教训，终于领了结婚证，还应该干些什么呢？
对了，还应该把所有的经验教训总结一下，以书面的形式汇报给老妈，并张贴于门后。
然后在中堂挂一幅对联：欲谈恋爱者需先阅读门后之——《恋爱指南》
以后凡是自己的兄弟姐妹要谈恋爱的，必须先参阅门后的恋爱指南。
这样能起到什么效果呢，对，以后他们的恋爱项目操作至少能停留在这个水平。
这个过程怎样来保证呢，对，还需要我们的QA人员，也就是他的妈妈负责质量控制。
家规一条，不参阅者或不照此操作者不许谈恋爱！
大公司一般有质量管理部门（QA），QA的成员基本上都是由非常有经验的PM转型过来的老狐狸，是老总接班人的有力争夺者：）
这也是我们说一个失败的项目会培养一批优秀的项目经理的原因。
哪个门后的《恋爱指南》我们称之为文档，文档重要吗？我们说在电信科技处的同志们说重要，为什么因为他们管这个，但对于我们呢？
大家拿起你身边的一只笔，告诉我他多长？
有的说10厘米，有的说10。0987厘米。
我们说他的估算很精确，但不准确！！
这是我如果拿一只笔告诉你正好10厘米，然后和你的笔比对你是不是就比较容易得出测算？
这说明文档是非常重要的，有的人认为文档是最无聊的，项目结束后做个总结不就是了吗。
错，文档的整理应该贯穿于项目管理的始终。
文档的管理是对项目进行良好的跟踪和监控的一个手段，简单的讲就是根据你的项目计划进行你的文档管理。
一般档案分类主线是：立项、计划、执行、结束4大类；然后在每大类中，再根据任务或者团组分类管理，根据哪个需要根据你项目复杂程度和管理习惯，总之原则是方便你对整个项目进度的追踪。
以上我们讲了项目管理的九个知识领域，五大过程组，还有“项目管理三角形“，下面我们讲PMBOK。
PMBOK是项目管理圣经，也就是Project management body of knowledge，项目管理知识体系指南
它是美国项目管理协会（PMI）的核心指导出版物
但它象一本字典，往往你看到第三页会睡着：）
在此简单介绍美国项目管理协会（PMI）和国际项目管理协会（IPMA）
美国项目管理协会只有PMP一个证书，而IPMA有四级，你可以一毕业就可以考试，这个我们后面详细的讲。
下面讲几个名词，如果你掌握了，一和人讲项目管理你就抛出来，一定没有人敢小看你。
他们是WBS、甘特图、基准（BASELINE）、项目干系人和关键路径
WBS是WORK BREAKDOWN STRUCTRE ，工作分解结构
WBS的定义还是很麻烦的，PM要召开团队进行讨论，向成员提供与项目相关的所有详细资料，并把WBS树分解到二层三层。然后要花上一段时间让成员进行头脑风暴式（BRAINING STORM）思考，制订工作产出和相应人员的职责，记录每一个工作包的完成标准。
比如我们要结婚了，怎么来分解呢
无非是办酒席，拍结婚照，，等等，这个在论坛上曾有人做了详细的分解，大家都可以找到。
我们说为什么WBS重要，而且大部分项目管理的咨询都是针对WBS的咨询
因为WBS做好了，以后工作就有了参考物，你就知道在不同的阶段你应该干什么，完成到什么进度。
其实WBS的划分是没有规则的，主要的考虑角度是方便你做各类的统计工作，为管理服务。
同样的一个项目其管理的侧重点不同，WBS结构的划分也可能是完全不同的。
衡量划分好坏的标准应该是看其是否满足你管理的需要。
甘特图也叫横道图等，很多名称，我们说它是甘特在第一次世界大战时开始使用，它就是在WBS的基础上将WBS形象化老控制进度
对于基准，我象举个例子。
我们在没有结婚之前，你脚踩几只船？
我们说法律允许但道德不允许，但你可以脚踩N只船：）
但当有一天你和你的朋友进了一个小黑屋子，然后带了两个盖章的本本的时候，你还可以脚踩N只船吗？
我们说此时就不允许了，因为你过了一个基准线（BASELINE）
如果你还想脚踩N只船就需要重新回小黑屋子再盖两个章就可以了。
那我们的项目要越轨怎么办，也就是项目变更？
我们说对这样的项目变更会影响各要素比如时间，成本，质量等
我们应该统一由项目管理办公室来进行控制，如果你要变更基准，必须要进行严格的限制。
在客户提出变更请求时，要建立变更申请登记表和变更申请表，并让客户签字。
有时候一些不是非常关键的模块PM也不至于一点不讲情面，该卖面子的时候还是要卖，尤其是当着对方领导的面，千万要卖面子，但是也别卖的太干脆，不要让他们得到的太容易。
PM在变更管理中需要做的是分析变更请求，评估变更可能带来的风险和修改基准文件。
如果一个项目进行过程中，比如现在的点心的3G项目，你发现如果再多花一点时间就可以编写出对以后非常有用处的程序，但这个程序不在本项目范围之内，你要不要做？
对，我们说不能做，你可以重新起一个项目来做，但不能在这个项目里做，这样会是我们的项目成本超出，风险增加，而且和其他的项目缺少比对性和参照的价值。
这也是我们说现在有大约80%以上的项目失败的原因，我们说项目失败并不是项目进行不下去了，彻底破产，在PMI有明确的定义，凡是项目的成本超出预算，质量没有得到保证，时间超过预计等等都在失败的范围之内。
这个在华为做的很好，华为有个有名的增量开发的名声。
只用20%的功能先满足你80%的需求，其他的功能我可以开发升级的版本，于是就在小数点后平明的增加数字，于是就是了V1，V1.1，V1.11....等版本
它从来不一下子满足你所有的需求，我们大家想想，谁没有事情拿出自己的手机把所有的PING码都试用一下，我们说没有，我们大部分的需求是在打电话，发消息，打打游戏，对不对？
这点在项目管理中非常重要，请大家结合资料好好研究。
项目干系人是什么东东，谁给我举一个例子？
对，包括项目人员的老婆孩子，正确
我们说有的项目需要的时间很紧张，如果你的项目成功了，但项目的程序员们都成了光棍，那项目还是非常失败，至少不是丧心病狂的PM这么想。
合理解决项目干系人的冲突是个很累的问题，其中还包括你的只能经理们，你的董事长，你的客户，等等，等等，有的说没用？
好，如果你的项目进展不下去，你该怎么办？
对，开会，把你的高层找一个坐到会议室，不用他说话，只让他暧昧的看着大家，大家一定会想，这个家伙一定和领导有关系，我们还是好好的做这个项目，下一个项目再给他使拌子吧：）
所以为了不累死好好分析一下你的项目干系人吧
我们上次讲了一些基础的知识，包括什么是项目管理，项目管理包括什么？
你说项目管理有几个知识领域？
你说项目管理有几个过程组？
让我们想起了泡MM的例子是不是？
还有老母亲做QA的比喻
几天我们着重强调的是
项目是什么?人们常用“时间”，“资源(或缺乏资源)”，“某种工作努力”，“交付物或者产品”，“综合工程”，“缺乏凌驾其他班组的职权”，以及“预算” 来给它下定义。实际上，项目是一种独特的工作努力，即遵照某种规范及应用标准去导入或生产某种新产品或某项新服务。这种工作努力应在限定的时间、成本费用、人力资源及资财等项目参数内完成。
首先给大家一个项目的定义，到底什么是项目？
根据PMPBOK的定义，项目是在一段时间内为完成某一独特的产品或提供独特的服务所进行努力的过程。
这个过程受到时间、人力、资源、成本、质量上的限制
项目有几个特征：1.临时性 2.独特性 3.一次性
下面大家告诉我下面哪个是项目：A惠普与康柏机构重组惠普与康柏机构重组。B建造一座新工厂 C改建道路 D工程材料采购 E开发软件包 F结婚典礼 G寻找拉登
有人说是寻找拉登，大家说寻找拉登有明确的结束时间吗？
当然我们可以假设寻找拉登50年如果找不到，项目就结束是不是？
所以说我们今天不讨论哪个到底是项目，所有的问题都要放到具体的环境下，否则没有意义。
下面大家可以开始提问了。
什么是WBS呢？
WBS是工作分解结构，就象一张道路交通图，它能够指引你如何从当前位置到达想去的地方。没有它，你可能就要迷路了。
怎样来做一个好的WBS呢？
有时候在接受新项目时前无例子可借鉴感觉分解时真困难, 因为每个人的解决问题思路不同,同一个项目不同的人有很多种分类, 因为可以按照工作的流程分解,也可以按照系统论的方法进行结构上的分解, 但我觉得有一条很重要的原则应该注意,那就是麦肯锡的精髓,他们在分解工作时非常强调的就是MECE, muturally exclusive, collectively exhaustive, 即相互独立,完全穷尽的原则, 也就是现在较流行的说法"横向到底,纵向到边" , 如果分解时坚持了这个原则, 我想一定会有Perfect 的WBS, 其实WBS并非是PMI的"真传", 只是被PMI起名为WBS, 有时候工作中我们也会用类似的方法解决问题无非是没有提升到理论高度, 但WBS确实是做事的核心步骤。
做一个WBS需要注意一些什么问题呢？
? 第一级通常与项目生命周期相同(如需求分析，设计，采购，施工……)
? 第一级应在项目进一步分解前完成
? WBS的每一级都是其上一级的片断(Segment)
? 一个工作单元只与一个上层单元相关
? 上层单元的工作内容应该等于其所有直接下层工作单元的总和
? 一个工作单元由一个人负责
? 在整个WBS中使用同一种定义，在整个组织中亦然
? 通过将人员包括进WBS来激励他去完成计划
什么是甘特图呢？
1.以图形或表格的形式显示活动。
2.现在是一种通用的显示进度的方法。
3.构造时应包括实际日历天和持续时间。不要将周末和节假日算在进度之内
什么是风险呢？
首先问一个问题
你们说在一个项目中，初始阶段和结束阶段哪个时候项目的风险大？
对，是开始的时候，因为在开始的时候有无数的不可控制的因素。
那什么阶段的损失大呢？
对，在结束的时候，所以说两者是相反的/
所以说在项目的启动阶段成功的可能性最小，风险发生的概率也就最高，但是这时候一旦预计的风险发生了，损失是最小的。
想想广州和深圳很多烂尾楼？损失会有多少？？？！！！！！
另外我们要明确几个定义：
1是确定性。具有明显的可能性，比如中国和韩国对抗赛，胜负是很明显的：）
2是风险。韩国队能赢中国队几个球是一种风险的预测。
3是未知性。中国和美国比赛门球那就是未知的：）

Martin 2006-04-21 18:01 发表评论

CVS-Commands

Martin — Thu, 13 Apr 2006 13:55:00 GMT

摘要: CVS 常用命令 1. CVS ... 阅读全文

Martin 2006-04-13 21:55 发表评论

CVS--Adminitration

Martin — Thu, 13 Apr 2006 13:54:00 GMT

摘要: CVS 管理 --- 以本次建立的 CVS 系统为例 ... 阅读全文

Martin 2006-04-13 21:54 发表评论

Porting Guideline (UNIX&Windows, C/C++/Fortran)

Martin — Thu, 13 Apr 2006 09:49:00 GMT

1. Difference among Different Platforms

   1) Different compilers ( pls read the makefiles of hspice)

   2) Create a lib

      Normally:
        $(AR) $(TARGET_LIB) %.o

      Exception: (while create C++ lib)

          SunOS : 
                $(CXX) -xar -o $(TARGET_LIB) %.o
          SGI:
                $(CXX) -ar -o $(TARGET_LIB) %.o

      Explanation :

        SunOS :
        -xar      Creates archive libraries.

               When building a C++ archive that uses templates,
               it is necessary in most cases to include in the
               archive those template functions that are instan-
               tiated in the template repository.  Using this
               option automatically adds those templates to the
               archive as needed.

               Examples:

               The following command archives the template func-
               tions contained in the repository and the object
               files.

               example% CC -xar -o libmain.a a.o b.o c.o

               Warnings:

               Do not add .o files from the template repository
               on the command line.

               Do not use the ar command directly for building
               archives. Use CC -xar to ensure that template
               instantiations are automatically included in the
               archive.

        SGI:
        -ar   may be the same.

   3) C++

      1) Include head files
         HP-UX & SGI :
            #include 
            #include 
            #include 
         Others :
            #include 
            #include 
            #include 

      2) using namespace std;
         HP-UX does not support namespace.     

      3) On ALPHA & IBM, the fstream class has no the following constructor:

           fstream(int fd);

2. Mixed Language Program

   1) Function Name Modification among C, FORTRAN and C++

      Focus on file src_metaq/ftnc.h:

      Linux,PC,HP,IBM :
      #define FTNC(f) f

      SUN,SGI :
      #ifdef __STDC__         /* Ansi C */
      #define FTNC(f) f##_
      #else
      #define FTNC(f) f_
      #endif

      ALPHA :
      #define FTNC(f)  f##_

      #define FCALL(f) FTNC(f)

   2) extern "C"
      In C++ program,use this to compile C++ function or others to C format.
      Thus,C can call C++ function,and C++ can call C function.

      Examples:

          extern "C" void foo1(void);
          extern "C" int FTNC(foo2)(void);

          extern "C"
          {
              void foo1(void);
              int FTNC(foo2)(void);
              ...
          }

          extern "C"
          {
          #include "foo1.h"
          #include "foo2.h"
          ...
          }

    3) FORTRAN call C, C++ (UNIX)

       C: void FTNC(foo)(int *,double*);
       F: external foo
          call foo(...)

       C++: extern "C" void FTNC(foo)(int*,double*);
       F: external foo
          call foo(...)

    4) C,C++ call FORTRAN (UNIX)

       F: subroutine foo(...)

       C: void FTNC(foo)(...)
          FTNC(foo)(...);

       C++:extern "C" FTNC(foo)(...)
          FTNC(foo)(...);

3.PC Porting

    1) FORTRAN call C, C++
       Focus on src_header/refs.dek ( Only used on PC )

       Should include header file refs.dek in fortran files.

       C: void FTNC(foo1)(int *arg1,double *arg2,char *arg3);
          int  FTNC(foo2)(int *arg1,double *arg2,char *arg3);

       In refs.dek:

          INTERFACE TO SUBROUTINE foo1 
         +     [C,ALIAS:'_foo1'] (arg1,arg2,arg3)
          INTEGER*4 arg1 [REFERENCE]
          DOUBLE PRECISION arg2 [REFERENCE]
          CHARACTER*8 arg3 [REFERENCE]
          END

          INTERFACE TO INTEGER*4 FUNCTION foo2
         +     [C,ALIAS:'_foo2'] (arg1,arg2,arg3)
          INTEGER*4 arg1 [REFERENCE]
          DOUBLE PRECISION arg2 [REFERENCE]
          CHARACTER*8 arg3 [REFERENCE]
          END    

       F: external foo1
          external foo2
          integer  foo2

          call foo1(...)
          ret=foo2(...)

    2) C, C++ call FORTRAN
       Focus on src_header/fortran2c.h

       F: subroutine foo(a,b)
          integer*4 a
          double precision b

       i) C: #define foo FTNC(FOO)  
             extern foo();         (default cdecl)
             foo(...);

       ii)C: #define foo FTNC(FOO)
             extern __stdcall void foo(int *a,double *b)

             foo(...);

    3) C, C++ call FORTRAN (Special Case)
       F: subroutine foo(a,b)
          integer*4 a
          character b

       C: extern __stdcall void foo(int *a,char *b,char *b1)

       Explanation:
          Fortran : _foo@nn      (nn -- length of stack)
          C :     : -foo@mm      (mm -- length of stack)
          mm should equal nn.
          But in Fortran: charactor --> 8 bytes
              in C, C++:  char * --> 4 bytes

          So,double char * to supply 8 bytes

Martin 2006-04-13 17:49 发表评论

Makefile Introduction

Martin — Thu, 13 Apr 2006 09:46:00 GMT

                  Makefile Introduction (SunOS platform as example)

1. A simple Makefile

EXE = foo
SRC = foo.cc
OBJ = foo.o

CC = /SunOS/5.7/SUNWspro_6.0.OLD/WS6U1/bin/CC
FLAG = -g

$(EXE):$(OBJ)
        $(CC) $(FLAG) $^ -o $@

$(OBJ):$(SRC)
        $(CC) $(FLAG) -c $< -o $@

2. How to use the Makefile

     /usr/ccs/bin/make  [ -d ]  [ -dd ]  [ -D ]  [ -DD ]  [ -e  ]
     [ -i ]  [ -k ]  [ -n ]  [ -p ]  [ -P ]  [ -q ]  [ -r ]  [ -s ]
     [ -S ]  [  -t  ]   [  -V  ]   [  -f makefile  ]   ...   
     [ -K statefile ]  ...  [ target ... ]  [ macro = value ...  ]

     /usr/xpg4/bin/make  [ -d ]  [ -dd ]  [ -D ]  [ -DD ]  [ -e ]
     [ -i ]  [ -k ]  [ -n ]  [ -p ]  [ -P ]  [ -q ]  [ -r ]  [ -s ]
     [ -S ]  [ -t ]  [ -V ]  [ -f makefile ]   ...   [  target... ]
     [ macro = value ...  ]

     -e : Environment variables override assignments  within makefiles.

     -f makefile : Uses the description file makefile.

     -i : Ignores  error   codes   returned   by   commands.

     -k : When a nonzero error status is returned by a rule,
          or when make  cannot find a rule, abandons work on
          the  current  target,  but  continues  with  other
          dependency branches that do not depend on it.

     -n : No execution mode.

3. Special Characters in Makefle

   # -- Start a comment
        For example : 
            #This is a makefile

   inlcude filename -- include a file
	For example :
            include make.sun57.inc

   : -- Target list terminator
        For example :
            foo.o:foo.c foo.h

   :: -- Target terminator for alternate dependencies
	For example :
            foo.o::foo.c foo.h

   % -- Pattern matching wild  card  metacharacter
        For example :
            %.o:%.c

4. Macros

   = -- Macro definition
        For example :
            CC=/SunOS/5.7/SUNWspro_6.0.OLD/WS6U1/bin/CC

   += appends a string to a macro definition
        For example :
            A=dir
            B=bin
            A+=$(B)

         result : $(A) == dir bin

   := Conditional macro assignment
        For example :
            A=dir
            B:=$(A)
            A=bin

        result : $(B) == dir

   $ -- Macro reference
        For example :
            $(A),$(B)

   ( ),{ } -- Macro-reference name delimiters
        For example :
            $(A),${B}

   $$ -- A reference to the dollar-sign macro
        For example :
            echo $$

        result : $

   \$ -- Escaped dollar-sign character

5. Rules

   1) Special characters

      + -- always execute the commands
           For example :
           +echo hello

      - -- ignores any nonzero error code returned by a command line
           For example :
           -echo hello

      @ -- does not print the command line before executing it
           For example :
           @echo hello

      ? -- Escape command-dependency checking

      ! -- Force command-dependency checking

   2) Dependency

      foo.o:foo.c foo.h foo1.h
              $(CC) $(FLAG) -c foo.c -o foo.o

   3) Special macros

      $@, $*, $(@D), $(@F) $^, $<, $?, $%
      $(MAKE)...

      $@ -- The name of the current target

      $* -- The basename of the current target

      $(@D) -- The directory part of the string `$@'
               if there is no  directory part, `.' is assigned

      $(@F) -- The file name of '$@'

      $^ -- All a dependency files

      $< -- The name of the first dependency files

      $? -- The list of dependencies that are newer than the target

      $% -- The name of the library member being processed

      $(MAKE) -- It  has  the  value make by default, and temporarily 
                 overrides the -n option for any line in which it is
                 referred  to.

      example :
          ../lib/liba.a:a.o b.o c.o d.o
                  @(AR) $@ $^

          result :
              $@ --> ../lib/liba.a
              $* --> ../lib/liba
              $(@D) --> ../lib
              $($F) --> liba.a
              $^ --> a.o b.o c.o d.o
              $< --> a.o
              $? --> b.o d.o (if b.o and d.o are newer than ../lib/liba.a)

      example :
           lib(member...):...

           lib(a.o b.o c.o):a.o b.o c.o
           $% --> a.o b.o c.o  (lib(...))

   4) Predefined Macros and Implicit Rules (Partly)

 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
                         Table of Predefined Macros
           Use           Macro                 Default Value
 ______________________________________________________________________
      Library         AR             ar
      Archives        ARFLAGS        rv
 ______________________________________________________________________
      Assembler       AS             as
      Commands        ASFLAGS
                      COMPILE.s      $(AS) $(ASFLAGS)
                      COMPILE.S      $(CC) $(ASFLAGS) $(CPPFLAGS) -c
 ______________________________________________________________________
      C               CC             cc
      Compiler        CFLAGS
      Commands        CPPFLAGS
                      COMPILE.c      $(CC) $(CFLAGS) $(CPPFLAGS) -c
                      LINK.c         $(CC)    $(CFLAGS)     $(CPPFLAGS)
                                     $(LDFLAGS)
 ______________________________________________________________________
      C++             CCC            CC
      Compiler        CCFLAGS        CFLAGS
      Commands        CPPFLAGS
                      COMPILE.cc     $(CCC) $(CCFLAGS) $(CPPFLAGS) -c
                      LINK.cc        $(CCC)   $(CCFLAGS)    $(CPPFLAGS)
                                     $(LDFLAGS)
                      COMPILE.C      $(CCC) $(CCFLAGS) $(CPPFLAGS) -c
                      LINK.C         $(CCC)   $(CCFLAGS)    $(CPPFLAGS)
                                     $(LDFLAGS)
 ______________________________________________________________________
      FORTRAN 77      FC             f77
      Compiler        FFLAGS
      Commands        COMPILE.f      $(FC) $(FFLAGS) -c
                      LINK.f         $(FC) $(FFLAGS) $(LDFLAGS)
                      COMPILE.F      $(FC) $(FFLAGS) $(CPPFLAGS) -c
                      LINK.F         $(FC)    $(FFLAGS)     $(CPPFLAGS)
                                     $(LDFLAGS)
 ______________________________________________________________________
      FORTRAN 90      FC             f90
      Compiler        F90FLAGS
      Commands        COMPILE.f90    $(F90C) $(F90FLAGS) -c
                      LINK.f90       $(F90C) $(F90FLAGS) $(LDFLAGS)
                      COMPILE.ftn    $(F90C) $(F90FLAGS) $(CPPFLAGS) -c
                      LINK.ftn       $(F90C)  $(F90FLAGS)   $(CPPFLAGS)
                                     $(LDFLAGS)
 ______________________________________________________________________
      Link Editor     LD             ld
      Command         LDFLAGS
 ______________________________________________________________________
      lex             LEX            lex
      Command         LFLAGS
                      LEX.l          $(LEX) $(LFLAGS) -t
 ______________________________________________________________________
      lint            LINT           lint
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++



    _______________________________________________________________
    |                      Table of  Standard                     |
    |                      Implicit  (Suffix)                     |
    |                      Rules for C Files                      |
    | Implicit Rule Name|               Command Line              |
    |___________________|_________________________________________|  
    | .c                |  $(LINK.c) -o $@ $< $(LDLIBS)           |
    |                   |                                         |
    | .c.ln             |  $(LINT.c) $(OUTPUT_OPTION) -i $<       |
    |                   |                                         |
    | .c.o              |  $(COMPILE.c) $(OUTPUT_OPTION) $<       |
    |                   |                                         |
    | .c.a              |  $(COMPILE.c) -o $% $<                  |
    |                   |  $(AR) $(ARFLAGS) $@ $%                 |
    |                   |  $(RM) $%                               |
    | .cc               |  $(LINK.cc) -o $@ $< $(LDLIBS)          |
    |                   |                                         |
    | .cc.o             |  $(COMPILE.cc) $(OUTPUT_OPTION) $<      |
    |                   |                                         |
    | .cc.a             |  $(COMPILE.cc) -o $% $<                 |
    |                   |  $(AR) $(ARFLAGS) $@ $%                 |
    |                   |  $(RM) $%                               |
    | .f                |  $(LINK.f) -o $@ $< $(LDLIBS)           |
    |                   |                                         |
    | .f.o              |  $(COMPILE.f) $(OUTPUT_OPTION) $<       |
    |                   |                                         |
    | .f.a              |  $(COMPILE.f) -o $% $<                  |
    |                   |  $(AR) $(ARFLAGS) $@ $%                 |
    |                   |  $(RM) $%                               |
    _______________________________________________________________


6. Reading Makefiles and the Environment

     When make  first starts, it reads the MAKEFLAGS  environment
     variable  to  obtain  any of the following options specified
     present in its value: -d, -D, -e, -i, -k, -n,  -p,  -q,  -r,
     -s,  -S,  or  -t.  Due to the implementation of POSIX.2 (see
     POSIX.2(5), the MAKEFLAGS values will contain a leading  `-'
     character.   The  make   utility then reads the command line
     for additional options, which also take effect.

     Next, make  reads in a default makefile that typically  con-
     tains  predefined  macro  definitions,  target  entries  for
     implicit rules, and additional rules, such as the  rule  for
     retrieving  SCCS  files.  If  present,  make   uses the file
     make.rules in the current directory; otherwise it reads  the
     file   /usr/share/lib/make/make.rules,  which  contains  the
     standard definitions and rules. Use the directive:

     include /usr/share/lib/make/make.rules
     in your local make.rules file to include them.

     Next, make  imports variables from the  environment  (unless
     the -e option is in effect), and treats them as defined mac-
     ros.  Because make   uses  the  most  recent  definition  it
     encounters,  a  macro  definition  in  the makefile normally
     overrides an environment variable of the same name. When  -e
     is  in  effect,  however,  environment variables are read in
     after all makefiles  have  been  read.  In  that  case,  the
     environment  variables  take  precedence over definitions in
     the makefile.

     Next, make  reads any makefiles you specify with -f, or  one
     of  makefile  or  Makefile  as  described above and then the
     state file, in the local directory  if  it  exists.  If  the
     makefile  contains  a .KEEP_STATE_FILE target, then it reads
     the state file that follows the target.   Refer  to  special
     target .KEEP_STATE_FILE for details.

     Next (after reading the environment if  -e  is  in  effect),
     make   reads  in  any  macro definitions supplied as command
     line arguments.  These override  macro  definitions  in  the
     makefile  and  the  environment  both, but only for the make
     command itself.

     make  exports environment variables, using the most recently
     defined  value.  Macro  definitions  supplied on the command
     line are not normally exported, unless the macro is also  an
     environment variable.

     make  does not export macros defined in the makefile. If  an
     environment  variable is set, and a macro with the same name
     is defined on the command line, make  exports its  value  as
     defined  on  the command line. Unless -e is in effect, macro
     definitions within the makefile take precedence  over  those
     imported from the environment.

     Simply :
     make --> Reads MAKEFLAGS environment variable to obtain the 
              following options :
                -d, -D, -e, -i, -k, -n, -p, -q, -r, -s, -S, or -t

          --> Reads in a default makefile, contains :
                Predefined  macros
                Target entries for implicit rules
                Additional rules
              Default makefile :
                make.rules in current directory
                if no,/usr/share/lib/make/make.rules
                in make.rules in current directory will include 
                /usr/share/lib/make/make.rules

          --> Imports environment variables as defined macros.
              if no -e,macros defined in makefile will override
                       the environment variables(same names)
              if -e, exchange

          --> Reads makefile specified by -f,
              or Makefile(makefile) in current directory.

          --> Reads in macro definitions supplied as command line.
              Overrides both Environment variables and macros 
              defined in makefile,even if -e is supplied.

          --> Exports environment variables,using the most recently
              value.

      Note : 
            Macros override sequence :
                The later override the previous.

7. Advanced Macro Definitions

   1) CSRC=$(wildcard *.c)

   2) $(name:str1=str2)
      For example :
      CSRC=a.c b.c c.c
      OBJS=$(CSRC:.c=.o)

      result: $(OBJS)==a.o b.o c.o

   3) OBJS=$(patsubst %.c,%.o,$(CSRC))
      For example :
      CSRC=a.c b.c c.c

      result: $(OBJS)==a.o b.o c.o

      CC=$(patsubst $(CC),$(CC_DBG),$(CC))
      replace the value of CC with the value of CC_DBG

          (patsubst or subst)

   4) OBJS=$(addprefix ../obj/,$(CSRC:.c=.o))
      For example :
      CSRC=a.c b.c c.c

      result: $(OBJS)==../obj/a.o ../obj/b.o ../obj/c.o

   4) $(name: op%os= np%ns)
           (op--old prefix,os--old suffix,
            np--new prefix,ns--new suffix)
      For example :
      name=MMandGG
      name1=$(name:MM%GG=GG%MM)

      result: $(name1) == GGandMM

      name=and
      name1=$(name:%=MM%GG)

      result: $(name1) == MMandGG 

8. Phony Targets
   1)
      .PHONY:all

      all:exe1 exe2

      Note:want to build two binaries:exe1 exe2,
           and exe1 and exe2 is separate.
           all does not exist,make will try to update this rule,
           so,make try to check exe1 and exe2 if they want to be updated.

    2)
      .PHONY:release debug
      release:
          ...

      debug:
          ...

      release and debug have no dependency,so it will not execute until
      use "make release" or "make debug"

      but,make's default is the first phony target:
      if release is the first,"make" means "make release"

      The dependency does not exist,

9. Control Structure

   1) Jump

      release:
              @$(MAKE) A=dir \
                       B=bin compile

      compile:
        ...
        ...     

   2) if
      if [ ! -d $(@D) ]; then $(MK_DIR) $(@D); fi   

   3) for
      compile:
              @for dir in $(SUBDIRS); do \
                   if [ -d $$dir ]; then \
                   (cd $$dir; echo build in $$dir;$(MAKE) compile;) \
                   else echo not build in $$dir; fi \
              done

   4) Command Macro definition

      define MKDIR
          if [ ! -d $(@D) ]; then $(MK_DIR) $(@D); fi
      endef

      usage: $(MKDIR)

10. A Makefile Example

#
# --> ***Makefile** <-- #
#

BIN     = bin
OBJ     = obj
RLS     = rls
DBG     = dbg

OBJS    = $(addprefix $(OBJ)/$(RLS)/,$(CCSRCS:.cc=.o))

BINDIR  = $(BIN)/$(RLS)
OBJDIR  = $(OBJ)/$(RLS)

RM = rm -rf
CP = cp -p
MV = mv
MK_DIR = mkdir -p
AR = /usr/local/bin/ar cq

CC_RE       = /SunOS/5.7/SUNWspro_6.0.OLD/WS6U1/bin/CC
CCFLAGS_RE  = -fast -xarch=v9 -DNDEBUG

CC_DBG      = $(CC_RE)
CCFLAGS_DBG = -g

#############define mkdir macro#############
define MKDIR
    if [ ! -d $(@D) ]; then $(MK_DIR) $(@D); fi
endef

define MKOBJDIR
    if [ ! -d $(OBJ)/$(RLS) ]; then $(MK_DIR) $(OBJ)/$(RLS); fi
endef

define MKLIBDIR
    if [ ! -d $(LIBDIR)/$(RLS) ]; then $(MK_DIR) $(LIBDIR)/$(RLS); fi
endef

define MKBINDIR
    if [ ! -d $(BIN)/$(RLS) ]; then $(MK_DIR) $(BIN)/$(RLS); fi
endef

################make release################
release:
	@$(MAKE) CC='$(subst $(CC),$(CC_RE),$(CC))' \
		CC_OPT='$(subst $(CC_OPT),$(CCFLAGS_RE),$(CC_OPT))' compile

################make debug##################
debug:
	@$(MAKE) CC='$(subst $(CC),$(CC_DBG),$(CC))'\
		CC_OPT='$(subst $(CC_OPT),$(CCFLAGS_DBG),$(CC_OPT))'\
		RLS='$(subst $(RLS),$(DBG),$(RLS))' compile

##################compile###################
compile:
ifdef SUBDIRS
	@for dir in $(SUBDIRS); do \
	    if [ -d $$dir ]; then \
		(cd $$dir; echo build in $$dir;$(MAKE) compile;) \
	    else echo not build in $$dir; fi \
	done
else
	@$(MKDIR)
	@$(MKOBJDIR)
ifdef EXECUTE
	@$(MKDIR)
	@$(MKBINDIR)
	@$(MAKE) build_bin
else
	@$(MKDIR)
	@$(MKLIBDIR)
	@$(MAKE) build_dir
endif
endif

build_bin:$(BINDIR)/$(EXECUTE)
	@echo finished building $(BINDIR)/$(EXECUTE)

build_dir:$(LIBDIR)/$(RLS)/$(LIB)
	@echo finished building $(LIBDIR)/$(LIB)

$(LIBDIR)/$(RLS)/$(LIB):$(OBJDIR)/$(LIB)
	$(RM) $(LIBDIR)/$(RLS)/$(LIB)
	$(CP) $(OBJDIR)/$(LIB) $(LIBDIR)/$(RLS)

$(OBJDIR)/$(LIB):$(OBJS)
#	$(CC) -xar -o $(OBJDIR)/$(LIB) $(OBJS)
	$(AR) $(OBJDIR)/$(LIB) $(OBJS)

#$(OBJDIR)/%.o:%.cc
$(OBJS):$(CCSRCS)
	$(CC) $(CC_OPT) $(INCDIR) -c $< -o $@

$(BINDIR)/$(EXECUTE):$(OBJS)
	$(CC) $(CC_OPT) $^ $(LINKLIB) -o $@

##################make clean###################
define CLEAN
    if [ -d $(OBJ) ]; then (echo $(RM) $(OBJ); $(RM) $(OBJ);)fi
    if [ -d $(BIN) ]; then (echo $(RM) $(BIN); $(RM) $(BIN);)fi
endef

clean:
ifdef SUBDIRS
	@for dir in $(SUBDIRS); do \
	    if [ -d $$dir ]; then \
		(cd $$dir; echo make clean in $$dir; $(MAKE) clean;) \
	    else echo not make clean in $$dir; fi \
	done
else
	@$(CLEAN)
endif

# --> **end of Makefile** <-- #

Martin 2006-04-13 17:46 发表评论