getFuncSrc() {
## Finds the original function source code for a currently loaded bash function
# USAGE: getFuncSrc [-q] [-r] <funcname>
#
# will pull the original source out of a file or, if available, out of the bash history
# if unable to retrieve original function source code, will instead return its `declare -f`
# if passed the path to a script file instead of a function, it will print the contents of the script file (e.g., `cat $file`)
#
# NOTE: cannot get the original source for functions defined interactively by sourcing a process substitutiion (e.g. `. <( ... )`)
#
# FLAGS: all flags must come before <funcname> and must be given seperately (use '-q -r', not '-qr')
# -q: dont print definition from primary input (inputs from dependencies may still be printed)
# -r: recursively find source for dependent functions too (requires that your bash binary has the --rpm-requires flag))
#
################################################################################
# make vars local
local out FF kk nn quietFlag recursionFlag
local -a F
# parse any flags
quietFlag=false
recursionFlag=false
while [[ "$1" == -[qr] ]] || [[ "$1" == --[qr]* ]] do
case "$1" in
-q|--quiet) quietFlag=true ;;
-r|--recursion) recursionFlag=falserecursionFlag=true ;;
*) break ;;
esac
shift 1
done
_getFuncSrc0() {
local m mm n p kk off funcDef0 validFuncDefFlag
local -a A off_A
# get where the function was sourced from using extdebug + declare -F
# NOTE: this will tell us where the function definition started, but not where it ends.
read -r _ n p < <(shopt -s extdebug; declare -F "${1}")
((n--))
if [[ "${p}" == 'main' ]]; then
# try to pull function definition out of the bash history
# NOTE: the LINENO returned by extdebug + declare -F is unreliable when using the history
# instead grep the history for the function header and find all possible start lines
[[ $(history) ]] || { declare -f "${1}"; return; }
mapfile -t off_A < <( history | grep -n '' | grep -E '^[0-9]+:[[:space:]]*[0-9]*.*((function[[:space:]]+'"${1}"')|('"${1}"'[[:space:]]*\(\)))' | sed -E s/'\:.*$'//)
off=$(history | grep -n '' | tail -n 1 | sed -E s/'\:.*$'// )
for kk in "${!off_A[@]}"; do
(( off_A[$kk] = 1 + off - off_A[$kk] ))
done
off=$(printf '%s\n' "${off_A[@]}" | sort -n | tail -n 1)
for kk in "${!off_A[@]}"; do
(( off_A[$kk] = off - off_A[$kk] ))
done
mapfile -t A < <(history | tail -n $off | sed -E s/'^[[:space:]]*[0-9]*[[:space:]]*'//)
elif [[ -f "${p}" ]]; then
# pull function definition from file
mapfile -t A <"${p}"
until grep -qE '^[[:space:]]*((function[[:space:]]+'"${1}"')|('"${1}"'[[:space:]]*\(\)))' <<<"${A[@]:$n:1}"; do
((n--))
done
A=("${A[@]:$n}")
off_A=(0)
else
# cant extract original source. use declare -f.
declare -f "${1}"
return
fi
# return declare -f if A is empty
(( ${#A[@]} == 0 )) && { declare -f "${1}"; return; }
# our text blob *should* now start at the start of a function definition, but goes all the way to the EOF.
# try sourcing (with set -n) just the 1st line, then the first 2, then the first 3, etc. until the function sources correctly.
# if pulling the function definition out of the history, repeat this for all possible start lines until one gives a function with the same declare -f
# note: "extra" commands need tro be removed from the 1st + last line before sourcing without set -n to check the declare -f
# get the declare -f for the loaded function
funcdef0="$(declare -f "${1}")"
validFuncDefFlag=false
# loop over all possible start locations
for mm in "${off_A[@]}"; do
# remove any preceeding commands on first history line
mapfile -t -d '' cmd_rm < <(. /proc/self/fd/0 <<<"trap 'set +n; printf '\"'\"'%s\0'\"'\"' \"\${BASH_COMMAND}\"; set -n'; ${A[$mm]}" 2>/dev/null)
for nn in "${cmd_rm[@]}"; do
A[$mm]="${A[$mm]//"$nn"//}"
done
while [[ "${A[$mm]}" =~ ^[[:space:]]*\;+.*$ ]]; do
A[$mm]="${A[$mm]#*\;}"
done
# find history line the function ends on by attempting to source (with set -n) progressively larger chunks of the history
m=$(kk=1; IFS=$'\n'; set -n; until . /proc/self/fd/0 <<<"${A[*]:${mm}:${kk}}" &>/dev/null || (( ( mm + kk ) > ${#A[@]} )); do ((kk++)); done; echo "$kk")
# remove any trailing commands on last history line
(( mmm = mm + m ))
mapfile -t -d '' cmd_rm < <(. /proc/self/fd/0 <<<"IFS=$'\n'; trap 'set +n; printf '\"'\"'%s\0'\"'\"' \"\${BASH_COMMAND}\"; set -n'; ${A[*]:${mm}:${m}}" 2>/dev/null)
for nn in "${cmd_rm[@]}"; do
A[$mmm]="${A[$mmm]//"$nn"//}"
done
while [[ "${A[$mmm]}" =~ ^.*\;+[[:space:]]*$ ]]; do
A[$mmm]="${A[$mmm]%\;*}"
done
# check if recovered + isolated function definition produces the same declare -f as the original (requires NOT using set -n)
if ( IFS=$'\n'; . /proc/self/fd/0 <<<"unset ${1}; ${A[*]:${mm}:${m}}" &>/dev/null && [[ "$(declare -f ${1})" == "${funcdef0}" ]] ); then
validFuncDefFlag=true
break
elif (( ( mm + m ) > ${#A[@]} )); then
break
fi
done
if ${validFuncDefFlag}; then
printf '%s\n' "${A[@]:${mm}:${m}}"
else
declare -f "${1}"
fi
}
if declare -F "${1}" &>/dev/null || ! [[ -f "${1}" ]]; then
# input is a defined function and/or doesnt existin filesystem. treat as a function.
out="$(_getFuncSrc0 "${1}")"
else
# input is not a function and exists in filesystenm. treat as script and cat it.
out="$(<"${1}")"
fi
${quietFlag} || echo "$out"
# feed the function definition through `bash --rpm-requires` to get dependencies, then test each with `type` to find function dependencies.
# recursively call getFuncSrc for each not-yet-processed dependent function, keeping track of which function deps were already listed to avoid duplicates
# NOTE: the "--rpm-requires" flag is non-standard, and may only be available on distros based on red hat / fedora
${recursionFlag} && : | bash --debug --rpm-requires -O extglob &>/dev/null && {
# get function dependencies
mapfile -t F < <(bash --debug --rpm-requires -O extglob <<<"$out" | sed -E s/'^executable\((.*)\)'/'\1'/ | sort -u | while read -r nn; do type $nn 2>/dev/null | grep -qF 'is a function' && echo "$nn"; done)
for kk in "${!F[@]}"; do
if [[ "${FF}" == *" ${F[$kk]} "* ]]; then
# we already processed this function. remove it from "functions to process" list (F)
unset "F[$kk]"
else
# we have not yet processed this function, keep it on the "functions to process" list (F) and add it to the "already processed functions" list (FF) so we dont process it again after this round
FF+=" ${F[$kk]} "
fi
done
for nn in "${F[@]}"; do
# for each function on the "functions to process" list (F), recursively call getFuncSrc -r and pass the "already processed functions" list (FF) as an environment variable
FF="${FF}" getFuncSrc -r "${nn}"
done
}
}
getFuncSrc() {
## Finds the original function source code for a currently loaded bash function
# USAGE: getFuncSrc [-q] [-r] <funcname>
#
# will pull the original source out of a file or, if available, out of the bash history
# if unable to retrieve original function source code, will instead return its `declare -f`
# if passed the path to a script file instead of a function, it will print the contents of the script file (e.g., `cat $file`)
#
# NOTE: cannot get the original source for functions defined interactively by sourcing a process substitutiion (e.g. `. <( ... )`)
#
# FLAGS: all flags must come before <funcname> and must be given seperately (use '-q -r', not '-qr')
# -q: dont print definition from primary input (inputs from dependencies may still be printed)
# -r: recursively find source for dependent functions too (requires that your bash binary has the --rpm-requires flag))
#
################################################################################
# make vars local
local out FF kk nn quietFlag recursionFlag
local -a F
# parse any flags
quietFlag=false
recursionFlag=false
while [[ "$1" == -[qr] ]] || [[ "$1" == --[qr]* ]] do
case "$1" in
-q|--quiet) quietFlag=true ;;
-r|--recursion) recursionFlag=false ;;
*) break ;;
esac
shift 1
done
_getFuncSrc0() {
local m mm n p kk off funcDef0 validFuncDefFlag
local -a A off_A
# get where the function was sourced from using extdebug + declare -F
# NOTE: this will tell us where the function definition started, but not where it ends.
read -r _ n p < <(shopt -s extdebug; declare -F "${1}")
((n--))
if [[ "${p}" == 'main' ]]; then
# try to pull function definition out of the bash history
# NOTE: the LINENO returned by extdebug + declare -F is unreliable when using the history
# instead grep the history for the function header and find all possible start lines
[[ $(history) ]] || { declare -f "${1}"; return; }
mapfile -t off_A < <( history | grep -n '' | grep -E '^[0-9]+:[[:space:]]*[0-9]*.*((function[[:space:]]+'"${1}"')|('"${1}"'[[:space:]]*\(\)))' | sed -E s/'\:.*$'//)
off=$(history | grep -n '' | tail -n 1 | sed -E s/'\:.*$'// )
for kk in "${!off_A[@]}"; do
(( off_A[$kk] = 1 + off - off_A[$kk] ))
done
off=$(printf '%s\n' "${off_A[@]}" | sort -n | tail -n 1)
for kk in "${!off_A[@]}"; do
(( off_A[$kk] = off - off_A[$kk] ))
done
mapfile -t A < <(history | tail -n $off | sed -E s/'^[[:space:]]*[0-9]*[[:space:]]*'//)
elif [[ -f "${p}" ]]; then
# pull function definition from file
mapfile -t A <"${p}"
until grep -qE '^[[:space:]]*((function[[:space:]]+'"${1}"')|('"${1}"'[[:space:]]*\(\)))' <<<"${A[@]:$n:1}"; do
((n--))
done
A=("${A[@]:$n}")
off_A=(0)
else
# cant extract original source. use declare -f.
declare -f "${1}"
return
fi
# return declare -f if A is empty
(( ${#A[@]} == 0 )) && { declare -f "${1}"; return; }
# our text blob *should* now start at the start of a function definition, but goes all the way to the EOF.
# try sourcing (with set -n) just the 1st line, then the first 2, then the first 3, etc. until the function sources correctly.
# if pulling the function definition out of the history, repeat this for all possible start lines until one gives a function with the same declare -f
# note: "extra" commands need tro be removed from the 1st + last line before sourcing without set -n to check the declare -f
# get the declare -f for the loaded function
funcdef0="$(declare -f "${1}")"
validFuncDefFlag=false
# loop over all possible start locations
for mm in "${off_A[@]}"; do
# remove any preceeding commands on first history line
mapfile -t -d '' cmd_rm < <(. /proc/self/fd/0 <<<"trap 'set +n; printf '\"'\"'%s\0'\"'\"' \"\${BASH_COMMAND}\"; set -n'; ${A[$mm]}" 2>/dev/null)
for nn in "${cmd_rm[@]}"; do
A[$mm]="${A[$mm]//"$nn"//}"
done
while [[ "${A[$mm]}" =~ ^[[:space:]]*\;+.*$ ]]; do
A[$mm]="${A[$mm]#*\;}"
done
# find history line the function ends on by attempting to source (with set -n) progressively larger chunks of the history
m=$(kk=1; IFS=$'\n'; set -n; until . /proc/self/fd/0 <<<"${A[*]:${mm}:${kk}}" &>/dev/null || (( ( mm + kk ) > ${#A[@]} )); do ((kk++)); done; echo "$kk")
# remove any trailing commands on last history line
(( mmm = mm + m ))
mapfile -t -d '' cmd_rm < <(. /proc/self/fd/0 <<<"IFS=$'\n'; trap 'set +n; printf '\"'\"'%s\0'\"'\"' \"\${BASH_COMMAND}\"; set -n'; ${A[*]:${mm}:${m}}" 2>/dev/null)
for nn in "${cmd_rm[@]}"; do
A[$mmm]="${A[$mmm]//"$nn"//}"
done
while [[ "${A[$mmm]}" =~ ^.*\;+[[:space:]]*$ ]]; do
A[$mmm]="${A[$mmm]%\;*}"
done
# check if recovered + isolated function definition produces the same declare -f as the original (requires NOT using set -n)
if ( IFS=$'\n'; . /proc/self/fd/0 <<<"unset ${1}; ${A[*]:${mm}:${m}}" &>/dev/null && [[ "$(declare -f ${1})" == "${funcdef0}" ]] ); then
validFuncDefFlag=true
break
elif (( ( mm + m ) > ${#A[@]} )); then
break
fi
done
if ${validFuncDefFlag}; then
printf '%s\n' "${A[@]:${mm}:${m}}"
else
declare -f "${1}"
fi
}
if declare -F "${1}" &>/dev/null || ! [[ -f "${1}" ]]; then
# input is a defined function and/or doesnt existin filesystem. treat as a function.
out="$(_getFuncSrc0 "${1}")"
else
# input is not a function and exists in filesystenm. treat as script and cat it.
out="$(<"${1}")"
fi
${quietFlag} || echo "$out"
# feed the function definition through `bash --rpm-requires` to get dependencies, then test each with `type` to find function dependencies.
# recursively call getFuncSrc for each not-yet-processed dependent function, keeping track of which function deps were already listed to avoid duplicates
# NOTE: the "--rpm-requires" flag is non-standard, and may only be available on distros based on red hat / fedora
${recursionFlag} && : | bash --debug --rpm-requires -O extglob &>/dev/null && {
# get function dependencies
mapfile -t F < <(bash --debug --rpm-requires -O extglob <<<"$out" | sed -E s/'^executable\((.*)\)'/'\1'/ | sort -u | while read -r nn; do type $nn 2>/dev/null | grep -qF 'is a function' && echo "$nn"; done)
for kk in "${!F[@]}"; do
if [[ "${FF}" == *" ${F[$kk]} "* ]]; then
# we already processed this function. remove it from "functions to process" list (F)
unset "F[$kk]"
else
# we have not yet processed this function, keep it on the "functions to process" list (F) and add it to the "already processed functions" list (FF) so we dont process it again after this round
FF+=" ${F[$kk]} "
fi
done
for nn in "${F[@]}"; do
# for each function on the "functions to process" list (F), recursively call getFuncSrc -r and pass the "already processed functions" list (FF) as an environment variable
FF="${FF}" getFuncSrc -r "${nn}"
done
}
}
getFuncSrc() {
## Finds the original function source code for a currently loaded bash function
# USAGE: getFuncSrc [-q] [-r] <funcname>
#
# will pull the original source out of a file or, if available, out of the bash history
# if unable to retrieve original function source code, will instead return its `declare -f`
# if passed the path to a script file instead of a function, it will print the contents of the script file (e.g., `cat $file`)
#
# NOTE: cannot get the original source for functions defined interactively by sourcing a process substitutiion (e.g. `. <( ... )`)
#
# FLAGS: all flags must come before <funcname> and must be given seperately (use '-q -r', not '-qr')
# -q: dont print definition from primary input (inputs from dependencies may still be printed)
# -r: recursively find source for dependent functions too (requires that your bash binary has the --rpm-requires flag))
#
################################################################################
# make vars local
local out FF kk nn quietFlag recursionFlag
local -a F
# parse any flags
quietFlag=false
recursionFlag=false
while [[ "$1" == -[qr] ]] || [[ "$1" == --[qr]* ]] do
case "$1" in
-q|--quiet) quietFlag=true ;;
-r|--recursion) recursionFlag=true ;;
*) break ;;
esac
shift 1
done
_getFuncSrc0() {
local m mm n p kk off funcDef0 validFuncDefFlag
local -a A off_A
# get where the function was sourced from using extdebug + declare -F
# NOTE: this will tell us where the function definition started, but not where it ends.
read -r _ n p < <(shopt -s extdebug; declare -F "${1}")
((n--))
if [[ "${p}" == 'main' ]]; then
# try to pull function definition out of the bash history
# NOTE: the LINENO returned by extdebug + declare -F is unreliable when using the history
# instead grep the history for the function header and find all possible start lines
[[ $(history) ]] || { declare -f "${1}"; return; }
mapfile -t off_A < <( history | grep -n '' | grep -E '^[0-9]+:[[:space:]]*[0-9]*.*((function[[:space:]]+'"${1}"')|('"${1}"'[[:space:]]*\(\)))' | sed -E s/'\:.*$'//)
off=$(history | grep -n '' | tail -n 1 | sed -E s/'\:.*$'// )
for kk in "${!off_A[@]}"; do
(( off_A[$kk] = 1 + off - off_A[$kk] ))
done
off=$(printf '%s\n' "${off_A[@]}" | sort -n | tail -n 1)
for kk in "${!off_A[@]}"; do
(( off_A[$kk] = off - off_A[$kk] ))
done
mapfile -t A < <(history | tail -n $off | sed -E s/'^[[:space:]]*[0-9]*[[:space:]]*'//)
elif [[ -f "${p}" ]]; then
# pull function definition from file
mapfile -t A <"${p}"
until grep -qE '^[[:space:]]*((function[[:space:]]+'"${1}"')|('"${1}"'[[:space:]]*\(\)))' <<<"${A[@]:$n:1}"; do
((n--))
done
A=("${A[@]:$n}")
off_A=(0)
else
# cant extract original source. use declare -f.
declare -f "${1}"
return
fi
# return declare -f if A is empty
(( ${#A[@]} == 0 )) && { declare -f "${1}"; return; }
# our text blob *should* now start at the start of a function definition, but goes all the way to the EOF.
# try sourcing (with set -n) just the 1st line, then the first 2, then the first 3, etc. until the function sources correctly.
# if pulling the function definition out of the history, repeat this for all possible start lines until one gives a function with the same declare -f
# note: "extra" commands need tro be removed from the 1st + last line before sourcing without set -n to check the declare -f
# get the declare -f for the loaded function
funcdef0="$(declare -f "${1}")"
validFuncDefFlag=false
# loop over all possible start locations
for mm in "${off_A[@]}"; do
# remove any preceeding commands on first history line
mapfile -t -d '' cmd_rm < <(. /proc/self/fd/0 <<<"trap 'set +n; printf '\"'\"'%s\0'\"'\"' \"\${BASH_COMMAND}\"; set -n'; ${A[$mm]}" 2>/dev/null)
for nn in "${cmd_rm[@]}"; do
A[$mm]="${A[$mm]//"$nn"//}"
done
while [[ "${A[$mm]}" =~ ^[[:space:]]*\;+.*$ ]]; do
A[$mm]="${A[$mm]#*\;}"
done
# find history line the function ends on by attempting to source (with set -n) progressively larger chunks of the history
m=$(kk=1; IFS=$'\n'; set -n; until . /proc/self/fd/0 <<<"${A[*]:${mm}:${kk}}" &>/dev/null || (( ( mm + kk ) > ${#A[@]} )); do ((kk++)); done; echo "$kk")
# remove any trailing commands on last history line
(( mmm = mm + m ))
mapfile -t -d '' cmd_rm < <(. /proc/self/fd/0 <<<"IFS=$'\n'; trap 'set +n; printf '\"'\"'%s\0'\"'\"' \"\${BASH_COMMAND}\"; set -n'; ${A[*]:${mm}:${m}}" 2>/dev/null)
for nn in "${cmd_rm[@]}"; do
A[$mmm]="${A[$mmm]//"$nn"//}"
done
while [[ "${A[$mmm]}" =~ ^.*\;+[[:space:]]*$ ]]; do
A[$mmm]="${A[$mmm]%\;*}"
done
# check if recovered + isolated function definition produces the same declare -f as the original (requires NOT using set -n)
if ( IFS=$'\n'; . /proc/self/fd/0 <<<"unset ${1}; ${A[*]:${mm}:${m}}" &>/dev/null && [[ "$(declare -f ${1})" == "${funcdef0}" ]] ); then
validFuncDefFlag=true
break
elif (( ( mm + m ) > ${#A[@]} )); then
break
fi
done
if ${validFuncDefFlag}; then
printf '%s\n' "${A[@]:${mm}:${m}}"
else
declare -f "${1}"
fi
}
if declare -F "${1}" &>/dev/null || ! [[ -f "${1}" ]]; then
# input is a defined function and/or doesnt existin filesystem. treat as a function.
out="$(_getFuncSrc0 "${1}")"
else
# input is not a function and exists in filesystenm. treat as script and cat it.
out="$(<"${1}")"
fi
${quietFlag} || echo "$out"
# feed the function definition through `bash --rpm-requires` to get dependencies, then test each with `type` to find function dependencies.
# recursively call getFuncSrc for each not-yet-processed dependent function, keeping track of which function deps were already listed to avoid duplicates
# NOTE: the "--rpm-requires" flag is non-standard, and may only be available on distros based on red hat / fedora
${recursionFlag} && : | bash --debug --rpm-requires -O extglob &>/dev/null && {
# get function dependencies
mapfile -t F < <(bash --debug --rpm-requires -O extglob <<<"$out" | sed -E s/'^executable\((.*)\)'/'\1'/ | sort -u | while read -r nn; do type $nn 2>/dev/null | grep -qF 'is a function' && echo "$nn"; done)
for kk in "${!F[@]}"; do
if [[ "${FF}" == *" ${F[$kk]} "* ]]; then
# we already processed this function. remove it from "functions to process" list (F)
unset "F[$kk]"
else
# we have not yet processed this function, keep it on the "functions to process" list (F) and add it to the "already processed functions" list (FF) so we dont process it again after this round
FF+=" ${F[$kk]} "
fi
done
for nn in "${F[@]}"; do
# for each function on the "functions to process" list (F), recursively call getFuncSrc -r and pass the "already processed functions" list (FF) as an environment variable
FF="${FF}" getFuncSrc -r "${nn}"
done
}
}
I know this question has an accepted answer and is a few years old....BUT, in case anyone else comes across this question with the goal of "recovering the original code that defines an already-loaded function"...
I've come up with a fairly robust way to accomplish this. My implementation is bash specific, but the underlying method could be used in other shells, so long as they have something analogous to declare -f (which prints a re-formatted function definition) and something analogous to shopt -s extdebug; declare -F (which gives the file the function was sourced from and the LINENO where the function definition starts).
See the code below for more detail (it is fairly well commented), but the general idea is that you:
- figure out where the function definition starts (a file or in the bash history), and load the file/history from that point onward into a variable.
- remove any preceding commands from the first line, then attempt to source (with
set -n) progressively larger chunks (1 line, then 2, then 3, ...) until it sources without error. - remove any trailing commands from the last line (leaving only the actual function definition), then source it in a subshell (without
set -n) and confirm that the function you sourced gives the samedeclare -fas the original loaded function does.
Once you have the original function source code, getting the line count is easy (e.g., run it through wc -l)
CODE:
getFuncSrc() {
## Finds the original function source code for a currently loaded bash function
# USAGE: getFuncSrc [-q] [-r] <funcname>
#
# will pull the original source out of a file or, if available, out of the bash history
# if unable to retrieve original function source code, will instead return its `declare -f`
# if passed the path to a script file instead of a function, it will print the contents of the script file (e.g., `cat $file`)
#
# NOTE: cannot get the original source for functions defined interactively by sourcing a process substitutiion (e.g. `. <( ... )`)
#
# FLAGS: all flags must come before <funcname> and must be given seperately (use '-q -r', not '-qr')
# -q: dont print definition from primary input (inputs from dependencies may still be printed)
# -r: recursively find source for dependent functions too (requires that your bash binary has the --rpm-requires flag))
#
################################################################################
# make vars local
local out FF kk nn quietFlag recursionFlag
local -a F
# parse any flags
quietFlag=false
recursionFlag=false
while [[ "$1" == -[qr] ]] || [[ "$1" == --[qr]* ]] do
case "$1" in
-q|--quiet) quietFlag=true ;;
-r|--recursion) recursionFlag=false ;;
*) break ;;
esac
shift 1
done
_getFuncSrc0() {
local m mm n p kk off funcDef0 validFuncDefFlag
local -a A off_A
# get where the function was sourced from using extdebug + declare -F
# NOTE: this will tell us where the function definition started, but not where it ends.
read -r _ n p < <(shopt -s extdebug; declare -F "${1}")
((n--))
if [[ "${p}" == 'main' ]]; then
# try to pull function definition out of the bash history
# NOTE: the LINENO returned by extdebug + declare -F is unreliable when using the history
# instead grep the history for the function header and find all possible start lines
[[ $(history) ]] || { declare -f "${1}"; return; }
mapfile -t off_A < <( history | grep -n '' | grep -E '^[0-9]+:[[:space:]]*[0-9]*.*((function[[:space:]]+'"${1}"')|('"${1}"'[[:space:]]*\(\)))' | sed -E s/'\:.*$'//)
off=$(history | grep -n '' | tail -n 1 | sed -E s/'\:.*$'// )
for kk in "${!off_A[@]}"; do
(( off_A[$kk] = 1 + off - off_A[$kk] ))
done
off=$(printf '%s\n' "${off_A[@]}" | sort -n | tail -n 1)
for kk in "${!off_A[@]}"; do
(( off_A[$kk] = off - off_A[$kk] ))
done
mapfile -t A < <(history | tail -n $off | sed -E s/'^[[:space:]]*[0-9]*[[:space:]]*'//)
elif [[ -f "${p}" ]]; then
# pull function definition from file
mapfile -t A <"${p}"
until grep -qE '^[[:space:]]*((function[[:space:]]+'"${1}"')|('"${1}"'[[:space:]]*\(\)))' <<<"${A[@]:$n:1}"; do
((n--))
done
A=("${A[@]:$n}")
off_A=(0)
else
# cant extract original source. use declare -f.
declare -f "${1}"
return
fi
# return declare -f if A is empty
(( ${#A[@]} == 0 )) && { declare -f "${1}"; return; }
# our text blob *should* now start at the start of a function definition, but goes all the way to the EOF.
# try sourcing (with set -n) just the 1st line, then the first 2, then the first 3, etc. until the function sources correctly.
# if pulling the function definition out of the history, repeat this for all possible start lines until one gives a function with the same declare -f
# note: "extra" commands need tro be removed from the 1st + last line before sourcing without set -n to check the declare -f
# get the declare -f for the loaded function
funcdef0="$(declare -f "${1}")"
validFuncDefFlag=false
# loop over all possible start locations
for mm in "${off_A[@]}"; do
# remove any preceeding commands on first history line
mapfile -t -d '' cmd_rm < <(. /proc/self/fd/0 <<<"trap 'set +n; printf '\"'\"'%s\0'\"'\"' \"\${BASH_COMMAND}\"; set -n'; ${A[$mm]}" 2>/dev/null)
for nn in "${cmd_rm[@]}"; do
A[$mm]="${A[$mm]//"$nn"//}"
done
while [[ "${A[$mm]}" =~ ^[[:space:]]*\;+.*$ ]]; do
A[$mm]="${A[$mm]#*\;}"
done
# find history line the function ends on by attempting to source (with set -n) progressively larger chunks of the history
m=$(kk=1; IFS=$'\n'; set -n; until . /proc/self/fd/0 <<<"${A[*]:${mm}:${kk}}" &>/dev/null || (( ( mm + kk ) > ${#A[@]} )); do ((kk++)); done; echo "$kk")
# remove any trailing commands on last history line
(( mmm = mm + m ))
mapfile -t -d '' cmd_rm < <(. /proc/self/fd/0 <<<"IFS=$'\n'; trap 'set +n; printf '\"'\"'%s\0'\"'\"' \"\${BASH_COMMAND}\"; set -n'; ${A[*]:${mm}:${m}}" 2>/dev/null)
for nn in "${cmd_rm[@]}"; do
A[$mmm]="${A[$mmm]//"$nn"//}"
done
while [[ "${A[$mmm]}" =~ ^.*\;+[[:space:]]*$ ]]; do
A[$mmm]="${A[$mmm]%\;*}"
done
# check if recovered + isolated function definition produces the same declare -f as the original (requires NOT using set -n)
if ( IFS=$'\n'; . /proc/self/fd/0 <<<"unset ${1}; ${A[*]:${mm}:${m}}" &>/dev/null && [[ "$(declare -f ${1})" == "${funcdef0}" ]] ); then
validFuncDefFlag=true
break
elif (( ( mm + m ) > ${#A[@]} )); then
break
fi
done
if ${validFuncDefFlag}; then
printf '%s\n' "${A[@]:${mm}:${m}}"
else
declare -f "${1}"
fi
}
if declare -F "${1}" &>/dev/null || ! [[ -f "${1}" ]]; then
# input is a defined function and/or doesnt existin filesystem. treat as a function.
out="$(_getFuncSrc0 "${1}")"
else
# input is not a function and exists in filesystenm. treat as script and cat it.
out="$(<"${1}")"
fi
${quietFlag} || echo "$out"
# feed the function definition through `bash --rpm-requires` to get dependencies, then test each with `type` to find function dependencies.
# recursively call getFuncSrc for each not-yet-processed dependent function, keeping track of which function deps were already listed to avoid duplicates
# NOTE: the "--rpm-requires" flag is non-standard, and may only be available on distros based on red hat / fedora
${recursionFlag} && : | bash --debug --rpm-requires -O extglob &>/dev/null && {
# get function dependencies
mapfile -t F < <(bash --debug --rpm-requires -O extglob <<<"$out" | sed -E s/'^executable\((.*)\)'/'\1'/ | sort -u | while read -r nn; do type $nn 2>/dev/null | grep -qF 'is a function' && echo "$nn"; done)
for kk in "${!F[@]}"; do
if [[ "${FF}" == *" ${F[$kk]} "* ]]; then
# we already processed this function. remove it from "functions to process" list (F)
unset "F[$kk]"
else
# we have not yet processed this function, keep it on the "functions to process" list (F) and add it to the "already processed functions" list (FF) so we dont process it again after this round
FF+=" ${F[$kk]} "
fi
done
for nn in "${F[@]}"; do
# for each function on the "functions to process" list (F), recursively call getFuncSrc -r and pass the "already processed functions" list (FF) as an environment variable
FF="${FF}" getFuncSrc -r "${nn}"
done
}
}
default