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