# -*- shell-script -*-
# dbg-processor.sh - Top-level debugger commands
#
# Copyright (C) 2008-2012, 2015
# Rocky Bernstein <rocky@gnu.org>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 2, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; see the file COPYING. If not, write to
# the Free Software Foundation, 59 Temple Place, Suite 330, Boston,
# MA 02111 USA.
# Are we inside the middle of a "skip" command?
typeset -i _Dbg_inside_skip=0
# Hooks that get run on each command loop
typeset -A _Dbg_cmdloop_hooks
_Dbg_cmdloop_hooks['display']='_Dbg_eval_all_display'
# Can be bash's "read" builtin or a command-completing "read" builtin
# provided by this debugger.
typeset _Dbg_read_fn; _Dbg_read_fn='read'
# A variable holding a space is set so it can be used in a "set prompt" command
# ("read" in the main command loop will remove a trailing space so we need
# another way to allow a user to enter spaces in the prompt.)
typeset _Dbg_space=' '
# Should we allow editing of debugger commands?
# The value should either be '-e' or ''. And if it is
# on, the edit style indicates what style edit keystrokes.
typeset _Dbg_edit='-e'
typeset _Dbg_edit_style='emacs' # or vi
set -o $_Dbg_edit_style
# What do we use for a debugger prompt? Technically we don't need to
# use the above $bashdb_space in the assignment below, but we put it
# in to suggest to a user that this is how one gets a spaces into the
# prompt.
typeset _Dbg_prompt_str='$_Dbg_debugger_name${_Dbg_less}${#_Dbg_history[@]}${_Dbg_greater}$_Dbg_space'
# The arguments in the last "x" command.
typeset _Dbg_last_x_args=''
# The canonical name of last command run.
typeset _Dbg_last_cmd=''
# A list of debugger command input-file descriptors.
# Duplicate standard input
typeset -i _Dbg_fdi ; exec {_Dbg_fdi}<&0
typeset -i _Dbg_fd_last=0
# keep a list of source'd command files. If the entry is "" then we are
# interactive.
typeset -a _Dbg_cmdfile; _Dbg_cmdfile=('')
# A list of debugger command input-file descriptors.
typeset -a _Dbg_fd; _Dbg_fd=($_Dbg_fdi)
typeset _Dbg_prompt_output
# ===================== FUNCTIONS =======================================
# The main debugger command reading loop.
#
# Note: We have to be careful here in naming "local" variables. In contrast
# to other places in the debugger, because of the read/eval loop, they are
# in fact seen by those using the debugger. So in contrast to other "local"s
# in the debugger, we prefer to preface these with _Dbg_.
function _Dbg_process_commands {
# initial debugger input source from bashdb arguments
if [[ ! -z "$_Dbg_tty_in" ]] && [[ -r "$_Dbg_tty_in" ]]
then
exec {_Dbg_fdi}<$_Dbg_tty_in
_Dbg_fd[++_Dbg_fd_last]=$_Dbg_fdi
_Dbg_cmdfile+=("$_Dbg_tty_in")
fi
# THIS SHOULD BE DONE IN dbg-sig.sh, but there's a bug in BASH in
# trying to change "trap RETURN" inside a "trap RETURN" handler....
# Turn off return trapping. Not strictly necessary, since it *should* be
# covered by the _Dbg_ test below if we've named functions correctly.
# However turning off the RETURN trap should reduce unnecessary
# trap RETURN calls.
_Dbg_inside_skip=0
_Dbg_step_ignore=-1 # Nuke any prior step ignore counts
_Dbg_continue_rc=-1 # Don't continue exectuion unless told to do so.
_Dbg_write_journal "_Dbg_step_ignore=$_Dbg_step_ignore"
typeset key
# Evaluate all hooks
for key in ${!_Dbg_cmdloop_hooks[@]} ; do
${_Dbg_cmdloop_hooks[$key]}
done
# Loop over all pending open input file descriptors
while (( _Dbg_fd_last > 0)) ; do
# Set up prompt to show shell and subshell levels.
typeset _Dbg_greater=''
typeset _Dbg_less=''
typeset _Dbg_result # Used by _Dbg_copies to return a value.
if _Dbg_copies '>' $_Dbg_DEBUGGER_LEVEL ; then
_Dbg_greater=$_Dbg_result
_Dbg_less=${_Dbg_result//>/<}
fi
if _Dbg_copies ')' $BASH_SUBSHELL ; then
_Dbg_greater="${_Dbg_result}${_Dbg_greater}"
_Dbg_less="${_Dbg_less}${_Dbg_result//)/(}"
fi
# Loop over debugger commands. But before reading a debugger
# command, we need to make sure IFS is set to spaces to ensure our
# two variables (command name and rest of the arguments) are set
# correctly. Saving the IFS and setting it to the "normal" value
# of space should be done in the DEBUG signal handler entry.
# Also, we need to make sure the prompt output is
# redirected to the debugger terminal. Both of these things may
# have been changed by the debugged program for its own
# purposes. Furthermore, were we *not* to redirect our stderr
# below, we may mess up what the debugged program expects to see
# in in stderr by adding our debugger prompt.
# if no tty, no prompt
_Dbg_prompt_output=${_Dbg_tty:-/dev/null}
eval "local _Dbg_prompt=$_Dbg_prompt_str"
_Dbg_preloop
typeset _Dbg_cmd
typeset args
typeset rc
while : ; do
set -o history
_Dbg_input_desc=${_Dbg_fd[_Dbg_fd_last]}
if [[ $_Dbg_tty == '&1' ]] ; then
echo -n "$_Dbg_prompt"
if ! read _Dbg_cmd args <&$_Dbg_input_desc 2>&1; then
break
fi
else
if ((_Dbg_set_read_completion)) ; then
_Dbg_read_fn='readc'
else
_Dbg_read_fn='read'
fi
if ! $_Dbg_read_fn $_Dbg_edit -p "$_Dbg_prompt" _Dbg_cmd args \
<&$_Dbg_input_desc 2>>$_Dbg_prompt_output ; then
set +o history
break
fi
fi
# FIXME: until I figure out to fix builtin readc, this happens
# on command completion:
if [[ $_Dbg_cmd =~ ' ' && -z $args ]] ; then
typeset -a ary; IFS=' ' ary=( $_Dbg_cmd )
_Dbg_cmd=${ary[0]}
unset ary[0]
args="${ary[@]}"
fi
set +o history
if (( _Dbg_brkpt_commands_defining )) ; then
case $_Dbg_cmd in
silent )
_Dbg_brkpt_commands_silent[$_Dbg_brkpt_commands_current]=1
continue
;;
end )
_Dbg_brkpt_commands_defining=0
#### ??? TESTING
## local -i cur=$_Dbg_brkpt_commands_current
## local -i start=${_Dbg_brkpt_commands_start[$cur]}
## local -i end=${_Dbg_brkpt_commands_end[$cur]}
## local -i i
## echo "++ brkpt: $cur, start: $start, end: $end "
## for (( i=start; (( i < end )) ; i++ )) ; do
## echo ${_Dbg_brkpt_commands[$i]}
## done
eval "_Dbg_prompt=$_Dbg_prompt_str"
continue
;;
*)
_Dbg_brkpt_commands[${#_Dbg_brkpt_commands[@]}]="$_Dbg_cmd $args"
(( _Dbg_brkpt_commands_end[$_Dbg_brkpt_commands_current]++ ))
continue
;;
esac
rc=$?
else
_Dbg_onecmd "$_Dbg_cmd" "$args"
_Dbg_postcmd
fi
((_Dbg_continue_rc >= 0)) && return $_Dbg_continue_rc
if (( _Dbg_brkpt_commands_defining )) ; then
_Dbg_prompt='>'
else
eval "_Dbg_prompt=$_Dbg_prompt_str"
fi
done # while read $_Dbg_edit -p ...
unset _Dbg_fd[_Dbg_fd_last--]
done # Loop over all open pending file descriptors
# EOF hit. Same as quit without arguments
_Dbg_msg '' # Cause <cr> since EOF may not have put in.
_Dbg_do_quit
}
# Run a debugger command "annotating" the output
_Dbg_annotation() {
typeset label="$1"
shift
_Dbg_do_print "$label"
$*
_Dbg_do_print ''
}
# Run a single command
# Parameters: _Dbg_cmd and args
#
_Dbg_onecmd() {
typeset full_cmd=$@
typeset _Dbg_orig_cmd="$1"
typeset expanded_alias; _Dbg_alias_expand "$_Dbg_orig_cmd"
typeset _Dbg_cmd="$expanded_alias"
shift
typeset _Dbg_args="$@"
# Set default next, step or skip command
if [[ -z $_Dbg_cmd ]]; then
_Dbg_cmd=$_Dbg_last_next_step_cmd
_Dbg_args=$_Dbg_last_next_step_args
full_cmd="$_Dbg_cmd $_Dbg_args"
fi
# If "set trace-commands" is "on", echo the the command
if [[ $_Dbg_set_trace_commands == 'on' ]] ; then
_Dbg_msg "+$full_cmd"
fi
local dq_cmd=$(_Dbg_esc_dq "$_Dbg_cmd")
local dq_args=$(_Dbg_esc_dq "$_Dbg_args")
# _Dbg_write_journal_eval doesn't work here. Don't really understand
# how to get it to work. So we do this in two steps.
_Dbg_write_journal \
"_Dbg_history[${#_Dbg_history[@]}]=\"$dq_cmd $dq_args\""
_Dbg_history[${#_Dbg_history[@]}]="$_Dbg_cmd $_Dbg_args"
_Dbg_hi=${#_Dbg_history[@]}
history -s -- "$full_cmd"
typeset -i _Dbg_redo=1
while (( _Dbg_redo )) ; do
_Dbg_redo=0
[[ -z $_Dbg_cmd ]] && _Dbg_cmd=$_Dbg_last_cmd
if [[ -n $_Dbg_cmd ]] ; then
typeset -i found=0
typeset found_cmd
if [[ -n ${_Dbg_debugger_commands[$_Dbg_cmd]} ]] ; then
found=1
found_cmd=$_Dbg_cmd
else
# Look for a unique abbreviation
typeset -i count=0
typeset list; list="${!_Dbg_debugger_commands[@]}"
for try in $list ; do
if [[ $try =~ ^$_Dbg_cmd ]] ; then
found_cmd=$try
((count++))
fi
done
((found=(count==1)))
fi
if ((found)); then
${_Dbg_debugger_commands[$found_cmd]} $_Dbg_args
IFS=$_Dbg_space_IFS;
eval "_Dbg_prompt=$_Dbg_prompt_str"
((_Dbg_continue_rc >= 0)) && return $_Dbg_continue_rc
continue
fi
fi
case $_Dbg_cmd in
# Comment line
[#]* )
_Dbg_history_remove_item
_Dbg_last_cmd='#'
;;
# list current line
. )
_Dbg_list $_Dbg_frame_last_filename $_Dbg_frame_last_lineno 1
_Dbg_last_cmd='list'
;;
# Search forwards for pattern
/* )
_Dbg_do_search $_Dbg_cmd
_Dbg_last_cmd='search'
;;
# Search backwards for pattern
[?]* )
_Dbg_do_reverse $_Dbg_cmd
_Dbg_last_cmd="reverse"
;;
# Change Directory
cd )
# Allow for tilde expansion. We also allow expansion of
# variables like $HOME which gdb doesn't allow. That's life.
local cd_command="cd $_Dbg_args"
eval $cd_command
_Dbg_do_pwd
_Dbg_last_cmd='cd'
;;
# complete
comp | compl | comple | complet | complete )
_Dbg_do_complete $_Dbg_args
_Dbg_last_cmd='complete'
;;
# Set up a script for debugging into.
debug )
_Dbg_do_debug $_Dbg_args
# Skip over the execute statement which presumably we ran above.
_Dbg_do_next_skip 'skip' 1
IFS="$_Dbg_old_IFS";
return 1
_Dbg_last_cmd='debug'
;;
# Delete all breakpoints.
D | deletea | deleteal | deleteall )
_Dbg_clear_all_brkpt
_Dbg_last_cmd='deleteall'
;;
# return from function/source without finishing executions
return )
;;
# run shell command. Has to come before ! below.
shell | '!!' )
eval $_Dbg_args ;;
# Send signal to process
si | sig | sign | signa | signal )
_Dbg_do_signal $_Dbg_args
_Dbg_last_cmd='signal'
;;
# single-step
'step+' | 'step-' )
_Dbg_do_step "$_Dbg_cmd" $_Dbg_args
return 0
;;
# # toggle execution trace
# to | tog | togg | toggl | toggle )
# _Dbg_do_trace
# ;;
# List all breakpoints and actions.
L )
_Dbg_do_list_brkpt
_Dbg_list_watch
_Dbg_list_action
;;
# Remove all actions
A )
_Dbg_do_clear_all_actions $_Dbg_args
;;
# List debugger command history
H )
_Dbg_history_remove_item
_Dbg_do_history_list $_Dbg_args
;;
# S List subroutine names
S )
_Dbg_do_list_functions $_Dbg_args
;;
# Dump variables
V )
_Dbg_do_info_variables "$_Dbg_args"
;;
# Has to come after !! of "shell" listed above
# Run an item from the command history
\!* | history )
_Dbg_do_history $_Dbg_args
;;
'' )
# Redo last_cmd
if [[ -n $_Dbg_last_cmd ]] ; then
_Dbg_cmd=$_Dbg_last_cmd
_Dbg_redo=1
fi
;;
* )
if (( _Dbg_set_autoeval )) ; then
_Dbg_do_eval $_Dbg_cmd $_Dbg_args
else
_Dbg_undefined_cmd "$_Dbg_cmd"
_Dbg_history_remove_item
# local -a last_history=(`history 1`)
# history -d ${last_history[0]}
fi
;;
esac
done # while (( $_Dbg_redo ))
IFS=$_Dbg_space_IFS;
eval "_Dbg_prompt=$_Dbg_prompt_str"
}
_Dbg_preloop() {
if ((_Dbg_set_annotate)) ; then
_Dbg_annotation 'breakpoints' _Dbg_do_info breakpoints
# _Dbg_annotation 'locals' _Dbg_do_backtrace 3
_Dbg_annotation 'stack' _Dbg_do_backtrace 3
fi
}
_Dbg_postcmd() {
if ((_Dbg_set_annotate)) ; then
case $_Dbg_last_cmd in
break | tbreak | disable | enable | condition | clear | delete )
_Dbg_annotation 'breakpoints' _Dbg_do_info breakpoints
;;
up | down | frame )
_Dbg_annotation 'stack' _Dbg_do_backtrace 3
;;
* )
esac
fi
}
