中山野鬼 linux 下 C 编程和make的方法（七、补充，模块化项目组织的Makefil...-白红宇

中山野鬼 linux 下 C 编程和make的方法（七、补充，模块化项目组织的Makefil...

阅读量：6876 次

发布时间：2019-06-26

本文共 35047 字，大约阅读时间需要 116 分钟。

正题谈到模块化的设计方式。这里给出模块化Makefile模板的创建脚本的改良方案。先说说目标。然后贴上源码，最后给出一些简单的解释。如果有网友对特别是脚本的实现方法，有更好的方式，记得给个指正。我一向，“不怕被鄙视，就怕自认为一切OK。”

谈目标前，得再谈一下程序开发，或者软件设计。编写程序，最终形成客户需要的软件，需要经过很多步骤。去掉后面包装的事情，仅谈开发，也包括问题细化，原型验证，平台验证，整体优化四个阶段。不过阶段与阶段之间，不是因果关系，有时甚至是递归。

什么是问题细化。假设客户说，我要吃东西。于是乎，你随地捡起块石头放桌上。客户说，不行，第一，我要吃食物（靠不早说，只不过他以为你知道），第二刚拉过便便，我需要工具而不是用手。但至少现在明确了，需要个桌子，椅子，而且他已经就位了。

于是乎，你拖来一头猪，外加一把菜刀。客户说，不行，第一，猪是生的，（死活暂不谈），第二，菜刀给我也没有用。

于是乎，你切成块，该煮的还要煮，遇到色香味缺一的，还要回炉。

软件开发，准确说是客户需求实现，和其他很多服务类似，例如“个人艺术照”，无论是定制，还是产品化。只不过后者是先将客户一棒子敲晕，后收钱。前者是不停的按客户需求实现，等到客户没时间了，算了解。

因此，问题的细化，有时不单单是设计人员的问题，和客户本身也有关系。而原型验证，平台验证是由具体问题需求所产生的。而整体优化，这属于一个客户体验度的问题。或者是问题本身。例如客户觉得原先的方案慢了。那么客户的基础目标已经全部确立，原先的方案就OK。只是体验度目标，客户要求调整。不过需要明确，这两类的目标有很大差异。基础目标是客户的问题本身，体验度属于实现方案客户体验的问题。因此，后者是明确建立在前者基础之上的。

说了这么多，是希望将整体优化，和其他工作区别开来。优化属于客户满意度的问题。而模块化项目组织，只是解决客户的基础问题而不是体验度。但是模块化的项目组织好坏，直接影响后期整体优化的项目开展进度。

而对于开发者而言，还有一个和客户没有关系的问题，如何提高工作效率，降低重复性劳动。在面向对象问题上，采用类复用的技术，而在C语言开发中，模块化的方式，则更为有效。采用模块化开发至少有以下几个优势：

1、问题分而治之。有效降低局部问题的扩散性的情况。

2、复用技术，可以将设计工作重点集中在目标的特性上。

3、对系统的理解更为容易，便于后期客户目标调整时的方案调整。

针对上述好处，由此确定出模块化Makefile创建模板的目标。需要达到以下几个要求。

1、每个目录组成一个模块。当然包括这个目录下的子模块。

2、模块模板创建脚本能自动生成模块，包括目录，模块接口C文件，对应头文件，对应测试文件。对应当前默认Makefile。

3、对应Makefile可以具备递归处理所依赖的子模块的make工作。

