build/tmp/constructor.tmp

   1
   2
   3 #
   4 #
   5 #
   6 __setvar ()
   7 {
   8         eval "$@"
   9 }
  10
  11
  12 running_dest_steps ()
  13 {
  14         :
  15 }
  16
  17 #
  18 # fsyntax: construct_one_dest <dest-name>
  19 # fdesc: construct one dest executables.
  20 #
  21 construct_one_dest ()
  22 {
  23         local dest=${dest#*-}
  24         local step=
  25         local ret=
  26
  27         dbgoutd "############################\n"
  28         dbgoutd "construct_one_dest(${1#*-})\n"
  29
  30         # init one dest cfg paramter
  31         eval "DEST_GENERAL_CFG_DIR=\"${DEST_GENERAL_CFG_DIR_EVL}\""
  32         dest_param_reset
  33         one_dest_init dest-general
  34         one_dest_init $1
  35
  36         CFLAGS="$CFLAGS"
  37
  38         mkdir -p ${OUTPUT_DIR}/${DEST_CFG_DIR_NAME}/
  39
  40         dbgout_construct_param
  41
  42         # check src file list to be compiled.
  43         check_and_get_src_compile_list
  44
  45         # compile if needed.
  46         if [[ $? == 0 ]]; then
  47                 compile_src_list
  48
  49                 [[ $? != 0 ]] && dbgoutd "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx1\n" && return 1
  50         fi
  51
  52         # try to check dest and obj tp, it output OBJ_LIST.
  53         dest_link_check $dest
  54         [[ $? != 0 ]] && dbgoutd "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx2\n" && return 1
  55
  56         link_dest $dest
  57         return $?
  58 }
  59
  60 #
  61 # fsyntax: construct_all_dest <dest-name>
  62 # fdesc: construct all dest executables.
  63 #
  64 construct_all_dest ()
  65 {
  66         #
  67         # load valid each dest.
  68         #
  69         if [[ -n $BUILD_DEST ]]; then
  70 #               BUILD_DEST="${BUILD_DEST//dest-/$'\ndest-'}"
  71                 for dest in $BUILD_DEST; do
  72 #                       declare -g -A DEST_CFG_DIR[${dest#*dest.?-}]="${SRCPKG_TOPDIR}/build/$dest"
  73                         DEST_CFG_DIR_NAME="$dest"
  74                         construct_one_dest $dest
  75                         [[ $? != 0 ]] && err "${CHIGHL}[build-dest][${dest#*-}]: build dest file \"$dest\" err.${CNORMAL}" && return 1
  76                 done
  77 #               DEST_LIST=( ${DEST_CFG_DIR[@]} )
  78 #               echo DEST_CFG_DIR[@]=${DEST_CFG_DIR[@]}
  79         else
  80                 err "no build dest defined in ${SRCPKG_TOPDIR}/build/dest/dest.list.\n"
  81                 return 1
  82         fi
  83 }
  84
  85 #################################################
  86 # public
  87 #################################################
  88 eval "SRCPKG_TOPDIR=\"$SRCPKG_TOPDIR_EVAL\""
  89
  90 #
  91 # fsyntax: get_CFLAGS
  92 # fdesc: get CFLAGS.
  93 #
  94 get_CFLAGS ()
  95 {
  96         :
  97 }
  98
  99
 100 src_obj_map[s]="o"
 101 src_obj_map[S]="o"
 102 src_obj_map[c]="o"
 103 src_obj_map[cpp]="o"
 104
 105 src_obj_map[asm]="obj"
 106 #src_obj_map[c]="obj"
 107 #src_obj_map[cpp]="obj"
 108
 109 #
 110 # fsyntax: compile_src_file
 111 # fdesc: compile each src file.
 112 #
 113 compile_src_file ()
 114 {
 115         local ret=
 116
 117         SRC_FILE[0]="$1"
 118
 119         src2dst_filename
 120 #       DST_FILE[0]="output/test.o"
 121 #       DST_FILE[1]="output/test.dep"
 122
 123         CMPL_FUNC
 124
 125         return $?
 126 }
 127
 128 foo ()
 129 {
 130 #       local C_SRC_LIST_FILE="dest/dest-libtui.so/c-src-file.list"
 131
 132         echo C_SRC_LIST_FILE=$C_SRC_LIST_FILE
 133         if [[ -e $C_SRC_LIST_FILE ]]; then
 134                 . $C_SRC_LIST_FILE
 135                 C_SRC_LIST="${C_SRC_LIST//\.c/$'.c\n'}"
 136         else
 137                 C_SRC_LIST_FILE="dest/dest-libtui.so/c-src-file.lst"
 138                 echo C_SRC_LIST_FILE=$C_SRC_LIST_FILE
 139                 [[ -e $C_SRC_LIST_FILE ]] && C_SRC_LIST=( $(cat $C_SRC_LIST_FILE | grep -v "^[[:space:]]*#" | sed -e "s/[[:space:]]*#.*$//g") )
 140         fi
 141 }
 142
 143 #
 144 # fsyntax: compile_src_list
 145 # fdesc: compile each src file in src file list.
 146 #
 147 compile_src_list ()
 148 {
 149         local file=
 150         local c_src_list=
 151         local cpp_src_list=
 152
 153         for file in $C_SRC_CMPL_LIST $CPP_SRC_CMPL_LIST; do
 154                 [[ -z "$file" ]] && continue
 155                 compile_src_file $file
 156                 [[ $? != 0 ]] && err "${CHIGHL}[build-compile]: compile file \"$file\" err.${CNORMAL}" && return 1
 157         done
 158
 159         return 0
 160 }
 161
 162
 163 #
 164 # fsyntax: check_and_get_src_compile_list
 165 # fdesc: check if src file is newer then dest file in $obj,
 166 #
 167 check_and_get_src_compile_list ()
 168 {
 169         local obj=
 170         local srcfile=
 171         local dstfile=
 172         local SRC_LIST_N2B_CMPL=
 173
 174         #C_SRC_LIST="${C_SRC_LIST//.c/.c$'\n'}"
 175         #echo C_SRC_LIST="${C_SRC_LIST}"
 176
 177         # check if no file to be compiled, and return 0.
 178         [[ -z ${C_SRC_LIST[@]} && -z ${CPP_SRC_LIST[@]} ]] && echo no src file in src list. && return 0
 179
 180         #
 181         # CPP_SRC_LIST list.
 182         #
 183         if [[ -n "$C_SRC_LIST" ]]; then
 184                 # get compiled obj file list
 185                 OBJ_LIST_N2B_CPLE=`cd ${OUTPUT_DIR}/${DEST_CFG_DIR_NAME}/; ls ${C_SRC_LIST[@]//\.c/\.o} 2>/dev/null`
 186
 187                 # test compiled obj file, to check if it need to be recompiled.
 188                 if [[ -n "$OBJ_LIST_N2B_CPLE" ]]; then
 189                         dbgoutd "OBJ_LIST_N2B_CPLE=${OBJ_LIST_N2B_CPLE}\n"
 190                         for obj in ${OBJ_LIST_N2B_CPLE}; do
 191                                 srcfile="${obj//\.o/\.c}"
 192                                 dstfile="${OUTPUT_DIR}/${DEST_CFG_DIR_NAME}/${obj}"
 193
 194                                 # check if file does not need to be compiled.
 195                                 if [[ "$dstfile" -nt "${srcfile}" ]]; then
 196                                         SRC_LIST_N2B_CMPL+="${srcfile}"$'\n'
 197                                         flag=compile
 198                                 fi
 199                         done
 200                 fi
 201
 202                 # filter compiled file.
 203                 # compare two list, delete lines in C_SRC_LIST list with that in SRC_LIST_N2B_CMPL.
 204                 # and store it to C_SRC_CMPL_LIST.
 205                 if [[ -n $SRC_LIST_N2B_CMPL ]]; then
 206                         C_SRC_CMPL_LIST="`comm <(echo "$C_SRC_LIST" | sort) <(echo "$SRC_LIST_N2B_CMPL" | sort) | sed -e "/^\t/d"`"
 207                 else
 208                         C_SRC_CMPL_LIST="$C_SRC_LIST"
 209                 fi
 210
 211                 echo C_SRC_CMPL_LIST="$C_SRC_CMPL_LIST"
 212         fi
 213
 214         #
 215         # CPP_SRC_LIST list.
 216         #
 217         if [[ -n "$CPP_SRC_LIST" ]]; then
 218                 # get compiled obj file list
 219                 OBJ_LIST_N2B_CPLE="${OUTPUT_DIR}/${DEST_CFG_DIR_NAME}/${CPP_SRC_LIST[@]//\.c/\.o}"
 220
 221                 # test compiled obj file, to check if it need to be recompiled.
 222                 if [[ -n "$OBJ_LIST_N2B_CPLE" ]]; then
 223 #                       dbgoutd "OBJ_LIST_N2B_CPLE=${OBJ_LIST_N2B_CPLE}\n"
 224                         for obj in ${OBJ_LIST_N2B_CPLE}; do
 225                                 srcfile="${obj//\.o/\.cpp}"
 226                                 dstfile="${OUTPUT_DIR}/${DEST_CFG_DIR_NAME}/${obj}"
 227
 228                                 # check if file does not need to be compiled.
 229                                 if [[ "$dstfile" -nt "${srcfile}" ]]; then
 230                                         SRC_LIST_N2B_CMPL+="${srcfile}"$'\n'
 231                                         flag=compile
 232                                 fi
 233                         done
 234                 fi
 235
 236                 [[ -n $SRC_LIST_N2B_CMPL ]] && CPP_SRC_CMPL_LIST="`comm <(echo "$CPP_SRC_LIST" | sort) <(echo "$SRC_LIST_N2B_CMPL" | sort) | sed -e "/^\t/d"`"
 237                 echo CPP_SRC_CMPL_LIST="$CPP_SRC_CMPL_LIST"
 238         fi
 239
 240         return 0
 241 }
 242
 243 #
 244 # fsyntax: dest_link_check
 245 # fdesc: check dest if it is not exist, or file in $obj is newer then dest,
 246 #
 247 dest_link_check ()
 248 {
 249         local obj=
 250         local file=
 251         local flag=
 252
 253         #SRC_FILE=( ${DS3T_FILE[@]} )
 254         DST_FILE[0]="${OUTPUT_DIR}/${DEST_CFG_DIR_NAME}/$1"
 255
 256         # translate src file list to obj file list
 257         #[[ -n "$C_SRC_LIST" ]] && OBJ_LIST=" ${C_SRC_LIST[@]//\.c/\.o} "
 258         #[[ -n "$CPP_SRC_LIST" ]] && OBJ_LIST+=" ${CPP_SRC_LIST[@]//\.cpp/\.o} "
 259         # translate to multi-line form.
 260         #OBJ_LIST="$(echo ${OBJ_LIST[@]} | tr -s ' ' $'\n')"
 261
 262         #SRC_FILE=( `cd ${OUTPUT_DIR}/${DEST_CFG_DIR_NAME}/; ls ${C_SRC_LIST[@]//\.c/\.o} 2>/dev/null` )
 263         SRC_FILE="${C_SRC_LIST[@]//\.c/\.o}"
 264         SRC_FILE+=" ${CPP_SRC_LIST[@]//\.c/\.o}"
 265         SRC_FILE="$(echo ${SRC_FILE} | tr '[\ |$'\\n']' ',')"
 266 #       if [[ ${SRC_FILE[@]: -1:1} == ',' ]]; then
 267 #               SRC_FILE="${SRC_FILE%,}"
 268 #       fi
 269         SRC_FILE="ls ${OUTPUT_DIR}/${DEST_CFG_DIR_NAME}/{${SRC_FILE:0:-1}} 2>/dev/null"
 270
 271 #       echo "$SRC_FILE"
 272         #ls ${OUTPUT_DIR}/${DEST_CFG_DIR_NAME}/{${SRC_FILE:0:-1}} 2>/dev/null"
 273
 274 #       set -x
 275         SRC_FILE="`eval $SRC_FILE`"
 276 #       set +x
 277
 278 #       echo === SRC_FILE="${SRC_FILE[@]}"
 279 #       echo === DST_FILE="${OUTPUT_DIR}/${DEST_CFG_DIR_NAME}/${DST_FILE[@]}"
 280
 281         flag=link;
 282         if [[ -f ${DST_FILE[0]} ]]; then
 283                 # dest is linked, check if obj to be compiled.
 284
 285                 # do not use for loop here, especially in large number
 286                 # of file to be compiled.
 287                 # for obj in ${OBJ_LIST[@]}; do
 288                 while read obj; do
 289                         file="${OUTPUT_DIR}/${DEST_CFG_DIR_NAME}/${obj}"
 290                         echo file=$file
 291                         [[ -f $file && $file -nt ${DST_FILE[0]} ]] && flag=compile
 292                         #OBJ_LIST+="$obj"$'\n';
 293                 done <<< "${SRC_FILE[@]}"
 294
 295                 echo "OBJ_LIST=$OBJ_LIST"
 296
 297                 [[ $flag == 'link' ]] && info "destination \"${DST_FILE[0]}\" has been existing." && return 1
 298         else
 299                 # if dest is not exist, all file should try to be recompiled.
 300                 return 0
 301         fi
 302
 303         if [[ $flag == 'link' ]]; then
 304                 return 0
 305         else
 306                 return 1
 307         fi
 308 }
 309
 310 #
 311 # fsyntax: link_dest
 312 # fdesc: link .o files to an executable.
 313 #
 314 link_dest ()
 315 {
 316 #       SRC_FILE=( ${OBJ_LIST[@]} )
 317         DST_FILE="${OUTPUT_DIR}/${DEST_CFG_DIR_NAME}/$1"
 318
 319 #       echo === SRC_LIST[@] = ${SRC_LIST[@]}
 320 #       echo === DST_FILE[@] = ${DST_FILE[@]}
 321
 322         o2exe
 323         [[ $? != 0 ]] && err "${CHIGHL}[build-link]: link file \"$1\" err.${CNORMAL}" && return 1
 324
 325         return 0
 326 #       fi
 327 }
 328
 329 #
 330 # fsyntax: compile_src_list
 331 # fdesc: compile each src file in src file list.
 332 #
 333 compile_src_list_bak ()
 334 {
 335         local abc=
 336         local C_SRC_LIST_FILE="dest/dest-libtui.so/c-src-file.list"
 337
 338         echo C_SRC_LIST_FILE=$C_SRC_LIST_FILE
 339         if [[ -e $C_SRC_LIST_FILE ]]; then
 340                 . $C_SRC_LIST_FILE
 341                 C_SRC_LIST="${C_SRC_LIST//\.c/$'.c\n'}"
 342         else
 343                 C_SRC_LIST_FILE="dest/dest-libtui.so/c-src-file.lst"
 344                 echo C_SRC_LIST_FILE=$C_SRC_LIST_FILE
 345                 [[ -e $C_SRC_LIST_FILE ]] && C_SRC_LIST=( $(cat $C_SRC_LIST_FILE | grep -v "^[[:space:]]*#" | sed -e "s/[[:space:]]*#.*$//g") )
 346         fi
 347
 348         [[ -z ${C_SRC_LIST[@]} ]] && echo no src file in src list. && return 0
 349
 350         echo C_SRC_LIST=${C_SRC_LIST[$i]}
 351
 352         while read file; do
 353                 [[ -z "$file" ]] && continue
 354
 355                 echo file=$file
 356                 compile_src_file $file
 357         done < $C_SRC_LIST_FILE
 358 }
 359
 360