kit

common.sh (5517B)

---

 #!/bin/sh
 
 set -eu
 
 : "${KIT:=./build/kit}"
 
 c_source() {
     "$KIT" build source "$1"
 }
 
 c_config() {
     key=$1
     def=$2
     "$KIT" build config-get --default "$def" "$key"
 }
 
 c_config_merge() {
     key=$1
     def=$2
     profile=$(c_config profile "")
     base=$(c_config "$key" "$def")
     prof=""
     extra=$(c_config "$key.extra" "")
     if [ -n "$profile" ]; then
         prof=$(c_config "profile.$profile.$key" "")
     fi
     printf '%s\n' "$base $prof $extra" | awk '{$1=$1; print}'
 }
 
 c_toolchain_init() {
     C_CC=$(c_config tool.c.cc "$(c_config cc "${CC:-cc}")")
     C_AR=$(c_config tool.c.ar "$(c_config ar "${AR:-ar}")")
     C_CFLAGS=$(c_config_merge tool.c.cflags "")
     C_LDFLAGS=$(c_config_merge tool.c.ldflags "")
     C_LDLIBS=$(c_config_merge tool.c.ldlibs "")
 }
 
 c_glob() {
     "$KIT" build glob "$1"
 }
 
 c_depfile() {
     if [ -s "$1" ]; then
         dep=$1
         if command -v c_depfile_filter >/dev/null 2>&1; then
             norm="$dep.norm"
             c_depfile_filter "$dep" > "$norm"
             dep=$norm
         fi
         "$KIT" build depfile "$dep" >/dev/null
         rm -f "$1" "${1}.norm"
     fi
 }
 
 c_compile() {
     src=$1
     obj=$2
     flags=$3
     mkdir -p "$(dirname "$obj")"
     dep="$obj.d"
     "$C_CC" $C_CFLAGS $flags -MMD -MP -MF "$dep" -c "$src" -o "$obj"
     c_depfile "$dep"
 }
 
 c_need() {
     label=$1
     case "$label" in
         :*|//*|@*) "$KIT" build need "$label" ;;
         *) "$KIT" build need ":$label" ;;
     esac
 }
 
 c_target_local() {
     if [ -n "${KIT_BUILD_LOCAL:-}" ]; then
         printf '%s\n' "$KIT_BUILD_LOCAL"
     else
         printf '%s\n' "${KIT_BUILD_TARGET##*:}"
     fi
 }
 
 c_require_hook() {
     if ! command -v "$1" >/dev/null 2>&1; then
         echo "missing C rule hook: $1" >&2
         exit 1
     fi
 }
 
 c_flags_init_default() {
     if command -v c_flags_init >/dev/null 2>&1; then
         c_flags_init
     else
         c_toolchain_init
     fi
 }
 
 c_default_object() {
     c_flags_init_default
     c_require_hook c_object_plan_find
     local=$(c_target_local)
     line=$(c_object_plan_find "$local") || {
         echo "no C object plan for target: $KIT_BUILD_TARGET" >&2
         exit 1
     }
 
     target=${line%%|*}
     rest=${line#*|}
     src=${rest%%|*}
     rest=${rest#*|}
     obj_rel=${rest%%|*}
     flags=${rest#*|}
 
     [ "$target" = "$local" ] || exit 1
 
     mkdir -p "$KIT_BUILD_OUT/obj"
     c_compile "$src" "$KIT_BUILD_OUT/obj/$local" "$flags"
     printf '%s\n' "obj/$local" > "$KIT_BUILD_OUT/object.list"
     printf '%s\n' "$obj_rel" > "$KIT_BUILD_OUT/object.rel"
     printf '%s\n' "$src" > "$KIT_BUILD_OUT/source.txt"
 }
 
 c_default_objects() {
     c_flags_init_default
     c_require_hook c_object_plan
     local=$(c_target_local)
     mkdir -p "$KIT_BUILD_OUT"
     objects="$KIT_BUILD_OUT/objects.list"
     : > "$objects"
 
     c_object_plan "$local" | while IFS='|' read -r _target src obj_rel flags; do
         [ -n "$src" ] || continue
         dst="$KIT_BUILD_OUT/$obj_rel"
         mkdir -p "$(dirname "$dst")"
         c_compile "$src" "$dst" "$flags"
         printf '%s\n' "$obj_rel" >> "$objects"
     done
 }
 
 c_default_archive() {
     c_flags_init_default
     c_require_hook c_archive_output
     c_require_hook c_archive_object_sets
     local=$(c_target_local)
     mkdir -p "$KIT_BUILD_OUT"
     archive=$(c_archive_output "$local")
     objects="$KIT_BUILD_OUT/archive-objects.list"
     : > "$objects"
 
     c_archive_object_sets "$local" | while IFS= read -r set_target; do
         [ -n "$set_target" ] || continue
         dep=$(c_need "$set_target")
         while IFS= read -r obj; do
             [ -n "$obj" ] || continue
             printf '%s/%s\n' "$dep" "$obj" >> "$objects"
         done < "$dep/objects.list"
     done
 
     rm -f "$KIT_BUILD_OUT/$archive"
     # shellcheck disable=SC2046
     "$C_AR" rcs "$KIT_BUILD_OUT/$archive" $(cat "$objects")
     rm -f "$objects"
 }
 
 c_default_executable() {
     c_flags_init_default
     c_require_hook c_executable_output
     local=$(c_target_local)
     mkdir -p "$KIT_BUILD_OUT"
     exe=$(c_executable_output "$local")
     objs=
     libs=
 
     if command -v c_executable_object_sets >/dev/null 2>&1; then
         for set_target in $(c_executable_object_sets "$local"); do
             dep=$(c_need "$set_target")
             while IFS= read -r obj; do
                 [ -n "$obj" ] || continue
                 objs="$objs $dep/$obj"
             done < "$dep/objects.list"
         done
     fi
 
     if command -v c_executable_libraries >/dev/null 2>&1; then
         c_executable_libraries "$local" | while IFS='|' read -r label file; do
             [ -n "$label" ] || continue
             dep=$(c_need "$label")
             printf '%s/%s\n' "$dep" "$file" >> "$KIT_BUILD_OUT/.link-libs"
         done
         if [ -f "$KIT_BUILD_OUT/.link-libs" ]; then
             while IFS= read -r lib; do
                 libs="$libs $lib"
             done < "$KIT_BUILD_OUT/.link-libs"
             rm -f "$KIT_BUILD_OUT/.link-libs"
         fi
     fi
 
     target_ldflags=""
     target_ldlibs=""
     if command -v c_executable_ldflags >/dev/null 2>&1; then
         target_ldflags=$(c_executable_ldflags "$local")
     fi
     if command -v c_executable_ldlibs >/dev/null 2>&1; then
         target_ldlibs=$(c_executable_ldlibs "$local")
     fi
 
     # shellcheck disable=SC2086
     "$C_CC" $C_LDFLAGS $target_ldflags -o "$KIT_BUILD_OUT/$exe" \
         $objs $libs $target_ldlibs $C_LDLIBS
 
     if command -v c_executable_after_link >/dev/null 2>&1; then
         c_executable_after_link "$local"
     fi
 }