由此我修正了前面的create_module.sh 的脚本。如下。

                  001          #!/bin/bash          
       
                  002          MODULE_PATH=$1         
       
                  003          MODULE_NAME=$1         
       
                  004                    
       
                  005          SRC_DIR_NAME=src         
       
                  006          INC_DIR_NAME=inc         
       
                  007          BIN_DIR_NAME=bin         
       
                  008          OBJ_DIR_NAME=obj         
       
                  009          C_FILE_SUFFIX=.c         
       
                  010          H_FILE_SUFFIX=.h         
       
                  011          TEST_FILE_SUFFIX=.t         
       
                  012          MAKE_FILE_SUFFIX=.m         
       
                  013          CREATE_FILE_FLAG=-f         
       
                  014          CREATE_H_FILE_FLAG=-h         
       
                  015          CREATE_TEST_FILE_FLAG=-t         
       
                  016          CREATE_MAKEFILE_FILE=-m         
       
                  017          CREATE_DEP_FILE=-d         
       
                  018          OVERWRITE_FILE=0         
       
                  019          NOT_OVERWRITE_FILE=1         
       
                  020                    
       
                  021          create_mkdir(){ 
         
                  022              mkdir $1 > /dev/null 2>&1         
       
                  023              if [ $? = 0 ];then          
       
                  024                  echo /$1 had created         
       
                  025                  return 1         
       
                  026              else         
       
                  027                  if [ -d $1 ];then         
       
                  028                      echo /$1 had exist         
       
                  029                      return 0         
       
                  030                  else         
       
                  031                      echo "could not create directory "/$1         
       
                  032                      exit         
       
                  033                  fi         
       
                  034              fi         
       
                  035                    
       
                  036          }         
       
                  037          check_file_exist(){ 
         
                  038              if [ -e $1 ];then         
       
                  039                  while :;do         
       
                  040                      echo -n "the $1 had exist , do you want to overwrite?(y(Y) done:n(N) not:e(E) exit) : "         
       
                  041                      read check_file_exist_ans         
       
                  042                      case $check_file_exist_ans in         
       
                  043                      y|Y)         
       
                  044                          echo you answer y         
       
                  045                          return $OVERWRITE_FILE         
       
                  046                      ;;         
       
                  047                      n|N)         
       
                  048                          echo you answer n         
       
                  049                          return $NOT_OVERWRITE_FILE         
       
                  050                      ;;         
       
                  051                      e|E)         
       
                  052                          exit         
       
                  053                      ;;         
       
                  054                      *)         
       
                  055                          echo  "fuck ,i need you correct answer!"         
       
                  056                      esac         
       
                  057                  done         
       
                  058              else         
       
                  059                  return $OVERWRITE_FILE         
       
                  060              fi         
       
                  061          }         
       
                  062          CREATE_NEW_FLIE=0         
       
                  063          CREATE_NEW_FILE_ERROR=1         
       
                  064          EXIST_FILE=2         
       
                  065          INSERT_FILE_CON=""         
       
                  066                    
       
                  067          get_c_init_context(){ 
         
                  068          #$1 path/filename.ext          
       
                  069          #$2 filename         
       
                  070              INSERT_FILE_CON="/***************\n$1\n by luckystar\n ***************/\n"         
       
                  071              INSERT_FILE_CON+="#include \"$2.h\"\n"         
       
                  072              INSERT_FILE_CON+="static int $2_flag =0;\n"         
       
                  073              INSERT_FILE_CON+="\nvoid $2_init(void){\n"         
       
                  074              INSERT_FILE_CON+="\tif ($2_flag) {\n\t\t//log(\"module inited..\",X);\n\t\treturn;\n\t}\n"         
       
                  075              INSERT_FILE_CON+="\t$2_flag = 1;\n"         
       
                  076              INSERT_FILE_CON+="\t//todo:module init...\n\n}\n"         
       
                  077          #up is create module_init func           
       
                  078              INSERT_FILE_CON+="\nvoid $2_destory(void){\n"         
       
                  079              INSERT_FILE_CON+="\tif (!$2_flag) {\n\t\t//log(\"module not inited..\",X);\n\t\treturn;\n\t}\n"         
       
                  080              INSERT_FILE_CON+="\t$2_flag = 0;\n"         
       
                  081              INSERT_FILE_CON+="\t//todo:module destory...\n\n}\n"         
       
                  082          #up is create module_destory func         
       
                  083          }         
       
                  084                    
       
                  085          get_h_init_context(){ 
         
                  086          #$1 path/filename.ext          
       
                  087          #$2 filename         
       
                  088              INSERT_FILE_CON="#ifndef _$2_H_\n#define _$2_H_\n"         
       
                  089              INSERT_FILE_CON+="\n//ins_inc_file\n"         
       
                  090              INSERT_FILE_CON+="\n//ins_typedef_def\n"         
       
                  091              INSERT_FILE_CON+="\n//ins_def\n"         
       
                  092              INSERT_FILE_CON+="\n//ins_func_declare\n"         
       
                  093              INSERT_FILE_CON+="\n\n"         
       
                  094              INSERT_FILE_CON+="#endif //_$2_H_\n"                
       
                  095          }         
       
                  096          get_test_init_context(){ 
         
                  097          #$1 filename          
       
                  098          #$2 libname         
       
                  099              INSERT_FILE_CON="#include \"$2.h\"\n"         
       
                  100              INSERT_FILE_CON+="#include <stdio.h>\n"         
       
                  101              INSERT_FILE_CON+="\n\n"         
       
                  102              INSERT_FILE_CON+="int main(int argc,char *argv[]){\n"         
       
                  103              INSERT_FILE_CON+="\tprintf(\"hello test_$2_main now run...\\\n\");\n"           
       
                  104              INSERT_FILE_CON+="\t$2_init();\n"         
       
                  105              INSERT_FILE_CON+="\t$2_destory();\n"         
       
                  106              INSERT_FILE_CON+="\tprintf(\"hello test_$2_main now exit...\\\n\");\n"              
       
                  107              INSERT_FILE_CON+="\treturn 0;\n"         
       
                  108              INSERT_FILE_CON+="}\n"              
       
                  109          }         
       
                  110          get_make_init_context(){ 
         
                  111          #$1 module_name         
       
                  112          INSERT_FILE_CON="SRC_PATH=src/\n"         
       
                  113          INSERT_FILE_CON+="INC_PATH=inc/\n"         
       
                  114          INSERT_FILE_CON+="OBJ_PATH=obj/\n"         
       
                  115          INSERT_FILE_CON+="BIN_PATH=bin/\n"         
       
                  116          INSERT_FILE_CON+="MODULE_NAME = $1\n"         
       
                  117          INSERT_FILE_CON+="MODULE_FILE = \$(MODULE_NAME) \n"         
       
                  118          INSERT_FILE_CON+="MODULE_INC =\n\n\n\n"         
       
                  119          INSERT_FILE_CON+="MODULE_T = test_\$(MODULE_NAME)_main\n"         
       
                  120          INSERT_FILE_CON+="MODULE_TS = \$(SRC_PATH)\$(MODULE_T).c\n"         
       
                  121          INSERT_FILE_CON+="MODULE_TB = \$(BIN_PATH)\$(MODULE_T)\n"         
       
                  122          INSERT_FILE_CON+="MODULE_SUB =\n\n\n"         
       
                  123          INSERT_FILE_CON+="MODULE_SRC = \$(addsuffix .c,\$(addprefix \$(SRC_PATH),\$(MODULE_FILE)))\n"         
       
                  124          INSERT_FILE_CON+="MODULE_OBJ = \$(addsuffix .o,\$(addprefix \$(OBJ_PATH),\$(MODULE_FILE)))\n"         
       
                  125          INSERT_FILE_CON+="MODULE_INC += \$(addsuffix .h,\$(addprefix \$(INC_PATH),\$(MODULE_FILE)))\n"         
       
                  126          INSERT_FILE_CON+="MODULE_LIB = lib\$(MODULE_NAME).a\n"         
       
                  127          INSERT_FILE_CON+="MODULE_BIN = \$(BIN_PATH)\$(MODULE_LIB)\n"         
       
                  128          INSERT_FILE_CON+="MODULE_SUB_LIB = \$(foreach var,\$(MODULE_SUB),\$(var)/\$(BIN_PATH)lib\$(var).a)\n"         
       
                  129          INSERT_FILE_CON+="MODULE_SUB_INC =\n\n\n"         
       
                  130          INSERT_FILE_CON+="test:\n\n\n\n"         
       
                  131          INSERT_FILE_CON+="ifndef MODULE_DEP\n"         
       
                  132          INSERT_FILE_CON+="\$(error No Dependence)\n"         
       
                  133          INSERT_FILE_CON+="endif\n"         
       
                  134          INSERT_FILE_CON+="\$(foreach var,\$(MODULE_FILE),\$(eval \$(OBJ_PATH)\$(var).o:\$(SRC_PATH)\$(var).c  \$(INC_PATH)\$(var).h))\n\n"         
       
                  135          INSERT_FILE_CON+="RM = -rm -f\n\n"         
       
                  136          INSERT_FILE_CON+="test:all \$(MODULE_TB)\n\n"         
       
                  137          INSERT_FILE_CON+="\$(MODULE_TB):\$(MODULE_TS)\n"         
       
                  138          INSERT_FILE_CON+="  gcc -O2 -I\$(MODULE_SUB_INC) -I\$(INC_PATH) \$^ -L\$(BIN_PATH) -l\$(MODULE_NAME)    -o \$@\n\n\n"         
       
                  139          INSERT_FILE_CON+="\$(MODULE_OBJ):\n"         
       
                  140          INSERT_FILE_CON+="  gcc  -I\$(MODULE_SUB_INC) -I\$(INC_PATH) -c \$< -o \$@\n\n\n"         
       
                  141          INSERT_FILE_CON+="\$(MODULE_BIN):\$(MODULE_OBJ) \$(MODULE_SUB_LIB)\n"         
       
                  142          INSERT_FILE_CON+="  <a href="http://my.oschina.net/yuning0502" target="_blank" rel="nofollow">@echo</a> module bin \$@\n"         
       
                  143          INSERT_FILE_CON+="  ar -r \$@ \$(MODULE_OBJ)\n"         
       
                  144          INSERT_FILE_CON+="  ar -q \$@ \$(MODULE_SUB_LIB)\n\n"         
       
                  145          INSERT_FILE_CON+="all:\$(MODULE_BIN)\n\n"           
       
                  146          INSERT_FILE_CON+="\$(MODULE_SUB_LIB):   \$(MODULE_SUB)\n\n"         
       
                  147          INSERT_FILE_CON+="clean: \$(MODULE_SUB) clean_self\n\n"         
       
                  148          INSERT_FILE_CON+="clean_self:\n"         
       
                  149          INSERT_FILE_CON+="  \$(RM) \$(MODULE_OBJ)\n"         
       
                  150          INSERT_FILE_CON+="  \$(RM) \$(MODULE_BIN)\n"         
       
                  151          INSERT_FILE_CON+="  \$(RM) \$(MODULE_TB)\n\n"         
       
                  152          INSERT_FILE_CON+="rebuild:clean module_dep all\n\n"         
       
                  153          INSERT_FILE_CON+="\$(MODULE_SUB):\n"         
       
                  154          INSERT_FILE_CON+="  <a href="http://my.oschina.net/yuning0502" target="_blank" rel="nofollow">@echo</a> \"***************  todo Module SUB\" \$@  \"*****************\"\n"         
       
                  155          INSERT_FILE_CON+="  - \$(MAKE) -C \$@ \$(MAKECMDGOALS)\n\n\n"         
       
                  156          INSERT_FILE_CON+="#module_dep:\n"         
       
                  157          INSERT_FILE_CON+="# gcc -I\$(MODULE_SUB_INC) -I\$(INC_PATH) -MM \$(MODULE_SRC)  > \$(MODULE_NAME).d\n"         
       
                  158          INSERT_FILE_CON+="# sed -i '1 i\$(MODULE_NAME)_DEP = \$(MODULE_NAME)_DEP' \$(MODULE_NAME).d\n"         
       
                  159          INSERT_FILE_CON+="# sed -i '/.o:/ s,^,\$(OBJ_PATH),' \$(MODULE_NAME).d\n\n"         
       
                  160          INSERT_FILE_CON+=".PHONY: test all clean clean_self rebuild \$(MODULE_SUB) module_dep\n"         
       
                  161          }         
       
                  162          insert_file_tmp(){ 
         
                  163          #$1 path/filename.ext          
       
                  164          #$2 filename         
       
                  165          #$3 ext mode         
       
                  166              case $3 in         
       
                  167              $C_FILE_SUFFIX)         
       
                  168              get_c_init_context $1 $2         
       
                  169              ;;         
       
                  170              $H_FILE_SUFFIX)         
       
                  171              get_h_init_context $1 $2         
       
                  172              ;;         
       
                  173              $TEST_FILE_SUFFIX)         
       
                  174              get_test_init_context $4 $2         
       
                  175              ;;         
       
                  176              $MAKE_FILE_SUFFIX)         
       
                  177              get_make_init_context $2         
       
                  178              ;;         
       
                  179              esac         
       
                  180              sed  -i "a\\$INSERT_FILE_CON" $1         
       
                  181                        
       
                  182          }         
       
                  183          create_Makefile(){ 
         
                  184          #$1 makefile name         
       
                  185              NEW_FILENAME="Makefile"         
       
                  186              check_file_exist $NEW_FILENAME         
       
                  187              echo > $NEW_FILENAME         
       
                  188              if [ $? = $OVERWRITE_FILE ];then         
       
                  189                  echo > $NEW_FILENAME         
       
                  190                  insert_file_tmp $NEW_FILENAME $MODULE_NAME $MAKE_FILE_SUFFIX         
       
                  191                  echo create /$MODULE_PATH/$NEW_FILENAME files         
       
                  192                  return $CREATE_NEW_FILE         
       
                  193              else         
       
                  194                  return $EXIST_FILE         
       
                  195              fi          
       
                  196                            
       
                  197          }         
       
                  198          create_file_in_sub_dir(){ 
         
                  199                        
       
                  200              if [ -d $1 ];then         
       
                  201                  if [ $3 = $TEST_FILE_SUFFIX ]; then         
       
                  202                  NEW_FILENAME=$1/test_$4_main.c         
       
                  203                  else         
       
                  204                  NEW_FILENAME=$1/$2$3         
       
                  205                  fi         
       
                  206                  check_file_exist $NEW_FILENAME         
       
                  207                  if [ $? = $OVERWRITE_FILE ];then         
       
                  208                      echo > $NEW_FILENAME         
       
                  209                      insert_file_tmp $NEW_FILENAME $2 $3 $4         
       
                  210                      echo create /$MODULE_PATH/$NEW_FILENAME files         
       
                  211                      return $CREATE_NEW_FILE         
       
                  212                  else         
       
                  213                      return $EXIST_FILE         
       
                  214                  fi         
       
                  215              else         
       
                  216                  echo  /$MODULE_PATH/$1 is not directory, create_file not continue...         
       
                  217                  return $CREATE_NEW_FILE_ERROR         
       
                  218                  #not exit , continue done the other cmd         
       
                  219              fi         
       
                  220          }         
       
                  221          MODULE_FILE=MODULE_FILE         
       
                  222          MODULE_SRC=""         
       
                  223          OBJ_PATH=OBJ_PATH         
       
                  224          SRC_PATH=SRC_PATH         
       
                  225          MODULE_NAME_DEP_CHECK="ifndef MODULE_DEP"         
       
                  226          RETURN_VALUE=         
       
                  227                    
       
                  228          read_value_from_file(){ 
         
                  229          #$1 filename $s2 valuename $3 is not add         
       
                  230          #get return ,need used RETURN_VALUE         
       
                  231          var=$2         
       
                  232          mode=         
       
                  233                    
       
                  234              unset RETURN_VALUE         
       
                  235                    
       
                  236              while read var;do         
       
                  237                            
       
                  238                  case $var in         
       
                  239                  \#*)    ;;         
       
                  240                  \.*)    ;;         
       
                  241                  *)         
       
                  242                            
       
                  243                  var=`echo $var | sed -n "/^$2[\ ]*=/p"`         
       
                  244                  #get name  += value         
       
                  245                  #name ?= value .....         
       
                  246                  if [ -z "$var" ]; then         
       
                  247                      continue;         
       
                  248                  fi         
       
                  249                  #echo step1 $var         
       
                  250                  mode=`echo $var | sed -n "/+=/p"`         
       
                  251                  var=`echo $var | sed -n "s/^.*=//p"`         
       
                  252                  if [ -z "$mode" ]; then         
       
                  253                      RETURN_VALUE=$var         
       
                  254                      continue;         
       
                  255                  else         
       
                  256                      if [ 3 -le $# ]; then         
       
                  257                      RETURN_VALUE=${RETURN_VALUE}${var}         
       
                  258                      fi         
       
                  259                  fi         
       
                  260                  #echo step2 $RETURN_VALUE         
       
                  261                    
       
                  262                  esac         
       
                  263              done < $1         
       
                  264          #   echo get return_value $RETURN_VALUE         
       
                  265              return         
       
                  266          }         
       
                  267          get_first_data(){ 
         
                  268              echo first data $1         
       
                  269              return $1         
       
                  270          }         
       
                  271          get_last_data(){ 
         
                  272              while [ 1 -lt $# ];do         
       
                  273                  shift         
       
                  274              done         
       
                  275              echo last1 data $1         
       
                  276              return $1         
       
                  277          }         
       
                  278          cut_lines_in_file(){ 
         
                  279          #cut from $2 line to $3 line in file $1         
       
                  280          #not check $1 file exist ,static func only         
       
                  281          first=         
       
                  282          last1=         
       
                  283              #echo $2 $3         
       
                  284              unset first         
       
                  285              unset last1         
       
                  286              first=`sed -n "/$2/=" $1`         
       
                  287              last1=`sed -n "/$3/=" $1`         
       
                  288              if [ -n "$first" -a -n "$last1" ]; then         
       
                  289                  get_first_data $first         
       
                  290                  first=$?         
       
                  291                  get_last_data $last1         
       
                  292                  last1=`expr $? - 1`         
       
                  293                  echo $first ${last1} $1         
       
                  294                  sed -i "${first},${last1}d" $1         
       
                  295              fi         
       
                  296              return         
       
                  297                         
       
                  298          }         
       
                  299          get_sub_module(){ 
         
                  300              #$1 Makefile file name         
       
                  301              if [ -e $MAKEFILE ];then         
       
                  302                  echo "read info form $MAKEFILE ..."         
       
                  303              else         
       
                  304                  echo "Makefile(${MAKEFILE}) not exist!"         
       
                  305                  unset RETURN_VALUE         
       
                  306                  return         
       
                  307              fi         
       
                  308              read_value_from_file $1 "MODULE_SUB"         
       
                  309          #   echo $RETURN_VALUE         
       
                  310              exit            
       
                  311          }         
       
                  312          cut_value_from_const(){ 
         
                  313          #$1 if have $(XXX) ,will cut         
       
                  314              RETURN_VALUE=`echo $RETURN_VALUE | sed -n "s/[\$][(][^)]*[)]/ /p"`         
       
                  315                        
       
                  316          }         
       
                  317          MODULE_INC=         
       
                  318          adjust_MODULE_INC(){ 
         
                  319              MODULE_INC=`echo $MODULE_INC|sed -n "s/[^ ]*/ -I&/gp"`         
       
                  320          }         
       
                  321          MODULE_SUB_ALL_PATH=         
       
                  322          get_inc_path(){ 
         
                  323          path_tmp=         
       
                  324              echo "all subdir is: " $@         
       
                  325              while [ 1 -le $# ] ;do         
       
                  326                            
       
                  327                  path_tmp=`echo $1 | sed -n "s/^.*$/ &\Makefile/p"`         
       
                  328                  echo "ready get file is :" $path_tmp         
       
                  329                  read_value_from_file $path_tmp "MODULE_SUB" "+"         
       
                  330                  MODULE_SUB1=$RETURN_VALUE         
       
                  331                            
       
                  332                  if [ -z "$MODULE_SUB1" ]; then         
       
                  333                      MODULE_SUB_ALL_PATH+=${1}         
       
                  334                      echo "No MODULE_SUB more..." $1         
       
                  335                      shift         
       
                  336                      continue;         
       
                  337                  fi         
       
                  338                  MODULE_SUB1=`echo $MODULE_SUB1 | sed -e "/[^ ]*/s,,$1&\/,g"`         
       
                  339                  MODULE_SUB_ALL_PATH+=$1         
       
                  340                  get_inc_path $MODULE_SUB1         
       
                  341                  shift         
       
                  342              done         
       
                  343          }         
       
                  344          get_all_INC_path(){ 
         
                  345              unset MODULE_SUB_ALL_PATH         
       
                  346              get_inc_path "../$MODULE_NAME/"         
       
                  347              MODULE_SUB_ALL_PATH=`echo $MODULE_SUB_ALL_PATH | sed -n "/[\.][\.][]\/]/s,, &,gp"`         
       
                  348              MODULE_SUB_ALL_PATH=`echo $MODULE_SUB_ALL_PATH | sed -n "/[\.][\.][]\/][^\.^ ]*/s,, -I&inc,gp"`         
       
                  349              echo "all path is : " $MODULE_SUB_ALL_PATH         
       
                  350              #exit            
       
                  351          }         
       
                  352          create_depend_file(){ 
         
                  353          #use gcc -MM create dependfile           
       
                  354          #$1 module_name $2 makefile name not support!!         
       
                  355              #if [ 2 -le $# ];then         
       
                  356              #   MAKEFILE=$2         
       
                  357              #else         
       
                  358                  MAKEFILE=Makefile         
       
                  359              #fi         
       
                  360                        
       
                  361                    
       
                  362              #get_sub_module $MAKEFILE         
       
                  363          #   echo $MAKEFILE set MAKEFILE default is Makefile         
       
                  364              if [ -e $MAKEFILE ];then         
       
                  365                  echo "read info form $MAKEFILE ..."         
       
                  366              else         
       
                  367                  echo "Makefile(${MAKEFILE}) not exist!"         
       
                  368                  exit         
       
                  369              fi         
       
                  370              read_value_from_file $MAKEFILE $SRC_PATH         
       
                  371              SRC_PATH=$RETURN_VALUE         
       
                  372              read_value_from_file $MAKEFILE $OBJ_PATH         
       
                  373              OBJ_PATH=$RETURN_VALUE           
       
                  374              read_value_from_file $MAKEFILE $MODULE_FILE "+"         
       
                  375              echo return_cut begin $RETURN_VALUE         
       
                  376              cut_value_from_const $RETURN_VALUE         
       
                  377              echo return_cut end $RETURN_VALUE         
       
                  378              MODULE_FILE=${MODULE_NAME}${RETURN_VALUE}         
       
                  379              MODULE_SRC=`echo $MODULE_FILE | sed -e "/[^ ]*/s,,$SRC_PATH&.c,g"`         
       
                  380              echo "MODULE INFO:"         
       
                  381              echo "SRC_PATH = "$SRC_PATH          
       
                  382              echo "OBJ_PATH = "$SRC_PATH         
       
                  383              echo "MODULE_FILE = "$MODULE_FILE         
       
                  384              echo "MODULE_SRC = "$MODULE_SRC         
       
                  385              get_all_INC_path         
       
                  386              gcc $MODULE_SUB_ALL_PATH  -MM $MODULE_SRC > $MODULE_NAME.d         
       
                  387              sed -i "1 iMODULE_DEP = ${MODULE_NAME}_DEP" $MODULE_NAME.d         
       
                  388              sed -i "/.o:/ s,^,${OBJ_PATH}," $MODULE_NAME.d         
       
                  389              cut_lines_in_file $MAKEFILE ${MODULE_NAME}_DEP  "$MODULE_NAME_DEP_CHECK"         
       
                  390              echo "Dependinfo is :"         
       
                  391              cat  $MODULE_NAME.d         
       
                  392              echo "Dependinfo end"         
       
                  393              sed -i "/ifndef[ ]*MODULE_DEP/i ifndef__TMP MODULE_DEP" $MAKEFILE          
       
                  394              sed -i "/ifndef__TMP[ ]*MODULE_DEP/r $MODULE_NAME.d" $MAKEFILE          
       
                  395              sed -i "/ifndef__TMP[ ]*MODULE_DEP/d"  $MAKEFILE         
       
                  396              sed -i "/^MODULE_SUB_INC.*$/s,,MODULE_SUB_INC = $MODULE_SUB_ALL_PATH," $MAKEFILE         
       
                  397              return         
       
                  398                    
       
                  399          }         
       
                  400                    
       
                  401          check_other_cmd(){ 
         
                  402          #MODULE_INC="a b/c/d e"         
       
                  403          #   echo $MODULE_INC         
       
                  404          #   adjust_MODULE_INC         
       
                  405          #   echo $MODULE_INC         
       
                  406          #   exit         
       
                  407              #MODULE_SUB= read_value_from_file "Makefile" "MODULE_SUB" "+"         
       
                  408                    
       
                  409              #echo $MODULE_SUB1         
       
                  410              #exit         
       
                  411                    
       
                  412                        
       
                  413          while [ 2 -le $# ];do         
       
                  414              case $2 in         
       
                  415              $CREATE_FILE_FLAG)          
       
                  416                  shift         
       
                  417                  create_file_in_sub_dir $SRC_DIR_NAME $2 $C_FILE_SUFFIX #$C_FILE_TMP         
       
                  418                  create_file_in_sub_dir $INC_DIR_NAME $2 $H_FILE_SUFFIX #$H_FILE_TMP         
       
                  419                            
       
                  420                  #create_file_in_sub_dir $LOG_DIR_NAME $2 $LOG_FILE_SUFFIX         
       
                  421                            
       
                  422              ;;         
       
                  423              $CREATE_TEST_FILE_FLAG)         
       
                  424                  shift         
       
                  425                  create_file_in_sub_dir $SRC_DIR_NAME $2 $TEST_FILE_SUFFIX  $3         
       
                  426                  shift         
       
                  427                            
       
                  428                  ;;         
       
                  429              $CREATE_H_FILE_FLAG)         
       
                  430                  shift         
       
                  431                  create_file_in_sub_dir $INC_DIR_NAME $2 $H_FILE_SUFFIX #$H_FILE_TMP         
       
                  432                  ;;           
       
                  433              $CREATE_DEP_FILE)         
       
                  434                  #shift         
       
                  435                  create_depend_file $MODULE_NAME #$2         
       
                  436                  ;;         
       
                  437              $CREATE_MAKEFILE_FILE)         
       
                  438                  #shift         
       
                  439                  create_Makefile $MODULE_NAME         
       
                  440                  ;;         
       
                  441              *)          
       
                  442                  ;;         
       
                  443                 #    echo $2" test "         
       
                  444              esac         
       
                  445                  shift         
       
                  446          done         
       
                  447              exit         
       
                  448          }         
       
                  449          echo $MODULE_PATH         
       
                  450                    
       
                  451          create_mkdir $MODULE_PATH         
       
                  452          is_created=$?         
       
                  453          echo $is_created         
       
                  454                    
       
                  455              MODULE_NAME=`echo $MODULE_PATH|sed -e "s/^.*[\/]//"`         
       
                  456                    
       
                  457          if [ -d $MODULE_PATH ];then         
       
                  458              cd $MODULE_PATH         
       
                  459              create_mkdir $SRC_DIR_NAME         
       
                  460              create_mkdir $INC_DIR_NAME         
       
                  461              create_mkdir $BIN_DIR_NAME         
       
                  462              create_mkdir $OBJ_DIR_NAME         
       
                  463                        
       
                  464              if [ "$is_created" -eq "1" ];then         
       
                  465              #create_Makefile $MODULE_NAME         
       
                  466              check_other_cmd $@ -f $MODULE_NAME -t $MODULE_NAME $MODULE_NAME -m -d         
       
                  467              else         
       
                  468              check_other_cmd $@         
       
                  469              fi         
       
                  470          else         
       
                  471              echo $MODULE_NAME is not directory ,could not continue...            
       
                  472              exit         
       
                  473          fi

