mirror of
https://github.com/crosstool-ng/crosstool-ng.git
synced 2024-12-30 01:28:53 +00:00
766 lines
19 KiB
Bash
Executable File
766 lines
19 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
|
|
if [ "${BASH_VERSINFO[0]}" -lt 4 ]; then
|
|
echo "Your BASH shell version (${BASH_VERSION}) is too old." >&2
|
|
echo "Run bootstrap on a machine with BASH 4.x" >&2
|
|
exit 1
|
|
fi
|
|
|
|
########################################
|
|
# Common meta-language implementation. Syntax:
|
|
#
|
|
# The template file is processed line by line, with @@VAR@@ placeholders
|
|
# being replaced with a value of the VAR variable.
|
|
# Special lines start with '#!' and a keyword:
|
|
#
|
|
# #!//
|
|
# Comment, the rest of the line is ignored
|
|
# #!if COND
|
|
# Conditional: the lines until the matching #!end-if are processed
|
|
# only if the conditional COND evaluates to true.
|
|
# #!foreach NAME
|
|
# Iterate over NAME entities (the iterator must be set up first
|
|
# using the set_iter function), processing the lines until the matching
|
|
# #!end-foreach line.
|
|
|
|
declare -A info
|
|
|
|
debug()
|
|
{
|
|
if [ -n "${DEBUG}" ]; then
|
|
echo "DEBUG :: $@" >&2
|
|
fi
|
|
}
|
|
|
|
msg()
|
|
{
|
|
if [ -z "${QUIET}" ]; then
|
|
echo "INFO :: $@" >&2
|
|
fi
|
|
}
|
|
|
|
warn()
|
|
{
|
|
echo "WARN :: $@" >&2
|
|
}
|
|
|
|
error()
|
|
{
|
|
echo "ERROR :: $@" >&2
|
|
exit 1
|
|
}
|
|
|
|
find_end()
|
|
{
|
|
local token="${1}"
|
|
local count=1
|
|
|
|
# Skip first line, we know it has the proper '#!' command on it
|
|
endline=$[l + 1]
|
|
while [ "${endline}" -le "${end}" ]; do
|
|
case "${tlines[${endline}]}" in
|
|
"#!${token} "*)
|
|
count=$[count + 1]
|
|
;;
|
|
"#!end-${token}")
|
|
count=$[count - 1]
|
|
;;
|
|
esac
|
|
if [ "${count}" = 0 ]; then
|
|
return
|
|
fi
|
|
endline=$[endline + 1]
|
|
done
|
|
error "${template}:${l}: '${token}' token is unpaired"
|
|
}
|
|
|
|
set_iter()
|
|
{
|
|
local name="${1}"
|
|
local -a temp
|
|
|
|
if [ "${info[iter_${name}]+set}" = "set" ]; then
|
|
error "Iterator over '${name}' is already set up"
|
|
fi
|
|
shift
|
|
debug "Setting iterator over '${name}' to '$*'"
|
|
temp=("$@")
|
|
info[iter_${name}]="$*"
|
|
info[#${name}]=${#temp[@]}
|
|
}
|
|
|
|
run_if()
|
|
{
|
|
local cond="$*"
|
|
local endline
|
|
|
|
find_end "if"
|
|
if eval "${cond}"; then
|
|
debug "True conditional '${cond}' at lines ${l}..${endline}"
|
|
run_lines $[l + 1] $[endline - 1]
|
|
else
|
|
debug "False conditional '${cond}' at lines ${l}..${endline}"
|
|
fi
|
|
lnext=$[endline + 1]
|
|
debug "Continue at line ${lnext}"
|
|
}
|
|
|
|
do_foreach()
|
|
{
|
|
local var="${1}"
|
|
local -A saveinfo
|
|
local v k
|
|
|
|
shift
|
|
if [ "`type -t enter_${var}`" != "function" ]; then
|
|
error "No parameter setup routine for iterator over '${var}'"
|
|
fi
|
|
for v in ${info[iter_${var}]}; do
|
|
# This works in bash 4.4, but not in bash 4.3:
|
|
# local saveinfo=`declare -p info`
|
|
# ...
|
|
# eval "${saveinfo}"
|
|
# Therefore, need to save key-by-key
|
|
saveinfo=()
|
|
for k in "${!info[@]}"; do
|
|
saveinfo["${k}"]=${info["${k}"]}
|
|
done
|
|
if eval "enter_${var} ${v}"; then
|
|
eval "$@"
|
|
fi
|
|
info=()
|
|
for k in "${!saveinfo[@]}"; do
|
|
info["${k}"]=${saveinfo["${k}"]}
|
|
done
|
|
done
|
|
}
|
|
|
|
run_foreach()
|
|
{
|
|
local endline
|
|
local var="${1}"
|
|
shift
|
|
|
|
if [ "${info[iter_${var}]+set}" != "set" ]; then
|
|
error "${template}:${l}: iterator over '${var}' is not defined"
|
|
fi
|
|
find_end "foreach"
|
|
debug "Loop over '${var}', lines ${l}..${endline}"
|
|
do_foreach ${var} run_lines_if $[l + 1] $[endline - 1] "$*"
|
|
lnext=$[endline + 1]
|
|
debug "Continue at line ${lnext}"
|
|
}
|
|
|
|
run_lines_if()
|
|
{
|
|
local start="${1}"
|
|
local end="${2}"
|
|
shift 2
|
|
local cond="$*"
|
|
local a prev
|
|
|
|
for a in ${cond}; do
|
|
if [ -n "${prev}" ]; then
|
|
case "${prev}" in
|
|
if-differs)
|
|
if [ "${info[${a}]}" = "${saveinfo[${a}]}" ]; then
|
|
return
|
|
fi
|
|
;;
|
|
*)
|
|
error "${template}:${l}: unknown condition '${prev}' for loop"
|
|
;;
|
|
esac
|
|
prev=
|
|
else
|
|
prev=${a}
|
|
fi
|
|
done
|
|
run_lines "${start}" "${end}"
|
|
}
|
|
|
|
run_lines()
|
|
{
|
|
local start="${1}"
|
|
local end="${2}"
|
|
local l lnext s s1 v vp pp p val
|
|
|
|
debug "Running lines ${start}..${end}"
|
|
l=${start}
|
|
while [ "${l}" -le "${end}" ]; do
|
|
lnext=$[l+1]
|
|
s="${tlines[${l}]}"
|
|
# Expand @@foo@@ to ${info[foo]}. First escape variables/backslashes for evals below.
|
|
s="${s//\\/\\\\}"
|
|
s="${s//\$/\\\$}"
|
|
s1=
|
|
while [ -n "${s}" ]; do
|
|
case "${s}" in
|
|
*@@*@@*)
|
|
v="${s#*@@}"
|
|
v="${v%%@@*}"
|
|
# $v now includes variable name + any postprocessing
|
|
vp="${v%%[|?]*}"
|
|
pp="${v#${vp}}"
|
|
# $vp is name of the variable proper, $pp is any postprocessing
|
|
if [ "${info[${vp}]+set}" != "set" ]; then
|
|
error "${template}:${l}: reference to undefined variable '${vp}'"
|
|
fi
|
|
if [ "${info[${v}]+set}" != "set" ]; then
|
|
# We know the base variable, need to cache postprocessed value
|
|
val="${info[${vp}]}"
|
|
# Apply postprocessing(s)
|
|
while [ -n "${pp}" ]; do
|
|
case "${pp}" in
|
|
"|"*)
|
|
# Kconfigize
|
|
pp="${pp#|}"
|
|
val=${val//[^0-9A-Za-z_]/_}
|
|
val=${val^^}
|
|
;;
|
|
"?"*)
|
|
pp="${pp#?}"
|
|
p="${pp%%[|?]*}"
|
|
pp="${pp#${p}}"
|
|
val="${val:+${p}}"
|
|
;;
|
|
esac
|
|
done
|
|
info[${v}]="${val}"
|
|
fi
|
|
s1="${s1}${s%%@@*}\${info[${v}]}"
|
|
s="${s#*@@*@@}"
|
|
;;
|
|
*@@*)
|
|
error "${template}:${l}: non-paired @@ markers"
|
|
;;
|
|
*)
|
|
s1="${s1}${s}"
|
|
break
|
|
;;
|
|
esac
|
|
done
|
|
s=${s1}
|
|
|
|
debug "Evaluate: ${s}"
|
|
case "${s}" in
|
|
"#!if "*)
|
|
run_if ${s#* }
|
|
;;
|
|
"#!foreach "*)
|
|
run_foreach ${s#* }
|
|
;;
|
|
"#!//"*)
|
|
# Comment, do nothing
|
|
;;
|
|
"#!"*)
|
|
error "${template}:${l}: unrecognized command"
|
|
;;
|
|
*)
|
|
# Not a special command
|
|
eval "echo \"${s//\"/\\\"}\""
|
|
;;
|
|
esac
|
|
l=${lnext}
|
|
done
|
|
}
|
|
|
|
run_template()
|
|
{
|
|
local -a tlines
|
|
local src="${1}"
|
|
|
|
if [ ! -r "${src}" ]; then
|
|
error "Template '${src}' not found"
|
|
fi
|
|
template="${src}"
|
|
debug "Running template ${src}"
|
|
mapfile -O 1 -t tlines < "${src}"
|
|
run_lines 1 ${#tlines[@]}
|
|
}
|
|
|
|
########################################
|
|
|
|
# Leave only relevant portion of the string
|
|
relevantize()
|
|
{
|
|
local p pb pa vx
|
|
local v="${1}"
|
|
shift
|
|
|
|
# Find the first match and contract to the matching portion.
|
|
for p in "$@"; do
|
|
pb=${p%|*}
|
|
pa=${p#*|}
|
|
eval "vx=\${v#${pb}${pa}}"
|
|
if [ "${v%${pa}${vx}}" != "${v}" ]; then
|
|
v=${v%${pa}${vx}}
|
|
break
|
|
fi
|
|
done
|
|
echo "${v}"
|
|
}
|
|
|
|
# Helper for cmp_versions: compare an upstream/debian portion of
|
|
# a version. Returns 0 if equal, otherwise echoes "-1" or "1" and
|
|
# returns 1.
|
|
equal_versions()
|
|
{
|
|
local v1="${1}"
|
|
local v2="${2}"
|
|
local p1 p2
|
|
|
|
# Compare alternating non-numerical/numerical portions, until
|
|
# non-equal portion is found or either string is exhausted.
|
|
while [ -n "${v1}" -a -n "${v2}" ]; do
|
|
# Find non-numerical portions and compare lexicographically
|
|
p1="${v1%%[0-9]*}"
|
|
p2="${v2%%[0-9]*}"
|
|
v1="${v1#${p1}}"
|
|
v2="${v2#${p2}}"
|
|
#debug "lex [${p1}] v [${p2}]"
|
|
if [ "${p1}" \< "${p2}" ]; then
|
|
echo "-1"
|
|
return 1
|
|
elif [ "${p1}" \> "${p2}" ]; then
|
|
echo "1"
|
|
return 1
|
|
fi
|
|
#debug "rem [${v1}] v [${v2}]"
|
|
# Find numerical portions and compare numerically
|
|
p1="${v1%%[^0-9]*}"
|
|
p2="${v2%%[^0-9]*}"
|
|
v1="${v1#${p1}}"
|
|
v2="${v2#${p2}}"
|
|
#debug "num [${p1}] v [${p2}]"
|
|
if [ "${p1:-0}" -lt "${p2:-0}" ]; then
|
|
echo "-1"
|
|
return 1
|
|
elif [ "${p1:-0}" -gt "${p2:-0}" ]; then
|
|
echo "1"
|
|
return 1
|
|
fi
|
|
#debug "rem [${v1}] v [${v2}]"
|
|
done
|
|
if [ -n "${v1}" ]; then
|
|
echo "1"
|
|
return 1
|
|
elif [ -n "${v2}" ]; then
|
|
echo "-1"
|
|
return 1
|
|
fi
|
|
return 0
|
|
}
|
|
|
|
# Compare two version strings, similar to sort -V. But we don't
|
|
# want to depend on GNU sort availability on the host.
|
|
# See http://www.debian.org/doc/debian-policy/ch-controlfields.html
|
|
# for description of what the version is expected to be.
|
|
# Returns "-1", "0" or "1" if first version is earlier, same or
|
|
# later than the second.
|
|
cmp_versions()
|
|
{
|
|
local v1="${1}"
|
|
local v2="${2}"
|
|
local e1=0 e2=0 u1 u2 d1=0 d2=0
|
|
|
|
# Case-insensitive comparison
|
|
v1="${v1^^}"
|
|
v2="${v2^^}"
|
|
|
|
# Find if the versions contain epoch part
|
|
case "${v1}" in
|
|
*:*)
|
|
e1="${v1%%:*}"
|
|
v1="${v1#*:}"
|
|
;;
|
|
esac
|
|
case "${v2}" in
|
|
*:*)
|
|
e2="${v2%%:*}"
|
|
v2="${v2#*:}"
|
|
;;
|
|
esac
|
|
|
|
# Compare epochs numerically
|
|
if [ "${e1}" -lt "${e2}" ]; then
|
|
echo "-1"
|
|
return
|
|
elif [ "${e1}" -gt "${e2}" ]; then
|
|
echo "1"
|
|
return
|
|
fi
|
|
|
|
# Find if the version contains a "debian" part.
|
|
# v1/v2 will now contain "upstream" part.
|
|
case "${v1}" in
|
|
*-*)
|
|
d1=${v1##*-}
|
|
v1=${v1%-*}
|
|
;;
|
|
esac
|
|
case "${v2}" in
|
|
*-*)
|
|
d2=${v2##*-}
|
|
v2=${v2%-*}
|
|
;;
|
|
esac
|
|
|
|
# Compare upstream
|
|
if equal_versions "${v1}" "${v2}" && equal_versions "${d1}" "${d2}"; then
|
|
echo "0"
|
|
fi
|
|
}
|
|
|
|
# Sort versions, descending
|
|
sort_versions()
|
|
{
|
|
local sorted
|
|
local remains="$*"
|
|
local next_remains
|
|
local v vx found
|
|
|
|
while [ -n "${remains}" ]; do
|
|
#debug "Sorting [${remains}]"
|
|
for v in ${remains}; do
|
|
found=yes
|
|
next_remains=
|
|
#debug "Candidate ${v}"
|
|
for vx in ${remains}; do
|
|
#debug "${v} vs ${vx} :: `cmp_versions ${v} ${vx}`"
|
|
case `cmp_versions ${v} ${vx}` in
|
|
1)
|
|
next_remains+=" ${vx}"
|
|
;;
|
|
0)
|
|
;;
|
|
-1)
|
|
found=no
|
|
#debug "Bad: earlier than ${vx}"
|
|
break
|
|
;;
|
|
esac
|
|
done
|
|
if [ "${found}" = "yes" ]; then
|
|
# $v is less than all other members in next_remains
|
|
sorted+=" ${v}"
|
|
remains="${next_remains}"
|
|
#debug "Good candidate ${v} sorted [${sorted}] remains [${remains}]"
|
|
break
|
|
fi
|
|
done
|
|
done
|
|
echo "${sorted}"
|
|
}
|
|
|
|
read_file()
|
|
{
|
|
local l p
|
|
|
|
while read l; do
|
|
l="${p}${l}"
|
|
p=
|
|
case "${l}" in
|
|
"")
|
|
continue
|
|
;;
|
|
*\\)
|
|
p="${l%\\}"
|
|
continue
|
|
;;
|
|
"#"*)
|
|
continue
|
|
;;
|
|
*=*)
|
|
echo "info[${l%%=*}]=${l#*=}"
|
|
;;
|
|
*)
|
|
error "syntax error in '${1}': '${l}'"
|
|
;;
|
|
esac
|
|
done < "${1}"
|
|
}
|
|
|
|
read_package_desc()
|
|
{
|
|
read_file "packages/${1}/package.desc"
|
|
}
|
|
|
|
read_version_desc()
|
|
{
|
|
read_file "packages/${1}/${2}/version.desc"
|
|
}
|
|
|
|
find_forks()
|
|
{
|
|
local -A info
|
|
|
|
info[preferred]=${1}
|
|
eval `read_package_desc ${1}`
|
|
|
|
if [ -n "${info[master]}" ]; then
|
|
pkg_nforks[${info[master]}]=$[pkg_nforks[${info[master]}]+1]
|
|
pkg_forks[${info[master]}]+=" ${1} "
|
|
else
|
|
pkg_preferred[${1}]=${info[preferred]}
|
|
pkg_nforks[${1}]=$[pkg_nforks[${1}]+1]
|
|
pkg_forks[${1}]+=" ${1} "
|
|
pkg_milestones[${1}]=`sort_versions ${info[milestones]}`
|
|
pkg_relevantpattern[${1}]=${info[relevantpattern]}
|
|
pkg_masters+=( "${1}" )
|
|
fi
|
|
# Keep sorting so that preferred fork is first
|
|
if [ -n "${pkg_preferred[${1}]}" ]; then
|
|
pkg_forks[${1}]="${pkg_preferred[${1}]} ${pkg_forks[${1}]##* ${pkg_preferred[${1}]} } ${pkg_forks[${1}]%% ${pkg_preferred[${1}]} *}"
|
|
fi
|
|
}
|
|
|
|
check_obsolete_experimental()
|
|
{
|
|
[ -z "${info[obsolete]}" ] && only_obsolete=
|
|
[ -z "${info[experimental]}" ] && only_experimental=
|
|
}
|
|
|
|
enter_fork()
|
|
{
|
|
local fork="${1}"
|
|
local versions
|
|
local only_obsolete only_experimental
|
|
|
|
# Set defaults
|
|
info[obsolete]=
|
|
info[experimental]=
|
|
info[repository]=
|
|
info[repository_branch]=
|
|
info[repository_cset]=
|
|
info[repository_subdir]=
|
|
info[bootstrap]=
|
|
info[fork]=${fork}
|
|
info[pkg_name]=${fork}
|
|
info[pkg_label]=${fork}
|
|
info[mirrors]=
|
|
info[archive_filename]='@{pkg_name}-@{version}'
|
|
info[archive_dirname]='@{pkg_name}-@{version}'
|
|
info[versionlocked]=
|
|
info[origin]=
|
|
info[signature_format]=
|
|
|
|
eval `read_package_desc ${fork}`
|
|
|
|
if [ -r "packages/${info[origin]}.help" ]; then
|
|
info[originhelp]=`sed 's/^/ /' "packages/${info[origin]}.help"`
|
|
else
|
|
info[originhelp]=" ${info[master]} from ${info[origin]}."
|
|
fi
|
|
|
|
if [ -n "${info[repository]}" ]; then
|
|
info[vcs]=${info[repository]%% *}
|
|
info[repository_url]=${info[repository]#* }
|
|
fi
|
|
|
|
versions=`cd packages/${fork} && \
|
|
for f in */version.desc; do [ -r "${f}" ] && echo "${f%/version.desc}"; done`
|
|
versions=`sort_versions ${versions}`
|
|
|
|
set_iter version ${versions}
|
|
info[all_versions]=${versions}
|
|
|
|
# If a fork does not define any versions at all ("rolling release"), do not
|
|
# consider it obsolete/experimental unless it is so marked in the fork's
|
|
# description.
|
|
if [ -n "${versions}" ]; then
|
|
only_obsolete=yes
|
|
only_experimental=yes
|
|
do_foreach version check_obsolete_experimental
|
|
info[only_obsolete]=${only_obsolete}
|
|
info[only_experimental]=${only_experimental}
|
|
else
|
|
info[only_obsolete]=${info[obsolete]}
|
|
info[only_experimental]=${info[experimental]}
|
|
fi
|
|
}
|
|
|
|
enter_version()
|
|
{
|
|
local version="${1}"
|
|
|
|
eval `read_version_desc ${info[fork]} ${version}`
|
|
info[ver]=${version}
|
|
info[ver_sel]=`relevantize ${version} ${info[relevantpattern]}`
|
|
}
|
|
|
|
enter_milestone()
|
|
{
|
|
local ms="${1}"
|
|
local cmp
|
|
|
|
info[ms]=${ms}
|
|
if [ -n "${info[ver]}" ]; then
|
|
info[version_cmp_milestone]=`cmp_versions ${info[ver]} ${info[ms]}`
|
|
fi
|
|
}
|
|
|
|
gen_packages()
|
|
{
|
|
local -A pkg_forks pkg_milestones pkg_nforks pkg_relevantpattern
|
|
local -a pkg_masters pkg_all pkg_preferred
|
|
|
|
pkg_all=( `cd packages && \
|
|
ls */package.desc 2>/dev/null | \
|
|
while read f; do [ -r "${f}" ] && echo "${f%/package.desc}"; done | \
|
|
xargs echo` )
|
|
|
|
debug "Packages: ${pkg_all[@]}"
|
|
|
|
# We need to group forks of the same package into the same
|
|
# config file. Discover such relationships and only iterate
|
|
# over "master" packages at the top.
|
|
for p in "${pkg_all[@]}"; do
|
|
find_forks "${p}"
|
|
done
|
|
msg "Master packages: ${pkg_masters[@]}"
|
|
|
|
# Now for each master, create its kconfig file with version
|
|
# definitions. As a byproduct, generate a list of all package
|
|
# versions for maintenance purposes.
|
|
exec 3>"maintainer/package-versions"
|
|
for p in "${pkg_masters[@]}"; do
|
|
msg "Generating '${config_versions_dir}/${p}.in'"
|
|
exec >"${config_versions_dir}/${p}.in"
|
|
# Base definitions for the whole config file
|
|
info=( \
|
|
[master]=${p} \
|
|
[nforks]=${pkg_nforks[${p}]} \
|
|
[relevantpattern]=${pkg_relevantpattern[${p}]} \
|
|
)
|
|
set_iter fork ${pkg_forks[${p}]}
|
|
set_iter milestone ${pkg_milestones[${p}]}
|
|
|
|
run_template "maintainer/kconfig-versions.template"
|
|
run_template "maintainer/package-versions.template" >&3
|
|
done
|
|
}
|
|
|
|
msg "*** Generating package version descriptions"
|
|
config_versions_dir=config/versions
|
|
rm -rf "${config_versions_dir}"
|
|
mkdir -p "${config_versions_dir}"
|
|
gen_packages
|
|
|
|
get_components()
|
|
{
|
|
local dir="${1}"
|
|
local f b
|
|
|
|
for f in ${dir}/*.in; do
|
|
b=${f#${dir}/}
|
|
echo ${b%.in}
|
|
done
|
|
}
|
|
|
|
enter_choice()
|
|
{
|
|
local choice="${1}"
|
|
local input="config/${info[dir]}/${choice}.in"
|
|
local l ln
|
|
|
|
info[choice]="${choice}"
|
|
info[pkg]="${choice}"
|
|
|
|
# Not local, we need these arrays be set in enter_dependency/enter_help
|
|
deplines=( )
|
|
helplines=( )
|
|
ln=0
|
|
while read l; do
|
|
ln=$[ln+1]
|
|
case "${l}" in
|
|
"## help "*)
|
|
helplines+=( "${l#\#\# help }" )
|
|
;;
|
|
"## depends "*|"## select "*|"## default "*)
|
|
deplines+=( "${l#\#\# }" )
|
|
;;
|
|
"## no-package")
|
|
info[pkg]=
|
|
;;
|
|
"## package "*)
|
|
info[pkg]=${l#\#\# package }
|
|
;;
|
|
"##"|"## help")
|
|
# accept empty, for formatting
|
|
;;
|
|
"##"*)
|
|
error "${input}:${ln}: unrecognized command"
|
|
;;
|
|
esac
|
|
done < "${input}"
|
|
set_iter dependency "${!deplines[@]}"
|
|
set_iter help "${!helplines[@]}"
|
|
}
|
|
|
|
enter_dependency()
|
|
{
|
|
info[depline]="${deplines[${1}]}"
|
|
}
|
|
|
|
enter_help()
|
|
{
|
|
info[helpline]="${helplines[${1}]}"
|
|
}
|
|
|
|
gen_selection()
|
|
{
|
|
local type="${1}"
|
|
local dir="${2}"
|
|
local label="${3}"
|
|
|
|
msg "Generating ${dir}.in (${type})"
|
|
exec >"${config_gen_dir}/${dir}.in"
|
|
info=( \
|
|
[dir]=${dir} \
|
|
[label]="${label}" \
|
|
)
|
|
set_iter choice `get_components config/${dir}`
|
|
run_template "maintainer/kconfig-${type}.template"
|
|
}
|
|
|
|
msg "*** Generating menu/choice selections"
|
|
config_gen_dir=config/gen
|
|
rm -rf "${config_gen_dir}"
|
|
mkdir -p "${config_gen_dir}"
|
|
|
|
gen_selection choice arch "Target Architecture"
|
|
gen_selection choice kernel "Target OS"
|
|
gen_selection choice cc "Compiler"
|
|
gen_selection choice binutils "Binutils"
|
|
gen_selection choice libc "C library"
|
|
gen_selection menu debug "Debug facilities"
|
|
gen_selection menu comp_tools "Companion tools"
|
|
gen_selection menu comp_libs "Companion libraries"
|
|
|
|
msg "*** Gathering the list of data files to install"
|
|
{
|
|
echo -n "verbatim_data ="
|
|
find config contrib packages samples scripts -type f | LANG=C sort | while read f; do
|
|
case "${f}" in
|
|
# Skip certain files not needed at runtime (used above for generating kconfig
|
|
# fragments).
|
|
packages/*.help|packages/*.desc)
|
|
continue
|
|
;;
|
|
# Special hack for configure.in.in - replace with the file that configure
|
|
# will produce. FIXME: create this file at the time of 'ct-ng build'.
|
|
config/configure.in.in)
|
|
f=config/configure.in
|
|
;;
|
|
esac
|
|
echo " \\"
|
|
echo -n " ${f}"
|
|
done
|
|
} > verbatim-data.mk
|
|
|
|
msg "*** Running autoreconf"
|
|
autoreconf -Wall --force
|
|
|
|
msg "*** Done!"
|