Advice and Suggestions for a Debug Feature

[Jerome H. Fine]

I have been investigating the possibility of adding an enhanced
feature to a debug program. There does not seem to be anything
specific about the concept, so it should be applicable to every
current CPU in addition to most old CPUs.

The current syntax for many debuggers uses the letter "S" along
with an optional value to specify a Single Step (or ONE instruction
to be executed when the value is omitted) or a number of Single
Steps (a number of instructions) equal to the optional value.  Of
the two different debuggers for the CPU, operating system and
code which I use most of the time, both debuggers display the
same information for each of the Single Steps, specifically the
actual instruction that will executed and the values of the registers
immediately before the instruction is executed.  So if a total of
5 instructions are executed, the display is updated 5 times.

For the debugger that I wish to enhance, the actual syntax is:
value1,value2,value3;S
and at present, value2 and value3 are ignored.

My question concerns using value2 and value3 to specify the
limits by which the stack pointer may change, specifically by
adding data (also called a push) and subtracting data (also
called a pop) to the stack in whatever manner the program
uses to alter the value of the stack pointer register, respectively.

Note that for many CPUs, adding values (a push) results in the
stack pointer becoming numerically smaller (unsigned of course).
Internally, the code would handle the actual arithmetic.

For example, if the user specifies:
45,4,2;S     then:
(a)  Up to 45 instructions are executed
(b)  If the stack has 4 or more pushes, instructions stop
(c)  If the stack has 2 or more pops, instructions stop

Additional information:
(a)  Scroll / NoScroll is enabled, so the user can
      pause / resume at any time
(b) Any single character by the user stops instructions
(c) All pushes and pops are noted AFTER the current
      instruction is executed - which allows subroutine calls
      to be automatically handled as per the examples

Defaults:
(a)  If no values are supplied (ONLY ";S"), then "1;S"
      is assumed and ONE instruction is executed
(b)  The debugger supports <ESC> in place of ";S" which
       supports Single Stepping with a single key
(c)  If any value is omitted, that limitation does not apply

More Examples:
,,1;S           instructions are executed until the code returns
                  from the subroutine - IF the current instruction
                  calls a subroutine
,,1;S           instructions are executed until the code returns
                  to the previous subroutine - IF the current
                  instruction does NOT call a subroutine
,,1;S           instructions are executed until the code restores
                  the stack pointer - IF the current instruction
                  does a push or creates space on the stack
,1,2;S         instructions are executed until the code calls a
                  second subroutine OR the code returns to the
                  previous subroutine - IF the current code calls
                  a subroutine
55,1,1;S    55 instructions are executed OR until the code
                  calls a second subroutine OR the code returns
                  to the current subroutine - IF the current
                  instruction calls a subroutine
55,1,1;S    55 instructions are executed OR until the code
                  calls a subroutine OR the code returns the the
                  previous subroutine - IF the current instruction
                  does NOT call a subroutine

Many more examples could be considered, but that seems to
be about the concept that I have.  Please advise and comment.
Please make any suggestions that would be any improvement
and, most important, point out any problems that I have not
considered.

Jerome Fine