# -*- shell-script -*-
# Call Stack routines
#
#   Copyright (C) 2002-2006, 2008-2010, 2014, 2017
#   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.

#================ VARIABLE INITIALIZATIONS ====================#

# _Dbg_stack_size: the number of entries on the call stack at the time
# the hook was entered. Note that bash updates the stack inside the
# debugger so it is important to save this value on entry. Also
# note that the most recent entries are pushed or at position 0.
# Thus to get position 0 of the debugged program we need to ignore leading
# any debugger frames.
typeset -i _Dbg_stack_size

# Where are we in stack? This can be changed by "up", "down" or
# "frame" commands. 0 means the most recent stack frame with respect
# to the debugged program and _Dbg_stack_size is the
# least-recent. Note that inside the debugger the stack is still
# updated.  On debugger entry, the value is set to 0
typeset -i  _Dbg_stack_pos

# Save the last-entered frame for to determine stopping when
# "set force" or step+ is in effect.
typeset _Dbg_frame_last_filename=''
typeset -i _Dbg_frame_last_lineno=0

#======================== FUNCTIONS  ============================#

function _Dbg_frame_adjust {
  (($# != 2)) && return 255

  typeset -i count=$1
  typeset -i signum=$2

  typeset -i retval
  _Dbg_frame_int_setup $count || return 2

  typeset -i pos
  if (( signum==0 )) ; then
      if (( count < 0 )) ; then
	  ((pos = _Dbg_stack_size + count - 1))
      else
	  ((pos = count))
      fi
  else
    ((pos=_Dbg_stack_pos+(count*signum)))
  fi

  if (( pos < 0 )) ; then
    _Dbg_errmsg 'Would be beyond bottom-most (most recent) entry.'
    return 1

  elif (( pos >= _Dbg_stack_size - 1 )) ; then
    _Dbg_errmsg 'Would be beyond top-most (least recent) entry.'
    return 1
  fi

  typeset -i adjusted_pos
  adjusted_pos=$(_Dbg_frame_adjusted_pos $pos)
  _Dbg_stack_pos=$pos

  ## DEBUG
  ## typeset -p pos
  ## typeset -p adjusted_pos
  ## typeset -p BASH_LINENO
  ## typeset -p BASH_SOURCE

  _Dbg_listline="${BASH_LINENO[adjusted_pos-1]}"
  # _Dbg_frame_last_lineno="$_Dbg_listline"
  _Dbg_frame_last_filename="${BASH_SOURCE[adjusted_pos]}"
  typeset filename; filename="$(_Dbg_file_canonic "$_Dbg_frame_last_filename")"
  _Dbg_frame_print '->' $_Dbg_stack_pos '' "$filename" $_Dbg_listline ''
  _Dbg_print_location_and_command "$_Dbg_listline"
  return 0
}

# Set $_Dbg_frame_filename to be frame file for the call stack at
# given position $1 or _Dbg_stack_pos if $1 is omitted. If $2 is
# given, it indicates if we want the basename only. Otherwise the
# $_Dbg_set_basename setting is used.  0 is returned if no error,
# nonzero means some sort of error.
_Dbg_frame_file() {
    (($# > 2)) && return 2
    # FIXME check to see that $1 doesn't run off the end.
    typeset -i pos=${1:-$_Dbg_stack_pos}
    typeset -i basename_only=${2:-$_Dbg_set_basename}
    _Dbg_frame_filename=${BASH_SOURCE[pos]}
    (( basename_only )) && _Dbg_frame_filename=${_Dbg_frame_filename##*/}
    return 0
}

# Set $_Dbg_frame_filename to be frame line for the call stack at
# given position $1 or _Dbg_stack_pos if $1 is omitted. 0 is returned
# if no error, nonzero means some sort of error.
_Dbg_frame_line() {
    (($# > 1)) && return 2
    # FIXME check to see that $1 doesn't run off the end.
    typeset -i pos=${1:-$_Dbg_stack_pos}
    _Dbg_frame_last_lineno="${BASH_LINENO[pos]}"
    return 0
}

# Tests for a signed integer parameter and set global retval
# if everything is okay. Retval is set to 1 on error
_Dbg_frame_int_setup() {

  _Dbg_not_running && return 1
  eval "$_Dbg_seteglob"
  if [[ $1 != '' && $1 != $_Dbg_signed_int_pat ]] ; then
      _Dbg_errmsg "Bad integer parameter: $1"
      eval "$_Dbg_resteglob"
      return 1
  fi
  eval "$_Dbg_resteglob"
  return 0
}

# Turn position $1 which uses 0 to represent the most-recent stack entry
# into which may have additional internal debugger frames pushed on.
function _Dbg_frame_adjusted_pos
{
    if (($# != 1)) ; then
	echo -n '-1'
	return 1
    fi
    typeset -i pos
    ((pos=${#FUNCNAME[@]} - _Dbg_stack_size + $1))
    echo -n $pos
    return 0
}

# Creates a parameter string for return in non-local variable
# _Dbg_parm_str. This is obtained from BASH_ARGC and BASH_ARGV.  On
# entry, _Dbg_next_argc, and _Dbg_next_argv should be set. These
# variables and _Dbg_parm_str are updated on exit.  _Dbg_next_argc is
# and integer index into BASH_ARGC and _Dbg_next_argv is and index
# into BASH_ARGV. On return
_Dbg_frame_fn_param_str() {
    (($# == 0)) || return 1
    _Dbg_is_int "$_Dbg_next_argc" || return 2
    _Dbg_is_int "$_Dbg_next_argv" || return 3

    # add 1 to argument count to compensate for this call (of zero
    # parameters) and at the same time we update _Dbg_next_argc for the
    # next call.
    #
    ((_Dbg_next_argc++))
    typeset -i arg_count=BASH_ARGC[$_Dbg_next_argc]
    if ((arg_count == 0)) ; then
	_Dbg_parm_str=''
    else
	typeset -i i
	_Dbg_parm_str="\"${BASH_ARGV[$_Dbg_next_argv+arg_count-1]}\""
	for (( i=1; i <= arg_count-1; i++ )) ; do
	    _Dbg_parm_str+=", \"${BASH_ARGV[$_Dbg_next_argv+arg_count-i-1]}\""
	done
	((_Dbg_next_argv+=arg_count))
    fi
    return 0
}

_Dbg_frame_set_fn_param() {
    (($# == 1)) || return 1
    typeset -i skip_count=$1
    # Set to ignore this call in computation
    _Dbg_next_argc=1
    _Dbg_next_argv=1

    typeset -i i
    for (( i=1; i <= skip_count; i++ )) ; do
	typeset -i arg_count=${BASH_ARGC[$i]}
	((_Dbg_next_argv+=arg_count))
    done
    # After this function returns argv will be one greater. So adjust
    # for that now.
    ((_Dbg_next_argc=skip_count))
    ((_Dbg_next_argv--))

    ## Debug:
    ## typeset -p BASH_ARGC
    ## typeset -p BASH_ARGV
    ## typeset -p FUNCNAME
    ## typeset -p _Dbg_next_argc
    ## typeset -p _Dbg_next_argv
}

# Print "##" or "->" depending on whether or not $1 (POS) is a number
# between 0 and _Dbg_stack_size-1. For POS, 0 is the top-most
# (newest) entry. For _Dbg_stack_pos, 0 is the bottom-most entry.
# 0 is returnd on success, nonzero on failure.
function _Dbg_frame_prefix {
    typeset    prefix='??'
    typeset -i rc=0
    if (($# == 1)) ; then
	typeset -i pos=$1
	if ((pos < 0)) ; then
	    rc=2
	elif ((pos >= _Dbg_stack_size)) ; then
	    rc=3
	elif (( pos == _Dbg_stack_pos )) ; then
	    prefix='->'
	else
	    prefix='##'
	fi
    else
	rc=1
    fi
    echo -n $prefix
    return $rc
}

# Print one line in a call stack
function _Dbg_frame_print {
    typeset prefix=$1
    typeset -i pos=$2
    typeset fn=$3
    typeset filename="$4"
    typeset -i line=$5
    typeset args="$6"
    typeset callstr=$fn
    [[ -n $args ]] && callstr="$callstr($args)"
    _Dbg_msg "$prefix$pos in file \`$filename' at line $line"
}
