You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

823 lines
22 KiB

#!/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.
#
# Also, several forms of @@VAR@@ expansions are possible:
#
# @@VAR@@
# Just the value of the variable VAR
# @@VAR|@@
# The value of VAR made into Kconfig-name: all non-alphanumeric character
# replaced with underscores; upper-cased.
# @@VAR?val@@
# If VAR is non-empty, insert value "val". Otherwise, insert nothing.
# @@*ITER@@
# Expands to a space separated list of values for the iterator ITER.
# Postprocess operations, if any, are applied to each value.
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
if [ "x${info[iter_${var}]+set}" != "xset" ]; then
error "Iterator over '${var}' not configured"
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 vn vp pp p val val0 is_iter pp_saved
local -a vpl
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 has the complete reference. First check if it is cached already.
if [ "${info[${v}]+set}" != "set" ]; then
case "${v}" in
"*"*) is_iter=y; vn="${v#\*}";;
*) is_iter=n; vn="${v}";;
esac
# $vn is now the reference without the preceding iterator
vp="${vn%%[|?]*}"
pp="${vn#${vp}}"
# $vp is name of the variable proper, $pp is any postprocessing
if [ "${is_iter}" = "n" ]; then
if [ "${info[${vp}]+set}" != "set" ]; then
error "${template}:${l}: reference to undefined variable '${vp}'"
fi
vpl=( "${info[${vp}]}" )
else
if [ "${info[iter_${vp}]+set}" != "set" ]; then
error "${template}:${l}: iterator over '${vp} is not defined"
fi
vpl=( ${info[iter_${vp}]} )
fi
# ${vpl[@]} now is an array of values to be transformed.
val=
pp_saved="${pp}"
for val0 in "${vpl[@]}"; do
debug "val0 [${val0}]"
pp="${pp_saved}"
# Apply postprocessing(s)
while [ -n "${pp}" ]; do
case "${pp}" in
"|"*)
# Kconfigize
pp="${pp#|}"
val0=${val0//[^0-9A-Za-z_]/_}
val0=${val0^^}
;;
"?"*)
pp="${pp#?}"
p="${pp%%[|?]*}"
pp="${pp#${p}}"
val0="${val0:+${p}}"
;;
esac
done
val="${val:+${val} }${val0}"
done
# Cache for future references.
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
}
enter_fork()
{
local fork="${1}"
local versions
local only_obsolete only_experimental
local -A seen_selectors
# 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}
check_relevant_pattern()
{
if [ "x${seen_selectors[${info[ver_sel]}]+set}" = "xset" ]; then
error "${info[pkg_name]}: version ${info[ver]} conflicts with version ${seen_selectors[${info[ver_sel]}]} (${info[ver_sel]} selector)"
else
seen_selectors[${info[ver_sel]}]=${info[ver]}
fi
}
do_foreach version check_relevant_pattern
# 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
check_obsolete_experimental()
{
[ -z "${info[obsolete]}" ] && only_obsolete=
[ -z "${info[experimental]}" ] && only_experimental=
}
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"
{
declare -A seen_files
echo -n "verbatim_data ="
find COPYING config contrib licenses.d packages samples scripts -type f | LANG=C sort | while read f; do
# Implement some kind of .installignore for these files?
case "${f}" in
# Avoid temp files
*.sw[po])
continue
;;
# And, some files automake insists we must have
scripts/compile | scripts/missing | scripts/depcomp | scripts/ltmain.sh | scripts/install-sh)
continue
;;
#
# will produce. FIXME: create this file at the time of 'ct-ng build'.
config/configure.in.in | config/configure.in)
continue
;;
esac
# Checks & substitutions above may result in duplicate files
if [ -n "${seen_files[${f}]}" ]; then
continue
fi
echo " \\"
echo -n " ${f}"
seen_files[${f}]=y
done
} > verbatim-data.mk
msg "*** Running autoreconf"
autoreconf -Wall --force
msg "*** Done!"