需要解释一下修正的几个部分。

1、./create_module name 时，如果 name这个目录不存在时，处理以下工作。

1、创建 name name/inc name/src name/obj name/bin 5个目录。

2、创建 name/src/name.c name/inc/name.h name/src/test_name_main.c 3个C语言文件。

3、创建 name/Makefile 这个Makefile。同时将上述3个C语言文件的对应信息加载进去。

4、修正Makefile的文件依赖规则，通过读取3步骤中的Makefile文件里的MODULE_FILE（这里仅针对 C文件），使用gcc -MM。（哈有人要骂我了。因为我前面才说不要依赖gcc -MM，我的理由是此处是为了给予方便）形成依赖规则，保存在 name/name.d内。同时将name.d内的内容，扩充到 name/Makefile的内容中去。

当你执行

./create_moudle learn_make 这里用learn_make作为一个典型模块举例。

你可以

cd learn_make

make

此时make 执行 make test的工作。完成所有的库的编译，并完成 test_learn_make_main.c的对应编译。

执行

bin/test_learn_make_main

此时会出现对应打印信息。你可以通过观察 test_learn_make_main.c的源码理解。

以上是针对一个模块。你可以继续，如下

./create_module learn_make/data_struct

此时会和 create_module learn_make一样，完成上述动作。同时你进入

