::proc AssureTraceWindow {} {
        variable trace
        if {![info exists trace]} {
            return 0
        }
        if {!$trace} {
            return 0
            }
            if {[catch {package require Tk}]} {
                return 0
        }
        if {![winfo exists .tclreadline_trace.text]} {
            toplevel .tclreadline_trace
            text .tclreadline_trace.text \
                -yscrollcommand { tclreadline::TraceReconf } \
                -wrap none
            scrollbar .tclreadline_trace.scroll \

# completer.
# If inhibit is non-zero, the result will be
# formatted such that readline will not insert
# a space after a complete (single) match.
#
proc TryFromList {text lst {allow ""} {inhibit 0}} {

    # puts stderr "(CompleteFromList) \ntext=|$text|"
    # puts stderr "(CompleteFromList) lst=|$lst|"
    set pre [GetQuotedPrefix ${text}]
    set matches [MatchesFromList ${text} ${lst} ${allow}]
        set pre [GetQuotedPrefix $text]
        set matches [MatchesFromList $text $lst $allow]

    # puts stderr "(CompleteFromList) matches=|$matches|"
    if {1 == [llength $matches]} { ; # unique match
        # puts stderr \nunique=$matches\n
        # puts stderr "\n|${pre}${matches}[Right ${pre}]|\n"
        set null [string index $matches 0]
        if {("<" == ${null} || "?" == ${null}) && \
            -1 == [string first ${null} ${allow}]
            if {("<" == $null || "?" == $null)
                    && -1 == [string first $null $allow]} {
        } {
            set completion [string trim "[list $text] $lst"]
        } else {
            set completion [string trim ${pre}${matches}[Right ${pre}]]
                set completion [string trim ${pre}${matches}[Right $pre]]
        }
        if {$inhibit} {
            return [list $completion {}]
        } else {
            return $completion
        }
    } elseif {"" != ${matches}} {
        } elseif {"" != $matches} {
        # puts stderr \nmore=$matches\n
        set longest [CompleteLongest ${matches}]
            set longest [CompleteLongest $matches]
        # puts stderr longest=|$longest|
        if {"" == $longest} {
            return [string trim "[list $text] ${matches}"]
                return [string trim "[list $text] $matches"]
        } else {
            return [string trim "${pre}${longest} ${matches}"]
                return [string trim "${pre}${longest} $matches"]
        }
    } else {
        return ""; # nothing to complete
    }
}

#**
# CompleteFromList will never return an empty string.
# completes, if a completion can be done, or ring
# the bell if not. If inhibit is non-zero, the result
# will be formatted such that readline will not insert
# a space after a complete (single) match.
#
proc CompleteFromList {text lst {allow ""} {inhibit 0}} {
    set result [TryFromList ${text} ${lst} ${allow} ${inhibit}]
    if {![llength ${result}]} {
        set result [TryFromList $text $lst $allow $inhibit]
        if {![llength $result]} {
        Alert
        # return [string trim [list ${text}] ${lst}"]
        if {[llength ${lst}]} {
            return [string trim "${text} ${lst}"]
            # return [string trim [list $text] $lst"]
            if {[llength $lst]} {
                return [string trim "$text $lst"]
        } else {
            return [string trim [list ${text} {}]]
                return [string trim [list $text {}]]
        }
    } else {
        return ${result}
            return $result
    }
}

#**
# CompleteBoolean does a CompleteFromList
# with a list of all valid boolean values.
#

    }

    set executables 0
    foreach dir [split $env(PATH) :] {
        if {[catch [list set files [glob -nocomplain ${dir}/*]]]} { continue }
        foreach file $files {
            if {[file executable $file]} {
                lappend executables [file tail ${file}]
                    lappend executables [file tail $file]
            }
        }
    }
}

#**
# build a list hosts from the /etc/hosts file.

    # read the host table only once.
    #
    variable hosts
    if {![info exists hosts]} {
        catch {
            set hosts ""
            set id [open /etc/hosts r]
            if {0 != ${id}} {
                while {-1 != [gets ${id} line]} {
                    regsub {#.*} ${line} {} line
                    if {[llength ${line}] >= 2} {
                        lappend hosts [lindex ${line} 1]
                if {0 != $id} {
                    while {-1 != [gets $id line]} {
                        regsub {#.*} $line {} line
                        if {[llength $line] >= 2} {
                            lappend hosts [lindex $line 1]
                    }
                }
                close ${id}
                    close $id
            }
        }
    }
    return ${hosts}
        return $hosts
}

#**
# never return an empty string, never complete.
# This is useful for showing options lists for example.
#
proc DisplayHints {lst} {
    return [string trim "{} ${lst}"]
        return [string trim "{} $lst"]
}

#**
# find (partial) matches for `text' in `lst'. Ring
# the bell and return the whole list, if the user
# tries to complete ?..? options or <..> hints.
#

    set null [string index $text 0]
    foreach char {< ?} {
        if {$char == $null && -1 == [string first $char $allow]} {
            Alert
            return $lst
        }
    }
    # puts stderr "(MatchesFromList) text=$text"
    # puts stderr "(MatchesFromList) lst=$lst"
    foreach word $lst {
        if {[string match ${text}* ${word}]} {
            lappend result ${word}
            if {[string match ${text}* $word]} {
                lappend result $word
        }
    }
    return [string trim $result]
}

#**
# invoke cmd with a (hopefully) invalid string and
# parse the error message to get an option list.
# The strings are carefully chosen to match the
# results produced by known tcl routines. It's a
# pity, that not all object commands generate
# standard error messages!
#
# @param   cmd
# @return  list of options for cmd
# @date    Sep-14-1999
#
proc TrySubCmds {text cmd} {

    set trystring ----

    # try the command with and w/o trystring.
    # Some commands, e.g.
    #     .canvas bind
    # return an error if invoked w/o arguments
    # but not, if invoked with arguments. Breaking
    # the loop is eventually done at the end ...
    #
    for {set str ${trystring}} {1} {set str ""} {
        for {set str $trystring} {1} {set str ""} {

        set code [catch {set result [eval ${cmd} ${str}]} msg]
            set code [catch {set result [eval $cmd $str]} msg]
        set result ""

        if {$code} {
            set tcmd [string trim ${cmd}]
                set tcmd [string trim $cmd]
            # puts stderr msg=$msg
            # XXX see
            #         tclIndexObj.c
            #         tkImgPhoto.c
            # XXX
            if {[regexp \
                {(bad|ambiguous|unrecognized) .*"----": *must *be( .*$)} \
                ${msg} all junk raw]
                         $msg all junk raw]} {
            } {
                regsub -all -- , ${raw} { } raw
                set len [llength ${raw}]
                set len_2 [expr ${len} - 2]
                for {set i 0} {${i} < ${len}} {incr i} {
                    set word [lindex ${raw} ${i}]
                    if {"or" != ${word} && ${i} != ${len_2}} {
                        lappend result ${word}
                    regsub -all -- , $raw { } raw
                    set len [llength $raw]
                    set len_2 [expr {$len - 2}]
                    for {set i 0} {$i < $len} {incr i} {
                        set word [lindex $raw $i]
                        if {"or" != $word && $i != $len_2} {
                            lappend result $word
                    }
                }
                if {[string length ${result}] && \
                    -1 == [string first ${trystring} ${result}]
                    if {[string length $result]
                            && -1 == [string first $trystring $result]} {
                } {
                    return [TryFromList ${text} ${result}]
                        return [TryFromList $text $result]
                }

            } elseif {[regexp \
                "wrong # args: should be \"?${tcmd}\[^ \t\]*\(.*\[^\"\]\)" \
                ${msg} all hint]
                               $msg all hint]} {

            } {

                # XXX see tclIndexObj.c XXX
                if {-1 == [string first ${trystring} ${hint}]} {
                    if {-1 == [string first $trystring $hint]} {
                    return [DisplayHints [list <[string trim $hint]>]]
                }
            } else {
                # check, if it's a blt error msg ...
                #
                set msglst [split ${msg} \n]
                foreach line ${msglst} {
                    set msglst [split $msg \n]
                    foreach line $msglst {
                    if {[regexp "${tcmd}\[ \t\]\+\(\[^ \t\]*\)\[^:\]*$" \
                        ${line} all sub]
                                 $line all sub]} {
                    } {
                        lappend result [list ${sub}]
                            lappend result [list $sub]
                    }
                }
                if {[string length ${result}] && \
                    -1 == [string first ${trystring} ${result}]
                    if {[string length $result]
                            && -1 == [string first $trystring $result]} {
                } {
                    return [TryFromList ${text} ${result}]
                        return [TryFromList $text $result]
                }
            }
        }
        if {"" == ${str}} {
            if {"" == $str} {
            break
        }
    }
    return ""
}

#**
# try to get casses for commands which
    # try to get classes for commands which
# allow `configure' (cget).
# @param  command.
# @param  optionsT where the table will be stored.
# @return number of options
# @date   Sat-Sep-18
#
proc ClassTable {cmd} {

    # first we build an option table.
    # We always use `configure' here,
    # because cget will not return the
    # option table.
    #
    if {[catch [list set option_table [eval ${cmd} configure]] msg]} {
        if {[catch [list set option_table [eval $cmd configure]] msg]} {
        return ""
    }
    set classes ""
    foreach optline ${option_table} {
        if {5 != [llength ${optline}]} continue else {
            lappend classes [lindex ${optline} 2]
        foreach optline $option_table {
            if {5 != [llength $optline]} {
                continue
            } else {
                lappend classes [lindex $optline 2]
        }
    }
    return ${classes}
        return $classes
}

#**
# try to get options for commands which
# allow `configure' (cget).
# @param command.
# @param optionsT where the table will be stored.
# @return number of options
# @date Sep-14-1999
#
proc OptionTable {cmd optionsT} {
    upvar $optionsT options
    # first we build an option table.
    # We always use `configure' here,
    # because cget will not return the
    # option table.
    #
    if {[catch [list set option_table [eval ${cmd} configure]] msg]} {
        if {[catch [list set option_table [eval $cmd configure]] msg]} {
        return 0
    }
    set retval 0
    foreach optline ${option_table} {
        if {5 == [llength ${optline}]} {
        foreach optline $option_table {
            if {5 == [llength $optline]} {
            # tk returns a list of length 5
            lappend options(switches) [lindex ${optline} 0]
            lappend options(value)    [lindex ${optline} 4]
                lappend options(switches) [lindex $optline 0]
                lappend options(value)    [lindex $optline 4]
            incr retval
        } elseif {3 == [llength ${optline}]} {
            } elseif {3 == [llength $optline]} {
            # itcl returns a list of length 3
            lappend options(switches) [lindex ${optline} 0]
            lappend options(value)    [lindex ${optline} 2]
                lappend options(switches) [lindex $optline 0]
                lappend options(value)    [lindex $optline 2]
            incr retval
        }
    }
    return $retval
}

#**
# try to complete a `cmd configure|cget ..' from the command's options.
# @param   text start line cmd, standard tclreadlineCompleter arguments.
# @return  -- a flag indicating, if (cget|configure) was found.
# @return  resultT -- a tclreadline completer formatted string.
# @date    Sep-14-1999
#
proc CompleteFromOptions {text start line resultT} {

    upvar ${resultT} result
        upvar $resultT result
    set result ""

    # check if either `configure' or `cget' is present.
    #
    set lst [ProperList ${line}]
        set lst [ProperList $line]
    foreach keyword {configure cget} {
        set idx [lsearch ${lst} ${keyword}]
        if {-1 != ${idx}} {
            set idx [lsearch $lst $keyword]
            if {-1 != $idx} {
            break
        }
    }
    if {-1 == ${idx}} {
        if {-1 == $idx} {
        return 0
    }

    if {[regexp {(cget|configure)$} ${line}]} {
        if {[regexp {(cget|configure)$} $line]} {
        # we are at the end of (configure|cget)
        # but there's no space yet.
        #
        set result ${text}
            set result $text
        return 1
    }

    # separate the command, but exclude (cget|configure)
    # because cget won't return the option table. Instead
    # OptionTable always uses `configure' to get the
    # option table.
    #
    set cmd [lrange ${lst} 0 [expr ${idx} - 1]]
        set cmd [lrange $lst 0 [expr {$idx - 1}]]

    TraceText ${cmd}
    if {0 < [OptionTable ${cmd} options]} {
        TraceText $cmd
        if {0 < [OptionTable $cmd options]} {

        set prev [PreviousWord ${start} ${line}]
        if {-1 != [set found [lsearch -exact $options(switches) ${prev}]]} {
            set prev [PreviousWord $start $line]
            if {-1 != [set found [lsearch -exact $options(switches) $prev]]} {

            # complete only if the user has not
            # already entered something here.
            #
            if {![llength ${text}]} {
                if {![llength $text]} {

                # check first, if the SpecificSwitchCompleter
                # knows something about this switch. (note that
                # `prev' contains the switch). The `0' as last
                # argument makes the SpecificSwitchCompleter
                # returning "" if it knows nothing specific
                # about this switch.
                #
                set values [SpecificSwitchCompleter \
                ${text} ${start} ${line} ${prev} 0]
                                    $text $start $line $prev 0]

                if [string length ${values}] {
                    set result ${values}
                    if [string length $values] {
                        set result $values
                    return 1
                } else {
                    set val [lindex $options(value) ${found}]
                    if [string length ${val}] {
                        set val [lindex $options(value) $found]
                        if [string length $val] {
                        # return the old value only, if it's non-empty.
                        # Use this double list to quote option
                        # values which have to be quoted.
                        #
                        set result [list [list ${val}]]
                            set result [list [list $val]]
                        return 1
                    } else {
                        set result ""
                        }
                        return 1
                    }
                }
            } else {
                set result [SpecificSwitchCompleter \
                ${text} ${start} ${line} ${prev} 1]
                                    $text $start $line $prev 1]
                return 1
            }

        } else {
            set result [CompleteFromList ${text} \
            [RemoveUsedOptions ${line} $options(switches)]]
                set result [CompleteFromList $text \
                                [RemoveUsedOptions $line $options(switches)]]
            return 1
        }
    }
    return 1
}

proc ObjectClassCompleter {text start end line pos resultT} {
    upvar ${resultT} result
    set cmd [Lindex ${line} 0]
    if {"." == [string index ${line} 0]} {
        upvar $resultT result
        set cmd [Lindex $line 0]
        if {"." == [string index $line 0]} {
        # it's a widget. Try to get it's class name.
        #
        if {![catch [list set class [winfo class [Lindex ${line} 0]]]]} {
            if {![catch [list set class [winfo class [Lindex $line 0]]]]} {
            if {[string length [info proc ${class}Obj]]} {
                set result [${class}Obj ${text} ${start} ${end} ${line} ${pos}]
                    set result [${class}Obj $text $start $end $line $pos]
                # puts stderr result=|$result|
                # joze, Thu Sep 30 16:43:17 1999
                if {[string length $result]} {
                    return 1
                } else {
                    return 0
                }
            } else {
                return 0
            }
        }
    }
    if {![catch {set type [image type $cmd]}]} {
        switch -- ${type} {
            switch -- $type {
            photo {
                set result [PhotoObj ${text} ${start} ${end} ${line} ${pos}]
                    set result [PhotoObj $text $start $end $line $pos]
                return 1
            }
            default {
                # let the fallback completers do the job.
                return 0
            }
        }
    }
    return 0
}

proc CompleteFromOptionsOrSubCmds {text start end line pos} {
    if [CompleteFromOptions ${text} ${start} ${line} from_opts] {
        if [CompleteFromOptions $text $start $line from_opts] {
        # always return, if CompleteFromOptions returns non-zero,
        # that means (configure|cget) were present. This ensures
        # that TrySubCmds will not configure something by chance.
        #
        return ${from_opts}
            return $from_opts
    } else {
        # puts stderr \n\n[lrange [ProperList ${line}] 0 [expr $pos - 1]]\n
        return [TrySubCmds ${text} \
        [lrange [ProperList ${line}] 0 [expr $pos - 1]]]
            return [TrySubCmds $text \
                        [lrange [ProperList $line] 0 [expr {$pos - 1}]]]
    }
    return ""
}

#**
# TODO: shit. make this better!
# @param  text, a std completer argument (current word).
# @param  fullpart, the full text of the current position.
# @param  lst, the list to complete from.
# @param  pre, leading `quote'.
# @param  sep, word separator.
# @param  post, trailing `quote'.
# @return a formatted completer string.
# @date   Sep-15-1999
#
proc CompleteListFromList {text fullpart lst pre sep post} {

    # puts stderr ""
    # puts stderr text=|$text|
    # puts stderr lst=|$lst|
    # puts stderr pre=|$pre|
    # puts stderr sep=|$sep|
    # puts stderr post=|$post|

    if {![string length ${fullpart}]} {
        if {![string length $fullpart]} {

        # nothing typed so far. Insert a $pre
        # and inhibit further completion.
        #
        return [list ${pre} {}]
            return [list $pre {}]

    } elseif {${post} == [String index ${text} end]} {
        } elseif {$post == [String index $text end]} {

        # finalize, append the post and a space.
        #
        set diff \
        [expr [CountChar ${fullpart} ${pre}] - [CountChar ${fullpart} ${post}]]
        for {set i 0} {${i} < ${diff}} {incr i} {
            append text ${post}
                [expr {[CountChar $fullpart $pre] - [CountChar $fullpart $post]}]
            for {set i 0} {$i < $diff} {incr i} {
                append text $post
        }
        append text " "
        return ${text}
            return $text

    } elseif {![regexp -- ^\(.*\[${pre}${sep}\]\)\(\[^${pre}${sep}\]*\)$ \
        ${text} all left right]
                        $text all left right]} {
    } {
        set left {}
        set right ${text}
            set right $text
    }

    # TraceVar left
    # TraceVar right

    # puts stderr \nleft=|$left|
    # puts stderr \nright=|$right|
    set exact_matches [MatchesFromList ${right} ${lst}]
        set exact_matches [MatchesFromList $right $lst]
    # TODO this is awkward. Think of making it better!
    #
    if {1 == [llength ${exact_matches}] && -1 != [lsearch ${lst} ${right}]
        if {1 == [llength $exact_matches] && -1 != [lsearch $lst $right]
    } {
        #set completion [CompleteFromList ${right} [list ${sep} ${post}] 1]
            #set completion [CompleteFromList $right [list $sep $post] 1]
        return [list ${left}${right}${sep} {}]
    } else {
        set completion [CompleteFromList ${right} ${lst} "" 1]
            set completion [CompleteFromList $right $lst "" 1]
    }
    # puts stderr \ncompletion=|$completion|
    if {![string length [lindex $completion 0]]} {
        return [concat [list ${left}] [lrange $completion 1 end]]
    } elseif {[string length ${left}]} {
        return [list ${left}]${completion}
            return [concat [list $left] [lrange $completion 1 end]]
        } elseif {[string length $left]} {
            return [list $left]$completion
    } else {
        return ${completion}
            return $completion
    }
    return ""
}

proc FirstNonOption {line} {
    set expr_pos 1
    foreach word [lrange ${line} 1 end] {; # 0 is the command itself
        if {"-" != [string index ${word} 0]} {
        foreach word [lrange $line 1 end] {; # 0 is the command itself
            if {"-" != [string index $word 0]} {
            break
        } else {
            incr expr_pos
        }
    }
    return ${expr_pos}
        return $expr_pos
}

proc RemoveUsedOptions {line opts {terminate {}}} {
    if {[llength ${terminate}]} {
        if {[regexp -- ${terminate} ${line}]} {
        if {[llength $terminate]} {
            if {[regexp -- $terminate $line]} {
            return ""
        }
    }
    set new ""
    foreach word ${opts} {
        if {-1 == [string first ${word} ${line}]} {
            lappend new ${word}
        foreach word $opts {
            if {-1 == [string first $word $line]} {
                lappend new $word
        }
    }

    # check if the last word in the line is an options
    # and if this word is at the very end of the line,
    # that means no space after.
    # If this is so, the word is stuffed into the result,
    # so that it can be completed -- probably with a space.
    #
    set last [Lindex ${line} end]
    if {[expr [string last ${last} ${line}] + [string length ${last}]] == \
        [string length ${line}]
        set last [Lindex $line end]
        if {[string last $last $line] + [string length $last]
                == [string length $line]} {
    } {
        if {-1 != [lsearch ${opts} ${last}]} {
            lappend new ${last}
            if {-1 != [lsearch $opts $last]} {
                lappend new $last
        }
    }

    return [string trim ${new}]
        return [string trim $new]
}

proc Alert {} {
    ::tclreadline::readline bell
}

#**
# get the longest common completion
# e.g. str == {tcl_version tclreadline_version tclreadline_library}
# --> [CompleteLongest ${str}] == "tcl"
    # --> [CompleteLongest $str] == "tcl"
#
proc CompleteLongest {str} {
    # puts stderr str=$str
    set match0 [lindex ${str} 0]
        set match0 [lindex $str 0]
    set len0 [string length $match0]
    set no_matches [llength ${str}]
        set no_matches [llength $str]
    set part ""
    for {set i 0} {$i < $len0} {incr i} {
        set char [string index $match0 $i]
        for {set j 1} {$j < $no_matches} {incr j} {
            if {$char != [string index [lindex ${str} $j] $i]} {
                if {$char != [string index [lindex $str $j] $i]} {
                break
            }
        }
        if {$j < $no_matches} {
            break
        } else {
            append part $char
        }
    }
    # puts stderr part=$part
    return ${part}
        return $part
}

proc SplitLine {start line} {
    set depth 0
    # puts stderr SplitLine
    for {set i $start} {$i >= 0} {incr i -1} {
        set c [string index $line $i]
        if {{;} == $c} {
            incr i; # discard command break character
            return [list [expr $start - $i] [String range $line $i end]]
                return [list [expr {$start - $i}] [String range $line $i end]]
        } elseif {{]} == $c} {
            incr depth
        } elseif {{[} == $c} {
            incr depth -1
            if {$depth < 0} {
                incr i; # discard command break character
                return [list [expr $start - $i] [String range $line $i end]]
                    return [list [expr {$start - $i}] [String range $line $i end]]
            }
        }
    }
    return ""
}

proc IsWhite {char} {
    if {" " == $char || "\n" == $char || "\t" == $char} {
        return 1
    } else {
        return 0
    }
}

proc PreviousWordOfIncompletePosition {start line} {
    return [lindex [ProperList [string range ${line} 0 ${start}]] end]
        return [lindex [ProperList [string range $line 0 $start]] end]
}

proc PreviousWord {start line} {
    incr start -1
    set found 0
    for {set i $start} {$i > 0} {incr i -1} {
        set c [string index $line $i]
        if {${found} && [IsWhite $c]} {
            if {$found && [IsWhite $c]} {
            break
        } elseif {!${found} && ![IsWhite $c]} {
            } elseif {!$found && ![IsWhite $c]} {
            set found 1
        }
    }
    return [string trim [string range ${line} $i $start]]
        return [string trim [string range $line $i $start]]
}

proc Quote {value left} {
    set right [Right ${left}]
        set right [Right $left]
    if {1 < [llength $value] && "" == $right} {
        return [list \"${value}\"]
            return [list \"$value\"]
    } else {
        return [list ${left}${value}${right}]
    }
}

# the following two channel proc's make use of
# the brandnew (Sep 99) `file channels' command
# but have some fallback behaviour for older
# tcl version.
#
proc InChannelId {text {switches ""}} {
    if [catch {set chs [file channels]}] {
        set chs {stdin}
    }
    set result ""
    foreach ch $chs {
        if {![catch {fileevent $ch readable}]} {
            lappend result $ch
        }
    }
    return [ChannelId ${text} <inChannel> $result $switches]
        return [ChannelId $text <inChannel> $result $switches]
}

proc OutChannelId {text {switches ""}} {
    if [catch {set chs [file channels]}] {
        set chs {stdout stderr}
    }
    set result ""
    foreach ch $chs {
        if {![catch {fileevent $ch writable}]} {
            lappend result $ch
        }
    }
    return [ChannelId ${text} <outChannel> $result $switches]
        return [ChannelId $text <outChannel> $result $switches]
}

proc ChannelId {text {descript <channelId>} {chs ""} {switches ""}} {
    if {"" == ${chs}} {
        if {"" == $chs} {
        # the `file channels' command is present
        # only in pretty new versions.
        #
        if [catch {set chs [file channels]}] {
            set chs {stdin stdout stderr}
        }
    }
    if {[llength [set channel [TryFromList ${text} "${chs} ${switches}"]]]} {
        return ${channel}
        if {[llength [set channel [TryFromList $text "$chs $switches"]]]} {
            return $channel
    } else {
        return [DisplayHints [string trim "${descript} ${switches}"]]
            return [DisplayHints [string trim "$descript $switches"]]
    }
}

proc QuoteQuotes {line} {
    regsub -all -- \" $line {\"} line
    regsub -all -- \{ $line {\{} line; # \}\} (keep the editor happy)
    return $line
}

#**
# get the word position.
# @return the word position
# @note will returned modified values.
# @sa EventuallyEvaluateFirst
# @date Sep-06-1999
#
# % p<TAB>
# % bla put<TAB> $b
# % put<TAB> $b
# part  == put
# start == 0
# end   == 3
# line  == "put $b"
# [PartPosition] should return 0
#
proc PartPosition {partT startT endT lineT} {

    upvar $partT part $startT start $endT end $lineT line
    EventuallyEvaluateFirst part start end line
    return [Llength [string range $line 0 [expr $start - 1]]]
        return [Llength [string range $line 0 [expr {$start - 1}]]]

#
#     set local_start [expr $start - 1]
    #     set local_start [expr {$start - 1}]
#     set local_start_chr [string index $line $local_start]
#     if {"\"" == $local_start_chr || "\{" == $local_start_chr} {
#         incr local_start -1
#     }
#
#     set pre_text [QuoteQuotes [string range $line 0 $local_start]]
#     return [llength $pre_text]
#
}

proc Right {left} {
    # puts left=$left
    if {"\"" == $left} {
        return "\""
    } elseif {"\\\"" == $left} {
        return "\\\""
    } elseif {"\{" == $left} {
        return "\}"
    } elseif {"\\\{" == $left} {

        return \\$null
    } else {
        return {}
    }
}

proc CountChar {line char} {
    # puts stderr char=|$char|
    set found 0
    set pos 0
    while {-1 != [set pos [string first $char $line $pos]]} {
        incr pos
        incr found
    }
    return $found
}

#**
# make a proper tcl list from an icomplete
# string, that is: remove the junk. This is
# complementary to `IncompleteListRemainder'.
# e.g.:
#       for {set i 1} "
#  -->  for {set i 1}
#
proc ProperList {line} {
    set last [expr [string length $line] - 1]
        set last [expr {[string length $line] - 1}]
    for {set i $last} {$i >= 0} {incr i -1} {
        if {![catch {llength [string range $line 0 $i]}]} {
            break
        }
    }
    return [string range $line 0 $i]
}

#**
# return the last part of a line which
# prevents the line from beeing a list.
    # prevents the line from being a list.
# This is complementary to `ProperList'.
#
proc IncompleteListRemainder {line} {
    set last [expr [string length $line] - 1]
        set last [expr {[string length $line] - 1}]
    for {set i $last} {$i >= 0} {incr i -1} {
        if {![catch {llength [string range $line 0 $i]}]} {
            break
        }
    }
    incr i
    return [String range $line $i end]
}

#**
# save `lindex'. works also for non-complete lines
# with opening parentheses or quotes.
# usage as `lindex'.
# Eventually returns the Rest of an incomplete line,
# if the index is `end' or == [Llength $line].
#
proc Lindex {line pos} {
    if {[catch [list set sub [lindex ${line} ${pos}]]]} {
        if {"end" == ${pos} || [Llength ${line}] == ${pos}} {
            return [IncompleteListRemainder ${line}]
        if {[catch [list set sub [lindex $line $pos]]]} {
            if {"end" == $pos || [Llength $line] == $pos} {
                return [IncompleteListRemainder $line]
        }
        set line [ProperList ${line}]
            set line [ProperList $line]
        # puts stderr \nproper_line=|$proper_line|
        if {[catch [list set sub [lindex ${line} ${pos}]]]} { return {} }
            if {[catch [list set sub [lindex $line $pos]]]} { return {} }
    }
    return ${sub}
        return $sub
}

#**
# save `llength' (see above).
#
proc Llength {line} {
    if {[catch [list set len [llength ${line}]]]} {
        set line [ProperList ${line}]
        if {[catch [list set len [llength ${line}]]]} { return {} }
        if {[catch [list set len [llength $line]]]} {
            set line [ProperList $line]
            if {[catch [list set len [llength $line]]]} { return {} }
    }
    # puts stderr \nline=$line
    return ${len}
        return $len
}

#**
# save `lrange' (see above).
#
proc Lrange {line first last} {
    if {[catch [list set range [lrange ${line} ${first} ${last}]]]} {
        set rest [IncompleteListRemainder ${line}]
        set proper [ProperList ${line}]
        if {[catch [list set range [lindex ${proper} ${first} ${last}]]]} {
        if {[catch [list set range [lrange $line $first $last]]]} {
            set rest [IncompleteListRemainder $line]
            set proper [ProperList $line]
            if {[catch [list set range [lindex $proper $first $last]]]} {
            return {}
        }
        if {"end" == ${last} || [Llength ${line}] == ${last}} {
            append sub " ${rest}"
            if {"end" == $last || [Llength $line] == $last} {
                append sub " $rest"
        }
    }
    return ${range}
        return $range
}

#**
# Lunique -- remove duplicate entries from a sorted list
    # Only useful prior to Tcl 8.3 when lsort didn't have the
    # -unique flag
# @param   list
# @return  unique list
# @author  Johannes Zellner
# @date    Sep-19-1999
#
proc Lunique lst {
    set unique ""
    foreach element ${lst} {
        if {${element} != [lindex ${unique} end]} {
            lappend unique ${element}
        foreach element $lst {
            if {$element != [lindex $unique end]} {
                lappend unique $element
        }
    }
    return ${unique}
        return $unique
}

#**
# string function, which works also for older versions
# of tcl, which don't have the `end' index.
# I tried also defining `string' and thus overriding
# the builtin `string' which worked, but slowed down
# things considerably. So I decided to call `String'
# only if I really need the `end' index.
#
proc String args {
    if {[info tclversion] < 8.2} {
        switch [lindex $args 1] {
            range -
            index {
                if {"end" == [lindex $args end]} {
                    set str [lindex $args 2]
                    lreplace args end end [expr [string length $str] - 1]
                        lreplace args end end [expr {[string length $str] - 1}]
                }
            }
        }
    }
    return [eval string $args]
}

proc StripPrefix {text} {
    # puts "(StripPrefix) text=|$text|"
    set null [string index $text 0]
    if {"\"" == $null || "\{" == $null} {
        return [String range $text 1 end]
    } else {
        return $text
    }
}

proc VarCompletion {text {level -1}} {
    if {"#" != [string index ${level} 0]} {
        if {-1 == ${level}} {
        if {"#" != [string index $level 0]} {
            if {-1 == $level} {
            set level [info level]
        } else {
            incr level
        }
    }
    set pre [GetQuotedPrefix ${text}]
    set var [StripPrefix ${text}]
        set pre [GetQuotedPrefix $text]
        set var [StripPrefix $text]
    # puts stderr "(VarCompletion) pre=|$pre|"
    # puts stderr "(VarCompletion) var=|$var|"

    # arrays
    #
    if {[regexp {([^(]*)\((.*)} ${var} all array name]} {
        set names [uplevel ${level} array names ${array} ${name}*]
        if {[regexp {([^(]*)\((.*)} $var all array name]} {
            set names [uplevel $level array names $array $name*]
        if {1 == [llength $names]} { ; # unique match
            return "${array}(${names})"
        } elseif {"" != ${names}} {
            return "${array}([CompleteLongest ${names}] ${names}"
                return "${array}($names)"
            } elseif {"" != $names} {
                return "${array}([CompleteLongest $names] $names"
        } else {
            return ""; # nothing to complete
        }
    }

    # non-arrays
    #
    regsub ":$" ${var} "::" var
        regsub ":$" $var "::" var
    set namespaces [namespace children :: ${var}*]
    if {[llength ${namespaces}] && "::" != [string range ${var} 0 1]} {
        foreach name ${namespaces} {
            regsub "^::" ${name} "" name
            if {[string length ${name}]} {
                lappend new ${name}::
        if {[llength $namespaces] && "::" != [string range $var 0 1]} {
            foreach name $namespaces {
                regsub "^::" $name "" name
                if {[string length $name]} {
                    lappend new $name::
            }
        }
        set namespaces ${new}
            set namespaces $new
        unset new
    }
    set matches \
    [string trim "[uplevel ${level} info vars ${var}*] ${namespaces}"]
            [string trim "[uplevel $level info vars ${var}*] $namespaces"]
    if {1 == [llength $matches]} { ; # unique match

        # check if this unique match is an
        # array name, (whith no "(" yet).
        #
        if {[uplevel ${level} array exists $matches]} {
            return [VarCompletion ${matches}( ${level}]; # recursion
            if {[uplevel $level array exists $matches]} {
                return [VarCompletion ${matches}( $level]; # recursion
        } else {
            return ${pre}${matches}[Right ${pre}]
                return ${pre}${matches}[Right $pre]
        }
    } elseif {"" != $matches} { ; # more than one match
          return [CompleteFromList ${text} ${matches}]
              return [CompleteFromList $text $matches]
    } else {
        return ""; # nothing to complete
    }
}

proc CompleteControlStatement {text start end line pos mod pre new_line} {
    set pre [GetQuotedPrefix ${pre}]
        set pre [GetQuotedPrefix $pre]
    set cmd [Lindex $new_line 0]
    set diff [expr \
    [string length $line] - [string length $new_line]]
    if {$diff == [expr $start + 1]} {
        set diff [expr {[string length $line] - [string length $new_line]}]
        if {$diff == [expr {$start + 1}]} {
        set mod1 $mod
    } else {
        set mod1 $text
        set pre ""
    }
    set new_end [expr $end - $diff]
    set new_start [expr $new_end - [string length $mod1]]
        set new_end [expr {$end - $diff}]
        set new_start [expr {$new_end - [string length $mod1]}]
    # puts ""
    # puts new_start=$new_start
    # puts new_end=$new_end
    # puts new_line=$new_line
    # puts mod1=$mod1
    if {$new_start < 0} {
        return ""; # when does this occur?
    }
    # puts stderr ""
    # puts stderr start=|$start|
    # puts stderr end=|$end|
    # puts stderr mod=|$mod|
    # puts stderr new_start=|$new_start|
    # puts stderr new_end=|$new_end|
    # puts stderr new_line=|$new_line|
    # puts stderr ""
    set res [ScriptCompleter $mod1 $new_start $new_end $new_line]
    # puts stderr \n\${pre}\${res}=|${pre}${res}|
    if {[string length [Lindex ${res} 0]]} {
        if {[string length [Lindex $res 0]]} {
        return ${pre}${res}
    } else {
        return ${res}
            return $res
    }
    return ""
}

proc BraceOrCommand {text start end line pos mod} {
    if {![string length [Lindex $line $pos]]} {
        return [list \{ {}]; # \}

}

proc FullQualifiedMatches {qualifier matchlist} {
    set new ""
    if {"" != $qualifier && ![regexp ::$ $qualifier]} {
        append qualifier ::
    }
    foreach entry ${matchlist} {
        foreach entry $matchlist {
        set full ${qualifier}${entry}
        if {"" != [namespace which ${full}]} {
            lappend new ${full}
            if {"" != [namespace which $full]} {
                lappend new $full
        }
    }
    return ${new}
        return $new
}

proc ProcsOnlyCompletion {cmd} {
    return [CommandCompletion ${cmd} procs]
        return [CommandCompletion $cmd procs]
}

proc CommandsOnlyCompletion {cmd} {
    return [CommandCompletion ${cmd} commands]
        return [CommandCompletion $cmd commands]
}

proc CommandCompletion {cmd {action both} {spc ::}} {
    # get the leading colons in `cmd'.
    regexp {^:*} ${cmd} pre
        regexp {^:*} $cmd pre
    return [CommandCompletionWithPre $cmd $action $spc $pre]
}

proc CommandCompletionWithPre {cmd action spc pre} {
    # puts stderr "(CommandCompletion) cmd=|$cmd|"
    # puts stderr "(CommandCompletion) action=|$action|"
    # puts stderr "(CommandCompletion) spc=|$spc|"

    set cmd [StripPrefix ${cmd}]
    set quali [namespace qualifiers ${cmd}]
    if {[string length ${quali}]} {
        set cmd [StripPrefix $cmd]
        set quali [namespace qualifiers $cmd]
        if {[string length $quali]} {
        # puts stderr \nquali=|$quali|
        set matches [CommandCompletionWithPre \
        [namespace tail ${cmd}] ${action} ${spc}${quali} ${pre}]
                             [namespace tail $cmd] $action ${spc}${quali} $pre]
        # puts stderr \nmatches1=|$matches|
        return $matches
    }
    set cmd [string trim ${cmd}]*
        set cmd [string trim $cmd]*
    # puts stderr \ncmd=|$cmd|\n
    if {"procs" != ${action}} {
        set all_commands [namespace eval $spc [list info commands ${cmd}]]
        if {"procs" != $action} {
            set all_commands [namespace eval $spc [list info commands $cmd]]
        # puts stderr all_commands=|$all_commands|
        set commands ""
        foreach command $all_commands {
            if {[namespace eval $spc [list namespace origin $command]] == \
                [namespace eval $spc [list namespace which $command]]} {
                if {[namespace eval $spc [list namespace origin $command]]
                        == [namespace eval $spc [list namespace which $command]]} {
                lappend commands $command
            }
        }
    } else {
        set commands ""
    }
    if {"commands" != ${action}} {
        set all_procs [namespace eval $spc [list info procs ${cmd}]]
        if {"commands" != $action} {
            set all_procs [namespace eval $spc [list info procs $cmd]]
        # puts stderr procs=|$procs|
        set procs ""
        foreach proc $all_procs {
            if {[namespace eval $spc [list namespace origin $proc]] == \
                [namespace eval $spc [list namespace which $proc]]} {
                if {[namespace eval $spc [list namespace origin $proc]]
                        == [namespace eval $spc [list namespace which $proc]]} {
                lappend procs $proc
            }
        }
    } else {
        set procs ""
    }
    set matches [namespace eval $spc concat ${commands} ${procs}]
    set namespaces [namespace children $spc ${cmd}]
        set matches [namespace eval $spc concat $commands $procs]
        set namespaces [namespace children $spc $cmd]

    if {![llength ${matches}] && 1 == [llength ${namespaces}]} {
        set matches [CommandCompletionWithPre {} ${action} ${namespaces} ${pre}]
        if {![llength $matches] && 1 == [llength $namespaces]} {
            set matches [CommandCompletionWithPre {} $action $namespaces $pre]
        # puts stderr \nmatches=|$matches|
        return $matches
    }

    # make `namespaces' having exactly
    # the same number of colons as `cmd'.
    #
    regsub -all {^:*} $spc $pre spc

    set matches [FullQualifiedMatches ${spc} ${matches}]
        set matches [FullQualifiedMatches $spc $matches]
    # puts stderr \nmatches3=|$matches|
    return [string trim "${matches} ${namespaces}"]
        return [string trim "$matches $namespaces"]
}

#**
# check, if the first argument starts with a '['
# and must be evaluated before continuing.
# NOTE: trims the `line'.
#       eventually modifies all arguments.
# DATE: Sep-06-1999
#
proc EventuallyEvaluateFirst {partT startT endT lineT} {
    # return; # disabled
    upvar $partT part $startT start $endT end $lineT line

    set oldlen [string length ${line}]
    # set line [string trim ${line}]
    set line [string trimleft ${line}]
    set diff [expr [string length $line] - $oldlen]
        set oldlen [string length $line]
        # set line [string trim $line]
        set line [string trimleft $line]
        set diff [expr {[string length $line] - $oldlen}]
    incr start $diff
    incr end $diff

    set char [string index ${line} 0]
    if {{[} != ${char} && {$} != ${char}} {return}
        set char [string index $line 0]
        if {{[} != $char && {$} != $char} {return}

    set pos 0
    while {-1 != [set idx [string first {]} ${line} ${pos}]]} {
        set cmd [string range ${line} 0 ${idx}]
        if {[info complete ${cmd}]} {
        while {-1 != [set idx [string first {]} $line $pos]]} {
            set cmd [string range $line 0 $idx]
            if {[info complete $cmd]} {
            break;
        }
        set pos [expr ${idx} + 1]
            set pos [expr {$idx + 1}]
    }

    if {![info exists cmd]} {return}
    if {![info complete ${cmd}]} {return}
    set cmd [string range ${cmd} 1 [expr [string length ${cmd}] - 2]]
    set rest [String range ${line} [expr ${idx} + 1] end]
        if {![info complete $cmd]} {return}
        set cmd [string range $cmd 1 [expr {[string length $cmd] - 2}]]
        set rest [String range $line [expr {$idx + 1}] end]

    if {[catch [list set result [string trim [eval ${cmd}]]]]} {return}
        if {[catch [list set result [string trim [eval $cmd]]]]} {return}

    set line ${result}${rest}
    set diff [expr [string length ${result}] - ([string length ${cmd}] + 2)]
    incr start ${diff}
    incr end ${diff}
        set diff [expr {[string length $result] - ([string length $cmd] + 2)}]
        incr start $diff
        incr end $diff
}

# if the line entered so far is
# % puts $b<TAB>
# part  == $b
# start == 5
# end   == 7
# line  == "$puts $b"
#
proc ScriptCompleter {part start end line} {

    # puts stderr "(ScriptCompleter) |$part| $start $end |$line|"

    # if the character before the cursor is a terminating
    # quote and the user wants completion, we insert a white
    # space here.
    #
    set char [string index $line [expr $end - 1]]
        set char [string index $line [expr {$end - 1}]]
    if {"\}" == $char} {
        append $part " "
        return [list $part]
    }

    if {{$} == [string index $part 0]} {

        # check for a !$ history event
        #
        if {$start > 0} {
            if {{!} == [string index $line [expr $start - 1]]} {
                if {{!} == [string index $line [expr {$start - 1}]]} {
                return ""
            }
        }
        # variable completion. Check first, if the
        # variable starts with a plain `$' or should
        # be enclosed in braces.
        #
        set var [String range $part 1 end]

        # check if $var is an array name, which
        # already has already a "(" somewhere inside.
        #
        if {"" != [set vc [VarCompletion $var]]} {
            if {"" == [lindex $vc 0]} {
                return "\$ [lrange ${vc} 1 end]"
                    return "\$ [lrange $vc 1 end]"
            } else {
                return \$${vc}
            }
            # puts stderr vc=|$vc|
        } else {
            return ""
        }

    # SCENARIO:
    #
    # % puts bla; put<TAB> $b
    # part  == put
    # start == 10
    # end   == 13
    # line  == "puts bla; put $b"
    # [SplitLine] --> {1 " put $b"} == sub
    # new_start = [lindex $sub 0] == 1
    # new_end   = [expr $end - ($start - $new_start)] == 4
        # new_end   = [expr {$end - ($start - $new_start)}] == 4
    # new_part  == $part == put
    # new_line  = [lindex $sub 1] == " put $b"
    #
    } elseif {"" != [set sub [SplitLine $start $line]]} {

        set new_start [lindex $sub 0]
        set new_end [expr $end - ($start - $new_start)]
            set new_end [expr {$end - ($start - $new_start)}]
        set new_line [lindex $sub 1]
        # puts stderr "(SplitLine) $new_start $new_end $new_line"
        return [ScriptCompleter $part $new_start $new_end $new_line]

    } elseif {0 == [set pos [PartPosition part start end line]]} {

        # XXX
        #     note that line will be [string trimleft'ed]
        #     after PartPosition.
        # XXX

        # puts stderr "(PartPosition) $part $start $end $line"
        set all [CommandCompletion ${part}]
            set all [CommandCompletion $part]
        # puts stderr "(ScriptCompleter) all=$all"
        #puts \nmatches=$matches\n
        # return [Format $all $part]
        return [TryFromList $part $all]

    } else {

        # try to use $pos further ...
        # puts stderr |$line|
        #
        # if {"." == [string index [string trim ${line}] 0]} {
            # if {"." == [string index [string trim $line] 0]} {
        #   set alias WIDGET
        #   set namespc ""; # widgets are always in the global
        # } else {

            # the double `lindex' strips {} or quotes.
            # the subst enables variables containing
            # command names.
            #
            set alias [uplevel [info level] \
            subst [lindex [lindex [QuoteQuotes ${line}] 0] 0]]
                               subst [lindex [lindex [QuoteQuotes $line] 0] 0]]

            # make `alias' a fully qualified name.
            # this can raise an error, if alias is
            # no valid command.
            #
            if {[catch {set alias [namespace origin $alias]}]} {
                return ""
            }

            # strip leading ::'s.
            #
            regsub -all {^::} $alias {} alias
            set namespc [namespace qualifiers $alias]
            set alias [namespace tail $alias]
        # }

        # try first a specific completer, then, and only then
        # the tclreadline_complete_unknown.
        #
        foreach cmd [list ${alias} tclreadline_complete_unknown] {
            foreach cmd [list $alias tclreadline_complete_unknown] {
            # puts stderr ${namespc}complete(${cmd})
            if {"" != [namespace eval ::tclreadline::${namespc} \
                [list info procs complete(${cmd})]]
                               [list info procs complete($cmd)]]} {
            } {
                # puts found=|complete($cmd)|
                # to be more error-proof, we check here,
                # if complete($cmd) takes exactly 5 arguments.
                #
                if {6 != [set arguments [llength \
                    if {6 != [set arguments \
                                  [llength \
                    [namespace eval ::tclreadline::${namespc} \
                    [list info args complete($cmd)]]]]
                                            [list info args complete($cmd)]]]]} {
                } {
                    error [list complete(${cmd}) takes ${arguments} \
                    arguments, but should take exactly 6.]
                        error "complete($cmd) takes $arguments arguments, but should take exactly 6"
                }

                # remove leading quotes
                #
                set mod [StripPrefix $part]
                # puts stderr mod=$mod

                if {[catch [list set script_result \
                    if {[catch {set script_result \
                    [namespace eval ::tclreadline::${namespc} \
                    [list complete(${cmd}) $part $start $end $line $pos $mod]]]\
                    ::tclreadline::errorMsg]
                                         [list complete($cmd) $part $start $end $line $pos $mod]]} \
                             ::tclreadline::errorMsg]} {
                } {
                    error [list error during evaluation of `complete(${cmd})']
                        error "error during evaluation of `complete($cmd)'"
                }
                # puts stderr \nscript_result=|${script_result}|
                if {![string length ${script_result}] && \
                    "tclreadline_complete_unknown" == ${cmd}
                    if {![string length $script_result]
                            && "tclreadline_complete_unknown" == $cmd} {
                } {
                    # as we're here, the tclreadline_complete_unknown
                    # returned an empty string. Fall thru and try
                    # further fallback completers.
                    #
                } else {
                    # return also empty strings, if
                    # they're from a specific completer.
                    #
                    TraceText script_result=|${script_result}|
                    return ${script_result}
                        TraceText script_result=|$script_result|
                        return $script_result
                }
            }
            # set namespc ""; # no qualifiers for tclreadline_complete_unknown
        }

        # as we've reached here no valid specific completer
        # was found. Check, if it's a proc and return the
        # arguments.
        #
        if {![string length ${namespc}]} {
            if {![string length $namespc]} {
            set namespc ::
        }
        if {[string length [uplevel [info level] \
            namespace eval ${namespc} [list ::info proc $alias]]]
                                    namespace eval $namespc [list ::info proc $alias]]]} {
        } {
            if ![string length [string trim $part]] {
                set args [uplevel [info level] \
                namespace eval ${namespc} [list info args $alias]]
                set arg [lindex $args [expr $pos - 1]]
                                  namespace eval $namespc [list info args $alias]]
                    set arg [lindex $args [expr {$pos - 1}]]
                if {"" != $arg && "args" != $arg} {
                    if {[uplevel [info level] namespace eval \
                        ${namespc} [list info default $alias $arg junk]]} {
                                 $namespc [list info default $alias $arg junk]]} {
                            return [DisplayHints ?$arg?]
                        } else {
                            return [DisplayHints <$arg>]
                        }
                }
            } else {
                return ""; # enable file name completion
            }
        }

        # check if the command is an object of known class.
        #
        if [ObjectClassCompleter ${part} ${start} ${end} ${line} ${pos} res] {
            return ${res}
            if [ObjectClassCompleter $part $start $end $line $pos res] {
                return $res
        }

        # Ok, also no proc. Try to do the same as for widgets now:
        # try to complete from the option table if the subcommand
        # is `configure' or `cget' otherwise try to get further
        # subcommands.
        #
        return [CompleteFromOptionsOrSubCmds \
        ${part} ${start} ${end} ${line} ${pos}]
                        $part $start $end $line $pos]
    }
    error "{NOTREACHED (this is probably an error)}"
}


# explicit command completers
#

# -------------------------------------
#                 TCL
# -------------------------------------

proc complete(after) {text start end line pos mod} {
    set sub [Lindex $line 1]
    # puts \npos=$pos
    switch -- $pos {
        1 {
            return [CompleteFromList ${text} {<ms> cancel idle info}]
                return [CompleteFromList $text {<ms> cancel idle info}]
        }
        2 {
            switch -- $sub {
                cancel {
                    return [CompleteFromList $text "<script> [after info]"]
                    cancel  { return [CompleteFromList $text "<script> [after info]"] }
                }
                idle {
                    return [DisplayHints <script>]
                    idle    { return [DisplayHints <script>] }
                }
                info {
                    return [CompleteFromList $text [after info]]
                    info    { return [CompleteFromList $text [after info]] }
                }
                default { return [DisplayHints ?script?] }
            }
        }
        default {
            switch -- $sub {
                info { return [DisplayHints {}] }
                default { return [DisplayHints ?script?] }
            }
        }
    }
    return ""
}

proc complete(append) {text start end line pos mod} {
    switch -- $pos {
        1       { return [VarCompletion ${text}] }
            1       { return [VarCompletion $text] }
        default { return [DisplayHints ?value?] }
    }
    return ""
}

proc complete(array) {text start end line pos mod} {
    switch -- $pos {
        1 {
            set cmds {
                anymore donesearch exists get names
                nextelement set size startsearch
                set cmds {anymore donesearch exists get names
                          nextelement set size startsearch}
            }
            return [CompleteFromList $text $cmds]
        }
        2 {
            set matches ""
            # set vars [uplevel [info level] info vars ${mod}*]
            #
            # better: this displays a list of array names if the
            # user inters with something which cannot be matched.
            # The matching against `text' is done by CompleteFromList.
            #
            set vars [uplevel [info level] info vars]
            foreach var ${vars} {
                if {[uplevel [info level] array exists ${var}]} {
                    lappend matches ${var}
                foreach var $vars {
                    if {[uplevel [info level] array exists $var]} {
                        lappend matches $var
                }
            }
            return [CompleteFromList ${text} ${matches}]
                return [CompleteFromList $text $matches]
        }
        3 {
            set cmd [Lindex $line 1]
            set array_name [Lindex $line 2]
            switch -- $cmd {
                get -
                names {
                    set pattern [Lindex $line 3]
                    set matches [uplevel [info level] \
                    array names ${array_name} ${pattern}*]
                                         array names $array_name ${pattern}*]
                    if {![llength $matches]} {
                        return [DisplayHints ?pattern?]
                    } else {
                        return [CompleteFromList ${text} ${matches}]
                            return [CompleteFromList $text $matches]
                    }
                }
                anymore -
                donesearch -
                nextelement { return [DisplayHints <searchId>] }
            }
        }

                }
                clicks  -
                seconds {}
            }
        }
        4 -
        6 {
            set sub [Lindex $line [expr $pos - 1]]
                set sub [Lindex $line [expr {$pos - 1}]]
            switch -- $cmd {
                format {
                    switch -- $sub {
                        -format { return [DisplayHints <string>] }
                        -gmt    { return [DisplayHints <boolean>] }
                    }
                }

            return [CompleteFromList $text {convertfrom convertto names system}]
        }
        2 {
            switch -- $cmd {
                convertfrom -
                convertto -
                system {
                    return [CompleteFromList ${text} [encoding names]]
                        return [CompleteFromList $text [encoding names]]
                }
            }
        }
        3 {
            switch -- $cmd {
                convertfrom { return [DisplayHints <data>] }
                convertto { return [DisplayHints <string>] }

        Rehash
    }
    switch -- $pos {
        1 {
            return [TryFromList $text "-keepnewline -- $executables"]
        }
        default {
            set prev [PreviousWord ${start} ${line}]
                set prev [PreviousWord $start $line]
            if {"-keepnewline" == $prev && 2 == $pos} {
                return [TryFromList $text "-- $executables"]
            }
            switch -exact -- $prev {
                | -
                |& { return [TryFromList $text $executables] }
                < -

    }
    return ""
}

proc complete(fconfigure) {text start end line pos mod} {
    set cmd [Lindex $line 1]
    switch -- $pos {
        1 {
            return [ChannelId ${text}]
            1       { return [ChannelId $text] }
        }
        default {
            set option [PreviousWord ${start} ${line}]
                set option [PreviousWord $start $line]
            switch -- $option {
                -blocking {
                    return [CompleteBoolean ${text}]
                    -blocking    { return [CompleteBoolean $text] }
                }
                -buffering {
                    return [CompleteFromList ${text} {full line none}]
                    -buffering   { return [CompleteFromList $text {full line none}] }
                }
                -buffersize {
                    if {![llength ${text}]} {
                        if {![llength $text]} {
                        return [DisplayHints <newSize>]
                    }
                }
                -encoding {
                    return [CompleteFromList ${text} [encoding names]]
                    -encoding    { return [CompleteFromList $text [encoding names]] }
                }
                -eofchar {
                    return [DisplayHints {\{<inChar>\ <outChar>\}}]
                    -eofchar     { return [DisplayHints {\{<inChar>\ <outChar>\}}] }
                }
                -translation {
                    -translation { return [CompleteFromList $text {auto binary cr crlf lf}] }
                    return [CompleteFromList ${text} {auto binary cr crlf lf}]
                }
                default {return [CompleteFromList $text \
                    [RemoveUsedOptions $line {
                    -blocking -buffering -buffersize
                    default      {
                        return [CompleteFromList $text \
                                    [RemoveUsedOptions $line \
                                         {-blocking -buffering -buffersize
                    -encoding -eofchar -translation}]]
                }
            }
        }
    }
    return ""
}

proc complete(fcopy) {text start end line pos mod} {
    switch -- $pos {
        1 {
            return [InChannelId ${text}]
            1       { return [InChannelId $text] }
        }
        2 {
            return [OutChannelId ${text}]
            2       { return [OutChannelId $text] }
        }
        default {
            set option [PreviousWord ${start} ${line}]
                set option [PreviousWord $start $line]
            switch -- $option {
                -size    { return [DisplayHints <size>] }
                -command { return [DisplayHints <callback>] }
                default  { return [CompleteFromList $text \
                    [RemoveUsedOptions $line {-size -command}]]
                }
            }

        }
    }
    return ""
}

proc complete(fileevent) {text start end line pos mod} {
    switch -- $pos {
        1 {
            return [ChannelId ${text}]
            1 { return [ChannelId $text] }
        }
        2 {
            return [CompleteFromList ${text} {readable writable}]
            2 { return [CompleteFromList $text {readable writable}] }
        }
        3 {
            return [DisplayHints ?script?]
            3 { return [DisplayHints ?script?] }
        }
    }
    return ""
}

proc complete(flush) {text start end line pos mod} {
    switch -- $pos {
        1 { return [OutChannelId ${text}] }
            1 { return [OutChannelId $text] }
    }
    return ""
}

proc complete(for) {text start end line pos mod} {
    switch -- $pos {
        1 -

}

proc complete(foreach) {text start end line pos mod} {
    switch -- $pos {
        1 { return [DisplayHints <varname>] }
        2 { return [DisplayHints <list>] }
        default {
            if {[expr $pos % 2]} {
                if {[expr {$pos % 2}]} {
                return [DisplayHints [list ?varname? <body>]]
            } else {
                return [DisplayHints ?list?]
            }
        }
    }
    return ""
}

proc complete(format) {text start end line pos mod} {
    switch -- $pos {
        1 { return [DisplayHints <formatString>] }
        default { return [DisplayHints ?arg?] }
    }
    return ""
}

proc complete(gets) {text start end line pos mod} {
    switch -- $pos {
        1 { return [InChannelId ${text}] }
        2 { return [VarCompletion ${text}]}
            1 { return [InChannelId $text] }
            2 { return [VarCompletion $text]}
    }
    return ""
}

proc complete(glob) {text start end line pos mod} {
    switch -- $pos {
        1 {
            # This also is not perfect.
            # This will not display the options as hints!
            set matches [TryFromList ${text} {-nocomplain --}]
            if {[llength [string trim ${text}]] && [llength ${matches}]} {
                return ${matches}
                set matches [TryFromList $text {-nocomplain --}]
                if {[llength [string trim $text]] && [llength $matches]} {
                    return $matches
            }
        }
    }
    return ""
}

proc complete(global) {text start end line pos mod} {
    return [VarCompletion ${text}]
        return [VarCompletion $text]
}

proc complete(history) {text start end line pos mod} {
    switch -- $pos {
        1 {
            set cmds {add change clear event info keep nextid redo}
            return [TryFromList $text $cmds]

        ::tclreadline::RemoveUsedOptions ::tclreadline::HostList \
        ::tclreadline::ChannelId ::tclreadline::Lindex \
        ::tclreadline::CompleteBoolean
    }
}

proc http::complete(config) {text start end line pos mod} {
    set prev [PreviousWord ${start} ${line}]
        set prev [PreviousWord $start $line]
    switch -- $prev {
        -accept { return [DisplayHints <mimetypes>] }
        -proxyhost {
            return [CompleteFromList $text [HostList]]
            -proxyhost   { return [CompleteFromList $text [HostList]] }
        }
        -proxyport { return [DisplayHints <number>] }
        -proxyfilter {
            return [CompleteFromList $text [CommandCompletion $text]]
            -proxyfilter { return [CompleteFromList $text [CommandCompletion $text]] }
        }
        -useragent { return [DisplayHints <string>] }
        default {
            return [CompleteFromList $text [RemoveUsedOptions $line {
                -accept -proxyhost -proxyport -proxyfilter -useragent
            }]]
                return [CompleteFromList $text \
                            [RemoveUsedOptions $line \
                                 {-accept -proxyhost -proxyport
                                  -proxyfilter -useragent}]]
        }
    }
    return ""
}

proc http::complete(geturl) {text start end line pos mod} {
    switch -- $pos {
        1 { return [DisplayHints <url>] }
        default {
            set prev [PreviousWord ${start} ${line}]
                set prev [PreviousWord $start $line]
            switch -- $prev {
                -blocksize { return [DisplayHints <size>] }
                -channel { return [ChannelId ${text}] }
                    -channel   { return [ChannelId $text] }
                -command -
                -handler -
                -progress {
                    return [CompleteFromList $text [CommandCompletion $text]]
                }
                -headers { return [DisplayHints <keyvaluelist>] }
                -query { return [DisplayHints <query>] }
                -timeout { return [DisplayHints <milliseconds>] }
                -validate { return [CompleteBoolean $text] }
                default {
                    return [CompleteFromList $text [RemoveUsedOptions $line {
                        -blocksize -channel -command -handler -headers
                        -progress -query -timeout -validate
                        return [CompleteFromList $text \
                                    [RemoveUsedOptions $line \
                                         {-blocksize -channel -command
                                          -handler -headers -progress
                                          -query -timeout -validate}]]
                    }]]
                }
            }
        }
    }
    return ""
}

proc http::complete(formatQuery) {text start end line pos mod} {
    switch -- $pos {
        1 { return [DisplayHints <key>] }
        2 { return [DisplayHints <value>] }
        default {
            switch [expr $pos % 2] {
                switch [expr {$pos % 2}] {
                0 { return [DisplayHints ?value?] }
                1 { return [DisplayHints ?key?] }
            }
        }
    }
    return ""
}

    #
    switch -- $pos {
        1 -
        2 {
            return [BraceOrCommand $text $start $end $line $pos $mod]
        }
        default {
            set prev [PreviousWord ${start} ${line}]
                set prev [PreviousWord $start $line]
            switch -- $prev {
                then -
                else -
                elseif {
                    return [BraceOrCommand \
                    $text $start $end $line $pos $mod]
                        return [BraceOrCommand $text $start \
                                    $end $line $pos $mod]
                }
                default {
                    if {-1 == [lsearch [ProperList $line] else]} {
                        return [CompleteFromList $text {else elseif}]
                    }
                }
            }

                if {[uplevel [info level] array exists $match]} {
                    continue
                }
                if {[regexp {^[0-9]+$} [uplevel [info level] set $match]]} {
                    lappend integers $match
                }
            }
            return [CompleteFromList ${text} ${integers}]
                return [CompleteFromList $text $integers]
        }
        2 { return [DisplayHints ?increment?] }
    }
    return ""
}

proc complete(info) {text start end line pos mod} {
    set cmd [Lindex $line 1]
    switch -- $pos {
        1 {
            set cmds {
                args body cmdcount commands complete default exists
                globals hostname level library loaded locals nameofexecutable
                patchlevel procs script sharedlibextension tclversion vars}
                    patchlevel procs script sharedlibextension tclversion vars
                }
            return [CompleteFromList $text $cmds]
        }
        2 {
            switch -- $cmd {
                args -
                body -
                default -
                procs { return [complete(proc) ${text} 0 0 ${line} 1 ${mod}] }
                    procs    { return [complete(proc) $text 0 0 $line 1 $mod] }
                complete { return [DisplayHints <command>] }
                level { return [DisplayHints ?number?] }
                loaded { return [DisplayHints ?interp?] }
                commands -
                exists -
                globals -
                locals -
                vars {
                    if {"exists" == $cmd} {
                        set do vars
                    } else {
                        set do $cmd
                    }
                    # puts stderr [list complete(info) level = [info level]]
                    return \
                    [CompleteFromList ${text} [uplevel [info level] info ${do}]]
                        return [CompleteFromList $text \
                                    [uplevel [info level] info $do]]
                }
            }
        }
        3 {
            switch -- $cmd {
                default {
                    set proc [Lindex $line 2]
                    return [CompleteFromList ${text} \
                        return [CompleteFromList $text \
                    [uplevel [info level] info args $proc]]
                }
                default {}
            }
        }
        4 {
            switch -- $cmd {
                default {
                    return [VarCompletion ${text}]
                    default { return [VarCompletion $text] }
                }
                default {}
            }
        }
    }
    return ""
}

proc complete(interp) {text start end line pos mod} {
    set cmd [Lindex $line 1]
    switch -- $pos {
        1 {
            set cmds {
                alias aliases create delete eval exists expose hide hidden
                invokehidden issafe marktrusted share slaves target transfer}
                    invokehidden issafe marktrusted share slaves target transfer
                }
            return [TryFromList $text $cmds]
        }
        2 {
            switch -- $cmd {

                create {
                    set cmds [RemoveUsedOptions ${line} {-save --} {--}]
                        set cmds [RemoveUsedOptions $line {-save --} {--}]
                    if {[llength $cmds]} {
                        return [CompleteFromList $text "$cmds ?path?"]
                    } else {
                        return [DisplayHints ?path?]
                    }
                }

                eval -
                exists -
                expose -
                hide -
                hidden -
                invokehidden -
                marktrusted -
                target { return [CompleteFromList ${text} [interp slaves]] }
                    target       { return [CompleteFromList $text [interp slaves]] }

                aliases -
                delete -
                issafe -
                slaves { return [CompleteFromList ${text} [interp slaves]] }
                    slaves  { return [CompleteFromList $text [interp slaves]] }

                alias -
                share -
                transfer { return [DisplayHints <srcPath>] }
            }
        }
        3 {
            switch -- $cmd {

                alias { return [DisplayHints <srcCmd>] }

                create {
                    set cmds [RemoveUsedOptions ${line} {-save --} {--}]
                        set cmds [RemoveUsedOptions $line {-save --} {--}]
                    if {[llength $cmds]} {
                        return [CompleteFromList $text "$cmds ?path?"]
                    } else {
                        return [DisplayHints ?path?]
                    }
                }

                eval { return [DisplayHints <arg>] }
                delete { return [CompleteFromList ${text} [interp slaves]] }
                    delete { return [CompleteFromList $text [interp slaves]] }

                expose { return [DisplayHints <hiddenName>] }
                hide { return [DisplayHints <exposedCmdName>] }

                invokehidden {
                    return \
                    [CompleteFromList $text {?-global? <hiddenCmdName>}]
                        return [CompleteFromList $text \
                                    {?-global? <hiddenCmdName>}]
                }

                target { return [DisplayHints <alias>] }

                exists {}
                hidden {}
                marktrusted {}
                aliases {}
                issafe {}
                slaves {}

                share -
                transfer {return [ChannelId ${text}]}
                    transfer { return [ChannelId $text] }
            }
        }
        4 {
            switch -- $cmd {

                alias { return [DisplayHints <targetPath>] }
                eval { return [DisplayHints ?arg?] }

                invokehidden {
                    return [CompleteFromList $text {<hiddenCmdName> ?arg?}]
                }

                create {
                    set cmds [RemoveUsedOptions ${line} {-save --} {--}]
                        set cmds [RemoveUsedOptions $line {-save --} {--}]
                    if {[llength $cmds]} {
                        return [CompleteFromList $text "$cmds ?path?"]
                    } else {
                        return [DisplayHints ?path?]
                    }
                }

                expose { return [DisplayHints ?exposedCmdName?] }
                hide { return [DisplayHints ?hiddenCmdName?] }

                share -
                transfer { return [CompleteFromList ${text} [interp slaves]] }
                    transfer { return [CompleteFromList $text [interp slaves]] }
            }
        }
        5 {
            switch -- $cmd {

                alias { return [DisplayHints <targetCmd>] }
                invokehidden -
                eval { return [DisplayHints ?arg?] }

                expose { return [DisplayHints ?exposedCmdName?] }
                hide { return [DisplayHints ?hiddenCmdName?] }

                share -
                transfer { return [CompleteFromList ${text} [interp slaves]] }
                    transfer { return [CompleteFromList $text [interp slaves]] }
            }
        }
    }
    return ""
}

proc complete(join) {text start end line pos mod} {
    switch -- $pos {
        1 { return [DisplayHints <list>] }
        2 { return [DisplayHints ?joinString?] }
    }
    return ""
}

proc complete(lappend) {text start end line pos mod} {
    switch -- $pos {
        1 { return [VarCompletion ${text}] }
        default { return [TryFromList ${text} ?value?] }
            1       { return [VarCompletion $text] }
            default { return [TryFromList $text ?value?] }
    }
    return ""
}

# the following routines are described in the
# `library' man page.
# --- LIBRARY ---

    return ""
}

proc complete(parray) {text start end line pos mod} {
    switch -- $pos {
        1 {
            set vars [uplevel [info level] info vars]
            foreach var ${vars} {
                if {[uplevel [info level] array exists ${var}]} {
                    lappend matches ${var}
                foreach var $vars {
                    if {[uplevel [info level] array exists $var]} {
                        lappend matches $var
                }
            }
            return [CompleteFromList $text $matches]
        }
    }
    return ""
}

proc complete(load) {text start end line pos mod} {
    switch -- $pos {
        1 {
            return ""; # filename
        }
        2 {
            if {![llength ${mod}]} {
                if {![llength $mod]} {
                return [DisplayHints ?packageName?]
            }
        }
        3 {
            if {![llength ${mod}]} {
                if {![llength $mod]} {
                return [DisplayHints ?interp?]
            }
        }
    }
    return ""
}

    return ""
}

proc complete(lsearch) {text start end line pos mod} {
    set options {-exact -glob -regexp}
    switch -- $pos {
        1 {
            return [CompleteFromList ${text} "$options <list>"]
                return [CompleteFromList $text "$options <list>"]
        }
        2 -
        3 -
        4 {
            set sub [Lindex $line 1]
            if {-1 != [lsearch $options $sub]} {
                incr pos -1
            }
            switch -- $pos {
                1 { return [DisplayHints <list>] }
                2 { return [DisplayHints <pattern>] }
            }
        }
    }
    return ""
}

proc complete(lsort) {text start end line pos mod} {
    set options [RemoveUsedOptions ${line} {
        -ascii -dictionary -integer -real -command
        -increasing -decreasing -index <list>
        set options [RemoveUsedOptions $line \
                         {-ascii -dictionary -integer -real -command
                          -increasing -decreasing -index <list>}]
    }]
    switch -- $pos {
        1 { return [CompleteFromList ${text} ${options}] }
            1       { return [CompleteFromList $text $options] }
        default {
            switch -- [PreviousWord ${start} ${line}] {
                switch -- [PreviousWord $start $line] {
                -command {
                    return [CompleteFromList $text [CommandCompletion $text]]
                    -command { return [CompleteFromList $text [CommandCompletion $text]] }
                }
                -index { return [DisplayHints <index>] }
                default { return [CompleteFromList ${text} ${options}] }
                    default  { return [CompleteFromList $text $options] }
            }
        }
    }
    return ""
}

# --- MSGCAT PACKAGE ---

# --- END OF MSGCAT PACKAGE ---

# TODO import ! -force
proc complete(namespace) {text start end line pos mod} {
    # TODO dosn't work ???
    set space_matches [namespace children :: [string trim ${mod}*]]
    # puts \nspace_matches=|${space_matches}|
    set cmd [Lindex $line 1]
    switch -- $pos {
        1 {
            set cmds {
                children code current delete eval export forget
                import inscope origin parent qualifiers tail which}
                    import inscope origin parent qualifiers tail which
                }
            return [TryFromList $text $cmds]
        }
        2 {
            switch -- $cmd {
                children -
                delete -
                eval -
                inscope -
                forget -
                parent -
                qualifiers -
                tail {
                    regsub {^([^:])} ${mod} {::\1} mod; # full qual. name
                    return [TryFromList ${mod} $space_matches]
                        regsub {^([^:])} $mod {::\1} mod; # full qual. name
                        return [TryFromList $mod $space_matches]
                }
                code { return [DisplayHints <script> ] }
                current {}
                export { return [CompleteFromList ${text} {-clear ?pattern?}] }
                    export     { return [CompleteFromList $text {-clear ?pattern?}] }
                import {
                    if {"-" != [string index ${mod} 0]} {
                        regsub {^([^:])} ${mod} {::\1} mod; # full qual. name
                        if {"-" != [string index $mod 0]} {
                            regsub {^([^:])} $mod {::\1} mod; # full qual. name
                    }
                    return [CompleteFromList ${mod} "-force $space_matches"]
                        return [CompleteFromList $mod "-force $space_matches"]
                }
                origin { return [DisplayHints <command>] }
                # qualifiers -
                # tail { return [DisplayHints <string>] }
                which { return [CompleteFromList ${mod} {
                    -command -variable <name>}] }
                    which      { return [CompleteFromList $mod {-command -variable <name>}] }
            }
        }
        3 {
            switch -- $cmd {
                children -
                export -
                forget -
                import { return [DisplayHints ?pattern?] }
                delete { return [TryFromList ${mod} $space_matches] }
                    delete   { return [TryFromList $mod $space_matches] }
                eval -
                inscope {
                    return [BraceOrCommand \
                    $text $start $end $line $pos $mod]
                    inscope  { return [BraceOrCommand $text $start $end $line $pos $mod] }
                }
                which { return [CompleteFromList ${mod} {-variable <name>}] }
                    which    { return [CompleteFromList $mod {-variable <name>}] }
            }
        }
        4 {
            switch -- $cmd {
                export -
                forget -
                import { return [DisplayHints ?pattern?] }
                delete { return [TryFromList ${mod} $space_matches] }
                    delete  { return [TryFromList $mod $space_matches] }
                eval -
                inscope { return [DisplayHints ?arg?] }
                which { return [CompleteFromList ${mod} {<name>}] }
                    which   { return [CompleteFromList $mod {<name>}] }
            }
        }
    }
    return ""
}

proc complete(open) {text start end line pos mod} {
        # 2 { return [DisplayHints ?access?] }
    switch -- $pos {
        2 {
            set access {r r+ w w+ a a+
                RDONLY WRONLY RDWR APPEND CREAT EXCL NOCTTY NONBLOCK TRUNC}
            return [CompleteFromList ${text} ${access}]
                set access {
                    r r+ w w+ a a+
                    RDONLY WRONLY RDWR APPEND CREAT
                    EXCL NOCTTY NONBLOCK TRUNC
                }
                return [CompleteFromList $text $access]
        }
        3 { return [DisplayHints ?permissions?] }
    }
    return ""
}

proc complete(package) {text start end line pos mod} {
    set cmd [Lindex $line 1]
    switch -- $pos {
        1 {
            set cmds {
                forget ifneeded names present provide require
                unknown vcompare versions vsatisfies}
                    unknown vcompare versions vsatisfies
                }
            return [TryFromList $text $cmds]
        }
        2 {
            switch -- ${cmd} {
                switch -- $cmd {
                forget -
                ifneeded -
                provide -
                versions { return [CompleteFromList ${mod} [package names]] }
                    versions   { return [CompleteFromList $mod [package names]] }
                present -
                require {
                    return [CompleteFromList ${mod} "-exact [package names]"] }
                        return [CompleteFromList $mod "-exact [package names]"] }
                names {}
                unknown { return [DisplayHints ?command?] }
                vcompare -
                vsatisfies { return [DisplayHints <version1>] }
            }
        }
        3 {
            set versions ""
            catch [list set versions [package versions [Lindex ${line} 2]]]
            switch -- ${cmd} {
                catch [list set versions [package versions [Lindex $line 2]]]
                switch -- $cmd {
                forget {}
                ifneeded {
                    if {"" != $versions} {
                        return [CompleteFromList ${text} ${versions}]
                            return [CompleteFromList $text $versions]
                    } else {
                        return [DisplayHints <version>]
                    }
                }
                provide {
                    if {"" != ${versions}} {
                        return [CompleteFromList ${text} ${versions}]
                        if {"" != $versions} {
                            return [CompleteFromList $text $versions]
                    } else {
                        return [DisplayHints ?version?]
                    }
                }
                versions {}
                present -
                require {
                    if {"-exact" == [PreviousWord ${start} ${line}]} {
                        return [CompleteFromList ${mod} [package names]]
                        if {"-exact" == [PreviousWord $start $line]} {
                            return [CompleteFromList $mod [package names]]
                    } else {
                        if {"" != ${versions}} {
                            return [CompleteFromList ${text} ${versions}]
                            if {"" != $versions} {
                                return [CompleteFromList $text $versions]
                        } else {
                            return [DisplayHints ?version?]
                        }
                    }
                }
                names {}
                unknown {}
                vcompare -
                vsatisfies { return [DisplayHints <version2>] }
            }
        }
    }
    return ""
}

proc complete(pid) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [ChannelId ${text}] }
        switch -- $pos {
            1 { return [ChannelId $text] }
    }
}

proc complete(pkg_mkIndex) {text start end line pos mod} {
    set cmds [RemoveUsedOptions ${line} {-direct -load -verbose -- <dir>} {--}]
    set res [string trim [TryFromList ${text} ${cmds}]]
    set prev [PreviousWord ${start} ${line}]
    if {"-load" == ${prev}} {
        set cmds [RemoveUsedOptions $line {-direct -load -verbose -- <dir>} {--}]
        set res [string trim [TryFromList $text $cmds]]
        set prev [PreviousWord $start $line]
        if {"-load" == $prev} {
        return [DisplayHints <pkgPat>]
    } elseif {"--" == ${prev}} {
        return [TryFromList ${text} <dir>]
        } elseif {"--" == $prev} {
            return [TryFromList $text <dir>]
    }
    return ${res}
        return $res
}

proc complete(proc) {text start end line pos mod} {
    switch -- ${pos} {
        switch -- $pos {
        1 {
            set known_procs [ProcsOnlyCompletion ${text}]
            return [CompleteFromList ${text} ${known_procs}]
                set known_procs [ProcsOnlyCompletion $text]
                return [CompleteFromList $text $known_procs]
        }
        2 {
            set proc [Lindex ${line} 1]
            if {[catch {set args [uplevel [info level] info args ${proc}]}]} {
                set proc [Lindex $line 1]
                if {[catch {set args [uplevel [info level] info args $proc]}]} {
                return [DisplayHints <args>]
            } else {
                return [list "\{${args}\}"]
            }
        }
        3 {
            if {![string length [Lindex ${line} ${pos}]]} {
                if {![string length [Lindex $line $pos]]} {
                return [list \{ {}]; # \}
            } else {
                # return [DisplayHints <body>]
                return [BraceOrCommand \
                    return [BraceOrCommand $text $start $end $line $pos $mod]
                ${text} ${start} ${end} ${line} ${pos} ${mod}]
            }
        }
    }
    return ""
}

proc complete(puts) {text start end line pos mod} {
    set cmd [Lindex $line 1]
    switch -- $pos {
        1 {
            return [OutChannelId ${text} "-nonewline"]
                return [OutChannelId $text "-nonewline"]
        }
        2 {
            switch -- $cmd {
                -nonewline { return [OutChannelId ${text}] }
                    -nonewline { return [OutChannelId $text] }
                default { return [DisplayHints <string>] }
            }
        }
        3 {
            switch -- $cmd {
                -nonewline { return [DisplayHints <string>] }
            }
        }
    }
    return ""
}

# proc complete(pwd) {text start end line pos mod} {
# }

proc complete(read) {text start end line pos mod} {
    set cmd [Lindex $line 1]
    switch -- $pos {
        1 {
            return [InChannelId ${text} "-nonewline"]
                return [InChannelId $text "-nonewline"]
        }
        2 {
            switch -- $cmd {
                -nonewline { return [InChannelId ${text}] }
                    -nonewline { return [InChannelId $text] }
                default { return [DisplayHints <numChars>] }
            }
        }
    }
    return ""
}

proc complete(regexp) {text start end line pos mod} {
    set prev [PreviousWord ${start} ${line}]
    if {[llength ${prev}] && "--" != $prev && \
        ("-" == [string index ${prev} 0] || 1 == $pos)} {
        set cmds [RemoveUsedOptions ${line} {
            -nocase -indices -expanded -line
        set prev [PreviousWord $start $line]
        if {[llength $prev] && "--" != $prev
                && ("-" == [string index $prev 0] || 1 == $pos)} {
            set cmds [RemoveUsedOptions $line \
                          {-nocase -indices -expanded -line
            -linestop -lineanchor -about <expression> --} {--}]
        if {[llength ${cmds}]} {
            return [string trim [CompleteFromList ${text} ${cmds}]]
            if {[llength $cmds]} {
                return [string trim [CompleteFromList $text $cmds]]
        }
    } else {
        set virtual_pos [expr ${pos} - [FirstNonOption ${line}]]
        switch -- ${virtual_pos} {
            set virtual_pos [expr {$pos - [FirstNonOption $line]}]
            switch -- $virtual_pos {
            0 { return [DisplayHints <string>] }
            1 { return [DisplayHints ?matchVar?] }
            default { return [DisplayHints ?subMatchVar?] }
        }
    }
    return ""
}

# proc complete(regexp) {text start end line pos mod} {
#     We're not on windoze here ...
# }

proc complete(regsub) {text start end line pos mod} {
    set prev [PreviousWord ${start} ${line}]
    if {[llength ${prev}] && "--" != $prev && \
        ("-" == [string index ${prev} 0] || 1 == ${pos})} {
        set cmds [RemoveUsedOptions ${line} {
            -all -nocase --} {--}]
        if {[llength ${cmds}]} {
            return [string trim [CompleteFromList ${text} ${cmds}]]
        set prev [PreviousWord $start $line]
        if {[llength $prev] && "--" != $prev
                && ("-" == [string index $prev 0] || 1 == $pos)} {
            set cmds [RemoveUsedOptions $line \
                          {-all -nocase --} {--}]
            if {[llength $cmds]} {
                return [string trim [CompleteFromList $text $cmds]]
        }
    } else {
        set virtual_pos [expr ${pos} - [FirstNonOption ${line}]]
        switch -- ${virtual_pos} {
            set virtual_pos [expr {$pos - [FirstNonOption $line]}]
            switch -- $virtual_pos {
            0 { return [DisplayHints <expression>] }
            1 { return [DisplayHints <string>] }
            2 { return [DisplayHints <subSpec>] }
            3 { return [DisplayHints <varName>] }
        }
    }
    return ""
}

proc complete(rename) {text start end line pos mod} {
    switch -- $pos {
        1 {
            return [CompleteFromList ${text} [CommandCompletion ${text}]]
            1 { return [CompleteFromList $text [CommandCompletion $text]] }
        }
        2 {
            return [DisplayHints <newName>]
            2 { return [DisplayHints <newName>] }
        }
    }
    return ""
}

# proc complete(resource) {text start end line pos mod} {
#     This is not a mac ...
# }

proc complete(return) {text start end line pos mod} {
    # TODO this is not perfect yet
    set cmds {-code -errorinfo -errorcode ?string?}
    set res [PreviousWord ${start} ${line}]
    switch -- ${res} {
        set res [PreviousWord $start $line]
        switch -- $res {
        -errorinfo { return [DisplayHints <info>] }
        -code -
        -errorcode {
            set codes {ok error return break continue}
            return [TryFromList ${mod} ${codes}]
                return [TryFromList $mod $codes]
        }
    }
    return [CompleteFromList ${text} [RemoveUsedOptions ${line} ${cmds}]]
        return [CompleteFromList $text [RemoveUsedOptions $line $cmds]]
}

# --- SAFE PACKAGE ---

# create a safe namespace inside
# tclreadline and import some commands.
#

        ::tclreadline::WidgetChildren
    }
    variable opts
    set opts {
        -accessPath -statics -noStatics -nested -nestedLoadOk -deleteHook
    }
    proc SlaveOrOpts {text start line pos slave} {
        set prev [PreviousWord ${start} ${line}]
            set prev [PreviousWord $start $line]
        variable opts
        if {$pos > 1} {
            set slave ""
        }
        switch -- $prev {
            -accessPath { return [DisplayHints <directoryList>] }
            -statics { return [CompleteBoolean $text] }
            -nested { return [CompleteBoolean $text] }
            -deleteHook { return [DisplayHints <script>] }
            default {
                return [CompleteFromList ${text} \
                [RemoveUsedOptions ${line} "${opts} $slave"]]
                    return [CompleteFromList $text \
                                [RemoveUsedOptions $line "$opts $slave"]]
            }
        }
    }
}

proc safe::complete(interpCreate) {text start end line pos mod} {
    return [SlaveOrOpts ${text} ${start} ${line} ${pos} ?slave?]
        return [SlaveOrOpts $text $start $line $pos ?slave?]
}

proc safe::complete(interpInit) {text start end line pos mod} {
    return [SlaveOrOpts ${text} ${start} ${line} ${pos} [interp slaves]]
        return [SlaveOrOpts $text $start $line $pos [interp slaves]]
}

proc safe::complete(interpConfigure) {text start end line pos mod} {
    return [SlaveOrOpts $text $start $line $pos [interp slaves]]
}

proc safe::complete(interpDelete) {text start end line pos mod} {
    return [CompleteFromList ${text} [interp slaves]]
        return [CompleteFromList $text [interp slaves]]
}

proc safe::complete(interpAddToAccessPath) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [CompleteFromList ${text} [interp slaves]] }
        switch -- $pos {
            1 { return [CompleteFromList $text [interp slaves]] }
    }
}

proc safe::complete(interpFindInAccessPath) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [CompleteFromList ${text} [interp slaves]] }
        switch -- $pos {
            1 { return [CompleteFromList $text [interp slaves]] }
    }
}

proc safe::complete(setLogCmd) {text start end line pos mod} {
    switch -- ${pos} {
        switch -- $pos {
        1 { return [DisplayHints ?cmd?] }
        default { return [DisplayHints ?arg?] }
    }
}

proc safe::complete(loadTk) {text start end line pos mod} {
    switch -- ${pos} {
        switch -- $pos {
        1 { return [DisplayHints <slave>] }
        default {
            switch -- [PreviousWord ${start} ${line}] {
                switch -- [PreviousWord $start $line] {
                -use {
                    return [CompleteFromList ${text} \
                    [::tclreadline::WidgetChildren ${text}]]
                        return [CompleteFromList $text \
                                    [::tclreadline::WidgetChildren $text]]
                }
                -display {
                    return [DisplayHints <display>]
                    -display { return [DisplayHints <display>] }
                }
                default {
                    return [CompleteFromList ${text} \
                    [RemoveUsedOptions ${line} {-use -display}]]
                        return [CompleteFromList $text \
                                    [RemoveUsedOptions $line {-use -display}]]
                }
            }
        }
    }
}

# --- END OF SAFE PACKAGE ---

proc complete(scan) {text start end line pos mod} {
    switch -- ${pos} {
        switch -- $pos {
        1 { return [DisplayHints <string>] }
        2 { return [DisplayHints <format>] }
        default { return [VarCompletion ${text}] }
            default { return [VarCompletion $text] }
    }
    return ""
}

proc complete(seek) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [ChannelId ${text}] }
        switch -- $pos {
            1 { return [ChannelId $text] }
        2 { return [DisplayHints <offset>] }
        3 { return [TryFromList ${text} {start current end}] }
            3 { return [TryFromList $text {start current end}] }
    }
    return ""
}

proc complete(set) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [VarCompletion ${text}] }
        switch -- $pos {
            1 { return [VarCompletion $text] }
        2 {
            if {${text} == "" || ${text} == "\"" || ${text} == "\{"} {
                if {$text == "" || $text == "\"" || $text == "\{"} {
                # set line [QuoteQuotes $line]
                    if {[catch {set value \
                if {[catch [list set value [list [uplevel [info level] \
                    set [Lindex ${line} 1]]]] msg]
                                    [list [uplevel [info level] \
                                               set [Lindex $line 1]]]} msg]} {
                } {
                    return ""
                } else {
                    return [Quote ${value} ${text}]
                        return [Quote $value $text]
                }
            }
        }
    }
    return ""
}

proc complete(socket) {text start end line pos mod} {
    set cmd [Lindex ${line} 1]
    set prev [PreviousWord ${start} ${line}]
    if {"-server" == ${cmd}} {
        set cmd [Lindex $line 1]
        set prev [PreviousWord $start $line]
        if {"-server" == $cmd} {
        # server sockets
        #
        switch -- ${pos} {
            switch -- $pos {
            2 { return [DisplayHints <command>] }
            default {
                if {"-myaddr" == ${prev}} {
                    if {"-myaddr" == $prev} {
                    return [DisplayHints <addr>]
                } else {
                    return [CompleteFromList ${mod} \
                        return [CompleteFromList $mod \
                    [RemoveUsedOptions $line {-myaddr -error -sockname <port>}]]
                }
            }
        }
    } else {
        # client sockets
        #
        switch -- ${prev} {
            switch -- $prev {
            -myaddr { return [DisplayHints <addr>] }
            -myport { return [DisplayHints <port>] }
        }

        set hosts [HostList]
        set cmds {-myaddr -myport -async -myaddr -error -sockname -peername}
        if {${pos} <= 1} {
            if {$pos <= 1} {
            lappend cmds -server
        }
        set cmds [RemoveUsedOptions ${line} ${cmds}]
        if {-1 != [lsearch ${hosts} ${prev}]} {
            set cmds [RemoveUsedOptions $line $cmds]
            if {-1 != [lsearch $hosts $prev]} {
            return [DisplayHints <port>]
        } else {
            return [CompleteFromList ${mod} [concat ${cmds} ${hosts}]]
                return [CompleteFromList $mod [concat $cmds $hosts]]
        }
    }
    return ""
}

proc complete(source) {text start end line pos mod} {
    # allow file name completion
    return ""
}

proc complete(split) {text start end line pos mod} {
    switch -- ${pos} {
        switch -- $pos {
        1 { return [DisplayHints <string>] }
        2 { return [DisplayHints ?splitChars?] }
    }
}

proc complete(string) {text start end line pos mod} {
    set cmd [Lindex ${line} 1]
    set prev [PreviousWord ${start} ${line}]
        set cmd [Lindex $line 1]
        set prev [PreviousWord $start $line]
    set cmds {
        bytelength compare equal first index is last length map match
        range repeat replace tolower toupper totitle trim trimleft
        trimright wordend wordstart}
    switch -- ${pos} {
        switch -- $pos {
        1 {
            return [CompleteFromList ${text} ${cmds}]
            1 { return [CompleteFromList $text $cmds] }
        }
        2 {
            switch -- ${cmd} {
                switch -- $cmd {
                compare -
                equal {
                    return [CompleteFromList ${text} {
                        return [CompleteFromList $text {-nocase -length <string>}]
                        -nocase -length <string> }]
                }

                first -
                last { return [DisplayHints <string1>] }

                map { return [CompleteFromList ${text} {-nocase <charMap>]} }
                match { return [CompleteFromList ${text} {-nocase <pattern>]} }
                    map   { return [CompleteFromList $text {-nocase <charMap>]} }
                    match { return [CompleteFromList $text {-nocase <pattern>]} }

                is {
                    return [CompleteFromList ${text} {
                        alnum alpha ascii boolean control digit double
                        return [CompleteFromList $text \
                                    {alnum alpha ascii boolean control digit double
                        false graph integer lower print punct space
                        true upper wordchar xdigit
                                     true upper wordchar xdigit}]
                    }]
                }

                bytelength -
                index -
                length -
                range -
                repeat -
                replace -
                tolower -
                totitle -
                toupper -
                trim -
                trimleft -
                trimright -
                wordend -
                wordstart { return [DisplayHints <string>] }
            }
        }
        3 {
            switch -- ${cmd} {
                switch -- $cmd {
                compare -
                equal {
                    if {"-length" == ${prev}} {
                        if {"-length" == $prev} {
                        return [DisplayHints <int>]
                    }
                    return [CompleteFromList ${text} \
                    [RemoveUsedOptions ${line} {-nocase -length <string>}]]
                        return [CompleteFromList $text \
                                    [RemoveUsedOptions $line {-nocase -length <string>}]]
                }

                first -
                last { return [DisplayHints <string2>] }

                map {
                    if {"-nocase" == ${prev}} {
                        if {"-nocase" == $prev} {
                        return [DisplayHints <charMap>]
                    } else {
                        return [DisplayHints <string>]
                    }
                }
                match {
                    if {"-nocase" == ${prev}} {
                        if {"-nocase" == $prev} {
                        return [DisplayHints <pattern>]
                    } else {
                        return [DisplayHints <string>]
                    }
                }

                is {
                    return [CompleteFromList ${text} \
                    [RemoveUsedOptions ${line} {-strict -failindex <string>}]]
                        return [CompleteFromList $text \
                                    [RemoveUsedOptions $line {-strict -failindex <string>}]]
                }

                bytelength {}
                index -
                wordend -
                wordstart { return [DisplayHints <charIndex>] }
                range -
                replace { return [DisplayHints <first>] }
                repeat { return [DisplayHints <count>] }
                tolower -
                totitle -
                toupper { return [DisplayHints ?first?] }
                trim -
                trimleft -
                trimright { return [DisplayHints ?chars?] }
            }
        }
        4 {
            switch -- ${cmd} {
                switch -- $cmd {
                compare -
                equal {
                    if {"-length" == ${prev}} {
                        if {"-length" == $prev} {
                        return [DisplayHints <int>]
                    }
                    return [CompleteFromList ${text} \
                        return [CompleteFromList $text \
                    [RemoveUsedOptions $line {-nocase -length <string>}]]
                }

                first -
                last { return [DisplayHints ?startIndex?] }

                map -
                match { return [DisplayHints <string>] }

                is {
                    if {"-failindex" == ${prev}} {
                        return [VarCompletion ${text}]
                        if {"-failindex" == $prev} {
                            return [VarCompletion $text]
                    }
                    return [CompleteFromList ${text} \
                        return [CompleteFromList $text \
                    [RemoveUsedOptions $line {-strict -failindex <string>}]]
                }

                bytelength {}
                index {}
                length {}
                range -
                replace { return [DisplayHints <last>] }
                repeat {}
                tolower -
                totitle -
                toupper { return [DisplayHints ?last?] }
                trim -
                trimleft -
                trimright {}
                wordend -
                wordstart {}
            }
        }
        default {
            switch -- ${cmd} {
                switch -- $cmd {
                compare -
                equal {
                    if {"-length" == ${prev}} {
                        if {"-length" == $prev} {
                        return [DisplayHints <int>]
                    }
                    return [CompleteFromList ${text} \
                        return [CompleteFromList $text \
                    [RemoveUsedOptions $line {-nocase -length <string>}]]
                }

                is {
                    if {"-failindex" == ${prev}} {
                        return [VarCompletion ${text}]
                        if {"-failindex" == $prev} {
                            return [VarCompletion $text]
                    }
                    return [CompleteFromList ${text} \
                    [RemoveUsedOptions ${line} {-strict -failindex <string>}]]
                        return [CompleteFromList $text \
                                    [RemoveUsedOptions $line {-strict -failindex <string>}]]
                }

                replace { return [DisplayHints ?newString?] }
            }
        }
    }
    return ""
}

proc complete(subst) {text start end line pos mod} {
    return [CompleteFromList ${text} [RemoveUsedOptions ${line} {
        return [CompleteFromList $text [RemoveUsedOptions $line {
        -nobackslashes -nocommands -novariables <string>}]]
}

proc complete(switch) {text start end line pos mod} {
    set prev [PreviousWord ${start} ${line}]
    if {[llength ${prev}] && "--" != ${prev} && \
        ("-" == [string index ${prev} 0] || 1 == ${pos})} {
        set cmds [RemoveUsedOptions ${line} {
            -exact -glob -regexp --} {--}]
        if {[llength ${cmds}]} {
            return [string trim [CompleteFromList ${text} ${cmds}]]
        set prev [PreviousWord $start $line]
        if {[llength $prev] && "--" != $prev
                && ("-" == [string index $prev 0] || 1 == $pos)} {
            set cmds [RemoveUsedOptions $line \
                          {-exact -glob -regexp --} {--}]
            if {[llength $cmds]} {
                return [string trim [CompleteFromList $text $cmds]]
        }
    } else {
        set virtual_pos [expr ${pos} - [FirstNonOption ${line}]]
        switch -- ${virtual_pos} {
            set virtual_pos [expr {$pos - [FirstNonOption $line]}]
            switch -- $virtual_pos {
            0 { return [DisplayHints <string>] }
            1 { return [DisplayHints <pattern>] }
            2 { return [DisplayHints <body>] }
            default {
                switch [expr ${virtual_pos} % 2] {
                    switch [expr {$virtual_pos % 2}] {
                    0 { return [DisplayHints ?body?] }
                    1 { return [DisplayHints ?pattern?] }
                }
            }
        }
    }
    return ""

        ::tclreadline::CompleteFromList \
        ::tclreadline::Lindex \
        ::tclreadline::CompleteBoolean
    }
}

proc tclreadline::complete(readline) {text start end line pos mod} {
    set cmd [Lindex ${line} 1]
    switch -- ${pos} {
        1 { return [CompleteFromList ${text} {
            read initialize write add complete customcompleter
        set cmd [Lindex $line 1]
        switch -- $pos {
            1 { return [CompleteFromList $text \
                            {read initialize write add complete customcompleter
            builtincompleter eofchar reset-terminal bell}]
        }
        2 {
            switch -- ${cmd} {
                switch -- $cmd {
                read {}
                initialize {}
                write {}
                add { return [DisplayHints <completerLine>] }
                completer { return [DisplayHints <line>] }
                customcompleter { return [DisplayHints ?scriptCompleter?] }
                builtincompleter { return [CompleteBoolean ${text}] }
                    builtincompleter { return [CompleteBoolean $text] }
                eofchar { return [DisplayHints ?script?] }
                reset-terminal {
                    if {[info exists ::env(TERM)]} {
                        return [CompleteFromList ${text} $::env(TERM)]
                            return [CompleteFromList $text $::env(TERM)]
                    } else {
                        return [DisplayHints ?terminalName?]
                    }
                }
            }
        }
    }
    return ""
}

# --- END OF TCLREADLINE PACKAGE ---

proc complete(tell) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [ChannelId ${text}] }
        switch -- $pos {
            1 { return [ChannelId $text] }
    }
    return ""
}

proc complete(testthread) {text start end line pos mod} {

    set cmd [Lindex ${line} 1]
    switch -- ${pos} {
        set cmd [Lindex $line 1]
        switch -- $pos {
        1 {
            return [CompleteFromList ${text} {
                -async create errorproc exit id names send wait
                return [CompleteFromList $text \
                            {-async create errorproc exit id names send wait}]
            }]
        }
        2 {
            switch -- [PreviousWord ${start} ${line}] {
                switch -- [PreviousWord $start $line] {
                create {
                    return [BraceOrCommand \
                        return [BraceOrCommand $text $start $end $line $pos $mod]
                    ${text} ${start} ${end} ${line} ${pos} ${mod}]
                }
                -async {
                    return [CompleteFromList ${text} send]
                    -async  { return [CompleteFromList $text send] }
                }
                send {
                    return [CompleteFromList ${text} [testthread names]]
                    send    { return [CompleteFromList $text [testthread names]] }
                }
                default {}
            }
        }
        3 {
            if {"send" == [PreviousWord ${start} ${line}]} {
                return [CompleteFromList ${text} [testthread names]]
            } elseif {"send" == ${cmd}} {
                return [BraceOrCommand \
                if {"send" == [PreviousWord $start $line]} {
                    return [CompleteFromList $text [testthread names]]
                } elseif {"send" == $cmd} {
                    return [BraceOrCommand $text $start $end $line $pos $mod]
                ${text} ${start} ${end} ${line} ${pos} ${mod}]
            }
        }
        4 {
            if {"send" == [Lindex ${line} 2]} {
                return [BraceOrCommand \
                if {"send" == [Lindex $line 2]} {
                    return [BraceOrCommand $text $start $end $line $pos $mod]
                ${text} ${start} ${end} ${line} ${pos} ${mod}]
            }
        }
    }
    return ""
}

proc complete(time) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [BraceOrCommand \
        switch -- $pos {
            1 { return [BraceOrCommand $text $start $end $line $pos $mod]
            ${text} ${start} ${end} ${line} ${pos} ${mod}]
        }
        2 { return [DisplayHints ?count?] }
    }
    return ""
}

proc complete(trace) {text start end line pos mod} {
    set cmd [Lindex ${line} 1]
    switch -- ${pos} {
        set cmd [Lindex $line 1]
        switch -- $pos {
        1 {
            return [CompleteFromList ${mod} {variable vdelete vinfo}]
        }
        2 {
            return [CompleteFromList ${text} \
            [uplevel [info level] info vars "${mod}*"]]
            1 { return [CompleteFromList $mod {variable vdelete vinfo}] }
            2 { return [CompleteFromList $text [uplevel [info level] info vars "${mod}*"]] }
        }
        3 {
                # TODO LW: 2 'variable' cases, missing 'vinfo' case?
            switch -- ${cmd} {
                switch -- $cmd {
                variable -
                variable { return [CompleteFromList ${text} {r w u}] }
                    variable { return [CompleteFromList $text {r w u}] }
                vdelete {
                    set var [PreviousWord ${start} ${line}]
                        set var [PreviousWord $start $line]
                    set modes ""
                    foreach info [uplevel [info level] trace vinfo ${var}] {
                        lappend modes [lindex ${info} 0]
                        foreach info [uplevel [info level] trace vinfo $var] {
                            lappend modes [lindex $info 0]
                    }
                    return [CompleteFromList ${text} ${modes}]
                        return [CompleteFromList $text $modes]
                }
            }
        }
        4 {
            switch -- ${cmd} {
                switch -- $cmd {
                variable {
                    return [CompleteFromList ${text} \
                        return [CompleteFromList $text [CommandCompletion $text]]
                    [CommandCompletion ${text}]]
                }
                vdelete {
                    set var [Lindex ${line} 2]
                    set mode [PreviousWord ${start} ${line}]
                        set var [Lindex $line 2]
                        set mode [PreviousWord $start $line]
                    set scripts ""
                    foreach info [uplevel [info level] trace vinfo ${var}] {
                        if {${mode} == [lindex ${info} 0]} {
                            lappend scripts [list [lindex ${info} 1]]
                        foreach info [uplevel [info level] trace vinfo $var] {
                            if {$mode == [lindex $info 0]} {
                                lappend scripts [list [lindex $info 1]]
                        }
                    }
                    return [DisplayHints ${scripts}]
                        return [DisplayHints $scripts]
                }
            }
        }
    }
    return ""
}

proc complete(unknown) {text start end line pos mod} {
    switch -- ${pos} {
        switch -- $pos {
        1 {
            return [CompleteFromList ${text} [CommandCompletion ${text}]]
            1       { return [CompleteFromList $text [CommandCompletion $text]] }
        }
        default { return [DisplayHints ?arg?] }
    }
    return ""
}

proc complete(unset) {text start end line pos mod} {
    return [VarCompletion ${text}]
        return [VarCompletion $text]
}

proc complete(update) {text start end line pos mod} {
    switch -- ${pos} {
        switch -- $pos {
        1 { return idletasks }
    }
    return ""
}

proc complete(uplevel) {text start end line pos mod} {
    set one [Lindex ${line} 1]
    switch -- ${pos} {
        set one [Lindex $line 1]
        switch -- $pos {
        1 {
            return [CompleteFromList \
                return [CompleteFromList $text "?level? [CommandCompletion $text]"]
            ${text} "?level? [CommandCompletion ${text}]"]
        }
        2 {
            if {"#" == [string index ${one} 0] || [regexp {^[0-9]*$} ${one}]} {
                return [CompleteFromList ${text} [CommandCompletion ${text}]]
                if {"#" == [string index $one 0] || [regexp {^[0-9]*$} $one]} {
                    return [CompleteFromList $text [CommandCompletion $text]]
            } else {
                return [DisplayHints ?arg?]
            }
        }
        default { return [DisplayHints ?arg?] }
    }
    return ""
}

proc complete(upvar) {text start end line pos mod} {
    set one [Lindex ${line} 1]
        set one [Lindex $line 1]
    switch -- $pos {
        1 {
            return [DisplayHints {?level? <otherVar>}]
            1       { return [DisplayHints {?level? <otherVar>}] }
        }
        2 {
            if {"#" == [string index $one 0] || [regexp {^[0-9]*$} $one]} {
                return [DisplayHints <otherVar>]
            } else {
                return [DisplayHints <myVar>]
            }
        }
        3 {
            if {"#" == [string index $one 0] || [regexp {^[0-9]*$} $one]} {
                return [DisplayHints <myVar>]
            } else {
                return [DisplayHints ?otherVar?]
            }
        }
        default {
            set virtual_pos $pos
            if {"#" == [string index $one 0] || [regexp {^[0-9]*$} $one]} {
                incr virtual_pos
            }
            switch [expr $virtual_pos % 2] {
                switch [expr {$virtual_pos % 2}] {
                0 { return [DisplayHints ?myVar?] }
                1 { return [DisplayHints ?otherVar?] }
            }
        }
    }
    return ""
}

proc complete(variable) {text start end line pos mod} {
    set modulo [expr $pos % 2]
        set modulo [expr {$pos % 2}]
    switch -- $modulo {
        1 { return [VarCompletion ${text}] }
            1 { return [VarCompletion $text] }
        0 {
            if {$text == "" || $text == "\"" || $text == "\{"} {
                set line [QuoteQuotes $line]
                if {[catch [list set value [list [uplevel [info level] \
                    set [PreviousWord $start $line]]]] msg]
                    if {[catch {set value [list [uplevel [info level] \
                                    set [PreviousWord $start $line]]]} msg]} {
                } {
                    return ""
                } else {
                    return [Quote $value ${text}]
                        return [Quote $value $text]
                }
            }
        }
    }
    return ""
}

proc complete(vwait) {text start end line pos mod} {
    switch -- $pos {
        1 { return [VarCompletion ${mod}] }
            1 { return [VarCompletion $mod] }
    }
    return ""
}

proc complete(while) {text start end line pos mod} {
    switch -- $pos {
        1 -

# -------------------------------------
#                  TK
# -------------------------------------

# GENERIC WIDGET CONFIGURATION

proc WidgetChildren {{pattern .}} {
    regsub {^([^\.])} ${pattern} {\.\1} pattern
    if {![string length ${pattern}]} {
        regsub {^([^\.])} $pattern {\.\1} pattern
        if {![string length $pattern]} {
        set pattern .
    }
    if {[winfo exists ${pattern}]} {
        return [concat ${pattern} [winfo children ${pattern}]]
        if {[winfo exists $pattern]} {
            return [concat $pattern [winfo children $pattern]]
    } else {
        regsub {.[^.]*$} $pattern {.} pattern
        if {[winfo exists ${pattern}]} {
            return [concat ${pattern} [winfo children ${pattern}]]
            if {[winfo exists $pattern]} {
                return [concat $pattern [winfo children $pattern]]
        } else {
            return ""
        }
    }
}

proc WidgetDescendants {{pattern .}} {
    set tree [WidgetChildren ${pattern}]
        set tree [WidgetChildren $pattern]
    foreach widget $tree {
        append tree " [WidgetDescendants $widget]"
    }
    return $tree
}

proc ToplevelWindows {} {

}

# TODO
# write a dispatcher here, which gets the widget class name
# and calls specific completers.
#
# proc complete(WIDGET_COMMAND) {text start end line pos mod} {
#   return [CompleteFromOptionsOrSubCmds ${text} ${start} ${end} ${line} ${pos}]
    #   return [CompleteFromOptionsOrSubCmds $text $start $end $line $pos]
# }

proc EventuallyInsertLeadingDot {text fallback} {
    if {![string length ${text}]} {
        if {![string length $text]} {
        return [list . {}]
    } else {
        return [DisplayHints ${fallback}]
            return [DisplayHints $fallback]
    }
}

# TODO
proc CompleteColor {text {add ""}} {

    # we set the variable only once to speed up.

            gray92 grey92 gray93 grey93 gray94 grey94 gray95 grey95 gray96
            grey96 gray97 grey97 gray98 grey98 gray99 grey99 gray100 grey100
            DarkGrey DarkGray DarkBlue DarkCyan DarkMagenta DarkRed LightGreen
        }
    }
    if ![info exists numberless_colors] {
        set numberless_colors ""
        foreach color ${colors} {
            regsub -all {[0-9]*} ${color} "" color
            lappend numberless_colors ${color}
            foreach color $colors {
                regsub -all {[0-9]*} $color "" color
                lappend numberless_colors $color
        }
            if {[info tclversion] < 8.3} {
        set numberless_colors [Lunique [lsort ${numberless_colors}]]
                set numberless_colors [Lunique [lsort $numberless_colors]]
            } else {
                set numberless_colors [lsort -unique $numberless_colors]
    }
        }
    set matches [MatchesFromList ${text} ${numberless_colors}]
    if {[llength ${matches}] < 5} {
        set matches [MatchesFromList ${text} ${colors}]
        if {[llength ${matches}]} {
            return [CompleteFromList ${text} [concat ${colors} ${add}]]
        set matches [MatchesFromList $text $numberless_colors]
        if {[llength $matches] < 5} {
            set matches [MatchesFromList $text $colors]
            if {[llength $matches]} {
                return [CompleteFromList $text [concat $colors $add]]
        } else {
            return [CompleteFromList ${text} \
                return [CompleteFromList $text [concat $numberless_colors $add]]
            [concat ${numberless_colors} ${add}]]
        }
    } else {
        return [CompleteFromList ${text} [concat ${numberless_colors} ${add}]]
            return [CompleteFromList $text [concat $numberless_colors $add]]
    }
}

proc CompleteCursor text {
    # from <X11/cursorfont.h>
    #
    return [CompleteFromList ${text} {
        num_glyphs x_cursor arrow based_arrow_down based_arrow_up
        return [CompleteFromList $text \
                    {num_glyphs x_cursor arrow based_arrow_down based_arrow_up
        boat bogosity bottom_left_corner bottom_right_corner
        bottom_side bottom_tee box_spiral center_ptr circle clock
        coffee_mug cross cross_reverse crosshair diamond_cross dot
        dotbox double_arrow draft_large draft_small draped_box
        exchange fleur gobbler gumby hand1 hand2 heart icon iron_cross
        left_ptr left_side left_tee leftbutton ll_angle lr_angle
        man middlebutton mouse pencil pirate plus question_arrow
        right_ptr right_side right_tee rightbutton rtl_logo sailboat
        sb_down_arrow sb_h_double_arrow sb_left_arrow sb_right_arrow
        sb_up_arrow sb_v_double_arrow shuttle sizing spider spraycan
        star target tcross top_left_arrow top_left_corner
        top_right_corner top_side top_tee trek ul_angle umbrella
        ur_angle watch xterm
                     ur_angle watch xterm}]
    }]
}

#**
# SpecificSwitchCompleter
# ---
# @param    text   -- the word to complete.
# @param    start  -- the char index of text's start in line
# @param    line   -- the line gathered so far.
# @param    switch -- the switch to complete for.
# @return   a std tclreadline formatted completer string.
# @sa       CompleteWidgetConfigurations
# @date     Sep-17-1999
#
proc SpecificSwitchCompleter {text start line switch {always 1}} {

    switch -- ${switch} {
        switch -- $switch {

        -activebackground -
        -activeforeground -
        -fg -
        -foreground -
        -bg -
        -background -
        -disabledforeground -
        -highlightbackground -
        -highlightcolor -
        -insertbackground -
        -troughcolor -
        -selectbackground -
        -selectforeground { return [CompleteColor ${text}] }
            -selectforeground    { return [CompleteColor $text] }

        -activeborderwidth -
        -bd -
        -borderwidth -
        -insertborderwidth -
        -insertwidth -
        -selectborderwidth -
        -highlightthickness -
        -padx -
        -pady -
        -wraplength {
            if ${always} {
                if $always {
                return [DisplayHints <pixels>]
            } else {
                return ""
            }
        }

        -anchor {
            return [CompleteFromList ${text} {
                return [CompleteFromList $text {
                n ne e se s sw w nw center
            }]
        }


        -bitmap { return [CompleteFromBitmaps ${text} ${always}] }
            -bitmap { return [CompleteFromBitmaps $text $always] }


        -cursor {
            return [CompleteCursor ${text}]
                return [CompleteCursor $text]
            # return [DisplayHints <cursor>]
        }
        -exportselection -
        -jump -
        -setgrid -
        -takefocus { return [CompleteBoolean ${text}] }
            -takefocus       { return [CompleteBoolean $text] }
        -font {
            set names [font names]
            if {[string length ${names}]} {
                return [CompleteFromList ${text} ${names}]
                if {[string length $names]} {
                    return [CompleteFromList $text $names]
            } else {
                if ${always} {
                    if $always {
                    return [DisplayHints <font>]
                } else {
                    return ""
                }
            }
        }


        -image -
        -selectimage { return [CompleteFromImages ${text} ${always}] }
            -selectimage { return [CompleteFromImages $text $always] }
        -selectmode {
            return [CompleteFromList ${text} {
                return [CompleteFromList $text {single browse multiple extended}]
                single browse multiple extended
            }]
        }

        -insertofftime -
        -insertontime -
        -repeatdelay -
        -repeatinterval {
            if ${always} {
                if $always {
                return [DisplayHints <milliSec>]
            } else {
                return ""
            }
        }
        -justify {
            return [CompleteFromList ${text} {
            -justify        { return [CompleteFromList $text {left center right}] }
                left center right
            }]
        }
        -orient {
            return [CompleteFromList ${text} {
            -orient         { return [CompleteFromList $text {vertical horizontal}] }
                vertical horizontal
            }]
        }
        -relief {
            return [CompleteFromList ${text} {
                return [CompleteFromList $text { raised sunken flat ridge solid groove }]
                raised sunken flat ridge solid groove
            }]
        }

        -text {
            if ${always} {
                if $always {
                return [DisplayHints <text>]
            } else {
                return ""
            }
        }
        -textvariable { return [VarCompletion ${text} #0] }
            -textvariable { return [VarCompletion $text #0] }
        -underline {
            if ${always} {
                if $always {
                return [DisplayHints <index>]
            } else {
                return ""
            }
        }

-xscrollcommand -
-yscrollcommand {
            -yscrollcommand {}
}

        # WIDGET SPECIFIC OPTIONS
        # ---

        -state {
            return [CompleteFromList ${text} {
            -state { return [CompleteFromList $text {normal active disabled}] }
                normal active disabled
            }]
        }

        -columnbreak -
        -hidemargin -
        -indicatoron {
            -indicatoron { return [CompleteBoolean $text] }
            return [CompleteBoolean ${text}]
        }


        -variable {
            return [VarCompletion ${text} #0]
        }
            -variable { return [VarCompletion $text #0] }


        default {
            # if ${always} {
            #   set prev [PreviousWord ${start} ${line}]
            #   return [DisplayHints <[String range ${prev} 1 end]>]
                # if $always {
                #   set prev [PreviousWord $start $line]
                #   return [DisplayHints <[String range $prev 1 end]>]
            #} else {
                return ""
            #}
        }
    }
}
            # return [BraceOrCommand ${text} \
                # return [BraceOrCommand $text $start $line $pos $mod]
            # ${start}  ${line} ${pos} ${mod}]

#**
# CompleteWidgetConfigurations
# ---
# @param    text  -- the word to complete.
# @param    start -- the actual cursor position.
# @param    line  -- the line gathered so far.
# @param    lst   -- a list of possible completions.
# @return   a std tclreadline formatted completer string.
# @sa       SpecificSwitchCompleter
# @date     Sep-17-1999
#
proc CompleteWidgetConfigurations {text start line lst} {
    set prev [PreviousWord ${start} ${line}]
    if {"-" == [string index ${prev} 0]} {
        return [SpecificSwitchCompleter ${text} ${start} ${line} ${prev}]
        set prev [PreviousWord $start $line]
        if {"-" == [string index $prev 0]} {
            return [SpecificSwitchCompleter $text $start $line $prev]
    } else {
        return [CompleteFromList ${text} \
            return [CompleteFromList $text [RemoveUsedOptions $line $lst]]
        [RemoveUsedOptions ${line} ${lst}]]
    }
}

# --------------------------------------
# === SPECIFIC TK COMMAND COMPLETERS ===
# --------------------------------------

proc complete(bell) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [CompleteFromList ${text} -displayof] }
        switch -- $pos {
            1 { return [CompleteFromList $text -displayof] }
        2 {
            if {"-displayof" == [PreviousWord ${start} ${line}]} {
                return [CompleteFromList ${text} [ToplevelWindows]]
                if {"-displayof" == [PreviousWord $start $line]} {
                    return [CompleteFromList $text [ToplevelWindows]]
            }
        }
    }
}

proc CompleteSequence {text fulltext} {
    set modifiers {
        Alt Control Shift Lock Double Triple
        B1 B2 B3 B4 B5 Button1 Button2 Button3 Button4 Button5
        M M1 M2 M3 M4 M5
        Meta Mod1 Mod2 Mod3 Mod4 Mod5
    }
    set events {
        Activate Button ButtonPress ButtonRelease
        Circulate Colormap Configure Deactivate Destroy
        Enter Expose FocusIn FocusOut Gravity
        Key KeyPress KeyRelease Leave Map Motion
        MouseWheel Property Reparent Unmap Visibility
    }
    set sequence [concat ${modifiers} ${events}]
    return [CompleteListFromList ${text} ${fulltext} ${sequence} < - >]
        set sequence [concat $modifiers $events]
        return [CompleteListFromList $text $fulltext $sequence < - >]
}

proc complete(bind) {text start end line pos mod} {
    switch -- ${pos} {
        switch -- $pos {
        1 {
            set widgets [WidgetChildren ${text}]
                set widgets [WidgetChildren $text]
            set toplevels [ToplevelWindows]
            if {[catch {set toplevelClass [winfo class .]}]} {
                set toplevelClass ""
            }
            set rest {
                Button Canvas Checkbutton Entry Frame Label
                Listbox Menu Menubutton Message Radiobutton
                Scale Scrollbar Text
                all
            }
            return [CompleteFromList ${text} \
            [concat ${toplevels} ${widgets} ${toplevelClass} $rest]]
                return [CompleteFromList $text \
                            [concat $toplevels $widgets $toplevelClass $rest]]
        }
        2 {
            return [CompleteSequence ${text} [Lindex ${line} 2]]
                return [CompleteSequence $text [Lindex $line 2]]
        }
        default {
            # return [DisplayHints {<script> <+script>}]
            return [BraceOrCommand ${text} \
                return [BraceOrCommand $text $start $end $line $pos $mod]
            ${start} ${end} ${line} ${pos} ${mod}]
        }
    }
    return ""
}

proc complete(bindtags) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [CompleteFromList ${text} [WidgetChildren ${text}]] }
        switch -- $pos {
            1 { return [CompleteFromList $text [WidgetChildren $text]] }
        2 {
            # set current_tags \
                # set current_tags [RemoveUsedOptions $line [bindtags [Lindex $line 1]]]
            # [RemoveUsedOptions ${line} [bindtags [Lindex ${line} 1]]]
            set current_tags [bindtags [Lindex ${line} 1]]
            return [CompleteListFromList ${text} [Lindex ${line} 2] \
            ${current_tags} \{ { } \}]
                set current_tags [bindtags [Lindex $line 1]]
                return [CompleteListFromList $text [Lindex $line 2] \
                            $current_tags \{ { } \}]
        }
    }
    return ""
}

proc complete(button) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
        default {
            return [CompleteWidgetConfigurations ${text} ${start} ${line} {
                -activebackground -activeforeground -anchor
                return [CompleteWidgetConfigurations $text $start $line \
                            {-activebackground -activeforeground -anchor
                -background -bitmap -borderwidth -cursor
                -disabledforeground -font -foreground
                -highlightbackground -highlightcolor
                -highlightthickness -image -justify
                -padx -pady -relief -takefocus -text
                -textvariable -underline -wraplength
                -command -default -height -state -width
                             -command -default -height -state -width}]
            }]
        }
    }
    return ""
}

proc complete(canvas) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
        default {
            return [CompleteWidgetConfigurations ${text} ${start} ${line} {
                -background -borderwidth -cursor -highlightbackground
                return [CompleteWidgetConfigurations $text $start $line \
                            {-background -borderwidth -cursor -highlightbackground
                -highlightcolor -highlightthickness -insertbackground
                -insertborderwidth -insertofftime -insertontime
                -insertwidth -relief -selectbackground -selectborderwidth
                -selectforeground -takefocus -xscrollcommand -yscrollcommand
                -closeenough -confine -height -scrollregion -width
                -xscrollincrement -yscrollincrement
                             -xscrollincrement -yscrollincrement}]
            }]
        }
    }
    return ""
}

proc complete(checkbutton) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
        default {
            return [CompleteWidgetConfigurations ${text} ${start} ${line} {
                -activebackground activeBackground Foreground
                return [CompleteWidgetConfigurations $text $start $line \
                            {-activebackground activeBackground Foreground
                -activeforeground -anchor -background -bitmap
                -borderwidth -cursor -disabledforeground -font
                -foreground -highlightbackground -highlightcolor
                -highlightthickness -image -justify -padx -pady
                -relief -takefocus -text -textvariable -underline
                -wraplength -command -height -indicatoron -offvalue
                -onvalue -selectcolor -selectimage -state -variable
                -width
                             -width}]
            }]
        }
    }
    return ""
}

proc complete(clipboard) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [CompleteFromList ${text} {append clear}] }
        switch -- $pos {
            1       { return [CompleteFromList $text {append clear}] }
        default {
            set sub [Lindex ${line} 1]
            set prev [PreviousWord ${start} ${line}]
            switch -- ${sub} {
                set sub [Lindex $line 1]
                set prev [PreviousWord $start $line]
                switch -- $sub {
                append {
                    switch -- ${prev} {
                        switch -- $prev {
                        -displayof {
                            return [CompleteFromList ${text} [ToplevelWindows]]
                                return [CompleteFromList $text [ToplevelWindows]]
                        }
                        -format { return [DisplayHints <format>] }
                        -type { return [DisplayHints <type>] }
                        default {
                            set opts [RemoveUsedOptions ${line} {
                                -displayof -format -type --
                                set opts [RemoveUsedOptions $line \
                                              {-displayof -format -type --} {--}]
                            } {--}]
                            if {![string length ${opts}]} {
                                if {![string length $opts]} {
                                return [DisplayHints <data>]
                            } else {
                                return [CompleteFromList ${text} ${opts}]
                                    return [CompleteFromList $text $opts]
                            }
                        }
                    }
                }
                clear {
                    switch -- ${prev} {
                        switch -- $prev {
                        -displayof {
                            return [CompleteFromList ${text} [ToplevelWindows]]
                                return [CompleteFromList $text [ToplevelWindows]]
                        }
                        default {
                            return [CompleteFromList ${text} \
                            [RemoveUsedOptions ${line} {
                                return [CompleteFromList $text \
                                            [RemoveUsedOptions $line {-displayof}]]
                                -displayof
                            }]]
                        }
                    }
                }
            }
        }
    }
}

proc complete(destroy) {text start end line pos mod} {
    set remaining [RemoveUsedOptions ${line} [WidgetChildren ${text}]]
    return [CompleteFromList ${text} ${remaining}]
        set remaining [RemoveUsedOptions $line [WidgetChildren $text]]
        return [CompleteFromList $text $remaining]
}

proc complete(entry) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
        default {
            return [CompleteWidgetConfigurations ${text} ${start} ${line} {
                -background -borderwidth -cursor -exportselection
                return [CompleteWidgetConfigurations $text $start $line \
                            {-background -borderwidth -cursor -exportselection
                -font -foreground -highlightbackground -highlightcolor
                -highlightthickness -insertbackground -insertborderwidth
                -insertofftime -insertontime -insertwidth -justify -relief
                -selectbackground -selectborderwidth -selectforeground
                -takefocus -textvariable -xscrollcommand -show -state
                -width
                             -width}]
            }]
        }
    }
    return ""
}

proc complete(event) {text start end line pos mod} {
    set sub [Lindex ${line} 1]
    switch -- ${pos} {
        set sub [Lindex $line 1]
        switch -- $pos {
        1 {
            return [CompleteFromList ${text} { add delete generate info }]
                return [CompleteFromList $text {add delete generate info}]
        }
        2 {
            switch -- ${sub} {
                switch -- $sub {
                add { return [DisplayHints <<virtual>>] }
                info -
                delete {
                    return [CompleteFromList ${text} [event info] "<"]
                    delete   { return [CompleteFromList $text [event info] "<"] }
                }
                generate {
                    generate { return [TryFromList $text [WidgetChildren $text]] }
                    return [TryFromList ${text} [WidgetChildren ${text}]]
                }
            }
        }
        3 {
            switch -- ${sub} {
                switch -- $sub {
                add -
                delete -
                generate {
                    return [CompleteSequence ${text} [Lindex ${line} 3]]
                    generate { return [CompleteSequence $text [Lindex $line 3]] }
                }
                info {}
            }
        }
        default {
            switch -- ${sub} {
                switch -- $sub {
                add -
                delete {
                    return [CompleteSequence ${text} [Lindex ${line} 3]]
                    delete   { return [CompleteSequence $text [Lindex $line 3]] }
                }
                info {}
                generate {

                    switch -- [PreviousWord ${start} ${line}] {
                        switch -- [PreviousWord $start $line] {

                        -above -
                        -root -
                        -subwindow {
                            -subwindow { return [TryFromList $text [WidgetChildren $text]] }
                            return [TryFromList ${text} \
                            [WidgetChildren ${text}]]
                        }

                        -borderwidth { return [DisplayHints <size>] }

                        -button -
                        -delta -
                        -keycode -
                        -serial -
                        -count { return [DisplayHints <number>] }

                        -detail {
                            return [CompleteFromList ${text} {
                                NotifyAncestor    NotifyNonlinearVirtual
                                return [CompleteFromList $text \
                                            {NotifyAncestor    NotifyNonlinearVirtual
                                NotifyDetailNone  NotifyPointer
                                NotifyInferior    NotifyPointerRoot
                                NotifyNonlinear   NotifyVirtual
                                             NotifyNonlinear   NotifyVirtual}]
                            }]
                        }

                        -focus -
                        -override -
                        -sendevent { return [CompleteBoolean ${text}] }
                            -sendevent { return [CompleteBoolean $text] }

                        -height -
                        -width { return [DisplayHints <size>] }

                        -keysym { return [DisplayHints <name>] }

                        -mode {
                            return [CompleteFromList ${text} {
                                NotifyNormal NotifyGrab
                                NotifyUngrab NotifyWhileGrabbed
                                return [CompleteFromList $text \
                                            {NotifyNormal NotifyGrab
                                             NotifyUngrab NotifyWhileGrabbed}]
                            }]
                        }

                        -place {
                            return [CompleteFromList ${text} {
                                return [CompleteFromList $text {PlaceOnTop PlaceOnBottom}]
                                PlaceOnTop PlaceOnBottom
                            }]
                        }

                        -rootx -
                        -rooty -
                        -x -
                        -y { return [DisplayHints <coord>] }

                        -state {
                            return [CompleteFromList ${text} {
                                return [CompleteFromList $text \
                                VisibilityUnobscured
                                VisibilityPartiallyObscured
                                VisibilityFullyObscured
                                            {VisibilityUnobscured VisibilityPartiallyObscured
                                             VisibilityFullyObscured <integer>}]
                                <integer>
                            }]
                        }

                        -time { return [DisplayHints <integer>] }
                        -when {
                            return [CompleteFromList ${text} {
                            -when { return [CompleteFromList $text {now tail head mark}] }
                                now tail head mark
                            }]
                        }


                        default {
                            return [CompleteFromList ${text} \
                            [RemoveUsedOptions ${line} {
                                -above -borderwidth -button -count -delta
                                return [CompleteFromList $text \
                                            [RemoveUsedOptions $line \
                                                 {-above -borderwidth -button -count -delta
                                -detail -focus -height -keycode -keysym
                                -mode -override -place -root -rootx -rooty
                                -sendevent -serial -state -subwindow -time
                                -width -when -x -y
                                                  -width -when -x -y}]]
                            }]]

                            }
                        }
                    }
                    default { }
                }
            }
        }
    }
    return ""
}

proc complete(focus) {text start end line pos mod} {
    switch -- ${pos} {
        switch -- $pos {
        1 {
            return [CompleteFromList ${text} \
            [concat [WidgetChildren ${text}] -displayof -force -lastfor]]
                return [CompleteFromList $text \
                            [concat [WidgetChildren $text] -displayof -force -lastfor]]
        }
        default {
            switch -- [PreviousWord ${start} ${line}] {
                switch -- [PreviousWord $start $line] {
                -displayof -
                -force -
                -lastfor {
                    return [CompleteFromList ${text} \
                        return [CompleteFromList $text [WidgetChildren $text]]
                    [WidgetChildren ${text}]]
                }
            }
        }
    }
    return ""
}

proc FontConfigure {text line prev} {
    set fontopts {-family -overstrike -size -slant -underline -weight}
    switch -- ${prev} {
        switch -- $prev {
        -family {
            return [CompleteFromList ${text} [font families]]
            -family     { return [CompleteFromList $text [font families]] }
        }
        -underline -
        -overstrike { return [CompleteBoolean ${text}] }
            -overstrike { return [CompleteBoolean $text] }
        -size { return [DisplayHints <size>] }
        -slant {
            return [CompleteFromList ${text} { roman italic }]
            -slant      { return [CompleteFromList $text {roman italic}] }
        }
        -weight {
            return [CompleteFromList ${text} { normal bold }]
            -weight     { return [CompleteFromList $text {normal bold}] }
        }
        default {
            return [CompleteFromList ${text} \
                return [CompleteFromList $text [RemoveUsedOptions $line $fontopts]]
            [RemoveUsedOptions ${line} ${fontopts}]]
        }
    }
}

proc complete(font) {text start end line pos mod} {
    set fontopts {-family -overstrike -size -slant -underline -weight}
    set fontmetrics {-ascent -descent -linespace -fixed}
    set sub [Lindex ${line} 1]
    set prev [PreviousWord ${start} ${line}]
    switch -- ${pos} {
        set sub [Lindex $line 1]
        set prev [PreviousWord $start $line]
        switch -- $pos {
        1 {
            return [CompleteFromList ${text} {
                actual configure create delete families measure metrics names
            }]
                return [CompleteFromList $text \
                            {actual configure create delete
                             families measure metrics names}]
        }
        2 {
            switch -- ${sub} {
                switch -- $sub {
                actual -
                measure -
                metrics {
                    return [DisplayHints <font>]
                    metrics   { return [DisplayHints <font>] }
                }
                configure -
                delete {
                    set names [font names]
                    if {[string length ${names}]} {
                        return [CompleteFromList ${text} ${names}]
                        if {[string length $names]} {
                            return [CompleteFromList $text $names]
                    } else {
                        return [DisplayHints <fontname>]
                    }
                }
                create {
                    return [CompleteFromList ${text} \
                    create    { return [CompleteFromList $text [concat ?fontname? $fontopts]] }
                    [concat ?fontname? ${fontopts}]]
                }
                families {
                    return [CompleteFromList ${text} -displayof]
                    families  { return [CompleteFromList $text -displayof] }
                }
                names {}
            }
        }
        3 {
            switch -- ${sub} {
                switch -- $sub {
                actual {
                    return [CompleteFromList ${text} \
                    actual    { return [CompleteFromList $text [concat -displayof $fontopts]] }
                    [concat -displayof ${fontopts}]]
                }
                configure -
                create {
                    return [FontConfigure ${text} ${line} ${prev}]
                    create    { return [FontConfigure $text $line $prev] }
                }
                delete {
                    set names [font names]
                    if {[string length ${names}]} {
                        return [CompleteFromList ${text} ${names}]
                        if {[string length $names]} {
                            return [CompleteFromList $text $names]
                    } else {
                        return [DisplayHints <fontname>]
                    }
                }
                families {
                    switch -- ${prev} {
                        switch -- $prev {
                        -displayof {
                            return [CompleteFromList ${text} \
                            -displayof { return [CompleteFromList $text [WidgetChildren $text]] }
                            [WidgetChildren ${text}]]
                        }
                    }
                }
                measure {
                    return [CompleteFromList ${text} {-displayof <text>}]
                    measure   { return [CompleteFromList $text {-displayof <text>}] }
                }
                metrics {
                    return [CompleteFromList ${text} \
                    metrics   { return [CompleteFromList $text [concat -displayof $fontmetrics]] }
                    [concat -displayof ${fontmetrics}]]
                }
                names {}
            }
        }
        4 {
            switch -- ${sub} {
                switch -- $sub {
                actual {
                    switch -- ${prev} {
                        switch -- $prev {
                        -displayof {
                            return [CompleteFromList ${text} \
                            -displayof { return [CompleteFromList $text [WidgetChildren $text]] }
                            [WidgetChildren ${text}]]
                        }
                        default {
                            return [FontConfigure ${text} ${line} ${prev}]
                            default    { return [FontConfigure $text $line $prev] }
                        }
                    }
                }
                configure -
                create {
                    return [FontConfigure ${text} ${line} ${prev}]
                    create    { return [FontConfigure $text $line $prev] }
                }
                delete {
                    set names [font names]
                    if {[string length ${names}]} {
                        return [CompleteFromList ${text} ${names}]
                        if {[string length $names]} {
                            return [CompleteFromList $text $names]
                    } else {
                        return [DisplayHints <fontname>]
                    }
                }
                families {}
                measure {
                    switch -- ${prev} {
                        switch -- $prev {
                        -displayof {
                            return [CompleteFromList ${text} \
                            -displayof { return [CompleteFromList $text [WidgetChildren $text]] }
                            [WidgetChildren ${text}]]
                        }
                        default {
                            return [DisplayHints <text>]
                            default    { return [DisplayHints <text>] }
                        }
                    }
                }
                metrics {
                    switch -- ${prev} {
                        -displayof {
                            return [CompleteFromList ${text} \
                        switch -- $prev {
                            -displayof { return [CompleteFromList $text [WidgetChildren $text]] }
                            default    { return [CompleteFromList $text $fontmetrics] }
                            [WidgetChildren ${text}]]
                        }
                        default {
                            return [CompleteFromList ${text} ${fontmetrics}]
                        }
                    }
                }
                names {}
            }
        }
        default {
            switch -- ${sub} {
                switch -- $sub {
                actual -
                configure -
                create {
                    return [FontConfigure ${text} ${line} ${prev}]
                    create    { return [FontConfigure $text $line $prev] }
                }
                delete {
                    set names [font names]
                    if {[string length ${names}]} {
                        return [CompleteFromList ${text} ${names}]
                        if {[string length $names]} {
                            return [CompleteFromList $text $names]
                    } else {
                        return [DisplayHints <fontname>]
                    }
                }
                families {}
                measure {
                    return [DisplayHints <text>]
                    measure   { return [DisplayHints <text>] }
                }
                metrics {
                    return [CompleteFromList ${text} ${fontmetrics}]
                    metrics   { return [CompleteFromList $text $fontmetrics] }
                }
                names {}
            }
        }
    }
    return ""
}

proc complete(frame) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
        default {
            return [CompleteWidgetConfigurations ${text} ${start} ${line} {
                -borderwidth -cursor -highlightbackground -highlightcolor
                return [CompleteWidgetConfigurations $text $start $line \
                            {-borderwidth -cursor -highlightbackground -highlightcolor
                -highlightthickness -relief -takefocus -background
                -class -colormap -container -height -visual -width
                             -class -colormap -container -height -visual -width}]
            }]
        }
    }
    return ""
}

proc complete(grab) {text start end line pos mod} {
    switch -- ${pos} {
        switch -- $pos {
        1 {
            return [CompleteFromList ${text} [concat \
            current release set status -global [WidgetChildren ${text}]]]
                return [CompleteFromList $text \
                            [concat current release set status -global [WidgetChildren $text]]]
        }
        2 {
            switch -- [Lindex ${line} 1] {
                switch -- [Lindex $line 1] {
                -global -
                current -
                release -
                status {
                    return [CompleteFromList ${text} [WidgetChildren ${text}]]
                    status  { return [CompleteFromList $text [WidgetChildren $text]] }
                }
                set {
                    return [CompleteFromList ${text} \
                        return [CompleteFromList $text [concat -global [WidgetChildren $text]]]
                    [concat -global [WidgetChildren ${text}]]]
                }
            }
        }
        3 {
            switch -- [Lindex ${line} 1] {
                switch -- [Lindex $line 1] {
                set {
                    switch -- [PreviousWord ${start} ${line}] {
                        switch -- [PreviousWord $start $line] {
                        -global {
                            return [CompleteFromList ${text} \
                            -global { return [CompleteFromList $text [WidgetChildren $text]] }
                            [WidgetChildren ${text}]]
                        }
                    }
                }
            }
        }
    }
    return ""
}

proc GridConfig {text start line prev} {
    set opts {
        -column -columnspan -in -ipadx -ipady
        -padx -pady -row -rowspan -sticky
    }
    if {-1 == [string first "-" ${line}]} {
        set slave [WidgetChildren ${text}]
        if {-1 == [string first "-" $line]} {
            set slave [WidgetChildren $text]
    } else {
        set slave ""
    }
    switch -- ${prev} {
        switch -- $prev {
        -column -
        -columnspan -
        -row -
        -rowspan { return [DisplayHints <n>] }

        -ipadx -
        -ipady -
        -padx -
        -pady { return [DisplayHints <amount>] }

        -in { return [CompleteFromList ${text} [WidgetChildren ${text}]] }
            -in     { return [CompleteFromList $text [WidgetChildren $text]] }
        -sticky {
            set prev [PreviousWordOfIncompletePosition ${start} ${line}]
            return [CompleteListFromList ${text} \
            [string trimleft [IncompleteListRemainder ${line}]] \
                set prev [PreviousWordOfIncompletePosition $start $line]
                return [CompleteListFromList $text \
                            [string trimleft [IncompleteListRemainder $line]] \
            {n e s w} \{ { } \}]
        }


        default {
            return [CompleteFromList ${text} \
            [RemoveUsedOptions ${line} [concat ${opts} ${slave}]]]
                return [CompleteFromList $text \
                            [RemoveUsedOptions $line [concat $opts $slave]]]
        }
    }
}

proc complete(grid) {text start end line pos mod} {
    set sub [Lindex ${line} 1]
    set prev [PreviousWord ${start} ${line}]
    switch -- ${pos} {
        set sub [Lindex $line 1]
        set prev [PreviousWord $start $line]
        switch -- $pos {
        1 {
            return [CompleteFromList ${text} \
            [concat [WidgetChildren ${text}] {
                bbox columnconfigure configure forget
                return [CompleteFromList $text \
                            [concat [WidgetChildren $text] \
                                 {bbox columnconfigure configure forget
                info location propagate rowconfigure
                remove size slaves
                                  remove size slaves}]]
            }]]
        }
        2 {
            switch -- ${sub} {
                switch -- $sub {
                bbox -
                columnconfigure -
                configure -
                forget -
                info -
                location -
                propagate -
                rowconfigure -
                remove -
                size -
                slaves {
                    return [CompleteFromList ${text} [WidgetChildren ${text}]]
                    slaves          { return [CompleteFromList $text [WidgetChildren $text]] }
                }
                default {
                    return [GridConfig ${text} ${start} ${line} ${prev}]
                    default         { return [GridConfig $text $start $line $prev] }
                }
            }
        }
        default {
            switch -- ${sub} {
                switch -- $sub {
                bbox {
                    switch [expr ${pos} % 2] {
                        switch [expr {$pos % 2}] {
                        0 { return [DisplayHints ?row?] }
                        1 { return [DisplayHints ?column?] }
                    }
                }
                rowconfigure -
                columnconfigure {
                    switch -- ${pos} {
                        switch -- $pos {
                        3 { return [DisplayHints <index>] }
                        default {
                            switch -- ${prev} {
                                switch -- $prev {
                                -minsize { return [DisplayHints <minsize>] }
                                -weight { return [DisplayHints <weight>] }
                                -pad { return [DisplayHints <pad>] }
                                default {
                                    return [CompleteFromList ${text} \
                                    [RemoveUsedOptions ${line}  {
                                        -minsize -weight -pad
                                        return [CompleteFromList $text \
                                                    [RemoveUsedOptions $line \
                                                         {-minsize -weight -pad}]]
                                    }]]
                                }
                            }
                        }
                    }
                }
                configure {
                    configure       { return [GridConfig $text $start $line $prev] }
                    return [GridConfig ${text} ${start} ${line} ${prev}]
                }
                forget -
                remove {
                    return [CompleteFromList ${text} [WidgetChildren ${text}]]
                    remove          { return [CompleteFromList $text [WidgetChildren $text]] }
                }
                info {}
                location {
                    switch -- ${pos} {
                        switch -- $pos {
                        3 { return [DisplayHints <x>] }
                        4 { return [DisplayHints <y>] }
                    }
                }
                propagate {
                    switch -- ${pos} {
                        3 { return [CompleteBoolean ${text}] }
                        switch -- $pos {
                            3 { return [CompleteBoolean $text] }
                    }
                }
                size {}
                slaves {
                    switch -- ${prev} {
                        switch -- $prev {
                        -row { return [DisplayHints <row>] }
                        -column { return [DisplayHints <column>] }
                        default {
                            return [CompleteFromList ${text} \
                            [RemoveUsedOptions ${line}  { -row -column }]]
                                return [CompleteFromList $text \
                                            [RemoveUsedOptions $line {-row -column}]]
                        }
                    }
                }
                default {
                    return [GridConfig ${text} ${start} ${line} ${prev}]
                    default         { return [GridConfig $text $start $line $prev] }
                }
            }
        }
    }
    return ""
}

proc complete(image) {text start end line pos mod} {
set sub [Lindex ${line} 1]
    switch -- ${pos} {
        1 { return [TrySubCmds ${text} image] }
    set sub [Lindex $line 1]
        switch -- $pos {
            1 { return [TrySubCmds $text image] }
        2 {
            switch -- ${sub} {
                create { return [CompleteFromList ${text} [image types]] }
                switch -- $sub {
                    create { return [CompleteFromList $text [image types]] }
                delete -
                height -
                type -
                width { return [CompleteFromList ${text} [image names]] }
                    width  { return [CompleteFromList $text [image names]] }
                names {}
                types {}
            }
        }
        3 {
            switch -- ${sub} {
                switch -- $sub {
                create {
                    set type [Lindex ${line} 2]
                    switch -- ${type} {
                        set type [Lindex $line 2]
                        switch -- $type {
                        bitmap {
                            return [CompleteFromList ${text} {
                                ?name? -background -data -file
                                -foreground -maskdata -maskfile
                                return [CompleteFromList $text \
                                            {?name? -background -data -file
                                             -foreground -maskdata -maskfile}]
                            }]
                        }
                        photo {
                            return [CompleteFromList ${text} {
                                ?name? -data -format -file -gamma
                                -height -palette -width
                                return [CompleteFromList $text \
                                            {?name? -data -format -file -gamma
                                             -height -palette -width}]
                            }]
                        }
                        default {}
                    }
                }
                delete { return [CompleteFromList ${text} [image names]] }
                    delete  { return [CompleteFromList $text [image names]] }
                default {}
            }
        }
        default {
            switch -- ${sub} {
                switch -- $sub {
                create {
                    set type [Lindex ${line} 2]
                    set prev [PreviousWord ${start} ${line}]
                        set type [Lindex $line 2]
                        set prev [PreviousWord $start $line]
                    # puts stderr prev=$prev
                    switch -- ${type} {
                        switch -- $type {
                        bitmap {
                            switch -- ${prev} {
                                switch -- $prev {
                                -background -
                                -foreground { return [DisplayHints <color>] }
                                -data -
                                -maskdata { return [DisplayHints <string>] }
                                -file -
                                -maskfile { return "" }
                                default {
                                    return [CompleteFromList ${text} \
                                    [RemoveUsedOptions ${line} {
                                        -background -data -file
                                        -foreground -maskdata -maskfile
                                        return [CompleteFromList $text \
                                                    [RemoveUsedOptions $line \
                                                         {-background -data -file
                                                          -foreground -maskdata -maskfile}]]
                                    }]]
                                }
                            }
                        }
                        photo {
                            switch -- ${prev} {
                                switch -- $prev {
                                -data { return [DisplayHints <string>] }
                                -file { return "" }
                                -format { return [DisplayHints <format-name>] }
                                -gamma { return [DisplayHints <value>] }
                                -height -
                                -width { return [DisplayHints <number>] }
                                -palette {
                                    return [DisplayHints <palette-spec>]
                                }
                                default {
                                    return [CompleteFromList ${text} \
                                    [RemoveUsedOptions ${line} {
                                        -data -format -file -gamma
                                        -height -palette -width
                                        return [CompleteFromList $text \
                                                    [RemoveUsedOptions $line \
                                                         {-data -format -file -gamma
                                                          -height -palette -width}]]
                                    }]]
                                }
                            }
                        }
                    }
                }
                delete { return [CompleteFromList ${text} [image names]] }
                    delete  { return [CompleteFromList $text [image names]] }
                default {}
            }
        }
    }
}

proc complete(label) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
        default {
            return [CompleteWidgetConfigurations ${text} ${start} ${line} {
                -anchor -background -bitmap -borderwidth -cursor -font
                return [CompleteWidgetConfigurations $text $start $line \
                            {-anchor -background -bitmap -borderwidth -cursor -font
                -foreground -highlightbackground -highlightcolor
                -highlightthickness -image -justify -padx -pady -relief
                -takefocus -text -textvariable -underline -wraplength
                -height -width
                             -height -width}]
            }]
        }
    }
    return ""
}

proc complete(listbox) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
        default {
            return [CompleteWidgetConfigurations ${text} ${start} ${line} {
                -background -borderwidth -cursor -exportselection -font
                return [CompleteWidgetConfigurations $text $start $line \
                            {-background -borderwidth -cursor -exportselection -font
                -foreground -height -highlightbackground -highlightcolor
                -highlightthickness -relief -selectbackground
                -selectborderwidth -selectforeground -setgrid -takefocus
                -width -xscrollcommand -yscrollcommand -height -selectmode
                -width
                             -width}]
            }]
        }
    }
    return ""
}

proc complete(lower) {text start end line pos mod} {
    switch -- ${pos} {
        switch -- $pos {
        1 -
        2 {
            return [CompleteFromList ${text} [WidgetChildren ${text}]]
            2 { return [CompleteFromList $text [WidgetChildren $text]] }
        }
    }
}

proc complete(menu) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
        default {
            return [CompleteWidgetConfigurations ${text} ${start} ${line} {
                -activebackground -activeborderwidth -activeforeground
                return [CompleteWidgetConfigurations $text $start $line \
                            {-activebackground -activeborderwidth -activeforeground
                -background -borderwidth -cursor -disabledforeground
                -font -foreground -relief -takefocus -postcommand
                -selectcolor -tearoff -tearoffcommand -title -type
                             -selectcolor -tearoff -tearoffcommand -title -type}]
            }]
        }
    }
    return ""
}

proc complete(menubutton) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
        default {
            return [CompleteWidgetConfigurations ${text} ${start} ${line} {
                -activebackground -activeforeground -anchor -background
                return [CompleteWidgetConfigurations $text $start $line \
                            {-activebackground -activeforeground -anchor -background
                -bitmap -borderwidth -cursor -disabledforeground -font
                -foreground -highlightbackground -highlightcolor
                -highlightthickness -image -justify -padx -pady -relief
                -takefocus -text -textvariable -underline -wraplength
                -direction -height -indicatoron -menu -state -width
                             -direction -height -indicatoron -menu -state -width}]
            }]
        }
    }
    return ""
}

proc complete(message) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
        default {
            return [CompleteWidgetConfigurations ${text} ${start} ${line} {
                -anchor -background -borderwidth -cursor -font -foreground
                return [CompleteWidgetConfigurations $text $start $line \
                            {-anchor -background -borderwidth -cursor -font -foreground
                -highlightbackground -highlightcolor -highlightthickness
                -padx -pady -relief -takefocus -text -textvariable -width
                -aspect -justify -width
                             -aspect -justify -width}]
            }]
        }
    }
    return ""
}

proc OptionPriority text {
    return [CompleteFromList ${text} {
        widgetDefault startupFile userDefault interactive
        return [CompleteFromList $text {widgetDefault startupFile userDefault interactive}]
    }]
}

proc complete(option) {text start end line pos mod} {
    set sub [Lindex ${line} 1]
    switch -- ${pos} {
        set sub [Lindex $line 1]
        switch -- $pos {
        1 {
            return [CompleteFromList ${text} {
            1 { return [CompleteFromList $text {add clear get readfile}] }
                add clear get readfile
            }]
        }
        2 {
            switch -- ${sub} {
                switch -- $sub {
                add { return [DisplayHints <pattern>] }
                get {
                    return [CompleteFromList ${text} [WidgetChildren ${text}]]
                    get      { return [CompleteFromList $text [WidgetChildren $text]] }
                }
                readfile { return "" }
            }
        }
        3 {
            switch -- ${sub} {
                switch -- $sub {
                add { return [DisplayHints <value>] }
                get { return [DisplayHints <name>] }
                readfile { return [OptionPriority ${text}] }
                    readfile { return [OptionPriority $text] }
            }
        }
        4 {
            switch -- ${sub} {
                add { return [OptionPriority ${text}] }
                switch -- $sub {
                    add      { return [OptionPriority $text] }
                get {
                    return [CompleteFromList ${text} \
                    get      { return [CompleteFromList $text [ClassTable [Lindex $line 2]]] }
                    [ClassTable [Lindex ${line} 2]]]
                }
                readfile {}
            }
        }
    }
}

proc PackConfig {text line prev} {
    set opts {
        -after -anchor -before -expand -fill
        -in -ipadx -ipady -padx -pady -side
    }
    if {-1 == [string first "-" ${line}]} {
        set slave [WidgetChildren ${text}]
        if {-1 == [string first "-" $line]} {
            set slave [WidgetChildren $text]
    } else {
        set slave ""
    }
    switch -- ${prev} {
        switch -- $prev {
        -after -
        -before  { return [CompleteFromList ${text} [WidgetChildren ${text}]] }
        -anchor { return [CompleteAnchor ${text}] }
        -expand { return [CompleteBoolean ${text}] }
        -fill { return [CompleteFromList ${text} { none x y both }] }
            -before { return [CompleteFromList $text [WidgetChildren $text]] }
            -anchor { return [CompleteAnchor $text] }
            -expand { return [CompleteBoolean $text] }
            -fill   { return [CompleteFromList $text { none x y both }] }

        -ipadx -
        -ipady -
        -padx -
        -pady { return [DisplayHints <amount>] }

        -in { return [CompleteFromList ${text} [WidgetChildren ${text}]] }
        -side { return [CompleteFromList ${text} { left right top bottom }] }
            -in   { return [CompleteFromList $text [WidgetChildren $text]] }
            -side { return [CompleteFromList $text { left right top bottom }] }

        default {
            return [CompleteFromList ${text} \
            [RemoveUsedOptions ${line} [concat ${opts} ${slave}]]]
                return [CompleteFromList $text \
                            [RemoveUsedOptions $line [concat $opts $slave]]]
        }
    }
}

proc complete(pack) {text start end line pos mod} {
    set sub [Lindex ${line} 1]
    set prev [PreviousWord ${start} ${line}]
    switch -- ${pos} {
        set sub [Lindex $line 1]
        set prev [PreviousWord $start $line]
        switch -- $pos {
        1 {
            return [CompleteFromList ${text} \
            [concat [WidgetChildren ${text}] {
                configure forget info propagate slaves
                return [CompleteFromList $text \
                            [concat [WidgetChildren $text] \
                                 {configure forget info propagate slaves}]]
            }]]
        }
        2 {
            switch -- ${sub} {
                switch -- $sub {
                configure -
                forget -
                info -
                propagate -
                slaves {
                    return [CompleteFromList ${text} [WidgetChildren ${text}]]
                    slaves    { return [CompleteFromList $text [WidgetChildren $text]] }
                }
                default {
                    return [PackConfig ${text} ${line} ${prev}]
                    default   { return [PackConfig $text $line $prev] }
                }
            }
        }
        default {
            switch -- ${sub} {
                configure {
                switch -- $sub {
                    configure { return [PackConfig $text $line $prev] }
                    return [PackConfig ${text} ${line} ${prev}]
                }
                forget {
                    return [CompleteFromList ${text} [WidgetChildren ${text}]]
                    forget    { return [CompleteFromList $text [WidgetChildren $text]] }
                }
                info {}
                propagate {
                    switch -- ${pos} {
                        3 { return [CompleteBoolean ${text}] }
                        switch -- $pos {
                            3 { return [CompleteBoolean $text] }
                    }
                }
                slaves {}
                default {
                    return [PackConfig ${text} ${line} ${prev}]
                    default   { return [PackConfig $text $line $prev] }
                }
            }
        }
    }
    return ""
}

proc PlaceConfig {text line prev} {
    set opts {
        -in -x -relx -y -rely -anchor -width
        -relwidth -height -relheight -bordermode
    }
    switch -- ${prev} {
        switch -- $prev {

        -in { return [CompleteFromList ${text} [WidgetChildren ${text}]] }
            -in { return [CompleteFromList $text [WidgetChildren $text]] }

        -x -
        -relx -
        -y -
        -rely { return [DisplayHints <location>] }

        -anchor { return [CompleteAnchor ${text}] }
            -anchor { return [CompleteAnchor $text] }

        -width -
        -relwidth -
        -height -
        -relheight { return [DisplayHints <size>] }

        -bordermode {
            -bordermode { return [CompleteFromList $text {ignore inside outside}] }
            return [CompleteFromList ${text} {ignore inside outside}]
        }


        default {
            return [CompleteFromList ${text} \
            default { return [CompleteFromList $text [RemoveUsedOptions $line $opts]] }
            [RemoveUsedOptions ${line} ${opts}]]
        }
    }
}

proc complete(place) {text start end line pos mod} {
    set sub [Lindex ${line} 1]
    set prev [PreviousWord ${start} ${line}]
    switch -- ${pos} {
        set sub [Lindex $line 1]
        set prev [PreviousWord $start $line]
        switch -- $pos {
        1 {
            return [CompleteFromList ${text} \
            [concat [WidgetChildren ${text}] {
                configure forget info slaves
                return [CompleteFromList $text \
                            [concat [WidgetChildren $text] \
                                 {configure forget info slaves}]]
            }]]
        }
        2 {
            switch -- ${sub} {
                switch -- $sub {
                configure -
                forget -
                info -
                slaves {
                    return [CompleteFromList ${text} [WidgetChildren ${text}]]
                    slaves    { return [CompleteFromList $text [WidgetChildren $text]] }
                }
                default {
                    return [PlaceConfig ${text} ${line} ${prev}]
                    default   { return [PlaceConfig $text $line $prev] }
                }
            }
        }
        default {
            switch -- ${sub} {
                configure {
                switch -- $sub {
                    configure { return [PlaceConfig $text $line $prev] }
                    return [PlaceConfig ${text} ${line} ${prev}]
                }
                forget {}
                info {}
                slaves {}
                default {
                    return [PlaceConfig ${text} ${line} ${prev}]
                    default   { return [PlaceConfig $text $line $prev] }
                }
            }
        }
    }
    return ""
}

proc complete(radiobutton) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
        default {
            return [CompleteWidgetConfigurations ${text} ${start} ${line} {
                -activebackground -activeforeground -anchor -background
                return [CompleteWidgetConfigurations $text $start $line \
                            {-activebackground -activeforeground -anchor -background
                -bitmap -borderwidth -cursor -disabledforeground -font
                -foreground -highlightbackground -highlightcolor
                -highlightthickness -image -justify -padx -pady -relief
                -takefocus -text -textvariable -underline -wraplength -command
                -height -indicatoron -selectcolor -selectimage -state -value
                -variable -width
                             -variable -width}]
            }]
        }
    }
    return ""
}

proc complete(raise) {text start end line pos mod} {
    return [complete(lower) ${text} ${start} ${end} ${line} ${pos} ${mod}]
        return [complete(lower) $text $start $end $line $pos $mod]
}

proc complete(scale) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
        default {
            return [CompleteWidgetConfigurations ${text} ${start} ${line} {
                -activebackground -background -borderwidth -cursor -font
                return [CompleteWidgetConfigurations $text $start $line \
                            {-activebackground -background -borderwidth -cursor -font
                -foreground -highlightbackground -highlightcolor
                -highlightthickness -orient -relief -repeatdelay
                -repeatinterval -takefocus -troughcolor -bigincrement
                -command -digits -from -label -length -resolution
                -showvalue -sliderlength -sliderrelief -state -tickinterval
                -to -variable -width
                             -to -variable -width}]
            }]
        }
    }
    return ""
}

proc complete(scrollbar) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
        default {
            return [CompleteWidgetConfigurations ${text} ${start} ${line} {
                -activebackground -background -borderwidth -cursor
                return [CompleteWidgetConfigurations $text $start $line \
                            {-activebackground -background -borderwidth -cursor
                -highlightbackground -highlightcolor -highlightthickness
                -jump -orient -relief -repeatdelay -repeatinterval
                -takefocus -troughcolor -activerelief -command
                -elementborderwidth -width
                             -elementborderwidth -width}]
            }]
        }
    }
    return ""
}

proc SelectionOpts {text start end line pos mod lst} {
    set prev [PreviousWord ${start} ${line}]
    if {-1 == [lsearch ${lst} ${prev}]} {
        set prev [PreviousWord $start $line]
        if {-1 == [lsearch $lst $prev]} {
        set prev "" ;# force the default arm
    }
    switch -- ${prev} {
        switch -- $prev {
        -displayof {
            return [CompleteFromList ${text} \
            -displayof { return [CompleteFromList $text [WidgetChildren $text]] }
            [WidgetChildren ${text}]]
        }
        -selection {
            variable selection-selections
            return [CompleteFromList ${text} ${selection-selections}]
                return [CompleteFromList $text ${selection-selections}]
        }
        -type {
            variable selection-types
            return [CompleteFromList ${text} ${selection-types}]
                return [CompleteFromList $text ${selection-types}]
        }
        -command {
            return [BraceOrCommand ${text} \
                return [BraceOrCommand $text $start $end $line $pos $mod]
            ${start} ${end} ${line} ${pos} ${mod}]
        }
        -format {
            variable selection-formats
            return [CompleteFromList ${text} ${selection-formats}]
                return [CompleteFromList $text ${selection-formats}]
        }
        default {
            return [CompleteFromList ${text} \
                return [CompleteFromList $text [RemoveUsedOptions $line $lst]]
            [RemoveUsedOptions ${line} ${lst}]]
        }
    }
}

proc complete(selection) {text start end line pos mod} {
    switch -- ${pos} {
        switch -- $pos {
        1 {
            return [TrySubCmds ${text} [Lindex ${line} 0]]
            1       { return [TrySubCmds $text [Lindex $line 0]] }
        }
        default {
            set sub [Lindex ${line} 1]
            set widgets [WidgetChildren ${text}]
            switch -- ${sub} {
                set sub [Lindex $line 1]
                set widgets [WidgetChildren $text]
                switch -- $sub {
                clear {
                    return [SelectionOpts \
                        return [SelectionOpts $text $start $end $line \
                    ${text} ${start} ${end} ${line} ${pos} ${mod} {
                        -displayof -selection
                                    $pos $mod {-displayof -selection}]
                    }]
                }
                get {
                    return [SelectionOpts \
                        return [SelectionOpts $text $start $end $line \
                    ${text} ${start} ${end} ${line} ${pos} ${mod} {
                        -displayof -selection -type
                                    $pos $mod {-displayof -selection -type}]
                    }]
                }
                handle {
                    return [SelectionOpts \
                        return [SelectionOpts $text $start $end $line $pos $mod \
                    ${text} ${start} ${end} ${line} ${pos} ${mod} \
                    [concat {-selection -type -format} ${widgets}]]
                                    [concat {-selection -type -format} $widgets]]
                }
                own {
                    return [SelectionOpts \
                        return [SelectionOpts $text $start $end $line $pos $mod \
                    ${text} ${start} ${end} ${line} ${pos} ${mod} \
                    [concat {-command -selection} ${widgets}]]
                                    [concat {-command -selection} $widgets]]
                }
            }
        }
    }
}

proc complete(send) {text start end line pos mod} {
    set prev [PreviousWord ${start} ${line}]
    if {"-displayof" == ${prev}} {
        return [TryFromList ${text} [WidgetChildren ${text}]]
        set prev [PreviousWord $start $line]
        if {"-displayof" == $prev} {
            return [TryFromList $text [WidgetChildren $text]]
    }
    set cmds [RemoveUsedOptions ${line} {
        set cmds [RemoveUsedOptions $line {-async -displayof --} {--}]
        -async -displayof --
    } {--}]
    if {[llength ${cmds}]} {
        return [string trim [CompleteFromList ${text} \
        if {[llength $cmds]} {
            return [string trim [CompleteFromList $text [concat $cmds <app>]]]
        [concat ${cmds} <app>]]]
    } else {
        if {[regexp -- --$ ${line}]} {
            if {[regexp -- --$ $line]} {
            return [list {--}]; # append a blank
        } else {
            # TODO make this better!
            return [DisplayHints [list {<app cmd ?arg ...?>}]]
        }
    }
    return ""
}

proc complete(text) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
        default {
            return [CompleteWidgetConfigurations ${text} ${start} ${line} {
                -background -borderwidth -cursor -exportselection -font
                return [CompleteWidgetConfigurations $text $start $line \
                            {-background -borderwidth -cursor -exportselection -font
                -foreground -highlightbackground -highlightcolor
                -highlightthickness -insertbackground -insertborderwidth
                -insertofftime -insertontime -insertwidth -padx -pady
                -relief -selectbackground -selectborderwidth
                -selectforeground -setgrid -takefocus -xscrollcommand
                -yscrollcommand -height -spacing1 -spacing2 -spacing3
                -state -tabs -width -wrap
                             -state -tabs -width -wrap}]
            }]
        }
    }
    return ""
}

proc complete(tk) {text start end line pos mod} {
    switch -- ${pos} {
        switch -- $pos {
        1 {
            return [TrySubCmds ${text} [Lindex ${line} 0]]
            1       { return [TrySubCmds $text [Lindex $line 0]] }
        }
        default {
            switch -- [Lindex ${line} 1] {
                switch -- [Lindex $line 1] {
                appname { return [DisplayHints ?newName?]  }
                scaling {
                    switch -- [PreviousWord ${start} ${line}] {
                        switch -- [PreviousWord $start $line] {
                        -displayof {
                            return [TryFromList ${text} \
                                return [TryFromList $text [WidgetChildren $text]]
                            [WidgetChildren ${text}]]
                        }
                        default {
                            return [CompleteFromList ${text} \
                            [RemoveUsedOptions ${line} {-displayof ?number?}]]
                                return [CompleteFromList $text \
                                            [RemoveUsedOptions $line {-displayof ?number?}]]
                        }
                    }
                }
            }
        }
    }
}

# proc complete(tk_bisque) {text start end line pos mod} {
# }

proc complete(tk_chooseColor) {text start end line pos mod} {
    switch -- [PreviousWord ${start} ${line}] {
        -initialcolor { return [CompleteColor ${text}] }
        -parent { return [TryFromList ${text} [WidgetChildren ${text}]] }
        switch -- [PreviousWord $start $line] {
            -initialcolor { return [CompleteColor $text] }
            -parent       { return [TryFromList $text [WidgetChildren $text]] }
        -title { return [DisplayHints <string>] }
        default {
            return [TryFromList ${text} \
            [RemoveUsedOptions ${line} {-initialcolor -parent -title}]]
                return [TryFromList $text \
                            [RemoveUsedOptions $line {-initialcolor -parent -title}]]
        }
    }
}

proc complete(tk_dialog) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [CompleteFromList ${text} [ToplevelWindows]] }
        switch -- $pos {
            1       { return [CompleteFromList $text [ToplevelWindows]] }
        2 { return [DisplayHints <title>] }
        3 { return [DisplayHints <text>] }
        4 { return [CompleteFromBitmaps ${text}] }
            4       { return [CompleteFromBitmaps $text] }
        5 { return [DisplayHints <defaultIndex>] }
        default { return [DisplayHints ?buttonName?] }
    }
}

proc complete(tk_focusNext) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [CompleteFromList ${text} [WidgetChildren ${text}]] }
        switch -- $pos {
            1 { return [CompleteFromList $text [WidgetChildren $text]] }
    }
}

proc complete(tk_focusPrev) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [CompleteFromList ${text} [WidgetChildren ${text}]] }
        switch -- $pos {
            1 { return [CompleteFromList $text [WidgetChildren $text]] }
    }
}

# proc complete(tk_focusFollowsMouse) {text start end line pos mod} {
# }

proc GetOpenSaveFile {text start end line pos mod {add ""}} {
    # enable filename completion for the first four switches.
    switch -- [PreviousWord ${start} ${line}] {
        switch -- [PreviousWord $start $line] {
        -defaultextension {}
        -filetypes {}
        -initialdir {}
        -initialfile {}
        -parent {
            return [CompleteFromList ${text} [WidgetChildren ${text}]]
            -parent           { return [CompleteFromList $text [WidgetChildren $text]] }
        }
        -title { return [DisplayHints <titleString>] }
        default {
            return [CompleteFromList ${text} \
            [RemoveUsedOptions ${line} [concat {
                -defaultextension -filetypes -initialdir -parent -title
            } ${add}]]]
                return [CompleteFromList $text \
                            [RemoveUsedOptions $line \
                                 [concat {-defaultextension -filetypes
                                          -initialdir -parent -title} $add]]]
        }
    }
}

proc complete(tk_getOpenFile) {text start end line pos mod} {
    return [GetOpenSaveFile \
        return [GetOpenSaveFile $text $start $end $line $pos $mod]
    ${text} ${start} ${end} ${line} ${pos} ${mod}]
}

proc complete(tk_getSaveFile) {text start end line pos mod} {
    return [GetOpenSaveFile \
        return [GetOpenSaveFile $text $start $end $line $pos $mod -initialfile]
    ${text} ${start} ${end} ${line} ${pos} ${mod} -initialfile]
}

proc complete(tk_messageBox) {text start end line pos mod} {
    switch -- [PreviousWord ${start} ${line}] {
        switch -- [PreviousWord $start $line] {
        -default {
            return [CompleteFromList ${text} {
                abort cancel ignore no ok retry yes
            -default { return [CompleteFromList $text {abort cancel ignore no ok retry yes}] }
            }]
        }
        -icon {
            return [CompleteFromList ${text} {
                error info question warning
            -icon    { return [CompleteFromList $text {error info question warning}] }
            }]
        }
        -message { return [DisplayHints <string>] }
        -parent {
            return [CompleteFromList ${text} [WidgetChildren ${text}]]
            -parent  { return [CompleteFromList $text [WidgetChildren $text]] }
        }
        -title { return [DisplayHints <titleString>] }
        -type {
            return [CompleteFromList ${text} {
                abortretryignore ok okcancel retrycancel yesno yesnocancel
            }]
                return [CompleteFromList $text \
                            {abortretryignore ok okcancel
                             retrycancel yesno yesnocancel}]
        }
        default {
            return [CompleteFromList ${text} \
            [RemoveUsedOptions ${line} {
                -default -icon -message -parent -title -type
            }]]
                return [CompleteFromList $text \
                            [RemoveUsedOptions $line \
                                 {-default -icon -message
                                  -parent -title -type}]]
        }
    }
}

proc complete(tk_optionMenu) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        2 { return [VarCompletion ${text} #0] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
            2       { return [VarCompletion $text #0] }
        3 { return [DisplayHints <value>] }
        default { return [DisplayHints ?value?] }
    }
}

proc complete(tk_popup) {text start end line pos mod} {
    switch -- ${pos} {
        switch -- $pos {
        1 {
            # display only menu widgets
            #
            set widgets [WidgetChildren ${text}]
                set widgets [WidgetChildren $text]
            set menu_widgets ""
            foreach widget ${widgets} {
                if {"Menu" == [winfo class ${widget}]} {
                    lappend menu_widgets ${widget}
                foreach widget $widgets {
                    if {"Menu" == [winfo class $widget]} {
                        lappend menu_widgets $widget
                }
            }
            if {[llength ${menu_widgets}]} {
                return [TryFromList ${text} ${menu_widgets}]
                if {[llength $menu_widgets]} {
                    return [TryFromList $text $menu_widgets]
            } else {
                return [DisplayHints <menu>]
            }
        }
        2 { return [DisplayHints <x>] }
        3 { return [DisplayHints <y>] }
        4 { return [DisplayHints ?entryIndex?] }
    }
}

# TODO: the name - value construct didn't work in my wish.
#
proc complete(tk_setPalette) {text start end line pos mod} {
    set database {
        activeBackground        foreground              selectColor
        activeForeground        highlightBackground     selectBackground
        background              highlightColor          selectForeground
        disabledForeground      insertBackground        troughColor
    }
    switch -- ${pos} {
        switch -- $pos {
        1 {
            return [CompleteColor ${text} ${database}]
            1       { return [CompleteColor $text $database] }
        }
        default {
            switch [expr ${pos} % 2] {
                switch [expr {$pos % 2}] {
                1 {
                    return [CompleteFromList ${text} ${database}]
                    1 { return [CompleteFromList $text $database] }
                }
                0 {
                    return [CompleteColor ${text}]
                    0 { return [CompleteColor $text] }
                }
            }
        }
    }
}

proc complete(tkwait) {text start end line pos mod} {
    switch -- ${pos} {
        switch -- $pos {
        1 {
            return [CompleteFromList ${text} {
                variable visibility window
            1 { return [CompleteFromList $text {variable visibility window}] }
            }]
        }
        2 {
            switch [Lindex ${line} 1] {
                switch [Lindex $line 1] {
                variable {
                    return [VarCompletion ${text} #0]
                    variable   { return [VarCompletion $text #0] }
                }
                visibility -
                window {
                    return [TryFromList ${text} [WidgetChildren ${text}]]
                    window     { return [TryFromList $text [WidgetChildren $text]] }
                }
            }
        }
    }
}

proc complete(toplevel) {text start end line pos mod} {
    switch -- ${pos} {
        1 { return [EventuallyInsertLeadingDot ${text} <pathName>] }
        switch -- $pos {
            1       { return [EventuallyInsertLeadingDot $text <pathName>] }
        default {
            return [CompleteWidgetConfigurations ${text} ${start} ${line} {
                -borderwidth -cursor -highlightbackground -highlightcolor
                return [CompleteWidgetConfigurations $text $start $line \
                            {-borderwidth -cursor -highlightbackground -highlightcolor
                -highlightthickness -relief -takefocus -background
                -class -colormap -container -height -menu -screen
                -use -visual -width
                             -use -visual -width}]
            }]
        }
    }
    return ""
}

proc complete(winfo) {text start end line pos mod} {
    set sub [Lindex ${line} 1]
    switch -- ${pos} {
        set sub [Lindex $line 1]
        switch -- $pos {
        1 {
            return [TrySubCmds ${text} winfo]
            1       { return [TrySubCmds $text winfo] }
        }
        2 {
            switch -- ${sub} {
                switch -- $sub {
                atom {
                    return [TryFromList ${text} {-displayof <name>}]
                    atom       { return [TryFromList $text {-displayof <name>}] }
                }
                containing {
                    containing { return [TryFromList $text {-displayof <rootX>}] }
                    return [TryFromList ${text} {-displayof <rootX>}]
                }
                interps {
                    return [TryFromList ${text} -displayof]
                    interps    { return [TryFromList $text -displayof] }
                }
                atomname -
                pathname {
                    return [TryFromList ${text} {-displayof <id>}]
                    pathname   { return [TryFromList $text {-displayof <id>}] }
                    default    { return [TryFromList $text [WidgetChildren $text]] }
                }
                default {
                    return [TryFromList ${text} [WidgetChildren ${text}]]
                }
            }
        }
        default {
            switch -- ${sub} {
                switch -- $sub {
                atom {
                    switch -- [PreviousWord ${start} ${line}] {
                        -displayof {
                        switch -- [PreviousWord $start $line] {
                            -displayof { return [TryFromList $text [WidgetChildren $text]] }
                            return [TryFromList ${text} \
                            [WidgetChildren ${text}]]
                        }
                        default { return [DisplayHints <name>] }
                    }
                }
                containing {
                    switch -- [Lindex ${line} 2] {
                        switch -- [Lindex $line 2] {
                        -displayof {
                            switch -- ${pos} {
                                switch -- $pos {
                                3 {
                                    return [TryFromList ${text} \
                                    3 { return [TryFromList $text [WidgetChildren $text]] }
                                    [WidgetChildren ${text}]]
                                }
                                4 {
                                    return [DisplayHints <rootX>]
                                    4 { return [DisplayHints <rootX>] }
                                }
                                5 {
                                    return [DisplayHints <rootY>]
                                    5 { return [DisplayHints <rootY>] }
                                }
                            }
                        }
                        default { return [DisplayHints <rootY>] }
                    }
                }
                interps {
                    switch -- [PreviousWord ${start} ${line}] {
                        -displayof {
                        switch -- [PreviousWord $start $line] {
                            -displayof { return [TryFromList $text [WidgetChildren $text]] }
                            return [TryFromList ${text} \
                            [WidgetChildren ${text}]]
                        }
                        default {}
                    }
                }
                atomname -
                pathname {
                    switch -- [PreviousWord ${start} ${line}] {
                        -displayof {
                        switch -- [PreviousWord $start $line] {
                            -displayof { return [TryFromList $text [WidgetChildren $text]] }
                            return [TryFromList ${text} \
                            [WidgetChildren ${text}]]
                        }
                        default { return [DisplayHints <id>] }
                    }
                }
                visualsavailable { return [DisplayHints ?includeids?] }
                default {
                    return [TryFromList ${text} [WidgetChildren ${text}]]
                    default          { return [TryFromList $text [WidgetChildren $text]] }
                }
            }
        }
    }
    return ""
}

proc complete(wm) {text start end line pos mod} {
    set sub [Lindex ${line} 1]
    switch -- ${pos} {
        set sub [Lindex $line 1]
        switch -- $pos {
        1 {
            return [CompleteFromList ${text} {
                aspect client colormapwindows command deiconify focusmodel
                return [CompleteFromList $text \
                            {aspect client colormapwindows command deiconify focusmodel
                frame geometry grid group iconbitmap iconify iconmask iconname
                iconposition iconwindow maxsize minsize overrideredirect
                positionfrom protocol resizable sizefrom state title transient
                withdraw
                             withdraw}]
            }]
        }
        2 {
            return [TryFromList ${text} [ToplevelWindows]]
            2 { return [TryFromList $text [ToplevelWindows]] }
        }
        3 {
            switch -- ${sub} {
                switch -- $sub {
                aspect { return [DisplayHints ?minNumer?] }
                client { return [DisplayHints ?name?] }
                colormapwindows {
                    return [CompleteListFromList ${text} \
                    [string trimleft [IncompleteListRemainder ${line}]] \
                        return [CompleteListFromList $text \
                                    [string trimleft [IncompleteListRemainder $line]] \
                    [WidgetChildren .] \{ { } \}]
                }
                command { return [DisplayHints ?value?] }
                focusmodel {
                    return [CompleteListFromList ${text} {active passive}]
                    focusmodel       { return [CompleteListFromList $text {active passive}] }
                }
                geometry {
                    return [DisplayHints ?<width>x<height>+-<x>+-<y>?]
                    geometry         { return [DisplayHints ?<width>x<height>+-<x>+-<y>?] }
                }
                grid { return [DisplayHints ?baseWidth?] }
                group {
                    return [TryFromList ${text} [WidgetChildren ${text}]]
                    group            { return [TryFromList $text [WidgetChildren $text]] }
                }
                iconbitmap -
                iconmask { return [CompleteFromBitmaps ${text}] }
                    iconmask         { return [CompleteFromBitmaps $text] }
                iconname { return [DisplayHints ?newName?] }
                iconposition { return [DisplayHints ?x?] }
                iconwindow {
                    iconwindow       { return [TryFromList $text [WidgetChildren $text]] }
                    return [TryFromList ${text} [WidgetChildren ${text}]]
                }
                maxsize -
                minsize { return [DisplayHints ?width?] }
                overrideredirect { return [CompleteBoolean ${text}] }
                    overrideredirect { return [CompleteBoolean $text] }
                positionfrom -
                sizefrom {
                    return [CompleteFromList ${text} {position user}]
                    sizefrom         { return [CompleteFromList $text {position user}] }
                }
                protocol {
                    return [CompleteFromList ${text} {
                        WM_TAKE_FOCUS WM_SAVE_YOURSELF WM_DELETE_WINDOW
                        return [CompleteFromList $text \
                                    {WM_TAKE_FOCUS WM_SAVE_YOURSELF WM_DELETE_WINDOW}]
                    }]
                }
                resizable { return [DisplayHints ?width?] }
                title { return [DisplayHints ?string?] }
                transient {
                    transient        { return [TryFromList $text [WidgetChildren $text]] }
                    return [TryFromList ${text} [WidgetChildren ${text}]]
                }
                default {
                    return [TryFromList ${text} [ToplevelWindows]]
                    default          { return [TryFromList $text [ToplevelWindows]] }
                }
            }
        }
        4 {
            switch -- ${sub} {
                switch -- $sub {
                aspect { return [DisplayHints ?minDenom?] }
                grid { return [DisplayHints ?baseHeight?] }
                iconposition { return [DisplayHints ?y?] }
                maxsize -
                minsize { return [DisplayHints ?height?] }
                protocol {
                    return [BraceOrCommand ${text} \
                        return [BraceOrCommand $text $start $end $line $pos $mod]
                    ${start} ${end} ${line} ${pos} ${mod}]
                }
                resizable { return [DisplayHints ?height?] }
            }
        }
        5 {
            switch -- ${sub} {
                switch -- $sub {
                aspect { return [DisplayHints ?maxNumer?] }
                grid { return [DisplayHints ?widthInc?] }
            }
        }
        6 {
            switch -- ${sub} {
                switch -- $sub {
                aspect { return [DisplayHints ?maxDenom?] }
                grid { return [DisplayHints ?heightInc?] }
            }
        }
    }
    return ""
}