Universe has a debugger command that will allow you to skip through a
subroutine when doing single-step debugging (hazy memory recalls this being
an "S").

No reference to similar functionality is in the D3 online docs. Are any of
you aware of an equivilant undocumented feature that would do what I want?


thanks

"Brian Bond" <brian (AT) XYZXYZXYZXYZbonanzapress (DOT) com> wrote in
news:11lafkl96ufvfec (AT) corp (DOT) supernews.com:

Ctrl+J will single-step the D3 debugger. You will want to do an E1
and C! first.

--
================================================== =========
Norman Morgan <> http://www.norm-morgan.com
================================================== =========
Sometimes I wake up grumpy. Other times I let her sleep.
================================================== =========

I think what he is asking for the a switch that can be thrown that will
cause the program to enter the debugger on a subroutine call or return.
That functionality doesn't exist in D3 that I am aware of. I wish
that it did. It did exist in the Sanyo/Icon version years ago and it
was very helpful to skip the 1000+ line prompter routine.

From the D3 Reference manual:

n

Similar to the FlashBASIC debugger "g" command except that if
single-stepping is active, the <ctrl>+n command will step "over" any
subroutine calls.

Syntax: <ctrl>+n

Ed

"Brian Bond" <brian (AT) XYZXYZXYZXYZbonanzapress (DOT) com> wrote

Ed Sheehan wrote:
The only problem is that the D3 debugger shows the line you have *just*
executed, and by that time, you are already into the subroutine.
It would be more useful if the D3 debugger (which I hate) would show you
the line you were *about* to execute.


--
Bob Little
Graphik Dimensions, Ltd.
High Point, NC

The <ctrl>+n doesn't seem to do much of anything.

Not that there's a chance it will ever happen, but just for fun, what would
improvements you like to see in a new version of the debugger? I'll start
with #1:

1 - Functionality to actually debug programs.



"Bob Little" <rlittle (AT) graphikdimensions (DOT) com> wrote

Try using G<Enter> instead of <Ctrl>J. This might show the "before" state. I
don't have a D3 system just now to test this, so My Memory May Vary. The
manual does say that if you use C! it switches to "after." Not much use to
omit that if you want to see stuff though.

Ed

"Bob Little" <rlittle (AT) graphikdimensions (DOT) com> wrote

I wrote the C and CTL+J portions of the debugger in 1980. I got tired of
having to type L+return G+return to watch my programs run. In hind sight,
it probably would have been better to combine the G + L commands instead of
the L + G, but it also would have been ton's harder.

The reason you can't single step OVER a subroutine in D3 is because part of
the subroutine calling interface is to setup a new debugger control block
for that second level program. That dbcb has its own set of controls blah
blah and it doesn't inherit them because they might not match and when it
returns it doesn't pop the old dbcb off a stack as would make sense, but
rebuilds it like it had never been there. All gut-level stuff that hasn't
changed in 20 years for only one reason: no one's around anymore who
understands it.

Mark Brown

"Ed Sheehan" <NOedsSPAM (AT) xmission (DOT) com> wrote

Sheesh!

They should change the name from "D3" to "The Flying Dutchman".


"Mark Brown" <mbrown (AT) drexelmgt (DOT) com> wrote

Brian Bond wrote:
1. The afore mentioned feature of showing the line of code *before* it's
executed.
2. Keeping the watch on a variable through all subroutine calls. I.E. I
have to "re-watch" a variable each time I enter the external subroutine.
I'd like to have it stay set, so that each time I entered the sub, my
watch would still be there.
3. Being able to examine and modify any single attribute or value of a
dynamic array.

When I was on an Ultimate system, I got used to their debugger. I guess
I got spoiled.


Bob Little
Graphik Dimensions, Ltd.