Eskil

        "&Debug" {
            "Reread &Source" -acc F1 -cmd _rs
        }
    }
}

# Main call for psmenu. Optional arguments are for internal use.
proc psmenu::psmenu {top args} {
    set def [lindex $args end]
    set args [lrange $args 0 end-1]

    set opts(-top) ""
    set opts(-level) ""
    set opts(-level) ""
    set opts(-recursive) 0
    array set opts $args

    # Is given arg a toplevel or menu?
    if {$top eq "."} {
        set m .m
    } else {
        if {[winfo class $top] ne "Menu"} {
            set m $top.m
        } else {
            # A menu was given, assume -top
            set m $top
            set top $opts(-top)
        }
    }

    if {$opts(-recursive)} {
        # Locate a free window name for the menu, for internal call
        while {[winfo exists $m]} {
            if {[regexp {^(.*?)(\d+)$} $m -> prefix index]} {
                incr index
            } else {
                set prefix $m
                set index 0
            }
            set m $prefix$index
        }
    }
    # It might exist for a second user call
    if { ! [winfo exists $m]} {
        # Create
        menu $m -tearoff 0
    }

    if {$opts(-level) eq ""} {
        # Store initial level to handle scope when recursing cascades
        set opts(-level) [uplevel 1 info level]
    }
    if {$opts(-top) eq ""} {
        set opts(-top) $top
        $top configure -menu $m
    }

    # Comments in definition block
    set def [regsub -all -line {^\s*#.*$} $def ""]

    set state ""

        # Conditionals
        if {$label eq "if"} {
            # TBD support elseif
            set ifExpr [lindex $entry 1]
            set body   [lindex $entry 2]
            set elseBody [lindex $entry 4]
            set cond [uplevel \#$opts(-level) [list expr $ifExpr]]
            #puts "if expression '$ifExpr' = $cond"
            if {$cond} {
                # Prepend
                set def [list {*}$body {*}$def]
            } elseif {$elseBody ne ""} {
                set def [list {*}$elseBody {*}$def]
            }
            continue
        }

        # Recognise Cascade by even args "Name ?opts? Def"
        # An item will be "Name ?opts?", i.e odd
        if {[llength $entry] % 2 == 0} {
            # Cascade
            set options [lrange $entry 1 end-1]
            set body [lindex $entry end]
            # Recurse cascade defintion
            set cascade [psmenu $m {*}[array get opts] -recursive 1 $body]
            # Since -menu is last, processing below can assume that.
            lappend options -menu $cascade
        } else {
            set options [lrange $entry 1 end]
        }
        #puts "Label   '$label'"
        #puts "Options '$options'"

        set doBind ""
        set command ""
        set value ""
        set variable ""
        set cfgvar ""
        set default 0
        foreach {opt val} $options {
            set val [uplevel \#$opts(-level) [list subst $val]]
            switch -- $opt {
                -ul - -underline {
                    lappend newOptions -underline $val
                }
                -var - -variable {
                    if {$type eq "cascade"} {
                        set variable $val

                }
                -onvalue {
                    lappend newOptions -onvalue $val
                }
                -menu {
                    lappend newOptions -menu $val
                    if {$variable ne ""} {
                        uplevel \#$opts(-level) [list set $variable $val]
                    }
                }
                -def {
                    set default $val
                }
                default {
                    # Just let through
                    lappend newOptions $opt $val
                }
            }
        }

        if {$variable ne ""} {
            upvar \#$opts(-level) $variable __vv
            if {![info exists __vv]} {
                set __vv $default
            }
        }

        # TK helper to handle & in label
        ::tk::AmpMenuArgs $m add $type {*}$newOptions

        if {$cfgvar ne ""} {
            set ix [$m index end]
            set tmp [list $m entryconfigure $ix]
            uplevel \#$opts(-level) [list set $cfgvar $tmp]
        }

        if {$doBind ne ""} {
            if {[regexp {^(.*)-(.*)$} $doBind -> pre post]} {
                if {$pre eq "Ctrl"} {
                    set pre "Control"
                }
                set doBind $pre-Key-$post
            } else {
                set doBind Key-$doBind
            }
            #puts "Binding '$doBind' '$command'"
            bind $opts(-top) <$doBind> $command
        }
    }

    return $m
}

# Extract one entry from definiton