Re: retrieving line number in case of error - "simple debugger"

Bryan Oakley napisał(a): 
set lineno 0
foreach line [split $script \n] {
    if {![info exists command]} {
        set command $line
    } else {
        append command \n $line
    }
    incr lineno
    if {[info complete $command]} {
        if {[catch $command err]} {
            puts "error on line $lineno: $err"
        }
        unset command
    }
}


That one's actually tricky.

(zoro) 55 % info complete "puts \\"
1
(zoro) 56 % eval "puts \\
x"
x

So this would not get parsed correctly. The other tricky thing is:

(zoro) 57 % eval "puts \\\\
x"

Since it's the opposite. The moral of the story is that \\ at the end of a line are a PITA in this case. I think it is much safer to do info complete and check for an even number of \ at the end (0 is also even for me :-). But there's probably still some other issue (or issues) that do not make it work... Anyway, here's "info complete on steroids" :-)

proc checkIfReallyComplete {line} {
    if {![info complete $line]} {
        return false
    }
    set count 0
    while {[string index $line end-$count] == "\\"} {
        incr count
    }
    if {$count % 2} {
        return false
    }  else  {
        return true
    }
}

So, perhaps the answer to your question is "info complete" and "catch". That is, you can use [info complete] to know if a line or lines of user-entered text is a complete command, and "catch" to execute the command and to retrieve the result.

I no longer believe in [info complete]. Well, it would be great if Tcl would have [info complete -strict] or something, that would actually check what the interpreter would do. For now, I guess most people could live with the equivalent above.

But, assuming he would have a proc called checkIfReallyComplete (or something), then it would be much better to:

set realcode ""
set script [.text get 1.0 end-1c]
set lineno 0
foreach line [split $script \n] {
    if {![info exists command]} {
        set command $line
    } else {
        append command \n $line
    }
    incr lineno
    if {[checkIfReallyComplete $command]} {
        append realcode [list set ::lineNumber $lineno] \n $command \n
    }
}
if {[catch $realcode]} {
    puts "Error in $::lineNumber $::errorInfo"
}

And even better, this would allow storing the "debugable" version of the script.

Then we would probably come up with a problem with control statements like for/foreach/while/if and would have to emulate those (preferably at "parser" level). Well then we will have custom control statements... (ie expect command from expect or tcom::foreach). I think this is a messy situation. Well, not to mention considering namespaces while parsing (ie :

namespace eval tcom {
    foreach ....
}

is not quite obvious. Especially with the following "crude" code:

set ns tcom
namespace eval $ns {
    foreach ....
}

Then there's metaprogramming ;-)

I wonder if an universal parser could be produced this way - one that would return return something similar to command tree so that everyone could debug it the way they want to (GUI, logging, whatever).

Just my 2 cents in this matter. If anybody wants to pursue this, I would love to see the results. I wanted to, but got scared by the problems above. Anyway, for a plain Tcl script, those problems do not really exist :-) So just reparsing using info complete + for/foreach/while/if would easily debug 90% of the scripts.

--
WK
.

Relevant Pages