shlib/catalog.shlib

   1 #!/bin/bash
   2 ############################################################
   3 # source: catalog.shlib
   4 # author: CottonCandyOwner(CottonCandyOwner@126.com)
   5 # date: 2022-03-23
   6 ############################################################
   7 # note:
   8 #     catalog is a file that orgnize text string like tree-struct
   9 # by tabs. it is a good describe file for program design draft.
  10 # maybe it is used for program module struct describe, or for
  11 # rootfs dir struct describe, for menu structure. use
  12 # catalog.shlib to despatch file, and do some thing automatically.
  13 #    catalog contain a catalog-id, id=A.B.C. it can be used
  14 # to describe range of catalog operating, or exlude some id,
  15 # when the program ergodic a catalog file.
  16 #     every catalog is consisted by describe line string.
  17 # different syntax can be used for different purpose. this
  18 # shlib defined some syntax used for some application. eg:
  19 # scripttest, codegen.
  20 #
  21 ############################################################
  22
  23
  24 #
  25 # todo：
  26 # @ catalog file content is consiste of two part, one is dir and file, the
  27 #   other is file content structure. they are dispatched and restored in
  28 #   different variable category.
  29 # @ sub-catalog. if a catalog file referenced in another catalog item, it
  30 #   will add prefix for the referenced catalog.
  31 # @
  32 #
  33
  34 # @ 在<>中，-之后可根据需要添加一个6个字符的随机字符串，用于和<<<>>>中的cataid进行匹配。
  35 # 使用固定cataid时，可不用随机字符串。在cataidreset成<->时，对content中的catanode的<<<>>>添加随机字符串，并保存到cataid的关联数组。当变量dir时，对应cataid使用相关随机字符串。
  36
  37
  38 . shlibinc
  39
  40 include stdio.shlib
  41
  42 include envar.shlib
  43 include strfmt.shlib
  44
  45
  46
  47 ##############################
  48 # section: public comment info
  49 ##############################
  50
  51
  52
  53 ##############################
  54 # section: variable define
  55 ##############################
  56
  57
  58 vonThisDoc=
  59 vonCataNodeProc=onDefaultCataNodeProc
  60
  61
  62 vonItemEntering=
  63 vonItemSubjectDirEntering=
  64 vonItemExiting=
  65 vonItemFileProc=
  66
  67 vonDirSubjectDirEntering=
  68 vonDirFileProc=
  69
  70 vonContProc=
  71
  72
  73 # global temp var used in strfmt
  74 STR_FMT=
  75
  76
  77
  78 #NCATAID_REGEX="([[:xdigit:]-]*)"
  79 NCATAID_REGEX="(.*)"
  80 NNAME_REGEX="([[:alnum:]_]*)"
  81 #NDESC_REGEX="([[:alnum:]_-+[:blank:]]*)"
  82 NDESC_REGEX="([^\.\"]*)"
  83 NODE_TYPE_REGEX="([[:alnum:]_]*)"
  84 ALIGN_REGEX='([[:blank:]]+)'
  85
  86 # replace tab with blank string.
  87 TAB_BLANK_STR="    "
  88
  89 BLANKCNT=0
  90 LASTBLANKCNT=0
  91 TABS=
  92 LASTTABS=
  93 LAST_ID_NUM=
  94
  95 CATACNT=
  96 CTX_BAK_VAR_LIST='
  97 NFULLCATAID
  98 ${!LAYEDDIR_*}'
  99
 100
 101 # current ITEM info for content proc
 102 ITEM_NCATAID=
 103 ITEM_NFULLCATAID=
 104 ITEM_NTYPE=
 105 ITEM_NNAME=
 106 ITEM_NDESC=
 107 ITEM_NODE_TYPE=
 108
 109 CONT_TYPE=
 110 CONT_TYPE_LIST="
 111 tmpl
 112 var
 113 prop
 114 func
 115 elem
 116 cmntag
 117 cmntdoc
 118 test
 119 shtest
 120 args
 121 shargs"
 122
 123
 124
 125 ##############################
 126 # section: private function
 127 ##############################
 128
 129
 130
 131
 132 ##############################
 133 # section: public function
 134 ##############################
 135
 136
 137
 138
 139 ###########################################################################
 140 # catalog file
 141 ###########################################################################
 142
 143
 144 #
 145 # contex:
 146 # catalog_id/NFULLCATAID
 147 # LASTTABS/CATACNT/
 148 # LAYEDDIR_*
 149 #
 150
 151 #
 152 # fsyntax: save_curr_ctx <name>
 153 # fdesc: save current contex to specified name prefix.
 154 #        current contex include NFULLCATAID LAYEDDIR_*
 155 #
 156 save_curr_ctx ()
 157 {
 158         local name=$1
 159
 160         if [[ -z $name ]]; then
 161                 name=BAK
 162                 BAK_LASTTABS=$LASTTABS
 163
 164                 cataid_bak TEST
 165                 LAST_ID_NUM_BAK=( "${LAST_ID_NUM[@]}" )
 166                 LAST_DIR_TABS_BAK_TESTDIR="$LAST_DIR_TABS_SRCDIR"
 167                 LAST_DIR_TABS_BAK_DOCDIR="$LAST_DIR_TABS_DOCDIR"
 168                 LAST_DIR_TABS_BAK_DESIGNDIR="$LAST_DIR_TABS_DESIGNDIR"
 169                 LAST_DIR_TABS_BAK_TESTDIR="$LAST_DIR_TABS_TESTDIR"
 170         fi
 171
 172         BAK_CONTEX[$name]="$(eval declare -p $CTX_BAK_VAR_LIST)"
 173         BAK_CONTEX[$name]="${BAK_CONTEX[$name]//declare/declare -g}"
 174 }
 175
 176 #
 177 restore_curr_ctx ()
 178 {
 179         local name=$1
 180
 181         if [[ -z $name ]]; then
 182                 name=BAK
 183                 LASTTABS=$BAK_LASTTABS
 184
 185                 # re-calc CATACNT
 186                 CATACNT=$((TABS - LASTTABS))
 187                 REF_ITEM_CATAID=""
 188
 189                 cataid_restore TEST
 190                 LAST_ID_NUM=( "${LAST_ID_NUM_BAK[@]}" )
 191                 LAST_DIR_TABS="$LAST_DIR_TABS_BAK"
 192                 LAST_DIR_TABS_SRCDIR="$LAST_DIR_TABS_BAK_TESTDIR"
 193                 LAST_DIR_TABS_DOCDIR="$LAST_DIR_TABS_BAK_DOCDIR"
 194                 LAST_DIR_TABS_DESIGNDIR="$LAST_DIR_TABS_BAK_DESIGNDIR"
 195                 LAST_DIR_TABS_TESTDIR="$LAST_DIR_TABS_BAK_TESTDIR"
 196                 unset LAST_ID_NUM_BAK ${!LAST_DIR_TABS_BAK_*}
 197         else
 198                 CATACNT=0
 199         fi
 200
 201         [[ -z "${BAK_CONTEX[$name]}" ]] && echo "BAK_CONTEX[$name] does not setted."
 202         eval "${BAK_CONTEX[$name]}"
 203
 204         if [[ $name != BAK ]]; then
 205                 REF_ITEM_CATAID="$NFULLCATAID"
 206 #               declare -p TEST_CID TEST_DIR_DEPTH NFULLCATAID
 207                 cataid_set TEST $NFULLCATAID
 208         fi
 209 }
 210
 211 #
 212 # fsyntax: del_bak_ctx <name>
 213 #
 214 del_bak_ctx ()
 215 {
 216         local name=$1
 217
 218         [[ -z $name ]] && name=BAK
 219         unset BAK_CONTEX[$name]
 220 }
 221
 222 #
 223 node_indent_proc ()
 224 {
 225         if [[ -n $LASTTABS ]]; then
 226                 CATACNT=$((TABS-LASTTABS))
 227         else
 228                 CATACNT=0
 229         fi
 230
 231         ITEM_CHKSUM="$(echo "$NTYPE $NNAME $NDESC" | cksum)"
 232         ITEM_CHKSUM="${ITEM_CHKSUM:0:6}"
 233
 234         # item reference by ITEM_CHKSUM
 235         if [[ "${NCATAID:0:2}" == '<<' && "${NCATAID: -2:2}" == '>>' ]]; then
 236                 #
 237                 # <<<>>> is an item reference, it entering contex specified in <<<>>>.
 238                 # save current contex first, then set to contex specified in <<<>>>.
 239                 # restore current contex in func of onItemExiting().
 240                 #
 241                 dbgoutd "#############################################\n"
 242
 243                 [[ -z "${BAK_CONTEX[$ITEM_CHKSUM]}" ]] && warn "BAK_CONTEX[$ITEM_CHKSUM] does not defined.\n" && return
 244
 245                 # save current contex
 246                 save_curr_ctx
 247
 248                 # recovery contex
 249                 restore_curr_ctx "$ITEM_CHKSUM"
 250
 251 #               declare -p NCATAID NFULLCATAID ${!ITEM_LAYEDDIR_*}
 252                 NCATAID="${NFULLCATAID##*\.}"
 253 #               declare -p NFULLCATAID NCATAID TEST_DIR_DEPTH TEST_CID BAK_CID BAK_DIR_DEPTH
 254
 255                 return
 256         fi
 257
 258         if [[ $REF_ITEM_STATE == 1 ]]; then
 259                 :
 260         fi
 261
 262         if [[ "$CATACNT" -gt 0 ]]; then
 263                 if [[ "${NCATAID}" == '-' ]]; then
 264                         NCATAID="${CATAID_BEGIN_VAL}"
 265                 fi
 266
 267                 for ((; CATACNT>1; CATACNT--)); do
 268                         cataid_step_into_id TEST $CATAID_BEGIN_VAL
 269                 done
 270
 271                 cataid_step_into_id TEST $NCATAID
 272         elif [[ "$CATACNT" -lt 0 ]]; then
 273                 tmp="$((0 - CATACNT))"
 274                 for ((; tmp>0; tmp--)); do
 275                         unset LAST_ID_NUM[$TEST_DIR_DEPTH]
 276                         cataid_step_out TEST
 277                 done
 278
 279                 if [[ "${NCATAID}" == '-' ]]; then
 280                         NCATAID="${TEST_CID[$TEST_DIR_DEPTH]}"
 281                         LAST_ID_NUM[$TEST_DIR_DEPTH]=$NCATAID
 282                         NCATAID="$((NCATAID+1))"
 283                 fi
 284
 285                 cataid_step_to TEST $NCATAID
 286         else
 287                 if [[ "${NCATAID}" == '-' ]]; then
 288                         NCATAID=$((LAST_ID_NUM[$TEST_DIR_DEPTH]+1))
 289                 fi
 290
 291                 cataid_step_to TEST $NCATAID
 292         fi
 293         NFULLCATAID="$(cataid_get TEST)"
 294 #       declare -p NFULLCATAID TEST_DIR_DEPTH TEST_CID
 295
 296         LAST_ID_NUM[$TEST_DIR_DEPTH]=$NCATAID
 297
 298 #       declare -p CATACNT TEST_DIR_DEPTH LAST_ID_NUM NCATAID NFULLCATAID
 299 }
 300
 301 #
 302 # fsyntax: catalog_each_line <catafile>
 303 # design file analyzing.
 304 # @ 1.get each line data
 305 # @ 2.calc indent level
 306 # @ 3.disposing node string to NXXX variables
 307 # @ 4.get type info indent
 308 # @ 5.relative info process
 309 # @ 6.user proc func
 310 #
 311 catalog_each_line ()
 312 {
 313         local data=
 314         local tabcnt=           # blank count equals to a tab.
 315         local tabstr=           # a string equals to a tab.
 316
 317
 318 #       declare -p G_NODE_STR_FMT G_NODE_PAIRCHARS
 319
 320         #
 321         # 1.get each line data
 322         # get line data by readln, but not 'read'.
 323         # it improve blank char getting at the beginning of line string.
 324         #
 325         while readln data; do
 326                 [[ $verbose == "enable" ]] && info "data=$data\n"
 327             [[ ${data//[ \t]/} =~ ^[[:blank:]]*\# ]] && continue
 328                 # blank line filter.
 329                 [[ -z ${data} ]] && continue
 330                 if [[ $data == 'exit' ]]; then
 331                         $vonItemExiting "$ITEM_NODE_TYPE" "$ITEM_LAYEDDIR_TESTDIR" "$ITEM_DIR_NAME_TESTDIR"
 332
 333                         [[ -n $THISDOC ]] && $vonThisDoc
 334                         break
 335                 elif [[ $data =~ ^ignore ]]; then
 336                         local cnt="${data#*\ }"
 337
 338                         for ((i=0; i<$cnt; i++)); do
 339                                 read data
 340                         done
 341
 342                         #[[ -n $THISDOC ]] && $vonThisDoc
 343
 344                         continue
 345                 elif [[ $data =~ ^print ]]; then
 346                         local var="${data#*\ }"
 347                 fi
 348
 349                 if [[ ! "$data" =~ ^[[:blank:]]*[[:punct:]|[:digit:]] ]]; then
 350                         THISDOC+="$(echo "${data}" | sed -e 's/^[[:blank:]]*//g')"$'\n'
 351                         continue
 352                 elif [[ -z ${data//[[:blank:]]/} ]]; then
 353                         THISDOC+=$'\n'
 354                         continue
 355                 else
 356                         [[ -n $THISDOC ]] && $vonThisDoc
 357                         if [[ -n $THISDOC ]]; then
 358                                 echo aaa
 359                         fi
 360                 fi
 361
 362                 if [[ "${data: -1:1}" == '\' ]]; then
 363                         data="${data:0:-1}"
 364                         # here use read not readln, it will skip blanks at the beginning of
 365                         # line string.
 366                         # -r will ignore '\' special-char.
 367                         while read -d $'\n' -r tmp; do
 368                                 if [[ "${tmp: -1:1}" == '\' ]]; then
 369                                         data+="${tmp:0:-1}"
 370                                 else
 371                                         data+="$tmp"
 372                                         break
 373                                 fi
 374                         done
 375                 fi
 376
 377                 #
 378                 # 2.calc indent level
 379                 # get tab and blank count as catalog indent level number.
 380                 #
 381                 LASTBLANKCNT=${BLANKCNT}
 382                 LASTTABS=$TABS
 383                 BLANKCNT=${data%%[^[:blank:]]*}
 384                 data="${data#$BLANKCNT}"
 385                 BLANKCNT="${BLANKCNT//\t/$tabstr}"
 386                 eval "BLANKCNT=\"\${BLANKCNT//$'\t'/$TAB_BLANK_STR}\""
 387                 BLANKCNT="${#BLANKCNT}"
 388                 LASTBLANKCNT=${LASTBLANKCNT:-"$BLANKCNT"}
 389
 390                 # value in the first line to be the size unit in current file.
 391                 [[ -z $tabcnt ]] && tabcnt=$BLANKCNT && tabstr="`printf "%*s" $((TABS*tabcnt)) " "`"
 392                 [[ $tabcnt == 0 ]] && tabcnt=4 && tabstr="`printf "%*s" $((TABS*4)) " "`"
 393                 TABS=$(( BLANKCNT/${tabcnt:-'4'} ))
 394
 395 #               declare -p LASTBLANKCNT BLANKCNT TABS LASTTABS tabcnt tabstr
 396
 397                 #
 398                 # 3.disposing node string to NXXX variables
 399                 #
 400                 STR_FMT="$G_NODE_STR_FMT"
 401                 PAIRCHARS="$G_NODE_PAIRCHARS"
 402                 #PAIRCHARS='<>[]""'
 403 #               declare -p STR_FMT PAIRCHARS
 404                 str2var @data
 405
 406                 if [[ -z $NCATAID || -z $NNAME || -z $NTYPE || -z $NDESC ]]; then
 407                         err "node string '$data' can not matching variables.\n"
 408                         exit
 409                 fi
 410
 411 #               echo ======================================
 412 #               declare -p NCATAID NTYPE NNAME NDESC # STR_FMT ALIGN
 413 #               echo ======================================
 414
 415                 #
 416                 # 4.get type info
 417                 # NTYPE => SRC_TYPE & NODE_TYPE(dir/item/cont)
 418                 #
 419                 CONT_TYPE=""
 420                 if [[ "$NTYPE" =~ dir$ ]]; then
 421                         [[ "$NTYPE" == 'ignrdir' ]] && return 1
 422
 423                         NODE_TYPE="dir"
 424
 425                         # <NULL>/src/lib/bin/shlib/ex
 426                         if [[ "$NTYPE" != 'dir' ]]; then
 427                                 SRC_TYPE="${NTYPE%dir}"
 428
 429                                 if [[ $TABS != 1 && -n $SRC_TYPE ]]; then
 430                                         warn "(NTYPE=$NTYPE, TABS=$TABS, SRC_TYPE=$SRC_TYPE)do not specify dir type not in first dir level."
 431                                 fi
 432                         fi
 433                 elif [[ "$CONT_TYPE_LIST" =~ $NTYPE ]]; then
 434                         NODE_TYPE="cont"
 435                         CONT_TYPE="$NTYPE"
 436                 elif [[ "$NTYPE" =~ ^cont- ]]; then
 437                         dbgoutd "\$NTYPE =~ ^cont-"
 438                         # keep SRC_TYPE processed before.
 439                         NODE_TYPE="cont"
 440                         CONT_TYPE="${NTYPE#cont-}"
 441                 else
 442                         # keep SRC_TYPE processed before.
 443                         NODE_TYPE="item"
 444                         ITEM_TYPE="${NTYPE}"
 445                 fi
 446
 447 #       echo ++++++++++++++++++++++++++++++++++++++++++++++
 448 #       declare -p SRC_TYPE NODE_TYPE ITEM_TYPE 2>/dev/null
 449 #       echo ++++++++++++++++++++++++++++++++++++++++++++++
 450
 451                 if [[ ${NODE_TYPE} != 'cont' &&
 452                           -n $ITEM_NFULLCATAID &&
 453                           $ITEM_NFULLCATAID != NFULLCATAID ]]; then
 454                         if [[ -n $REF_ITEM_CATAID && -n "${BAK_CONTEX[BAK]}" ]]; then
 455 #                               ${#NFULLCATAID} -le ${#REF_ITEM_CATAID} &&
 456 #                               ${NFULLCATAID} != ${REF_ITEM_CATAID} ]]; then
 457                                 restore_curr_ctx
 458                                 del_bak_ctx
 459                         fi
 460                 fi
 461
 462                 #
 463                 # 5.indent relative info process
 464                 # NCATAID, maybe it is a string with <<>> or '-'.
 465                 # NFULLCATAID, generated by cataid_xxx().
 466                 # CATACNT,  TABS change count,
 467                 #                       >0 entering into a sub-node,
 468                 #                       <0 exiting from a sub-node,
 469                 #                       =0 same sub-node dir,
 470                 #
 471                 node_indent_proc
 472 #               declare -p NFULLCATAID CATACNT
 473 #               echo ======================================
 474
 475                 [[ -n $var ]] && declare -p $var
 476
 477                 #
 478                 # @ 6.user proc func
 479                 # analyze string to node variable.
 480                 #
 481                 $vonCataNodeProc
 482
 483                 LAST_TYPE="${NODE_TYPE}"
 484         done < $1
 485 }
 486
 487
 488 # XXX: does not used now.
 489 # eg: shlibsrcdir
 490 #SRC_DIR_TYPE=
 491 FILE_NAME_LIST=
 492
 493 # output dir under srcpkg.
 494 SUBJECTDIR=
 495 # output dir
 496 OUTPUT_DIR=
 497
 498 #
 499 # get info from $NCATAID $NTYPE $NNAME $NDESC
 500 #
 501 onDefaultCataNodeProc ()
 502 {
 503         local vname=
 504         local tmp=
 505         local idx=
 506         local tmpcnt=
 507         local DIR_DESC=
 508         local ext=
 509         local new_dir_flags=
 510
 511         #if [[ ${NODE_TYPE} != 'cont' && ${LAST_TYPE} == 'cont' ]]; then
 512         if [[ ${NODE_TYPE} != 'cont' &&
 513                   -n $ITEM_NFULLCATAID &&
 514                   $ITEM_NFULLCATAID != NFULLCATAID ]]; then
 515                 $vonItemExiting "$ITEM_NODE_TYPE" "$ITEM_LAYEDDIR_TESTDIR" "$ITEM_DIR_NAME_TESTDIR"
 516                 ITEM_NCATAID="" ITEM_NTYPE="" ITEM_NNAME="" ITEM_NDESC=""
 517                 ITEM_NFULLCATAID=""
 518                 ITEM_NODE_TYPE="" ITEM_DIR_NAME="" ITEM_LAYEDDIR=""
 519                 unset ${!ITEM_LAYEDDIR_*} ${!ITEM_DIR_NAME_*}
 520         fi
 521
 522         # NTYPE => NFTYPE
 523         if [[ "$NODE_TYPE" == 'dir' ]]; then
 524                 NFTYPE="$(envar_get catalog::${NODE_TYPE}node::NFTYPE)"
 525                 #  | sed -e "s/\;([[:blank:]])*([\n])*/\n/g"
 526         elif [[ "$NODE_TYPE" == 'item' ]]; then
 527                 NFTYPE="$(envar_get catalog::${ITEM_TYPE}::NFTYPE)"
 528                 $vonItemEntering "$NFULLCATAID" "$ITEM_CHKSUM" "$NNAME"
 529         elif [[ "$NODE_TYPE" == 'cont' ]]; then
 530                 $vonContProc "$CONT_TYPE" "$NNAME" "$NDESC"
 531                 return
 532         fi
 533
 534         NFTYPE="${NFTYPE//\;/$'\n'}"
 535         # TBD: the statement below does not effect in script, but it can work
 536         # in term.
 537         #NFTYPE="${NFTYPE//\;*([[:blank:]])*($'\n')/$'\n'}"
 538
 539         # NFTYPE => DIR_DESC => DIR_TYPE_LIST & FILE_EXT_LIST
 540         #
 541         # DIR_TYPE_LIST => DIR_TYPE
 542         # DIR_TYPE => OUTPUT_DIR_FMT
 543         # DIR_TYPE + catalog::${DIR_TYPE}::STR_FMT => DIR_NAME
 544         # DIR_TYPE => LAYEDDIR_${DIR_TYPE^^}[@] => OUTPUT_DIR
 545         #
 546         # FILE_EXT_LIST => NFEXT => <one-of-item-file-name>
 547         while read data; do
 548                 [[ -z ${data//[[:blank:]]/} ]] && continue
 549
 550                 DIR_DESC="${data%%:*}"
 551                 DIR_DESC="${DIR_DESC//\//$'\n'}"
 552
 553                 tmp="${data##*:}"
 554                 unset FILE_EXT_LIST
 555                 FILE_EXT_LIST=""
 556                 if [[ -n $tmp ]]; then
 557                         IFS_OLD=$IFS
 558                         IFS='/'
 559                         FILE_EXT_LIST=( $tmp )
 560                         IFS="$IFS_OLD"
 561                 fi
 562
 563                 for DIR_TYPE in ${DIR_DESC}; do
 564                         DIR_TYPE_LIST="${DIR_TYPE}"$'\n'
 565
 566                         [[ ${DIR_TYPE:0:1} == '@' ]] && new_dir_flags=1 && DIR_TYPE="${DIR_TYPE:1}"
 567
 568                         #
 569                         # dir name string.
 570                         # if it is an item node, it is used for sub-dir name when
 571                         # new_dir_flags tagged.
 572                         #
 573                         STR_FMT="$(envar_get catalog::${DIR_TYPE}::STR_FMT)"
 574                         strfmt @STR_FMT
 575                         DIR_NAME="${STR}"
 576
 577                         #
 578                         # 1.dir indent
 579                         #
 580                         if [[ ${NODE_TYPE} == 'dir' && $new_dir_flags == 1 ]]; then
 581                                 tmp="LAST_DIR_TABS_${DIR_TYPE^^}"
 582                                 if [[ -n ${!tmp} ]]; then
 583                                         tmp="$((TABS - ${!tmp}))"
 584                                 else
 585                                         tmp=0
 586                                 fi
 587 #                               declare -p LAST_DIR_TABS_${DIR_TYPE^^} tmp TABS
 588                                 if [[ "$tmp" -lt 0 ]]; then
 589                                         tmpcnt="$((0 - tmp))"
 590                                         eval tmp="\${#LAYEDDIR_${DIR_TYPE^^}[@]}"
 591                                         if [[ -n $tmp && $tmp -gt 0 ]]; then
 592                                                 for ((idx=0; idx<=tmpcnt; idx++)); do
 593                                                         local tmpidx=$((tmp - idx - 1))
 594                                                         echo xxx
 595 #                                                       declare -p tmp idx tmpcnt tmpidx
 596                                                         if [[ $tmpidx -ge 0 ]]; then
 597                                                                 unset LAYEDDIR_${DIR_TYPE^^}[$tmpidx]
 598                                                         else
 599                                                                 warn "indent is not correct."
 600                                                         fi
 601                                                 done
 602 #                                               declare -p DIR_NAME LAYEDDIR_${DIR_TYPE^^}
 603                                                 tmp=$((tmp - tmpcnt - 1))
 604                                                 [[ $tmp -ge 0 ]] && eval LAYEDDIR_${DIR_TYPE^^}[$tmp]=\"\$DIR_NAME\"
 605                                         fi
 606                                 elif [[ "$tmp" == 0 ]]; then
 607                                         eval tmp="\${#LAYEDDIR_${DIR_TYPE^^}[@]}"
 608                                         tmp=$((tmp-1))
 609                                         if [[ $tmp -ge 0 ]]; then
 610                                                 eval LAYEDDIR_${DIR_TYPE^^}[$tmp]=\"\$DIR_NAME\"
 611                                         else
 612                                                 eval "LAYEDDIR_${DIR_TYPE^^}=( \"\$DIR_NAME\" )"
 613                                         fi
 614                                 elif [[ "$tmp" == 1 ]]; then
 615                                         eval "LAYEDDIR_${DIR_TYPE^^}+=( \"\$DIR_NAME\" )"
 616                                 else
 617                                         err "TABS=$TABS LASTTABS=$LASTTABS LAST_DIR_TABS=$LAST_DIR_TABS tmp=$tmp dir node define err.\n"
 618                                         exit
 619                                 fi
 620                                 eval LAST_DIR_TABS_${DIR_TYPE^^}="$TABS"
 621
 622                                 # save to ITEM_* info
 623                                 eval ITEM_LAYEDDIR_${DIR_TYPE^^}=\( "\"\${LAYEDDIR_${DIR_TYPE^^}[@]}\"" \)
 624                         fi
 625
 626 #                       declare -p LAYEDDIR_${DIR_TYPE^^}
 627
 628                         eval LAYEDDIR="\${LAYEDDIR_${DIR_TYPE^^}[@]}"
 629                         LAYEDDIR="${LAYEDDIR//\ /\/}"
 630 #                       declare -p LAYEDDIR LAYEDDIR_${DIR_TYPE^^} 2>/dev/null
 631
 632                         if [[ -n $LAYEDDIR ]]; then
 633                                 NPFXID="${NCATAID}"
 634                         else
 635                                 NPFXID="${NFULLCATAID}"
 636                         fi
 637
 638                         SUBJECTDIR="$(envar_get catalog::${DIR_TYPE}::SUBJECTDIR)"
 639                         OUTPUT_DIR_FMT="$(envar_get catalog::${DIR_TYPE}::OUTPUT_DIR_FMT)"
 640                         [[ -z $OUTPUT_DIR_FMT ]] && OUTPUT_DIR_FMT="$G_OUTPUT_DIR_FMT"
 641                         strfmt @OUTPUT_DIR_FMT
 642 #                       declare -p G_OUTPUT_DIR_FMT OUTPUT_DIR_FMT OUTPUT_DIR SUBJECTDIR
 643
 644                         mkdir -p "$OUTPUT_DIR"
 645                         cd "$OUTPUT_DIR"
 646 #                       declare -p new_dir_flags DIR_TYPE NPFXID SUBJECTDIR STR_FMT
 647 #                       declare -p DIR_NAME FILE_EXT_LIST OUTPUT_DIR_FMT LAYEDDIR_${DIR_TYPE^^} LAYEDDIR
 648
 649                         if [[ ${NODE_TYPE} == 'item' && $new_dir_flags == 1 ]]; then
 650                                 mkdir -p "$DIR_NAME"
 651                                 cd "$DIR_NAME"
 652                                 ITEMNODE_DIR="DIR_NAME"
 653                         fi
 654
 655                         #
 656                         # 2.file output proc.
 657                         #
 658                         if [[ ${NODE_TYPE} == 'dir' ]]; then
 659                                 $vonDirSubjectDirEntering "${DIR_TYPE}" "${SUBJECTDIR}" "${DIR_NAME}"
 660
 661                                 for NFEXT in ${FILE_EXT_LIST[@]}; do
 662                                         STR_FMT="$(envar_get catalog::${NFEXT}::STR_FMT)"
 663                                         strfmt @STR_FMT
 664                                         FILE_NAME_LIST[$DIR_TYPE]+="touch ${OUTPUT_DIR}/$ITEMNODE_DIR/${STR}"$'\n'
 665
 666                                         $vonDirFileProc "$STR"
 667                                 done
 668                         elif [[ ${NODE_TYPE} == 'item' ]]; then
 669                                 $vonItemSubjectDirEntering "${DIR_TYPE}" "${SUBJECTDIR}" "${DIR_NAME}"
 670
 671                                 for NFEXT in ${FILE_EXT_LIST[@]}; do
 672                                         STR_FMT="$(envar_get catalog::${NFEXT}::STR_FMT)"
 673                                         strfmt @STR_FMT
 674                                         FILE_NAME_LIST[$DIR_TYPE]+="touch ${OUTPUT_DIR}/$ITEMNODE_DIR/${STR}"$'\n'
 675
 676                                         $vonItemFileProc "$STR"
 677                                 done
 678
 679                                 eval ITEM_DIR_NAME_${DIR_TYPE^^}="$DIR_NAME"
 680                         #elif [[ ${NODE_TYPE} == 'cont' ]]; then
 681                         #       $onContProc "$NNAME"
 682                         fi
 683
 684                         # reset variables.
 685                         new_dir_flags=0
 686                         DIR_NAME=""
 687                         OUTPUT_DIR=""
 688                         LAYEDDIR=""
 689                         NPFXID=""
 690                         unset STR
 691                 done
 692         done <<< "$NFTYPE"
 693
 694         if [[ "$NODE_TYPE" == 'item' ]]; then
 695                 ITEM_NCATAID="$NCATAID"
 696                 ITEM_NFULLCATAID="$NFULLCATAID"
 697                 ITEM_NTYPE="$NTYPE"
 698                 ITEM_NNAME="$NNAME"
 699                 ITEM_NDESC="$NDESC"
 700                 ITEM_NODE_TYPE="$NODE_TYPE"
 701         fi
 702 }
 703
 704
 705
 706 ##############################
 707 # section: file tail
 708 ##############################
 709
 710
 711
 712
 713
 714
 715
 716
 717
 718
 719
 720
 721
 722
 723
 724 ###########################################################################
 725 #
 726 ###########################################################################
 727
 728
 729
 730
 731
 732
 733
 734
 735
 736
 737
 738
 739
 740
 741