cd learn_make/data_struct

make

bin/test_data_struct_main

也可以。

不过这个只解决了如何在模块下面创建子模块的问题。

有另外个问题。此时learn_make和 data_struct并没有关联起来。你需要在

learn_make/Makefile的文件中，找到

MODULE_SUB= 的位置，此处添加data_struct，该行的处理结果如下

MODULE_SUB= data_struct 这个作用下面会说到。如果不这么关联，Makefile只能递归执行所有模块的独自编译和.a 的依次合并。

此时，保存退出。你进入learn_make目录下，

此时

make

实际执行make test。

此时，make会将learn_make 和data_struct均make一遍，同时Makefile文件保持一个递归模式，将data_struct/bin/libdata_struct.a 并入到当前bin/liblearn_make.a中。

由此完成每个子模块内的.a文件，如何被最上层模块使用的问题。但问题只完成了一半。当你在learn_make/src/learn_make.c 或者learn_make/src/test_learn_make_main.c中，尝试 #include "data_struct.h"时，gcc会出错。因此你需要使用create_module的另一个自动检测。

./create_module.sh learn_make -d

但这样并不会立刻有效果。是因为，这个工作我实现的方法是，依赖于对/learn_make/Makefile里，MODULE_SUB的变量进行检查。以递归的寻找所有的inc目录。

