# -*- shell-script -*-
# gdb-like "kill" debugger command
#
#   Copyright (C) 2002-2006, 2008, 2009, 2010-2011, 2016
#   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.

_Dbg_help_add kill \
"**kill** [*signal-number*]

Send this process a POSIX signal ('9' for 'SIGKILL' or 'kill -SIGKILL')

9 is a non-maskable interrupt that terminates the program. If program is threaded it may
be expedient to use this command to terminate the program.

However other signals, such as those that allow for the debugged to handle them can be
sent.

Giving a negative number is the same as using its positive value.

Examples:
---------

    kill                # non-interuptable, nonmaskable kill
    kill 9              # same as above
    kill -9             # same as above
    kill 15             # nicer, maskable TERM signal
    kill! 15            # same as above, but no confirmation

See also:
---------

**quit** for less a forceful termination command.
**run** is a way to restart the debugged program.
Also similar is the **signal** command."

proc _Dbg_do_kill {
    if (($# > 1)) {
        _Dbg_errmsg "Got $Argc parameters, but need 0 or 1."
        return 1
    }
    typeset _Dbg_prompt_output=$(_Dbg_tty:-/dev/null)
    typeset signal='-9'
    (($# == 1)) && global signal := $1

    if [[ ${signal:0:1} != '-' ]]  {
        _Dbg_errmsg "Kill signal ($signal) should start with a '-'"
        return 2
    }

    _Dbg_confirm "Send kill signal $(signal) which may terminate the debugger? (y/N): " 'N'

    if [[ $_Dbg_response == [yY] ]]  {
        matchstr $signal {
            -9 | -SEGV  {
                _Dbg_cleanup2
                }
        }
        kill $signal $Pid
    } else {
        _Dbg_msg "Kill not done - not confirmed."
        return 3
    }
    return 0
}
(CommandList
  children: [
    (C {(_Dbg_help_add)} {(kill)} 
      {
        (DQ ("**kill** [*signal-number*]\n") ("\n") 
          ("Send this process a POSIX signal ('9' for 'SIGKILL' or 'kill -SIGKILL')\n") ("\n") ("9 is a non-maskable interrupt that terminates the program. If program is threaded it may\n") 
          ("be expedient to use this command to terminate the program.\n") ("\n") ("However other signals, such as those that allow for the debugged to handle them can be\n") 
          ("sent.\n") ("\n") ("Giving a negative number is the same as using its positive value.\n") ("\n") ("Examples:\n") 
          ("---------\n") ("\n") ("    kill                # non-interuptable, nonmaskable kill\n") 
          ("    kill 9              # same as above\n") ("    kill -9             # same as above\n") 
          ("    kill 15             # nicer, maskable TERM signal\n") ("    kill! 15            # same as above, but no confirmation\n") ("\n") ("See also:\n") 
          ("---------\n") ("\n") ("**quit** for less a forceful termination command.\n") 
          ("**run** is a way to restart the debugged program.\n") ("Also similar is the **signal** command.")
        )
      }
    )
    (FuncDef
      name: _Dbg_do_kill
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DParen
                          child: 
                            (ArithBinary
                              op_id: Arith_Great
                              left: (ArithWord w:{($ VSub_Pound "$#")})
                              right: (ArithWord w:{(Lit_Digits 1)})
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(_Dbg_errmsg)} 
                      {(DQ ("Got ") ($ VSub_Pound "$#") (" parameters, but need 0 or 1."))}
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
                  ]
                  spids: [-1 116]
                )
              ]
              spids: [-1 133]
            )
            (C {(typeset)} 
              {(Lit_VarLike "_Dbg_prompt_output=") 
                (BracedVarSub
                  token: <VSub_Name _Dbg_tty>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonHyphen
                      arg_word: {(Lit_Slash /) (dev) (Lit_Slash /) (null)}
                    )
                  spids: [139 146]
                )
              }
            )
            (C {(typeset)} {(Lit_VarLike "signal=") (SQ <-9>)})
            (AndOr
              children: [
                (DParen
                  child: 
                    (ArithBinary
                      op_id: Arith_DEqual
                      left: (ArithWord w:{($ VSub_Pound "$#")})
                      right: (ArithWord w:{(Lit_Digits 1)})
                    )
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:signal)
                      op: Equal
                      rhs: {(DQ ($ VSub_Number "$1"))}
                      spids: [168]
                    )
                  ]
                  spids: [168]
                )
              ]
              op_id: Op_DAmp
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobNEqual
                              left: 
                                {
                                  (BracedVarSub
                                    token: <VSub_Name signal>
                                    suffix_op: 
                                      (Slice
                                        begin: (ArithWord w:{(Lit_Digits 0)})
                                        length: (ArithWord w:{(Lit_Digits 1)})
                                      )
                                    spids: [179 185]
                                  )
                                }
                              right: {(SQ <->)}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(_Dbg_errmsg)} 
                      {(DQ ("Kill signal (") ($ VSub_Name "$signal") (") should start with a '-'"))}
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(2)})
                  ]
                  spids: [-1 197]
                )
              ]
              spids: [-1 214]
            )
            (C {(_Dbg_confirm)} 
              {
                (DQ ("Send kill signal ") (${ VSub_Name signal) 
                  (" which may terminate the debugger? (y/N): ")
                )
              } {(SQ <N>)}
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {($ VSub_Name "$_Dbg_response")}
                              right: {(Lit_Other "[") (yY) (Lit_Other "]")}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Case
                      to_match: {($ VSub_Name "$signal")}
                      arms: [
                        (case_arm
                          pat_list: [{(-9)} {(-SEGV)}]
                          action: [(C {(_Dbg_cleanup2)})]
                          spids: [260 266 272 -1]
                        )
                      ]
                      spids: [253 257 275]
                    )
                    (C {(kill)} {($ VSub_Name "$signal")} {($ VSub_Dollar "$$")})
                  ]
                  spids: [-1 250]
                )
              ]
              else_action: [
                (C {(_Dbg_msg)} {(DQ ("Kill not done - not confirmed."))})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(3)})
              ]
              spids: [285 300]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
          spids: [101]
        )
      spids: [97 100]
    )
  ]
)