fixed valgrind sources path trimming

.gitignore

@@ -9,10 +9,6 @@ obj/
 *.user
 *.vcxproj.filters
 
-# local cbuild config giles
-current.config
-*.current.config
-
 # other files
 .old*/
 old/

CBUILD_VERSION

@@ -0,0 +1 @@
+2.1.4

CHANGELOG.md

@@ -1,3 +1,23 @@
+# v2.1.4
++ added `-Wl,-rpath` argument generation in `link()`. It forces ld to link to local shared library in `OUTDIR`
+
+# v2.1.3
++ added `DEP_OTHER_OUT_FILES` to dependency configs
++ if `PRESERVE_OUT_DIRECTORY_STRUCTURE=true` then `DEP_DYNAMIC_OUT_FILES` and `DEP_OTHER_OUT_FILES` are copied to `OUTDIR` preserving directory structure (example_dir/lib1.so -> $OUTDIR/example_dir/lib1.so)
+
+# v2.1.2
++ changed compile_c and compile_cpp functions
++ bootstrap now can print help and list of installed versions 
+
+# v2.1.1
++ **config**: removed `TESTS_C` and `TESTS_CPP` compilation
+
+# v2.1.0
++ **config**: no more `current.config` and `default.config`, just `project.config`
++ improved version checking
++ `setup.sh` now installs each minor version in separate dicectory
++ added `bootstrap.sh` which automaticly selects cbuild version specified in project config 
+
 # v2.0.2
 + new dependency resolution system (see **config** and `example_dependency_configs`)
 + **config**: changed description of `OBJDIR`

README.md

@@ -1,23 +1,31 @@
 # cbuild
-My C/C++ build system written in bash.
+My C/C++ build system written in sh.
 
 
 ## Installation
-```bash
+```sh
-git clone https://timerix.ddns.net:3322/cbuild.git
+git clone https://timerix.ddns.net:3322/Timerix/cbuild.git
 cd cbuild
 sudo ./setup.sh 
 ```
+Can be installed to `~/.local/` if you have no root rights.
+- ```sh
+  ./setup.sh --local
+  ```
+- Then add `~/.local/bin` to `PATH` in your shell config.
 
 ## Usage
 1. Initialize cbuild project in some directory:
-    ```bash
+    ```sh
     cd some_project
     cbuild --new-project
     ```
-
+2. Edit `project.config`.
-2. Edit `default.config`.
 3. Call some tasks:
-    ```bash
+    ```sh
     cbuild build_exec_dbg exec
     ```
+P.S. See help
+```sh
+cbuild -h
+```

bootstrap.sh

@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+CBUILD_BOOTSTRAP_VERSION=1.0.1
+set -eo pipefail
+
+function version_parse {
+    local value="$1"
+    var_name="$2"
+    IFS_backup="$IFS"
+    IFS='.'
+    local v_array=($value)
+    IFS="$IFS_backup"
+    eval ${var_name}_version_major=${v_array[0]}
+    eval ${var_name}_version_minor=${v_array[1]}
+    eval ${var_name}_version_patch=${v_array[2]}
+}
+
+function safeprint {
+    printf "%s" "$@"
+}
+
+function exec_script_line {
+    local script="$1"
+    local line_num="$2"
+    local line_str="$(sed $line_num'!d' $script)"
+    if [ -z "$line_str" ]; then
+        echo "script line is empty"
+        exit 1
+    fi
+    eval "$line_str"
+}
+
+function print_version_list {
+    dir_local="$HOME/.local/share/cbuild"
+    dir_global="/usr/local/share/cbuild"
+    files=""
+    if [ -d "$dir_local" ]; then
+        files+="$(find $dir_local -name 'CBUILD_VERSION')"
+    fi
+    if [ -d "$dir_global" ]; then
+        files+="$(find $dir_global -name 'CBUILD_VERSION')"
+    fi
+    for f in $files; do
+        cat $f | sed '$a\'
+    done | sort -V
+}
+
+function print_help {
+    echo "cbuild-bootstrap v$CBUILD_BOOTSTRAP_VERSION"
+    echo "Script that launches a specific cbuild version selected by user or defined in a project config."
+    echo "Usage: cbuild [OPTIONS]"
+    echo "Options:"
+    echo "    -h, --help         Show this message"
+    echo "    -v, --version      Shows version"
+    echo "    -c, --config FILE  Set project config file path (default=./project.config)"
+    echo "    --list-versions    Shows list of installed cbuild versions"
+}
+
+# parse command line arguments
+project_config_path="./project.config"
+args=($@)
+args_count=${#args[@]}
+i=0
+if [ $args_count -eq 0 ]; then
+    print_help
+fi
+while [ $i -lt $args_count ]
+do
+    case "${args[i]}" in
+        '-v' | '--version')
+            echo "cbuild-bootstrap v$CBUILD_BOOTSTRAP_VERSION"
+            ;;
+        '-h' | '--help')
+            print_help
+            ;;
+        '-c' | '--config')
+            i=$((i+1))
+            project_config_path="${args[i]}"
+            ;;
+        '--list-versions')
+            print_version_list
+            exit 0
+            ;;
+        *)
+            ;;
+    esac
+    i=$((i+1))
+done
+
+if [ -z "$CBUILD_VERSION" ]; then
+    if [ -f "$project_config_path" ]; then
+        # read version from project config
+        exec_script_line "$project_config_path" 2
+    else
+        echo "project config not found"
+        echo "list of installed cbuild versions:"
+        versions=$(print_version_list)
+
+        echo "$versions"
+        latest_version=$(echo "$versions" | tail -n 1)
+        echo "select version (default=$latest_version):"
+        read -r CBUILD_VERSION
+        [ -z "$CBUILD_VERSION" ] && CBUILD_VERSION=$latest_version
+    fi
+fi
+
+version_parse "$CBUILD_VERSION"
+cbuild_ommand="cbuild${_version_major}.${_version_minor} $@"
+
+LOG_FILE="$(realpath cbuild.log)"
+set +eo pipefail
+# enable logging stdout and stderr to file
+$cbuild_ommand 2>&1 | tee "$LOG_FILE"
+# log file can be deleted by clean task
+if [ -f "$LOG_FILE" ]; then
+    # remove terminal escape codes
+    sed -e 's/[^[:blank:][:print:]]//g' \
+        -e 's/\[0;[0-9][0-9]m//g' \
+        -e 's/\[0;[0-9]m//g' \
+        -e 's/\[[0-9][0-9]m//g' \
+        -e 's/\[[0-9]m//g' \
+        -e 's/  H  //g' \
+        -e 's/\[3gH  //g' \
+        -i "$LOG_FILE"
+fi

cbuild.sh

@@ -1,14 +1,34 @@
 #!/usr/bin/env bash
+INSTALLED_CBUILD_VERSION=2.1.4
 
+# set \t size to 4 spaces
 tabs 4
 
 # exit on errors
 set -eo pipefail
 
-INSTALLED_CBUILD_VERSION=2.0.2
+function version_parse {
+    local value="$1"
+    var_name="$2"
+    IFS_backup="$IFS"
+    IFS='.'
+    local v_array=($value)
+    IFS="$IFS_backup"
+    eval ${var_name}_version_major=${v_array[0]}
+    eval ${var_name}_version_minor=${v_array[1]}
+    eval ${var_name}_version_patch=${v_array[2]}
+}
 
+version_parse $INSTALLED_CBUILD_VERSION installed
 if [ -z "$CBUILD_INSTALL_DIR" ]; then
-    CBUILD_INSTALL_DIR="/usr/local/share/cbuild"
+    CBUILD_INSTALL_DIR="$HOME/.local/share/cbuild/${installed_version_major}.${installed_version_minor}"
+    if [ ! -f "$CBUILD_INSTALL_DIR/cbuild.sh" ]; then
+        CBUILD_INSTALL_DIR="/usr/local/share/cbuild/${installed_version_major}.${installed_version_minor}"
+        if [ ! -f "$CBUILD_INSTALL_DIR/cbuild.sh" ]; then
+            echo "CBUILD_INSTALL_DIR '$CBUILD_INSTALL_DIR' doesn't exist" 
+            exit 1
+        fi
+    fi
 fi
 
 function include {
@@ -27,62 +47,60 @@ include "cbuild/config.sh"
 function print_help {
     myprint "cbuild v$INSTALLED_CBUILD_VERSION"
     myprint "C/C++ project build system written in bash."
-    myprint "Usage: cbuild [OPTIONS] [TASK]"
+    myprint "Usage: cbuild [OPTIONS] [TASKS]"
-    myprint "    -h, --help                     Show this message"
+    myprint "Options:"
-    myprint "    -v, --version                     Shows version"
+    myprint "    -h, --help               Show this message"
-    myprint "    -n, --new-project  [PROJ_DIR]  Initialize new cbuild project directory (default=./)"
+    myprint "    -v, --version            Shows version"
-    myprint "    -c, --current-config  FILE     Set current config file path (default=./current.config)"
+    myprint "    -c, --config FILE        Set project config file path (default=./project.config)"
-    myprint "    -d, --default-config  FILE     Set default config file path (default=./current.config)"
+    myprint "    -n, --new-project [DIR]  Initialize new cbuild project directory (default=./)"
 }
 
-current_config_path="./current.config"
+# parse command line arguments
-default_config_path="./default.config"
+project_config_path="./project.config"
 args=($@)
 args_count=${#args[@]}
 selected_tasks_array=()
 i=0
 if [ $args_count -eq 0 ]; then
     print_help
+    exit 1
 fi
 
-function get_next_arg {
-    i=$((i+1))
-    safeprint "${args[i]}"
-}
-
 while [ $i -lt $args_count ]
 do
     case "${args[i]}" in
         '-h' | '--help')
             print_help
+            exit 0
             ;;
         '-v' | '--version')
-            myprint $INSTALLED_CBUILD_VERSION
+            myprint "cbuild v$INSTALLED_CBUILD_VERSION"
+            exit 0
             ;;
-        '-c' | '--current-config')
+        '-c' | '--config')
             i=$((i+1))
-            current_config_path="${args[i]}"
+            project_config_path="${args[i]}"
-            myprint "<$current_config_path>"
-            exit
-            ;;
-        '-d' | '--default-config')
-            default_config_path="$(get_next_arg)"
             ;;
         '-n' | '--new-project')
-            new_project_dir="$(get_next_arg)"
+            i=$((i+1))
+            new_project_dir="${args[i]}"
             if [ -z "$new_project_dir" ]; then
-                new_project_dir="./"
+                new_project_dir="."
+            else
+                mkdir -p "$new_project_dir"
             fi
-            
+            if ask_yn "create default cbuild project config?"; then
-            if ask_yn "create default.config?"; then
+                project_config_path="$new_project_dir/project.config"
-                cp "$CBUILD_INSTALL_DIR/default.config" "$new_project_dir"
+                cp "$CBUILD_INSTALL_DIR/default.config" "$project_config_path"
                 myprint "Enter project name: "
                 read -r project_name
-                sed -i "s,\%PROJECT_NAME\%,$project_name,g" "default.config"
+                sed -i "s,\%PROJECT_NAME\%,$project_name,g" "$project_config_path"
+                myprint "${GREEN}created config at '$project_config_path'"
             fi
             if ask_yn "Copy default .gitignore?"; then
-                cp "$CBUILD_INSTALL_DIR/.gitignore" "$new_project_dir"
+                cp "$CBUILD_INSTALL_DIR/.gitignore" "$new_project_dir/"
             fi
+            exit 0
             ;;
         *)
             selected_tasks_array+=(${args[i]})
@@ -92,13 +110,12 @@ do
 done
 
 function call_task {
-    local current_config_path="$1"
+    local project_config_path="$1"
-    local default_config_path="$2"
+    local task="$2"
-    local task="$3"
+    TASK_ARGS="$3"
-    TASK_ARGS="$4"
 
     print_header "${CYAN}" "─" "$PROJECT/$task"
-    load_config "$current_config_path" "$default_config_path" "$task" true
+    load_config "$project_config_path" "$task" true
 
     if [ ! -z "$PRE_TASK_SCRIPT" ]; then
         myprint "${BLUE}executing ${WHITE}$TASK_SCRIPT"
@@ -116,7 +133,7 @@ function call_task {
 
 function call_tasks {
     local tasks="$@"
-    load_config "$current_config_path" "$default_config_path" "" false
+    load_config "$project_config_path" "" false
     print_header "${WHITE}" "═" "$PROJECT"
     project_dir="$(pwd)"
     for task_str in $tasks ; do
@@ -126,7 +143,7 @@ function call_tasks {
         IFS=',;'
         args_array=($args_str)
         IFS="$IFS_backup"
-        call_task "$current_config_path" "$default_config_path" "$task" "${args_array[@]}"
+        call_task "$project_config_path" "$task" "${args_array[@]}"
         cd "$project_dir"
     done
 }

config.sh

@@ -4,37 +4,18 @@ include cbuild/myprint.sh
 include cbuild/functions.sh
 include cbuild/detect_os.sh
 
-function myprint_quiet {
-    local quiet=$1
-    local text="$2"
-    if [ "$quiet" != true ]; then
-        myprint "$text"
-    fi
-}
-
-function exec_script_line {
-    local script="$1"
-    local line_num="$2"
-    local quiet=$3
-    myprint_quiet $quiet "${BLUE}reading line $line_num from $script"
-    local line_str="$(sed $line_num'!d' $script)"
-    myprint_quiet $quiet "$line_str"
-    eval "$line_str"
-}
-
 function load_config {
-    local current_config_path="$1"
+    local project_config_path="$1"
-    local default_config_path="$2"
+    TASK="$2"
-    TASK="$3"
+    local quiet=$3
-    local quiet=$4
 
-    myprint "${BLUE}loading config current='$(realpath $current_config_path)' default='$(realpath $default_config_path)'"
+    myprint "${BLUE}loading config ${WHITE}'$(realpath $project_config_path)'"
 
-    if [ -z "$current_config_path" ]; then
+    if [ -z "$project_config_path" ]; then
-        error "current_config_path is null"
+        error "config path is null"
     fi
-    if [ -z "$default_config_path" ]; then
+    if [ ! -f "$project_config_path" ]; then
-        error "default_config_path is null"
+        error "${YELLOW}$project_config_path doesn't exist"
     fi
 
     OS=$(detect_os)
@@ -45,42 +26,30 @@ function load_config {
         error "couldnt get current cbuild installation version"
     fi
 
-    # getting version of default config
-    exec_script_line "$default_config_path" 3 $quiet
-    DEFAULT_CONFIG_VERSION="$CONFIG_VERSION"
-    unset CONFIG_VERSION
-
     # undefined task
     [ -z "$TASK" ] && TASK="no_task"
 
-    # error on undefined
+    # getting cbuild version from config (CBUILD_VERSION declaration is at line 2)
-    set -u
+    exec_script_line "$project_config_path" 2 $quiet
 
-    # reading current config or creating default
+    myprint_quiet $quiet "${WHITE}${project_config_path} cbuild version: ${CYAN}$CBUILD_VERSION"
-    if [ ! -f "$current_config_path" ]; then
-        myprint "${YELLOW}$current_config_path doesn't exist"
-        cp "$default_config_path" "$current_config_path"
-        myprint "${YELLOW}Created copy (${current_config_path}) of default config (${default_config_path})"
-    fi
-
-    myprint_quiet $quiet "${BLUE}reading $current_config_path"
-    include "$current_config_path"
-
-    myprint_quiet $quiet "${WHITE}project: ${CYAN}$PROJECT"
-
-    myprint_quiet $quiet "${WHITE}${current_config_path} cbuild version: ${CYAN}$CBUILD_VERSION"
     myprint_quiet $quiet "${WHITE}installed cbuild version: ${CYAN}$INSTALLED_CBUILD_VERSION"
-    myprint_quiet $quiet "${WHITE}${current_config_path} version: ${CYAN}$CONFIG_VERSION"
-    myprint_quiet $quiet "${WHITE}${default_config_path} version: ${CYAN}$DEFAULT_CONFIG_VERSION"
 
     # checking versions
-    if [ "$CBUILD_VERSION" != "$INSTALLED_CBUILD_VERSION" ]; then
+    version_parse $INSTALLED_CBUILD_VERSION installed
-        error "config was created for outdated cbuild version"
+    version_parse $CBUILD_VERSION config
+    if [ "$installed_version_major.$installed_version_minor" != "$config_version_major.$config_version_minor" ]; then
+        error "config was created for cbuild$config_version_major.$config_version_minor, but loaded whith cbuild$installed_version_major.$installed_version_minor which is incompatible"
     fi
-    if [ "$CONFIG_VERSION" != "$DEFAULT_CONFIG_VERSION" ]; then
+    if [[ $installed_version_patch < $config_version_patch ]]; then
-        error "current config version doesn't match default config version"
+        myprint "${YELLOW}New patch for cbuild$installed_version_major.$installed_version_minor is abaliable."
+        myprint "${YELLOW}Install it to get latest bugfixes."
     fi
 
+    # throw error on undefined variable usage
+    set -u
+    include "$project_config_path"
+
     mkdir -p "$OUTDIR"
     mkdir -p "$OBJDIR/objects"
     mkdir -p "$OBJDIR/static_libs"

default.config

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-CBUILD_VERSION=2.0.2
+CBUILD_VERSION=2.1.4
 CONFIG_VERSION=1
 
 PROJECT="%PROJECT_NAME%"
@@ -9,10 +9,8 @@ STD_C="c11"
 STD_CPP="c++11"
 WARN_C="-Wall -Wno-discarded-qualifiers -Wextra -Wno-unused-parameter"
 WARN_CPP="-Wall -Wextra -Wno-unused-parameter"
-SRC_C="$(    find src -name '*.c')"
+SRC_C="$(find src -name '*.c')"
-SRC_CPP="$(  find src -name '*.cpp')"
+SRC_CPP="$(find src -name '*.cpp')"
-TESTS_C="$(  find tests -name '*.c')"
-TESTS_CPP="$(find tests -name '*.cpp')"
 
 # Directory with dependency configs.
 # See cbuild/example_dependency_configs
@@ -113,7 +111,7 @@ case "$TASK" in
         ;;
     # executes $EXEC_FILE with valgrind memory checker
     valgrind)  
-        VALGRIND_ARGS="-s --read-var-info=yes --track-origins=yes --fullpath-after=$(pwd) --leak-check=full --show-leak-kinds=all" 
+        VALGRIND_ARGS="-s --read-var-info=yes --track-origins=yes --fullpath-after=$(pwd)/ --leak-check=full --show-leak-kinds=all" 
         TASK_SCRIPT=cbuild/default_tasks/valgrind.sh
         ;;
     # generates profiling info
@@ -155,9 +153,9 @@ case "$TASK" in
         C_ARGS="-O2 -flto=auto -fuse-linker-plugin"
         CPP_ARGS="$C_ARGS"
         LINKER_ARGS="$CPP_ARGS"
-        PRE_TASK_SCRIPT=tasks/pre_build.sh
+        PRE_TASK_SCRIPT=cbuild/default_tasks/build_exec.sh
-        TASK_SCRIPT=cbuild/default_tasks/build_exec.sh
+        TASK_SCRIPT=cbuild/default_tasks/callgrind.sh
-        POST_TASK_SCRIPT=cbuild/default_tasks/callgrind.sh
+        POST_TASK_SCRIPT=
         ;;
     # compiles executable with sanitizers and executes it to find errors and warnings
     sanitize)

default_tasks/build_exec.sh

@@ -15,6 +15,6 @@ else
     done
 fi
 
-compile_c "$C_ARGS" "$SRC_C $TESTS_C"
+[ ! -z "$SRC_C" ] && compile_c "$CMP_C" "$STD_C" "$WARN_C" "$C_ARGS" "$INCLUDE" "$SRC_C"
-compile_cpp "$CPP_ARGS" "$SRC_CPP $TESTS_CPP"
+[ ! -z "$SRC_CPP" ] && compile_cpp "$CMP_CPP" "$STD_CPP" "$WARN_CPP" "$CPP_ARGS" "$INCLUDE" "$SRC_CPP"
 link "$LINKER_ARGS" "$EXEC_FILE"

default_tasks/build_shared_lib.sh

@@ -2,6 +2,6 @@
 
 # delete old objects
 clean_dir "$OBJDIR/objects"
-compile_c "$C_ARGS" "$SRC_C"
+[ ! -z "$SRC_C" ] && compile_c "$CMP_C" "$STD_C" "$WARN_C" "$C_ARGS" "$INCLUDE" "$SRC_C"
-compile_cpp "$CPP_ARGS" "$SRC_CPP"
+[ ! -z "$SRC_CPP" ] && compile_cpp "$CMP_CPP" "$STD_CPP" "$WARN_CPP" "$CPP_ARGS" "$INCLUDE" "$SRC_CPP"
 link "$LINKER_ARGS" "$SHARED_LIB_FILE"

default_tasks/build_static_lib.sh

@@ -2,6 +2,6 @@
 
 # delete old objects
 clean_dir "$OBJDIR/objects"
-compile_c "$C_ARGS" "$SRC_C"
+[ ! -z "$SRC_C" ] && compile_c "$CMP_C" "$STD_C" "$WARN_C" "$C_ARGS" "$INCLUDE" "$SRC_C"
-compile_cpp "$CPP_ARGS" "$SRC_CPP"
+[ ! -z "$SRC_CPP" ] && compile_cpp "$CMP_CPP" "$STD_CPP" "$WARN_CPP" "$CPP_ARGS" "$INCLUDE" "$SRC_CPP"
 pack_static_lib "$STATIC_LIB_FILE" 

example_dependency_configs/libexample1.config

@@ -6,5 +6,8 @@ DEP_POST_BUILD_COMMAND=''
 DEP_CLEAN_COMMAND='make clean'
 # won't be copied to project $OUTDIR
 DEP_STATIC_OUT_FILES='libexample1.a libexample1_addon.a'
-# will be copied tp project $OUTDIR
+PRESERVE_OUT_DIRECTORY_STRUCTURE=false;
+# will be copied to project $OUTDIR
 DEP_DYNAMIC_OUT_FILES='libexample1.config.json'
+# will be copied to project $OUTDIR
+DEP_OTHER_OUT_FILES=''

example_dependency_configs/libexample2.config

@@ -4,14 +4,17 @@ DEP_PRE_BUILD_COMMAND=''
 DEP_POST_BUILD_COMMAND=''
 DEP_CLEAN_COMMAND='make clean'
 DEP_STATIC_OUT_FILES=''
+DEP_OTHER_OUT_FILES=''
 case $OS in
     WINDOWS)
-        DEP_BUILD_COMMAND='make libexample2.dll'
+        DEP_BUILD_COMMAND='make libexample2.dll && mkdir -p win-x64 && mv libexample.dll win-x64'
-        DEP_DYNAMIC_OUT_FILES='libexample2.dll'
+        DEP_DYNAMIC_OUT_FILES='win-x64/libexample2.dll'
+        PRESERVE_OUT_DIRECTORY_STRUCTURE=true # library will be copied to $OUTDIR/win-x64
         ;;
     LINUX)
-        DEP_BUILD_COMMAND='make libexample2.so'
+        DEP_BUILD_COMMAND='make libexample2.so && mkdir -p linux-x64 && mv libexample.so linux-x64'
-        DEP_DYNAMIC_OUT_FILES='libexample2.so'
+        DEP_DYNAMIC_OUT_FILES='linux-x64/libexample2.so'
+        PRESERVE_OUT_DIRECTORY_STRUCTURE=true # library will be copied to $OUTDIR/linux-x64
         ;;
     *)
         error "operating system $OS has no configuration variants"

functions.sh

@@ -2,6 +2,19 @@
 
 include "cbuild/myprint.sh"
 
+function exec_script_line {
+    local script="$1"
+    local line_num="$2"
+    local quiet=$3
+    myprint_quiet $quiet "${BLUE}reading line $line_num from $script"
+    local line_str="$(sed $line_num'!d' $script)"
+    if [ -z "$line_str" ]; then
+        error "script line is empty"
+    fi
+    myprint_quiet $quiet "$line_str"
+    eval "$line_str"
+}
+
 function clean_dir {
     local dir="$1"
 	myprint "${WHITE}cleaning $dir"
@@ -51,7 +64,7 @@ function build_dependency {
 
     local build_needed="$force_build"
     if [ "$build_needed" != true ]; then
-        for file in $DEP_STATIC_OUT_FILES $DEP_DYNAMIC_OUT_FILES; do
+        for file in $DEP_STATIC_OUT_FILES $DEP_DYNAMIC_OUT_FILES $DEP_OTHER_OUT_FILES; do
             if [ ! -f "$file" ]; then
                 myprint "${GRAY}missing file '$file'"
                 local build_needed=true
@@ -69,21 +82,55 @@ function build_dependency {
     fi
 
     if [ ! -z "$DEP_DYNAMIC_OUT_FILES" ]; then
-        # copy each file to $OUTDIR
+        # copies each file to $OUTDIR and creates symbolic link in $OBJDIR/dynamic_libs
-        cp -rv $DEP_DYNAMIC_OUT_FILES "$proj_root_dir/$OUTDIR"
-        # symlink each file to $OBJDIR/dynamic_libs
         for file in $DEP_DYNAMIC_OUT_FILES; do
-            ln -sfv $(realpath $file) "$proj_root_dir/$OBJDIR/dynamic_libs"
+            # doesnt return error if called not like this
+            real_file=$(realpath $file)
+            file_dir=$(dirname $file)
+            if [ "$PRESERVE_OUT_DIRECTORY_STRUCTURE" = true ] && [ "$file_dir" != '.' ]; then
+                mkdir -p "$proj_root_dir/$OUTDIR/$file_dir"
+                mkdir -p "$proj_root_dir/$OBJDIR/dynamic_libs/$file_dir"
+                cp -v "$file" "$proj_root_dir/$OUTDIR/$file"
+                ln -sfv "$real_file" "$proj_root_dir/$OBJDIR/dynamic_libs/$file"
+            else
+                cp -v "$file" "$proj_root_dir/$OUTDIR/"
+                ln -sfv "$real_file" "$proj_root_dir/$OBJDIR/dynamic_libs/"
+            fi
+        done
+    fi
+    if [ ! -z "$DEP_OTHER_OUT_FILES" ]; then
+        # copies each file to $OUTDIR
+        for file in $DEP_OTHER_OUT_FILES; do
+            if [ "$PRESERVE_OUT_DIRECTORY_STRUCTURE" = true ]; then
+                file_dir=$(dirname $file)
+                mkdir -p "$proj_root_dir/$OUTDIR/$file_dir"
+                cp -v "$file" "$proj_root_dir/$OUTDIR/$file"
+            else
+                cp -v "$file" "$proj_root_dir/$OUTDIR/"
+            fi
         done
     fi
     if [ ! -z "$DEP_STATIC_OUT_FILES" ]; then
-        # symlink each file to $OBJDIR/static_libs
+        # creates symbolic link to each file in $OBJDIR/static_libs
         for file in $DEP_STATIC_OUT_FILES; do
-            ln -sfv $(realpath $file) "$proj_root_dir/$OBJDIR/static_libs"
+            # doesnt return error if called not like this
+            f=$(realpath $file)
+            ln -sfv $f "$proj_root_dir/$OBJDIR/static_libs"
         done
     fi
     
     cd "$proj_root_dir"
+
+    # unsed all dependency config variables to not mess with next dependencies
+    unset DEP_WORKING_DIR
+    unset DEP_PRE_BUILD_COMMAND
+    unset DEP_BUILD_COMMAND
+    unset DEP_POST_BUILD_COMMAND
+    unset DEP_CLEAN_COMMAND
+    unset DEP_STATIC_OUT_FILES
+    unset PRESERVE_OUT_DIRECTORY_STRUCTURE
+    unset DEP_DYNAMIC_OUT_FILES
+    unset DEP_OTHER_OUT_FILES
 }
 
 function build_dependencies {
@@ -103,16 +150,16 @@ function compile {
     print_hline "${BLUE}" "─"
 
     local cmp="$1"
-    myprint "${BLUE}compiler: ${GRAY}$cmp"
     local std="$2"
-    myprint "${BLUE}standard: ${GRAY}$std"
     local warn="$3"
-    myprint "${BLUE}warnings: ${GRAY}$warn"
     local args="$4"
-    myprint "${BLUE}args: ${GRAY}$args"
     local include="$5"
-    myprint "${BLUE}include dirs: ${GRAY}$include"
     local sources="$6"
+    myprint "${BLUE}compiler: ${GRAY}$cmp"
+    myprint "${BLUE}standard: ${GRAY}$std"
+    myprint "${BLUE}warnings: ${GRAY}$warn"
+    myprint "${BLUE}args: ${GRAY}$args"
+    myprint "${BLUE}include dirs: ${GRAY}$include"
     myprint "${BLUE}sources: ${GRAY}$sources"
 	for srcfile in $sources
     do (
@@ -128,14 +175,26 @@ function compile {
 
 # (args, sources)
 function compile_c {
+    local cmp="$1"
+    local std="$2"
+    local warn="$3"
+    local args="$4"
+    local include="$5"
+    local sources="$6"
     print_header "${CYAN}" "─" "$PROJECT/$TASK/compile_c"
-    compile "$CMP_C" "$STD_C" "$WARN_C" "$1" "$INCLUDE" "$2"
+    compile "$cmp" "$std" "$warn" "$args" "$include" "$sources"
 }
 
 # (args, sources)
 function compile_cpp {
+    local cmp="$1"
+    local std="$2"
+    local warn="$3"
+    local args="$4"
+    local include="$5"
+    local sources="$6"
     print_header "${CYAN}" "─" "$PROJECT/$TASK/compile_cpp"
-    compile "$CMP_CPP" "$STD_CPP" "$WARN_CPP" "$1" "$INCLUDE" "$2"
+    compile "$cmp" "$std" "$warn" "$args" "$include" "$sources"
 }
 
 # (outfile)
@@ -143,8 +202,13 @@ function pack_static_lib {
     print_header "${CYAN}" "─" "$PROJECT/$TASK/pack_static_lib"
     local outfile="$1"
     myprint "${BLUE}outfile: ${GRAY}$outfile"
-    local objects="$(find $OBJDIR/objects -type f,l | tr '\n' ' ')"
+    
+    local objects=$(find $OBJDIR/objects -type f,l | tr '\n' ' ')
     myprint "${BLUE}objects: ${GRAY}$objects"
+    if [ -z "$objects" ]; then
+        error "no compiled objects found"
+    fi
+
     local command="ar rcs $OUTDIR/$outfile  $objects"
     myprint "$command"
     if $command
@@ -153,6 +217,7 @@ function pack_static_lib {
     else
         error "some error happened"
     fi
+    clean_dir "$OBJDIR/objects"
 }
 
 function link {
@@ -161,16 +226,24 @@ function link {
     local outfile="$2"
     myprint "${BLUE}args: ${GRAY}$args"
     myprint "${BLUE}outfile: ${GRAY}$outfile"
-    local objects="$(find $OBJDIR/objects -type f,l | tr '\n' ' ')"
+
+    local objects=$(find $OBJDIR/objects -type f,l | tr '\n' ' ')
     myprint "${BLUE}objects: ${GRAY}$objects"
-    local static_libs="$(find $OBJDIR/static_libs -type f,l | tr '\n' ' ')"
+    if [ -z "$objects" ]; then
+        error "no compiled objects found"
+    fi
+
+    local static_libs=$(find $OBJDIR/static_libs -type f,l | tr '\n' ' ')
     myprint "${BLUE}static libraries: ${GRAY}$static_libs"
-    local dynamic_libs="$(find $OBJDIR/dynamic_libs -type f,l | tr '\n' ' ')"
+
+    local dynamic_libs=$(find $OBJDIR/dynamic_libs -type f,l | tr '\n' ' '\
+        | sed "s,$OBJDIR/dynamic_libs/,,g")
     myprint "${BLUE}dynamic libraries: ${GRAY}$dynamic_libs"
-    local dynamic_libs_args="-L $OBJDIR/dynamic_libs"
+    local dynamic_libs_args="-L./$OBJDIR/dynamic_libs -Wl,-Bdynamic"
     for lib in $dynamic_libs; do
-        dynamic_libs_args="$dynamic_libs_args -l:$lib"
+        dynamic_libs_args="$dynamic_libs_args -Wl,-rpath=$(dirname $lib) -l:$lib"
     done
+
     local command="$CMP_CPP $objects $static_libs $args $dynamic_libs_args -o $OUTDIR/$outfile"
     myprint "$command"
     if $command
@@ -179,4 +252,5 @@ function link {
     else
         error "some error happened"
     fi
+    clean_dir "$OBJDIR/objects"
 }

myprint.sh

@@ -21,6 +21,14 @@ function myprint {
     printf "${GRAY}$@${GRAY}\n"
 }
 
+function myprint_quiet {
+    local quiet=$1
+    local text="$2"
+    if [ "$quiet" != true ]; then
+        myprint "$text"
+    fi
+}
+
 # print message and exit
 function error {
     myprint "${RED}$@"
@@ -36,6 +44,16 @@ function ask_yn {
     return $([[ "$answ" = [Yy] ]]); 
 }
 
+function char_multiply {
+    local character="$1"
+    local length="$2"
+    i=0
+    while [ $i -lt $length ]; do
+        printf $character
+        i=$((i+1))
+    done
+}
+
 # prints horizontal line occupying whole terminal row
 # https://en.wikipedia.org/wiki/Box-drawing_characters
 function print_hline {
@@ -47,7 +65,10 @@ function print_hline {
     if [ -z "$character" ]; then
         character="-";
     fi
-    printf "${color}%.s${character}" $(seq 2 $(tput cols))
+    local term_width=$(tput cols)
+    local line_length=$((term_width - 1))
+    printf "${color}"
+    char_multiply "$character" $line_length
     printf "${GRAY}\n"
 }
 
@@ -65,10 +86,11 @@ function print_header {
     local term_width=$(tput cols)
     local label_length=${#label}
     local line_characters_count=$((term_width - label_length - 2))
-    local letf_line_length=$(( line_characters_count / 2 ))
+    local left_line_length=$(( line_characters_count / 2 ))
-    local right_line_length=$(( letf_line_length + line_characters_count % 2 ))
+    local right_line_length=$(( left_line_length - 1 + line_characters_count % 2 ))
-    printf "${color}%.s${character}" $(seq 1 $letf_line_length)
+    printf "${color}"
-    printf "[${label}]"
+    char_multiply "$character" $left_line_length
-    printf "${color}%.s${character}" $(seq 2 $right_line_length)
+    printf "[${label}]${color}"
+    char_multiply "$character" $right_line_length
     printf "${GRAY}\n"
 }

setup.sh

@@ -1,15 +1,74 @@
 #!/usr/bin/env bash
+# USAGE: ./setup.sh             install cbuild to /usr/local
+#        ./setup.sh --local     install cbuild to $HOME/.local
 
 # exit on errors
-set -eo pipefail
+set -xeo pipefail
-set -x
+CBUILD_VERSION=$(<CBUILD_VERSION)
 
+function version_parse {
+    local value="$1"
+    var_name="$2"
+    IFS_backup="$IFS"
+    IFS='.'
+    local v_array=($value)
+    IFS="$IFS_backup"
+    eval ${var_name}_version_major=${v_array[0]}
+    eval ${var_name}_version_minor=${v_array[1]}
+    eval ${var_name}_version_patch=${v_array[2]}
+}
+
+function exec_script_line {
+    local script="$1"
+    local line_num="$2"
+    local line_str="$(sed $line_num'!d' $script)"
+    if [ -z "$line_str" ]; then
+        echo "script line is empty"
+        exit 1
+    fi
+    eval "$line_str"
+}
+
+version_parse $CBUILD_VERSION local
 if [ -z "$CBUILD_INSTALL_DIR" ]; then
-    CBUILD_INSTALL_DIR="/usr/local/share/cbuild"
+    if [ "$1" = "--local" ]; then
+        if [ ! -d "$HOME" ]; then
+            echo "ERROR: home directory '$HOME' doesn't exist"
+            exit 1
+        fi
+        CBUILD_INSTALL_DIR="$HOME/.local/share/cbuild/${local_version_major}.${local_version_minor}"
+        CBUILD_BIN_DIR="$HOME/.local/bin"
+        mkdir -p "$HOME/.local"
+        mkdir -p "$HOME/.local/share"
+        mkdir -p "$HOME/.local/share/cbuild"
+        mkdir -p "$HOME/.local/bin"
+    else
+        CBUILD_INSTALL_DIR="/usr/local/share/cbuild/${local_version_major}.${local_version_minor}"
+        CBUILD_BIN_DIR="/usr/local/bin"
+        mkdir -p "/usr/local/share"
+        mkdir -p "/usr/local/share/cbuild"
+        mkdir -p "/usr/local/bin"
+    fi
 fi
 
-if [ "$CBUILD_INSTALL_DIR" != "." ]; then
+rm -rf "$CBUILD_INSTALL_DIR"
-    cp -r ./ "$CBUILD_INSTALL_DIR"
+cp -r ./ "$CBUILD_INSTALL_DIR"
-    rm -rf "$CBUILD_INSTALL_DIR/.git"
+rm -rf "$CBUILD_INSTALL_DIR/.git"
+ln -sf "$(realpath $CBUILD_INSTALL_DIR/cbuild.sh)" -T "$CBUILD_BIN_DIR/cbuild${local_version_major}.${local_version_minor}"
+
+bootstrap_install_path="$CBUILD_INSTALL_DIR/../bootstrap.sh"
+if [ -f "$bootstrap_install_path" ]; then
+    exec_script_line "$bootstrap_install_path" 2
+    installed_bootstrap_version=$CBUILD_BOOTSTRAP_VERSION
+    installed_bootstrap_version_int=$(echo $installed_bootstrap_version | sed 's/\.//g')
+    exec_script_line "./bootstrap.sh" 2
+    local_bootstrap_version=$CBUILD_BOOTSTRAP_VERSION
+    local_bootstrap_version_int=$(echo $local_bootstrap_version | sed 's/\.//g')
+    
+    if [[ $local_bootstrap_version_int > $installed_bootstrap_version_int ]]; then
+        ln -sf "$(realpath $CBUILD_INSTALL_DIR/bootstrap.sh)" -T "$bootstrap_install_path"
+    fi
+else
+    ln -sf "$(realpath $CBUILD_INSTALL_DIR/bootstrap.sh)" -T "$bootstrap_install_path"
 fi
-ln -sf "$(realpath $CBUILD_INSTALL_DIR/cbuild.sh)" -T "/usr/local/bin/cbuild"
+ln -sf "$(realpath $bootstrap_install_path)" -T "$CBUILD_BIN_DIR/cbuild"