如上方法，你需要将learn_make/Makefile的文件，在 MODULE_SUB=这行进行修改，最终效果如下

MODULE_SUB= data_struct

此时，你执行

./create_module.sh learn_make -d

则对应的文件依赖性的关系，会自动创建在 /learn_make/Makefile 中，同时，对应也修改了Makefile 里 MODULE_SUB_INC的变量内容。

当然你会发现，这里多了一个-I../learn_make/inc 这么变态的内容，而我的Makefile的内部模板在gcc -c 中本身包行了 -Iinc。这是为了简单的递归查找 Makefile的文件时的遗留问题，我暂时不做此修正了。

现在你会发现，以上的工作，已经可以使得模块调用子模块存在自动化的操作。

当你进入每个目录时，均是针对当前这个目录对应的模块处理。同时你可以通过COPY其他模块到本模块下，进行操作。但是有个很致命的问题。假设你现在有如下的模块

A/B/C

也即A 模块下有B ，B 模块下有C 。此时，你将 C的整体目录COPY到A目录下，由此，A目录下存在两个C模块。则会导致一个非常头疼的事情。即库函数冲突。

因为目前的操作，是将 C的.a，合并到B的.a，B的.a合并到A的.a中。而当A下还有个C。则出现同样C模块的函数，在最终A的库中存在重名问题。

解决这个问题，有两个操作方式。

1、库化。将C的.a不是依次继承到最上层的.a中，而是独立放在一个A,B都能看到的lib 目录里，同时 .h放置在一个include的目录里，用于给A调用。和传统的库一样。但是这是基于C已经没有问题下。此时C模块已经不属于开发态。

2、强制A模块禁止直接挂载C这个目录，如果C的目录被A的子模块使用时。但这个当B模块被拿走时，A又郁闷了。此时，则当C模块处于开发态时，B拿走，需要将B下的所有子模块，强制挂载到A下，如果C模块不属于开发态时，则按照1的方案实施。

需要注意，上述这个问题，在目前的create_module脚本中，并没有处理。

目前只是解决，假设存在，A，AA两个模块。当A模块下的B子模块被AA也需要使用。则可以采用COPY B目录下所有内容。到AA下，并修改AA/Makefile，MODULE_SUB 加上 B。随后执行 ./create_module AA -d 则，B模块会自动作为AA的依赖，并入到AA的Makefile里。

同样需要注意的Makefile内的细节问题。

Makefile 目前存在依赖冗余，就是一个相同依赖被几个不同地方描述。这个暂时不考虑。提一下一些变量的内容含义。

SRC_PATH=src/

INC_PATH=inc/

OBJ_PATH=obj/

BIN_PATH=bin/

MODULE_NAME = learn_make

以上5个，原则上，禁止修改，此是和

$./create_module learn_make

创建模块形成目录有关

MODULE_FILE = $(MODULE_NAME)

这里可以后续增加当前模块下，新的C文件的文件名，但别加后缀以及路径。对应在MODULE_SRC MODULE_INC中，会自动增加同名的.c和同名的.h

MODULE_INC =

这里只增加只有头文件，没有实际C文件的独立头文件名。但是此时需要注意,例如你要增加个type.h则需要写为 $(INC_PATH)type.h。

MODULE_T = test_$(MODULE_NAME)_main

这个是定义该模块的唯一测试主程序。模块本身并不可直接编译运行。模块内部不存在main函数。这个唯一测试文件名，是由./create_module 创建，当然你可以自己任意修改成自己的名字。但是对应的 src/下的C文件名也需要修改。当然此处一样，不需要加.c后缀。

MODULE_TS = $(SRC_PATH)$(MODULE_T).c

MODULE_TB = $(BIN_PATH)$(MODULE_T)

这两个不许要修改，是根据测试文件本身，获取测试文件C源文件全名，和输出执行程序名。在bin/下。

MODULE_SUB =

这里是用于添加子模块名称。不需要路径。同时只需要当前目录下直接关联的子模块，对于孙子等等模块，Makefile描述中包含了递归自动处理的部分。这样处理也希望开发人员，只关注当前模块和当前直接调用的模块的关系，而不要关注子模块内部。当然前面说的父子同调用一个孙子的情况另谈。

MODULE_SRC = $(addsuffix .c,$(addprefix $(SRC_PATH),$(MODULE_FILE)))

MODULE_OBJ = $(addsuffix .o,$(addprefix $(OBJ_PATH),$(MODULE_FILE)))

MODULE_INC += $(addsuffix .h,$(addprefix $(INC_PATH),$(MODULE_FILE)))

MODULE_LIB = lib$(MODULE_NAME).a

MODULE_BIN = $(BIN_PATH)$(MODULE_LIB)

MODULE_SUB_LIB = $(foreach var,$(MODULE_SUB),$(var)/$(BIN_PATH)lib$(var).a)

MODULE_SUB_INC =

以上均不要改动，除非你要改动下面Makefile的依赖规则或目标

MODULE_DEP = learn_make_DEP

ifndef MODULE_DEP

$(error No Dependence)

endif

以上需要注意，均是自动生成的。

ifndef MODULE_DEP

$(error No Dependence)

endif

是通过创建Makefile的模板自动添加的，目的是防止没有O文件，C文件依赖描述时，make的依赖出现遗漏。

而MODULE_DEP = learn_make_DEP 是通过 ./create_module learn_make -d 这个操作实现的。这个操作前面说过。根据MODULE_SUB,获取头文件信息，并针对当前模块的源进行 gcc -MM。随后将依赖填写到这里，并自动加上 MODULE_DEP = learn_make_DEP

但需要非常注意的一点。gcc -MM 并没有递归实现每个子模块的依赖。因为我的逻辑是，当前模块的依赖自动生成，只是针对当前模块的情况，而子模块，假设 learn_make/data_struct ，你需要 ./create_module learn_make/data_struct -d来手动完成。因为你尝试在learn_make/data_struct内增加一个C文件，或#include的动作，此属于data_struct 本身，而不属于learn_make本身。各个模块做各个模块的事情嘛。呵呵。

以下给出create_module脚本的参数和举例

./create_module module_name

会自动创建目录，某块接口C，头文件， MAKEFILE和依赖

此处会自动调用 -d -m -f module_name -t module_name module_name

./create_module module_name -d

-d 自动刷新依赖

./create_module module_name -m

-m 重建MAKEFILE 但不会处理依赖

-f name 生成name.c 的C文件，对应有name.h的头文件。

-h name 生成name.h的头文件

-t name1 name2 生成 test_name2_main.c的 C文件，不会生成头文件，但会在 test_name2_main.c 自动增加 #include "name1.h"

：SORRY，Makefile有个依赖缺失的错误，在137行。原先的INSERT_FILE_CON+="\$(MODULE_TB):\$(MODULE_TS)\n"需要修改为： INSERT_FILE_CON+="\$(MODULE_TB):\$(MODULE_TS) \$(MODULE_TB)\n" 否则，模块文件更新后，make test并不会重新链接模块。删除 3个月前

：sorry ,又错了。笔误，笔误，哈哈。对应的修改应该为 INSERT_FILE_CON+="\$(MODULE_TB):\$(MODULE_TS) \$(MODULE_BIN)\n" 删除 3个月前

后续实际使用，又发现错误，已经做了些小操作的增补，当然代码越来越不成样子了。（2010年7月）以下给出目前代码

#!/bin/bash

002 MODULE_PATH=$1

003 MODULE_NAME=$1

004

005 SRC_DIR_NAME=src

006 INC_DIR_NAME=inc

007 BIN_DIR_NAME=bin

008 OBJ_DIR_NAME=obj

009 INCLUDE_DIR_NAME=include

010 LIB_DIR_NAME=lib

011 C_FILE_SUFFIX=.c

012 H_FILE_SUFFIX=.h

013 TEST_FILE_SUFFIX=.t

014 MAKE_FILE_SUFFIX=.m

015 CREATE_FILE_FLAG=-f

016 CREATE_H_FILE_FLAG=-h

017 CREATE_TEST_FILE_FLAG=-t

018 CREATE_MAKEFILE_FILE=-m

019 CREATE_DEP_FILE=-d

020 OVERWRITE_FILE=0

021 NOT_OVERWRITE_FILE=1

022

023

create_mkdir(){

024 mkdir $1 > /dev/null 2>&1

025 if [ $? = 0 ];then

026 echo /$1 had created

027 return 1

028 else

029 if [ -d $1 ];then

030 echo /$1 had exist

031 return 0

032 else

033 echo "could not create directory "/$1

034 exit

035 fi

036 fi

037

038 }

039

check_file_exist(){

040 if [ -e $1 ];then

041 while :;do

042 echo -n "the $1 had exist , do you want to overwrite?(y(Y) done:n(N) not:e(E) exit) : "

043 read check_file_exist_ans

044 case $check_file_exist_ans in

045 y|Y)

046 echo you answer y

047 return $OVERWRITE_FILE

048 ;;

049 n|N)

050 echo you answer n

051 return $NOT_OVERWRITE_FILE

052 ;;

053 e|E)

054 exit

055 ;;

056 *)

057 echo "fuck ,i need you correct answer!"

058 esac

059 done

060 else

061 return $OVERWRITE_FILE

062 fi

063 }

064 CREATE_NEW_FLIE=0

065 CREATE_NEW_FILE_ERROR=1

066 EXIST_FILE=2

067 INSERT_FILE_CON=""

068

069

get_c_init_context(){

070 #$1 path/filename.ext

071 #$2 filename

072 INSERT_FILE_CON="/***************\n$1\n by luckystar\n ***************/\n"

073 INSERT_FILE_CON+="#include \"$2.h\"\n"

074 INSERT_FILE_CON+="static int $2_flag =0;\n"

075 INSERT_FILE_CON+="\nvoid $2_init(void*pv){\n"

076 INSERT_FILE_CON+="\tif ($2_flag) {\n\t\t//log(\"module inited..\",X);\n\t\treturn;\n\t}\n"

077 INSERT_FILE_CON+="\t$2_flag = 1;\n"

078 INSERT_FILE_CON+="\t//todo:module init...\n\n}\n"

079 #up is create module_init func

080 INSERT_FILE_CON+="\nvoid $2_destory(void){\n"

081 INSERT_FILE_CON+="\tif (!$2_flag) {\n\t\t//log(\"module not inited..\",X);\n\t\treturn;\n\t}\n"

082 INSERT_FILE_CON+="\t$2_flag = 0;\n"

083 INSERT_FILE_CON+="\t//todo:module destory...\n\n}\n"

084 #up is create module_destory func

085 }

086

087

get_h_init_context(){

088 #$1 path/filename.ext

089 #$2 filename

090 INSERT_FILE_CON="#ifndef _$2_H_\n#define _$2_H_\n"

091 INSERT_FILE_CON+="\n//ins_inc_file\n"

092 INSERT_FILE_CON+="\n//ins_typedef_def\n"

093 INSERT_FILE_CON+="\n//ins_def\n"

094 INSERT_FILE_CON+="\n//ins_func_declare\n"

095 INSERT_FILE_CON+="void $2_init(void*);\n"

096 INSERT_FILE_CON+="void $2_destory(void);\n"

097 INSERT_FILE_CON+="\n\n"

098 INSERT_FILE_CON+="#endif //_$2_H_\n"

099 }

100

get_test_init_context(){

101 #$1 filename

102 #$2 libname

103 INSERT_FILE_CON="#include \"$2.h\"\n"

104 INSERT_FILE_CON+="#include <stdio.h>\n"

105 INSERT_FILE_CON+="\n\n"

106 INSERT_FILE_CON+="int main(int argc,char *argv[]){\n"

107 INSERT_FILE_CON+="\tprintf(\"hello test_$2_main now run...\\\n\");\n"

108 INSERT_FILE_CON+="\t$2_init(0);\n"

109 INSERT_FILE_CON+="\t$2_destory();\n"

110 INSERT_FILE_CON+="\tprintf(\"hello test_$2_main now exit...\\\n\");\n"

111 INSERT_FILE_CON+="\treturn 0;\n"

112 INSERT_FILE_CON+="}\n"

113 }

114

get_make_init_context(){

115 #$1 module_name

116 INSERT_FILE_CON="SRC_PATH=src/\n"

117 INSERT_FILE_CON+="INC_PATH=inc/\n"

118 INSERT_FILE_CON+="OBJ_PATH=obj/\n"

119 INSERT_FILE_CON+="BIN_PATH=bin/\n"

120 INSERT_FILE_CON+="INCLUDE_PATH=include/\n"

121 INSERT_FILE_CON+="LIB_PATH=lib/\n"

122 INSERT_FILE_CON+="MODULE_NAME = $1\n"

123 INSERT_FILE_CON+="MODULE_FILE = \$(MODULE_NAME) \n"

124 INSERT_FILE_CON+="MODULE_INC =\n\n\n\n"

125 INSERT_FILE_CON+="MODULE_T = test_\$(MODULE_NAME)_main\n"

126 INSERT_FILE_CON+="MODULE_TS = \$(SRC_PATH)\$(MODULE_T).c\n"

127 INSERT_FILE_CON+="MODULE_TB = \$(BIN_PATH)\$(MODULE_T)\n"

128 INSERT_FILE_CON+="MODULE_SUB =\n\n\n"

129 INSERT_FILE_CON+="MODULE_SRC = \$(addsuffix .c,\$(addprefix \$(SRC_PATH),\$(MODULE_FILE)))\n"

130 INSERT_FILE_CON+="MODULE_OBJ = \$(addsuffix .o,\$(addprefix \$(OBJ_PATH),\$(MODULE_FILE)))\n"

131 INSERT_FILE_CON+="MODULE_INC += \$(addsuffix .h,\$(addprefix \$(INC_PATH),\$(MODULE_FILE)))\n"

132 INSERT_FILE_CON+="MODULE_LIB = lib\$(MODULE_NAME).a\n"

133 INSERT_FILE_CON+="MODULE_BIN = \$(BIN_PATH)\$(MODULE_LIB)\n"

134 INSERT_FILE_CON+="MODULE_SUB_LIB = \$(foreach var,\$(MODULE_SUB),\$(var)/\$(BIN_PATH)lib\$(var).a)\n"

135 INSERT_FILE_CON+="MODULE_SUB_INC =\n\n\n"

136 INSERT_FILE_CON+="LIB_NAME =\n\n"

137 INSERT_FILE_CON+="test:\n\n\n\n"

138 INSERT_FILE_CON+="ifndef MODULE_DEP\n"

139 INSERT_FILE_CON+="\$(error No Dependence)\n"

140 INSERT_FILE_CON+="endif\n"

141 INSERT_FILE_CON+="\$(foreach var,\$(MODULE_FILE),\$(eval \$(OBJ_PATH)\$(var).o:\$(SRC_PATH)\$(var).c \$(INC_PATH)\$(var).h))\n\n"

142 INSERT_FILE_CON+="RM = -rm -f\n\n"

143 INSERT_FILE_CON+="test:all \$(MODULE_TB)\n\n"

144 INSERT_FILE_CON+="\$(MODULE_TB):\$(MODULE_TS) \$(MODULE_BIN)\n"

145 INSERT_FILE_CON+="ifeq (\$(strip \$(LIB_NAME)),)\n"

146 INSERT_FILE_CON+=" gcc -O2 \$(MODULE_SUB_INC) -I\$(INCLUDE_PATH) -I\$(INC_PATH) \$^ -L\$(BIN_PATH) -L\$(LIB_PATH) -l\$(MODULE_NAME) -o \$@\n"

147 INSERT_FILE_CON+="else\n"

148 INSERT_FILE_CON+=" gcc -O2 \$(MODULE_SUB_INC) -I\$(INCLUDE_PATH) -I\$(INC_PATH) \$^ -L\$(BIN_PATH) -L\$(LIB_PATH) -l\$(MODULE_NAME) -l\$(LIB_NAME) -o \$@\n"

149 INSERT_FILE_CON+="endif\n\n"

150 INSERT_FILE_CON+="\$(MODULE_OBJ):\n"

151 INSERT_FILE_CON+=" gcc \$(MODULE_SUB_INC) -I\$(INCLUDE_PATH) -I\$(INC_PATH) -c \$< -o \$@\n\n\n"

152 INSERT_FILE_CON+="\$(MODULE_BIN):\$(MODULE_OBJ) \$(MODULE_SUB_LIB)\n"

153 INSERT_FILE_CON+=" <a href="http://my.oschina.net/u/578052" class="referer" target="_blank">@echo</a> module bin \$@\n"

154 INSERT_FILE_CON+=" -ar -r \$@ \$(MODULE_OBJ)\n"

155 INSERT_FILE_CON+=" -ar -x \$(MODULE_SUB_LIB)\n"

156 INSERT_FILE_CON+=" -ar -q \$@ *.o\n"

157 INSERT_FILE_CON+=" \$(RM) *.o\n"

158 INSERT_FILE_CON+=" ranlib \$@\n\n"

159

160

161

162

163 INSERT_FILE_CON+="all:\$(MODULE_BIN)\n\n"

164 INSERT_FILE_CON+="\$(MODULE_SUB_LIB): \$(MODULE_SUB)\n\n"

165 INSERT_FILE_CON+="clean: \$(MODULE_SUB) clean_self\n\n"

166 INSERT_FILE_CON+="clean_self:\n"

167 INSERT_FILE_CON+=" \$(RM) \$(MODULE_OBJ)\n"

168 INSERT_FILE_CON+=" \$(RM) \$(MODULE_BIN)\n"

169 INSERT_FILE_CON+=" \$(RM) \$(MODULE_TB)\n\n"

170 INSERT_FILE_CON+="rebuild:clean module_dep all\n\n"

171 INSERT_FILE_CON+="\$(MODULE_SUB):\n"

172 INSERT_FILE_CON+=" <a href="http://my.oschina.net/u/578052" class="referer" target="_blank">@echo</a> \"*************** todo Module SUB\" \$@ \"*****************\"\n"

173 INSERT_FILE_CON+=" - \$(MAKE) -C \$@ \$(MAKECMDGOALS)\n\n\n"

174 INSERT_FILE_CON+="#module_dep:\n"

175 INSERT_FILE_CON+="# gcc \$(MODULE_SUB_INC) -I\$(INC_PATH) -MM \$(MODULE_SRC) > \$(MODULE_NAME).d\n"

176 INSERT_FILE_CON+="# sed -i '1 i\$(MODULE_NAME)_DEP = \$(MODULE_NAME)_DEP' \$(MODULE_NAME).d\n"

177 INSERT_FILE_CON+="# sed -i '/.o:/ s,^,\$(OBJ_PATH),' \$(MODULE_NAME).d\n\n"

178 INSERT_FILE_CON+=".PHONY: test all clean clean_self rebuild \$(MODULE_SUB) module_dep\n"

179 }

180

insert_file_tmp(){

181 #$1 path/filename.ext

182 #$2 filename

183 #$3 ext mode

184 case $3 in

185 $C_FILE_SUFFIX)

186 get_c_init_context $1 $2

187 ;;

188 $H_FILE_SUFFIX)

189 get_h_init_context $1 $2

190 ;;

191 $TEST_FILE_SUFFIX)

192 get_test_init_context $4 $2

193 ;;

194 $MAKE_FILE_SUFFIX)

195 get_make_init_context $2

196 ;;

197 esac

198 sed -i "a\\$INSERT_FILE_CON" $1

199

200 }

201

create_Makefile(){

202 #$1 makefile name

203 NEW_FILENAME="Makefile"

204 check_file_exist $NEW_FILENAME

205 echo > $NEW_FILENAME

206 if [ $? = $OVERWRITE_FILE ];then

207 echo > $NEW_FILENAME

208 insert_file_tmp $NEW_FILENAME $MODULE_NAME $MAKE_FILE_SUFFIX

209 echo create /$MODULE_PATH/$NEW_FILENAME files

210 return $CREATE_NEW_FILE

211 else

212 return $EXIST_FILE

213 fi

214

215 }

216

create_file_in_sub_dir(){

217

218 if [ -d $1 ];then

219 if [ $3 = $TEST_FILE_SUFFIX ]; then

220 NEW_FILENAME=$1/test_$4_main.c

221 else

222 NEW_FILENAME=$1/$2$3

223 fi

224 check_file_exist $NEW_FILENAME

225 if [ $? = $OVERWRITE_FILE ];then

226 echo > $NEW_FILENAME

227 insert_file_tmp $NEW_FILENAME $2 $3 $4

228 echo create /$MODULE_PATH/$NEW_FILENAME files

229 return $CREATE_NEW_FILE

230 else

231 return $EXIST_FILE

232 fi

233 else

234 echo /$MODULE_PATH/$1 is not directory, create_file not continue...

235 return $CREATE_NEW_FILE_ERROR

236 #not exit , continue done the other cmd

237 fi

238 }

239 MODULE_FILE=MODULE_FILE

240 MODULE_SRC=""

241 OBJ_PATH=OBJ_PATH

242 SRC_PATH=SRC_PATH

243 MODULE_NAME_DEP_CHECK="ifndef MODULE_DEP"

244 RETURN_VALUE=

245

246

read_value_from_file(){

247 #$1 filename $s2 valuename $3 is not add

248 #get return ,need used RETURN_VALUE

249 var=$2

250 mode=

251

252 unset RETURN_VALUE

253

254 while read var;do

255

256 case $var in

257 \#*) ;;

258 \.*) ;;

259 *)

260

261 var=`echo $var | sed -n "/^$2[\ ]*=/p"`

262 #get name += value

263 #name ?= value .....

264 if [ -z "$var" ]; then

265 continue;

266 fi

267 #echo step1 $var

268 mode=`echo $var | sed -n "/+=/p"`

269 var=`echo $var | sed -n "s/^.*=//p"`

270 if [ -z "$mode" ]; then

271 RETURN_VALUE=$var

272 continue;

273 else

274 if [ 3 -le $# ]; then

275 RETURN_VALUE=${RETURN_VALUE}${var}

276 fi

277 fi

278 #echo step2 $RETURN_VALUE

279

280 esac

281 done < $1

282 # echo get return_value $RETURN_VALUE

283 return

284 }

285

get_first_data(){

286 echo first data $1

287 return $1

288 }

289

get_last_data(){

290 while [ 1 -lt $# ];do

291 shift

292 done

293 echo last1 data $1

294 return $1

295 }

296

cut_lines_in_file(){

297 #cut from $2 line to $3 line in file $1

298 #not check $1 file exist ,static func only

299 first=

300 last1=

301 #echo $2 $3

302 unset first

303 unset last1

304 first=`sed -n "/$2/=" $1`

305 last1=`sed -n "/$3/=" $1`

306 if [ -n "$first" -a -n "$last1" ]; then

307 get_first_data $first

308 first=$?

309 get_last_data $last1

310 last1=`expr $? - 1`

311 echo $first ${last1} $1

312 sed -i "${first},${last1}d" $1

313 fi

314 return

315

316 }

317

get_sub_module(){

318 #$1 Makefile file name

319 if [ -e $MAKEFILE ];then

320 echo "read info form $MAKEFILE ..."

321 else

322 echo "Makefile(${MAKEFILE}) not exist!"

323 unset RETURN_VALUE

324 return

325 fi

326 read_value_from_file $1 "MODULE_SUB"

327 # echo $RETURN_VALUE

328 exit

329 }

330

cut_value_from_const(){

331 #$1 if have $(XXX) ,will cut

332 RETURN_VALUE=`echo $RETURN_VALUE | sed -n " s/[\$][(][^)]*[)]/ /p"`

333

334 }

335 MODULE_INC=

336

adjust_MODULE_INC(){

337 MODULE_INC=`echo $MODULE_INC|sed -n "s/[^ ]*/ -I&/gp"`

338 }

339 MODULE_SUB_ALL_PATH=

340

get_inc_path(){

341 path_tmp=

342 echo "all subdir is: " $@

343 while [ 1 -le $# ] ;do

344

345 path_tmp=`echo $1 | sed -n "s/^.*$/ &\Makefile/p"`

346 echo "ready get file is :" $path_tmp

347 read_value_from_file $path_tmp "MODULE_SUB" "+"

348 MODULE_SUB1=$RETURN_VALUE

349

350 if [ -z "$MODULE_SUB1" ]; then

351 MODULE_SUB_ALL_PATH+=${1}

352 echo "No MODULE_SUB more..." $1

353 shift

354 continue;

355 fi

356 MODULE_SUB1=`echo $MODULE_SUB1 | sed -e "/[^ ]*/s,,$1&\/,g"`

357 MODULE_SUB_ALL_PATH+=$1

358 get_inc_path $MODULE_SUB1

359 shift

360 done

361 }

362

get_all_INC_path(){

363 unset MODULE_SUB_ALL_PATH

364 get_inc_path "../$MODULE_NAME/"

365

366 MODULE_SUB_ALL_PATH=`echo $MODULE_SUB_ALL_PATH | sed -n "/[\.][\.][]\/]/s,, &,gp"`

367 MODULE_SUB_ALL_PATH=`echo $MODULE_SUB_ALL_PATH | sed -n "/[\.][\.][]\/][^\.^ ]*/s,, -I&inc -I&include,gp"`

368 echo "all path is : " $MODULE_SUB_ALL_PATH

369 #exit

370 }

371

create_depend_file(){

372 #use gcc -MM create dependfile

373 #$1 module_name $2 makefile name not support!!

374 #if [ 2 -le $# ];then

375 # MAKEFILE=$2

376 #else

377 MAKEFILE=Makefile

378 #fi

379

380

381 #get_sub_module $MAKEFILE

382 # echo $MAKEFILE set MAKEFILE default is Makefile

383 if [ -e $MAKEFILE ];then

384 echo "read info form $MAKEFILE ..."

385 else

386 echo "Makefile(${MAKEFILE}) not exist!"

387 exit

388 fi

389 read_value_from_file $MAKEFILE $SRC_PATH

390 SRC_PATH=$RETURN_VALUE

391 read_value_from_file $MAKEFILE $OBJ_PATH

392 OBJ_PATH=$RETURN_VALUE

393 read_value_from_file $MAKEFILE $MODULE_FILE "+"

394 echo return_cut begin $RETURN_VALUE

395 cut_value_from_const $RETURN_VALUE

396 echo return_cut end $RETURN_VALUE

397 MODULE_FILE=${MODULE_NAME}" "${RETURN_VALUE} #insert space

398 MODULE_SRC=`echo $MODULE_FILE | sed -e "/[^ ]*/s,,$SRC_PATH&.c,g"`

399 echo "MODULE INFO:"

400 echo "SRC_PATH = "$SRC_PATH

401 echo "OBJ_PATH = "$SRC_PATH

402 echo "MODULE_FILE = "$MODULE_FILE

403 echo "MODULE_SRC = "$MODULE_SRC

404 get_all_INC_path

405 gcc $MODULE_SUB_ALL_PATH -MM $MODULE_SRC > $MODULE_NAME.d

406 sed -i "1 iMODULE_DEP = ${MODULE_NAME}_DEP" $MODULE_NAME.d

407 sed -i "/.o:/ s,^,${OBJ_PATH}," $MODULE_NAME.d

408 cut_lines_in_file $MAKEFILE ${MODULE_NAME}_DEP "$MODULE_NAME_DEP_CHECK"

409 echo "Dependinfo is :"

410 cat $MODULE_NAME.d

411 echo "Dependinfo end"

412 sed -i "/ifndef[ ]*MODULE_DEP/i ifndef__TMP MODULE_DEP" $MAKEFILE

413

414 sed -i "/ifndef__TMP[ ]*MODULE_DEP/r $MODULE_NAME.d" $MAKEFILE

415 sed -i "/ifndef__TMP[ ]*MODULE_DEP/d" $MAKEFILE

416 sed -i "/^MODULE_SUB_INC.*$/s,,MODULE_SUB_INC = $MODULE_SUB_ALL_PATH," $MAKEFILE

417 #check LIB_NAME

418

419

420 return

421

422 }

423

424

check_other_cmd(){

425 #MODULE_INC="a b/c/d e"

426 # echo $MODULE_INC

427 # adjust_MODULE_INC

428 # echo $MODULE_INC

429 # exit

430 #MODULE_SUB= read_value_from_file "Makefile" "MODULE_SUB" "+"

431

432 #echo $MODULE_SUB1

433 #exit

434

435

436 while [ 2 -le $# ];do

437 case $2 in

438 $CREATE_FILE_FLAG)

439 shift

440 create_file_in_sub_dir $SRC_DIR_NAME $2 $C_FILE_SUFFIX #$C_FILE_TMP

441 create_file_in_sub_dir $INC_DIR_NAME $2 $H_FILE_SUFFIX #$H_FILE_TMP

442

443 #create_file_in_sub_dir $LOG_DIR_NAME $2 $LOG_FILE_SUFFIX

444

445 ;;

446 $CREATE_TEST_FILE_FLAG)

447 shift

448 create_file_in_sub_dir $SRC_DIR_NAME $2 $TEST_FILE_SUFFIX $3

449 shift

450

451 ;;

452 $CREATE_H_FILE_FLAG)

453 shift

454 create_file_in_sub_dir $INC_DIR_NAME $2 $H_FILE_SUFFIX #$H_FILE_TMP

455 ;;

456 $CREATE_DEP_FILE)

457 #shift

458 create_depend_file $MODULE_NAME #$2

459 ;;

460 $CREATE_MAKEFILE_FILE)

461 #shift

462 create_Makefile $MODULE_NAME

463 ;;

464 *)

465 ;;

466 # echo $2" test "

467 esac

468 shift

469 done

470 exit

471 }

472 echo $MODULE_PATH

473

474 create_mkdir $MODULE_PATH

475 is_created=$?

476 echo $is_created

477

478 MODULE_NAME=`echo $MODULE_PATH|sed -e "s/^.*[\/]//"`

479

480 if [ -d $MODULE_PATH ];then

481 cd $MODULE_PATH

482 create_mkdir $SRC_DIR_NAME

483 create_mkdir $INC_DIR_NAME

484 create_mkdir $BIN_DIR_NAME

485 create_mkdir $OBJ_DIR_NAME

486 create_mkdir $LIB_DIR_NAME

487 create_mkdir $INCLUDE_DIR_NAME

488 if [ "$is_created" -eq "1" ];then

489 #create_Makefile $MODULE_NAME

490 check_other_cmd $@ -f $MODULE_NAME -t $MODULE_NAME $MODULE_NAME -m -d

491 else

492 check_other_cmd $@

493 fi

494 else

495 echo $MODULE_NAME is not directory ,could not continue...

496 exit

497 fi

转载于:https://my.oschina.net/luckystar/blog/67090

你可能感兴趣的文章

Windows Server 2008 FTP用户目录隔离模式

查看>>

python实现linux下指定目录下文件中的单词个数统计

通向架构师的道路（第一天）之Apache整合Tomcat - lifetragedy的专栏 - 博客频道 - CSDN.NET...

CSS实现背景透明，文字不透明（各浏览器兼容）

查看>>

【转】[大学引导]超级链接、字体颜色、音乐播放公式

查看>>

T-SQL中INSERT、UPDATE

查看>>

Linux下Nginx服务器配置Modsecurity实现Web应用防护系统

查看>>

用 zabbix 监测 snmptrap 的主动告警功能