@@ -1,8 +1,8 @@
 #!/usr/locanl/bin/tclsh
-# FILE: "/diska/home/joze/src/tclreadline/tclreadlineCompleter.tcl"
-# LAST MODIFICATION: "Wed Sep  8 17:30:20 1999 (joze)"
+# FILE: "/home/joze/src/tclreadline/tclreadlineCompleter.tcl"
+# LAST MODIFICATION: "Fri Sep 10 03:06:31 1999 (joze)"
 # (C) 1998, 1999 by Johannes Zellner, <johannes@zellner.org>
 # $Id$
 # ---
 #
 # tclreadline -- gnu readline for tcl
@@ -27,10 +27,11 @@
 #
 # ================================================================== 
 
 # done:
 #
+# - after
 # - append
 # - array
 # - bgerror
 # - binary
 # - break
@@ -114,10 +115,104 @@
 # - while # TODO
 # 
 
 
 namespace eval tclreadline {
+
+# TryFromList will return an empty string, if
+# the text typed so far does not match any of the
+# elements in list. This might be used to allow
+# subsequent filename completion by the builtin
+# completer.
+#
+proc TryFromList {text lst} {
+
+    # puts stderr "(CompleteFromList) \ntext=|$text|"
+    # puts stderr "(CompleteFromList) lst=|$lst|"
+    set pre [GetQuotedPrefix ${text}]
+    set matches [MatchesFromList $text $lst]
+
+    # puts stderr "(CompleteFromList) matches=|$matches|"
+    if {1 == [llength $matches]} { ; # unique match
+        # puts stderr \nunique=$matches\n
+        # puts stderr "\n|${pre}${matches}[Right ${pre}]|\n"
+        return [string trim ${pre}${matches}[Right ${pre}]]
+    } elseif {"" != ${matches}} {
+        # puts stderr \nmore=$matches\n
+        set longest [CompleteLongest ${matches}]
+        # puts stderr longest=|$longest|
+        if {"" == $longest} {
+            return [string trim "[list $text] ${matches}"]
+        } else {
+            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.
+#
+proc CompleteFromList {text lst} {
+    set result [TryFromList ${text} ${lst}]
+    if {![llength ${result}]} {
+        Alert
+        # return [string trim [list ${text}] ${lst}"]
+        return [string trim "${text} ${lst}"]
+    } else {
+        return ${result}
+    }
+}
+
+proc MenuFromList {text lst} {
+    return [CompleteFromList $text $lst]
+}
+# ???????
+# 
+# proc MenuFromList {text lst} {
+#     if {![llength ${text}]} {
+#         return [string trim "{} ${lst}"]
+#     } else {
+#         return [TryFromList ${text} ${lst}]
+#     }
+# }
+# 
+
+
+#**
+# never return an empty string, never complete.
+# This is useful for showing options lists for example.
+#
+proc DisplayHints {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.
+#
+proc MatchesFromList {text lst} {
+    set result ""
+    set text [StripPrefix $text]
+    set null [string index $text 0]
+    if {"<" == $null || "?" == $null} {
+        Alert
+        return $lst
+    }
+    # puts stderr "(MatchesFromList) text=$text"
+    # puts stderr "(MatchesFromList) lst=$lst"
+    foreach word $lst {
+        if {[string match ${text}* ${word}]} {
+            lappend result ${word}
+        }
+    }
+    return [string trim $result]
+}
 
 proc FirstNonOption {line} {
     set expr_pos 1
     foreach word [lrange ${line} 1 end] {; # 0 is the command itself
         if {"-" != [string index ${word} 0]} {
@@ -147,63 +242,16 @@
 proc Alert {} {
     puts -nonewline \a
     flush stdout
 }
 
-# AttemptFromList will return an empty string, if
-# the text typed so far does not match any of the
-# elements in list. This might be used to allow
-# subsequent filename completion by the builtin
-# completer.
-#
-proc AttemptFromList {text lst} {
-    return [string trim [Format [FindInList $text $lst] $text]]
-}
-
-# CompleteFromList will never return an empty string.
-#
-proc CompleteFromList {text lst} {
-    set result [AttemptFromList ${text} ${lst}]
-    if {![llength ${result}]} {
-        Alert
-        return [string trim "${text} ${lst}"]
-    } else {
-        return ${result}
-    }
-}
-
-# ???????
-proc MenuFromList {text lst} {
-    if {![llength ${text}]} {
-        return [string trim "{} ${lst}"]
-    } else {
-        return [AttemptFromList ${text} ${lst}]
-    }
-}
-
-# never return an empty string
-#
-proc Menu {lst} {
-    return [string trim "{} ${lst}"]
-}
-
-proc FindInList {text lst} {
-    set result ""
-    foreach word $lst {
-        if {[string match ${text}* ${word}]} {
-            lappend result ${word}
-        }
-    }
-    return [string trim $result]
-}
-
 
 # get the longest common completion
 # e.g. str == {tcl_version tclreadline_version tclreadline_library}
-# --> [GetCommon ${str}] == "tcl"
+# --> [CompleteLongest ${str}] == "tcl"
 #
-proc GetCommon {str} {
+proc CompleteLongest {str} {
     # puts stderr str=$str
     set match0 [lindex ${str} 0]
     set len0 [string length $match0]
     set no_matches [llength ${str}]
     set part ""
@@ -222,13 +270,13 @@
     }
     # puts stderr part=$part
     return ${part}
 }
 
-proc SubCmd {start line} {
+proc SplitLine {start line} {
     set depth 0
-    # puts stderr SubCmd
+    # 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]]
@@ -286,26 +334,40 @@
     return [ChannelId ${text} outChannel]
 }
 
 proc ChannelId {text {descript channelId} {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 [MenuFromList ${text} ${chs}]]]} {
+    if {[llength [set channel [MatchesFromList ${text} ${chs}]]]} {
         return ${channel}
     } else {
-        return [Menu ${descript}]
+        return [DisplayHints ${descript}]
     }
 }
 
 proc QuoteQuotes {line} {
     regsub -all -- \" $line {\"} line
     regsub -all -- \{ $line {\{} line; # \}\} (keep the editor happy)
     return $line
 }
+
+proc Trace {varT} {
+    if {![info exists ::tclreadline::Debug]} {return}
+    upvar $varT var
+    if {![info exists var]} {
+        puts $varT=<notdefined>
+    } else {
+        puts $varT=|$var|
+    }
+    # puts $var
+}
 
 #**
 # get the word position.
 # @return the word position
 # @note will returned modified values.
@@ -323,73 +385,110 @@
 #
 proc PartPosition {partT startT endT lineT} {
 
     upvar $partT part $startT start $endT end $lineT line
     EventuallyEvaluateFirst part start end line
-
-    # puts stderr "(PartPosition) line\[start\]=[string index $line $start]"
-    # puts stderr "(PartPosition) part=|$part|"
-    incr start -1
-    if {"\"" == [string index $line $start]} {
-        incr start -1
-    }
-    # puts stderr "(PartPosition) line=|$line|" 
-    # puts stderr "(PartPosition) start=$start"
-    set line [string range $line 0 $start]
-    set line [QuoteQuotes $line]
-    # puts stderr "(PartPosition) line=|$line|" 
-    set result [llength $line]
-    # puts stderr $result
-    return $result
+    return [Llength [string range $line 0 [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 ""
+        return {\"}
+    } elseif {"\\\"" == $left} {
+        return "\\\""
     } elseif {"\{" == $left} {
         return "\}"
     } elseif {"\\\{" == $left} {
         return "\\\}"
     }
     return ""
 }
 
-proc GetPrefix {text} {
+proc GetQuotedPrefix {text} {
+    set null [string index $text 0]
+    if {"\"" == $null || "\{" == $null} {
+        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
+}
+
+#**
+# save `lindex'. works also for non-complete lines
+# with opening parentheses or quotes.
+# usage as `lindex'.
+#
+proc Lindex {line pos} {
+    if {[catch [list set sub [lindex $line $pos]]]} {
+        set diff [expr [CountChar $line \{] - [CountChar $line \}]]
+        # puts stderr diff=$diff
+        for {set i 0} {$i < $diff} {incr i} { ; # \{ keep the editor happy
+            append line \}
+        }
+        # puts stderr line=$line
+        if {!$diff || [catch [list set sub [lindex $line $pos]]]} {
+            if {[expr [CountChar $line \"] % 2]} { append line \" }
+        }
+        if {[catch [list set sub [lindex $line $pos]]]} { return {} }
+    }
+    return $sub
+}
+
+#**
+# save `llength' (see above).
+#
+proc Llength {line} {
+    set diff 0
+    if {[catch [list set len [llength $line]]]} {
+        set diff [expr [CountChar $line \{] - [CountChar $line \}]]
+        # puts stderr diff=$diff
+        for {set i 0} {$i < $diff} {incr i} { ; # \{ keep the editor happy
+            append line \}
+        }
+        if {$diff < 0} {
+            set diff 0
+        }
+        # puts stderr line=$line
+        if {!$diff || [catch [list set len [llength $line]]]} {
+            incr diff
+            if {[expr [CountChar $line \"] % 2]} { append line \" }
+        }
+        if {[catch [list set len [llength $line]]]} { return {} }
+    }
+    return [expr $len - $diff]
+}
+
+proc StripPrefix {text} {
+    # puts "(StripPrefix) text=|$text|"
     set null [string index $text 0]
-    # puts null=|$null|
-    if {"\"" == $null} {
-        # puts stderr \neins\n
-        set pre "\\\""
-    } elseif {"\{" == $null} {
-        # puts stderr \nzwei\n
-        set pre "\\\{"
-    } else {
-        # puts stderr \ndrei\n
-        set pre ""
-    }
-    return ${pre}
-}
-
-proc Format {matches {part {}}} {
-    # puts matches=|$matches|
-    # puts stderr \npart=|$part|\n
-    set pre [GetPrefix ${part}]
-    if {1 == [llength $matches]} { ; # unique match
-        # puts stderr \nunique=$matches\n
-        # puts stderr "\n|${pre}${matches}[Right ${pre}]|\n"
-        return [string trim ${pre}${matches}[Right ${pre}]]
-    } elseif {"" != ${matches}} {
-        # puts stderr \nmore=$matches\n
-        set common [GetCommon ${matches}]
-        # puts stderr common=|$common|
-        if {"" == $common} {
-            return [string trim "[list $part] ${matches}"]
-        } else {
-            return [string trim "${pre}${common} ${matches}"]
-        }
-    } else {
-        return ""; # nothing to complete
+    if {"\"" == $null || "\{" == $null} {
+        return [string range $text 1 end]
+    } else {
+        return $text
     }
 }
 
 proc ListCompletion {text {level -1}} {
     # TODO
@@ -401,26 +500,23 @@
     if {-1 == ${level}} {
         set level [info level]
     } else {
         incr level
     }
-    set pre [GetPrefix ${text}]
-
-    if {"" == ${pre}} {
-        set var ${text}
-    } else {
-        set var [string range ${text} 1 end]
-    }
+    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 {1 == [llength $names]} { ; # unique match
             return "${array}(${names})"
         } elseif {"" != ${names}} {
-            return "${array}([GetCommon ${names}] ${names}"
+            return "${array}([CompleteLongest ${names}] ${names}"
         } else {
             return ""; # nothing to complete
         }
     }
 
@@ -448,16 +544,21 @@
             return [VarCompletion ${matches}( ${level}]; # recursion
         } else {
             return ${pre}${matches}[Right ${pre}]
         }
     } elseif {"" != $matches} { ; # more than one match
-        set common [GetCommon ${matches}]
-        if {"" == ${common}} {
-            return [Format ${matches} ${text}]
-        } else {
-            return [string trim "${pre}${common} ${matches}"]
-        }
+        #puts stderr "(VarComletion) matches=|$matches|"
+        #puts stderr "(VarComletion) text=|$text|"
+# 
+#         set common [CompleteLongest ${matches}]
+#         if {"" == ${common}} {
+#             return [Format ${matches} ${text}]
+#         } else {
+#             return [string trim "${pre}${common} ${matches}"]
+#         }
+# 
+          return [CompleteFromList ${text} ${matches}]
     } else {
         return ""; # nothing to complete
     }
 }
 
@@ -479,10 +580,13 @@
 proc CommandsOnlyCompletion {cmd} {
     return [CommandCompletion ${cmd} commands]
 }
 
 proc CommandCompletion {cmd {action both} {spc ::}} {
+    # puts stderr "(CommandCompletion) cmd=|$cmd|"
+    # puts stderr "(CommandCompletion) action=|$action|"
+    # puts stderr "(CommandCompletion) spc=|$spc|"
     set quali [namespace qualifiers ${cmd}]
     if {[llength ${quali}]} {
         set rec [CommandCompletion [namespace tail ${cmd}] ${action} ${quali}]
         return [FullQualifiedMatches ${quali} ${rec}]
     }
@@ -539,12 +643,14 @@
 #             unset new
 # 
             set matches [FullQualifiedMatches ${namespaces} ${matches}]
             set namespaces ""
         }
+        return [string trim "${matches} ${namespaces}"]
+    } else {
+        return [string trim "${matches} ${namespaces}"]
     }
-    return [string trim "${matches} ${namespaces}"]
 }
 
 #**
 # check, if the first argument starts with a '['
 # and must be evaluated before continuing.
@@ -631,32 +737,34 @@
     # % puts bla; put<TAB> $b
     # part  == put
     # start == 10
     # end   == 13
     # line  == "puts bla; put $b"
-    # [SubCmd] --> {1 " put $b"} == sub
+    # [SplitLine] --> {1 " put $b"} == sub
     # new_start = [lindex $sub 0] == 1
     # new_end   = [expr $end - ($start - $new_start)] == 4
     # new_part  == $part == put
     # new_line  = [lindex $sub 1] == " put $b"
     # 
-    } elseif {"" != [set sub [SubCmd $start $line]]} {
+    } elseif {"" != [set sub [SplitLine $start $line]]} {
         set new_start [lindex $sub 0]
         set new_end [expr $end - ($start - $new_start)]
         set new_line [lindex $sub 1]
-        # puts stderr "(SubCmd) $new_start $new_end $new_line"
+        # 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]]} {
         # puts stderr "(PartPosition) $part $start $end $line"
         # set matches [array names known_cmds "[string trim ${part}]*"]
         set all [CommandCompletion ${part}]
+        # puts stderr "(ScriptCompleter) all=$all"
         #puts \nmatches=$matches\n
-        return [Format $all $part]
+        # return [Format $all $part]
+        return [TryFromList $part $all]
     } else {
         # try to use $pos further ...
         # puts stderr |$line|
-        if {"." == [string index [lindex ${line} 0] 0]} {
+        if {"." == [string index [string trim ${line}] 0]} {
             set alias WIDGET
         } else {
             set alias [lindex [QuoteQuotes ${line}] 0]
         }
         foreach cmd [list ${alias} tclreadline_complete_unknown] {
@@ -674,24 +782,20 @@
                     arguments, but should take exactly 6.]
                 }
 
                 # remove leading quotes
                 #
-                if {"\"" == [string index $part 0] \
-                    || "\{" == [string index $part 0]
-                } {
-                    set mod [string range $part 1 end]
-                } else {
-                    set mod $part
-                }
+                set mod [StripPrefix $part]
+                # puts stderr mod=$mod
 
                 if {[catch [list set script_result \
                     [complete(${cmd}) $part \
                     $start $end $line $pos $mod]] ::tclreadline::errorMsg]
                 } {
                     error "error during evaluation of `complete(${cmd})'"
                 }
+                # puts stderr \nscript_result=|${script_result}|
                 return ${script_result}
             }
         }
         # no specific command completer found.
         if {"" != [array names known_cmds $cmd]} {
@@ -713,31 +817,159 @@
 #
 
 # -------------------------------------
 #                 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}]
+        }
+        2 {
+            switch -- $sub {
+                cancel {
+                    set after_info [after info]
+                    if {![llength $after_info]} {
+                        return [DisplayHints <script>]
+                    } else {
+                        return [CompleteFromList $mod "<script> [after info]"]
+                    }
+                }
+                idle {
+                    return [DisplayHints <script>]
+                }
+                info {
+                    return [CompleteFromList $mod [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}] }
-        default { return [Menu ?value?] }
+        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
+            }
+            return [CompleteFromList $text $cmds]
+        }
+        2 {
+            set matches ""
+            set vars [uplevel [info level] info vars ${mod}*]
+            foreach var ${vars} {
+                if {[uplevel [info level] array exists ${var}]} {
+                    lappend matches ${var}
+                }
+            }
+            return [CompleteFromList ${text} ${matches}]
+        }
+        default {
+            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}*]
+                    if {![llength $matches]} {
+                        return [Menu ?pattern?]
+                    } else {
+                        return [CompleteFromList ${text} ${matches}]
+                    }
+                }
+                anymore -
+                donesearch -
+                nextid { return [Menu <searchId>] }
+            }
+        }
+    }
+    return ""
+}
+
+# proc complete(bgerror) {text start end line pos mod} {
+# }
+
+proc complete(binary) {text start end line pos mod} {
+    set cmd [Lindex $line 1]
+    switch -- $pos {
+        1 {
+            return [CompleteFromList $text {format scan}]
+        }
+        2 {
+            switch -- $cmd {
+                format { return [DisplayHints <formatString>] }
+                scan   { return [DisplayHints <string>] }
+            }
+        }
+        3 {
+            switch -- $cmd {
+                format { return [DisplayHints ?arg?] }
+                scan   { return [DisplayHints <formatString>] }
+            }
+        }
+        default {
+            switch -- $cmd {
+                format { return [DisplayHints ?arg?] }
+                scan   { return [DisplayHints ?varName?] }
+            }
+        }
+    }
+    return ""
+}
+
+# proc complete(break) {text start end line pos mod} {
+# }
+
+proc complete(catch) {text start end line pos mod} {
+    switch -- $pos {
+        1 { return [DisplayHints <script>] }
+        2 { return [DisplayHints ?varName?] }
     }
+    return ""
 }
+
+# proc complete(cd) {text start end line pos mod} {
+# }
 
 proc complete(if) {text start end line pos mod} {
     # TODO: this is not good yet.
-    if {2 == $pos} {
-        return [AttemptFromList $text {then}]
-    } elseif {$pos > 2} {
-        set prev [PreviousWord ${start} ${line}]
-        switch $prev {
-            then -
-            else -
-            elseif { return "" }
-        }
-        return [AttemptFromList $text {then else elseif}]
-    }
+    switch -- $pos {
+        1 { return [CompleteFromList $mod {\{}] }
+        2 { return [TryFromList $mod {then}] }
+        default {
+            set prev [PreviousWord ${start} ${line}]
+            switch $prev {
+                then -
+                else -
+                elseif { return [CompleteFromList $mod {\{}] }
+                default { return [TryFromList $text {then else elseif}] }
+            }
+        }
+    }
+    return ""
 }
 
 proc complete(incr) {text start end line pos mod} {
     if {1 == $pos} {
         set matches [uplevel 2 info vars "${mod}*"]
@@ -754,115 +986,35 @@
         }
         return [Format ${final} $text]
     }
 }
 
-proc complete(array) {text start end line pos mod} {
-    if {1 == $pos} {
-        set cmds {
-            anymore donesearch exists get names
-            nextelement set size startsearch
-        }
-        return [AttemptFromList $text $cmds]
-    } elseif {2 == $pos} {
-        set cmd [lindex $line 1]
-        switch -- $cmd {
-            anymore -
-            donesearch -
-            exists -
-            get -
-            names -
-            nextelement -
-            set -
-            size -
-            startsearch {
-                set matches ""
-                set vars [uplevel [info level] info vars ${mod}*]
-                foreach var ${vars} {
-                    if {[uplevel [info level] array exists ${var}]} {
-                        lappend matches ${var}
-                    }
-                }
-                return [Format ${matches} ${text}]
-            }
-        }
-    } elseif {3 == $pos} {
-        set cmd [lindex $line 1]
-        switch -- $cmd {
-            get -
-            names {
-                if {[catch {
-                    set names [uplevel [info level] \
-                    array names [lindex $line 2] [lindex $line 3]*]}]} {
-                    return ""
-                } else {
-                    set common [GetCommon ${names}]
-                    if {"" == ${common}} {
-                        return [Format ${names} ${text}]
-                    } else {
-                        return [string trim "${common} ${names}"]
-                    }
-                }
-            }
-        }
-    }
-    return ""
-}
-
-proc complete(binary) {text start end line pos mod} {
-    set cmd [lindex $line 1]
-    switch -- $pos {
-        1 {
-            return [AttemptFromList $text {format scan}]
-        }
-        2 {
-            switch -- $cmd {
-                format { return [Menu formatString] }
-                scan   { return [Menu string] }
-            }
-        }
-        3 {
-            switch -- $cmd {
-                format { return [Menu ?arg?] }
-                scan   { return [Menu formatString] }
-            }
-        }
-        default {
-            switch -- $cmd {
-                format { return [Menu ?arg?] }
-                scan   { return [Menu ?varName?] }
-            }
-        }
-    }
-    return ""
-}
-
 proc complete(clock) {text start end line pos mod} {
     set cmd [lindex $line 1]
     switch -- $pos {
         1 {
-            return [AttemptFromList $text {clicks format scan seconds}]
+            return [TryFromList $text {clicks format scan seconds}]
         }
         2 {
             switch -- $cmd {
-                format  { return [Menu clockValue] }
-                scan    { return [Menu dateString] }
+                format  { return [DisplayHints clockValue] }
+                scan    { return [DisplayHints dateString] }
                 clicks  -
                 seconds {}
             }
         }
         3 {
             switch -- $cmd {
                 format {
                     set sub [lindex $line 3]
                     set subcmds {-fmt -gmt}
-                    return [AttemptFromList $text $subcmds]
+                    return [TryFromList $text $subcmds]
                 }
                 scan {
                     set sub [lindex $line 3]
                     set subcmds {-base -gmt}
-                    return [AttemptFromList $text $subcmds]
+                    return [TryFromList $text $subcmds]
                 }
                 clicks  -
                 seconds {}
             }
         }
@@ -872,19 +1024,19 @@
 
 proc complete(encoding) {text start end line pos mod} {
     set cmd [lindex $line 1]
     switch -- $pos {
         1 {
-            return [AttemptFromList $text {convertfrom convertto names system}]
+            return [TryFromList $text {convertfrom convertto names system}]
         }
         2 {
             switch -- $cmd {
                 names {}
                 convertfrom -
                 convertto -
                 system {
-                    return [AttemptFromList ${text} [encoding names]]
+                    return [TryFromList ${text} [encoding names]]
                 }
             }
         }
     }
     return ""
@@ -898,11 +1050,11 @@
         atan2   floor   pow     tanh 
         ceil    fmod    sin     abs 
         double  int     rand    round 
         srand 
     }
-    return [AttemptFromList $text $cmds]
+    return [TryFromList $text $cmds]
 }
 
 proc complete(fconfigure) {text start end line pos mod} {
     set cmd [lindex $line 1]
     switch -- $pos {
@@ -911,30 +1063,30 @@
         }
         default {
             set option [PreviousWord ${start} ${line}]
             switch -- $option {
                 -blocking {
-                    return [AttemptFromList ${text} {yes no}]
+                    return [TryFromList ${text} {yes no}]
                 }
                 -buffering {
-                    return [AttemptFromList ${text} {full line none}]
+                    return [TryFromList ${text} {full line none}]
                 }
                 -buffersize {
                     if {![llength ${text}]} {
-                        return [Menu newSize]
+                        return [DisplayHints newSize]
                     }
                 }
                 -encoding {
-                    return [AttemptFromList ${text} [encoding names]]
+                    return [TryFromList ${text} [encoding names]]
                 }
                 -eofchar {
-                    return [Menu {\{inChar\ outChar\}}]
+                    return [DisplayHints {\{inChar\ outChar\}}]
                 }
                 -translation {
-                    return [AttemptFromList ${text} {auto binary cr crlf lf}]
+                    return [TryFromList ${text} {auto binary cr crlf lf}]
                 }
-                default {return [AttemptFromList $text {
+                default {return [TryFromList $text {
                     -blocking -buffering -buffersize
                     -encoding -eofchar -translation}]
                 }
             }
         }
@@ -951,13 +1103,13 @@
             return [OutChannelId ${mod}]
         }
         default {
             set option [PreviousWord ${start} ${line}]
             switch -- $option {
-                -size    { return [Menu size] }
-                -command { return [Menu callback] }
-                default  { return [AttemptFromList $text {-size -command}] }
+                -size    { return [DisplayHints size] }
+                -command { return [DisplayHints callback] }
+                default  { return [TryFromList $text {-size -command}] }
             }
         }
     }
     return ""
 }
@@ -969,11 +1121,11 @@
                 atime attributes copy delete dirname executable exists
                 extension isdirectory isfile join lstat mtime mkdir
                 nativename owned pathtype readable readlink rename
                 rootname size split stat tail type volumes writable
             }
-            return [AttemptFromList $text $cmds]
+            return [TryFromList $text $cmds]
         }
         2 {
             set cmd [lindex $line 1]
             switch -- $cmd {
                 atime -
@@ -1020,11 +1172,11 @@
     switch -- $pos {
         1 {
             return [ChannelId ${mod}]
         }
         2 {
-            return [CompleteFromList ${mod} {readable writable}]
+            return [MenuFromList ${mod} {readable writable}]
         }
     }
     return ""
 }
 
@@ -1043,11 +1195,11 @@
 }
 
 proc complete(glob) {text start end line pos mod} {
     switch -- $pos {
         1 {
-            set matches [AttemptFromList ${mod} {-nocomplain --}]
+            set matches [TryFromList ${mod} {-nocomplain --}]
             if {[llength [string trim ${mod}]] && [llength ${matches}]} {
                 return ${matches}
             }
         }
     }
@@ -1071,11 +1223,11 @@
     if {1 == $pos} {
         set cmds {
             args body cmdcount commands complete default exists
             globals hostname level library loaded locals nameofexecutable
             patchlevel procs script sharedlibextension tclversion vars}
-        return [AttemptFromList $text $cmds]
+        return [TryFromList $text $cmds]
     } elseif {2 == $pos} {
         set cmd [lindex $line 1]
         switch -- $cmd {
             args -
             body -
@@ -1110,15 +1262,15 @@
     set cmd [lindex $line 1]
     if {1 == $pos} {
         set cmds {
             alias aliases create delete eval exists expose hide hidden
             issafe invokehidden marktrusted slaves share target transfer}
-        return [AttemptFromList $text $cmds]
+        return [TryFromList $text $cmds]
     } elseif {2 == $pos} {
         switch -- $cmd {
             create {
-                return [AttemptFromList $text {-safe -- ?path?}]
+                return [TryFromList $text {-safe -- ?path?}]
             }
 
             eval -
             exists -
             expose -
@@ -1141,11 +1293,11 @@
         switch -- $cmd {
 
             alias {if {![llength ${mod}]} { return <srcCmd> }}
 
             create {
-                return [AttemptFromList $text {-safe -- ?path?}]
+                return [TryFromList $text {-safe -- ?path?}]
             }
 
             eval {if {![llength ${mod}]} { return <arg> }}
             delete {if {![llength ${mod}]} { return ?path? }}
 
@@ -1152,11 +1304,11 @@
             expose {if {![llength ${mod}]} { return <hiddenName> }}
             hide {if {![llength ${mod}]} { return <exposedCmdName> }}
 
             invokehidden {
                 return \
-                [AttemptFromList $text {?-global? <hiddenCmdName}]
+                [TryFromList $text {?-global? <hiddenCmdName}]
             }
 
             target {if {![llength ${mod}]} { return <alias> }}
 
             exists {}
@@ -1173,11 +1325,11 @@
         switch -- $cmd {
 
             alias {if {![llength ${mod}]} { return <targetPath> }}
 
             create {
-                return [AttemptFromList $text {-safe -- path}]
+                return [TryFromList $text {-safe -- path}]
             }
 
             expose {if {![llength ${mod}]} { return ?exposedCmdName? }}
             hide {if {![llength ${mod}]} { return ?hiddenCmdName? }}
 
@@ -1273,11 +1425,11 @@
     }
     return ""
 }
 
 proc complete(lsort) {text start end line pos mod} {
-    set options [Menu ${mod} {
+    set options [DisplayHints ${mod} {
         -ascii -dictionary -integer -real -command
         -increasing -decreasing -index
     }]
     set matches [ListCompletion ${text}]
     return [string trim "${matches} ${options}"]
@@ -1284,11 +1436,11 @@
 }
 
 proc complete(history) {text start end line pos mod} {
     if {1 == $pos} {
         set cmds {add change clear event info keep nextid redo}
-        return [AttemptFromList $text $cmds]
+        return [TryFromList $text $cmds]
     } elseif {2 == ${pos}} {
         set cmd [lindex $line 1]
         switch -- $cmd {
             add { if {![llength ${mod}]} { return <newValue> } }
             change { if {![llength ${mod}]} { return <newValue> } }
@@ -1314,24 +1466,24 @@
     set cmd [lindex $line 1]
     if {1 == $pos} {
         set cmds {
             children code current delete eval export forget
             import inscope origin parent qualifiers tail which}
-        return [AttemptFromList $text $cmds]
+        return [TryFromList $text $cmds]
     } elseif {2 == $pos} {
         switch -- $cmd {
             children -
             delete -
             eval -
             inscope -
             forget -
-            parent { return [AttemptFromList ${mod} $space_matches] }
+            parent { return [TryFromList ${mod} $space_matches] }
             code { return "" }
             current {}
-            export { return [MenuFromList ${mod} -clear ?pattern?] }
+            export { return [MenuFromList ${mod} {-clear ?pattern?}] }
             import {
-                return [MenuFromList ${mod} "-force $space_matches"]
+                return [MenuFromList ${mod} {-force $space_matches}]
             }
             origin { if {![llength ${mod}]} { return <command> } }
             qualifiers -
             tail { if {![llength ${mod}]} { return <string> } }
             which { return [MenuFromList ${mod} {
@@ -1341,19 +1493,19 @@
     } elseif {3 == $pos && "inscope" == $cmd} {
             if {![llength ${mod}]} { return arg }
     } else {
         switch -- $cmd {
             children { if {![llength ${mod}]} { return ?pattern? } }
-            delete { return [AttemptFromList $text $space_matches] }
+            delete { return [TryFromList $text $space_matches] }
             eval { if {![llength ${mod}]} { return ?arg? } }
             inscope { if {![llength ${mod}]} { return ?arg? } }
             parent {}
             code {}
             current {}
             export -
             forget -
-            import { return [Menu ?pattern?] }
+            import { return [DisplayHints ?pattern?] }
             origin {}
             qualifiers {}
             tail {}
             which { return [MenuFromList $text {
                 -command -variable <name>}] }
@@ -1377,11 +1529,11 @@
     set cmd [lindex $line 1]
     if {1 == $pos} {
         set cmds {
             forget ifneeded names present provide require
             unknown vcompare versions vsatisfies}
-        return [AttemptFromList $text $cmds]
+        return [TryFromList $text $cmds]
     } elseif {2 == $pos} {
         switch -- $cmd {
             forget -
             ifneeded -
             provide -
@@ -1435,11 +1587,11 @@
 
 proc complete(proc) {text start end line pos mod} {
     # puts known_procs=|${known_procs}|
     if {1 == $pos} {
         set known_procs [ProcsOnlyCompletion ${mod}]
-        set common [GetCommon ${known_procs}]
+        set common [CompleteLongest ${known_procs}]
         if {"" == ${common}} {
             return [Format ${known_procs} ${text}]
         } else {
             return [string trim "${common} ${known_procs}"]
         }
@@ -1454,38 +1606,38 @@
     return ""
 }
 
 proc complete(puts) {text start end line pos mod} {
     if {1 == $pos} {
-        return [MenuFromList ${mod} "-nonewline [OutChannelId ${mod}]"]
+        return [TryFromList ${mod} "-nonewline [OutChannelId ${mod}]"]
     } elseif {2 <= $pos} {
         if {![llength ${mod}]} {
             set opt [lindex ${line} 1]
             if {[llength [MenuFromList ${opt} {-nonewline}]]} {
                 incr pos -1
             }
             if {1 == $pos} {
                 return [OutChannelId ${mod}]
             } elseif {2 == $pos} {
-                return [Menu <string>]
+                return [DisplayHints <string>]
                 return <string>
             }
         }
     }
     return ""
 }
 
 proc complete(read) {text start end line pos mod} {
     if {1 == $pos} {
-        return [MenuFromList ${mod} "-nonewline [InChannelId ${mod}]"]
+        return [MenuFromList ${mod} {-nonewline [InChannelId ${mod}]}]
     } elseif {2 == $pos} {
         if {![llength ${mod}]} {
             set opt [lindex ${line} 1]
             if {[llength [MenuFromList ${opt} {-nonewline}]]} {
                 return [InChannelId ${mod}]
             } elseif {![llength ${mod}]} {
-                return <numBytes>
+                return [DisplayHints <numBytes>]
             }
         }
     }
     return ""
 }
@@ -1530,11 +1682,11 @@
     return ""
 }
 
 proc complete(rename) {text start end line pos mod} {
     if {1 == $pos} {
-        set all [CommandCompletion ${mod}]
+        # TODO set all [CommandCompletion ${mod}]
         return [Format $all ${mod}]
     } elseif {2 == $pos && ![llength ${mod}]} {
         return <newName>
     }
     return ""
@@ -1548,11 +1700,11 @@
         switch -- ${res} {
             -errorinfo { if {![llength ${mod}]} { return <info> } }
             -code -
             -errorcode {
                 set codes {ok error return break continue}
-                return [AttemptFromList ${mod} ${codes}]
+                return [TryFromList ${mod} ${codes}]
             }
         }
     }
     set cmds [RemoveUsedOptions ${line} ${cmds}]
     set res [string trim [MenuFromList ${mod} ${cmds}]]
@@ -1564,11 +1716,11 @@
 
 proc complete(seek) {text start end line pos mod} {
     if {1 == $pos} {
         return [ChannelId ${mod}]
     } elseif {2 == $pos} {
-        return [AttemptFromList ${mod} {start current end}]
+        return [TryFromList ${mod} {start current end}]
     }
     return ""
 }
 
 proc complete(set) {text start end line pos mod} {
@@ -1597,11 +1749,11 @@
         #
         if {2 == $pos && ![llength ${mod}]} { return <command> }
         switch -- ${prev} {
             -myaddr { if {![llength ${mod}]} { return <addr> } }
         }
-        return [AttemptFromList ${mod} [concat {-error -sockname -peername}]]
+        return [TryFromList ${mod} [concat {-error -sockname -peername}]]
     } else {
         # client sockets
         #
         switch -- ${prev} {
             -myaddr { if {![llength ${mod}]} { return <addr> } }
@@ -1626,11 +1778,11 @@
         }
         set cmds {-myaddr -myport -async -myaddr -error -sockname -peername}
         if {$pos <= 1} {
             lappend cmds -server
         }
-        return [AttemptFromList ${mod} [concat ${cmds} ${hosts}]]
+        return [TryFromList ${mod} [concat ${cmds} ${hosts}]]
     }
     return ""
 }
 
 proc complete(source) {text start end line pos mod} {
@@ -1641,11 +1793,11 @@
     set cmd [lindex ${line} 1]
     set cmds {
         compare first index last length match range tolower
         totitle toupper trim trimleft trimright wordend wordstart}
     if {1 == $pos} {
-        return [AttemptFromList ${mod} ${cmds}]
+        return [TryFromList ${mod} ${cmds}]
     } elseif {2 == $pos} {
         switch -- $cmd {
             compare -
             first -
             last { if {![llength ${mod}]} { return <string1> } }
@@ -1692,18 +1844,18 @@
 }
 
 proc complete(subst) {text start end line pos mod} {
     set opts {-nobackslashes -nocommands -novariables}
     set opts [RemoveUsedOptions ${line} ${opts}]
-    return [AttemptFromList ${mod} [concat ${opts} <string>]]
+    return [TryFromList ${mod} [concat ${opts} <string>]]
     return ""
 }
 
 proc complete(switch) {text start end line pos mod} {
     set opts {-exact -glob -regexp --}
     set opts [RemoveUsedOptions ${line} ${opts} {--}]
-    return [AttemptFromList ${mod} [concat ${opts} <string>]]
+    return [TryFromList ${mod} [concat ${opts} <string>]]
     return ""
 }
 
 proc complete(tell) {text start end line pos mod} {
     if {1 == $pos} {
@@ -1713,15 +1865,15 @@
 }
 
 proc complete(trace) {text start end line pos mod} {
     set cmd [lindex ${line} 1]
     if {1 == $pos} {
-        return [AttemptFromList ${mod} {variable vdelete vinfo}]
+        return [TryFromList ${mod} {variable vdelete vinfo}]
     } elseif {2 == $pos} {
         return [Format [uplevel 2 info vars "${mod}*"] ${mod}]
     } elseif {3 == $pos && "variable" == ${cmd}} {
-        return [AttemptFromList ${mod} {r w u}]
+        return [TryFromList ${mod} {r w u}]
     }
     return ""
 }
 
 proc complete(update) {text start end line pos mod} {
@@ -1857,11 +2009,11 @@
     }
 
     if {1 >= ${pos}} {
         set cmds [TrySubCmds ${widget}]
         if {[llength ${cmds}]} {
-            return [AttemptFromList ${mod} ${cmds}]
+            return [TryFromList ${mod} ${cmds}]
         }
     } elseif {2 <= ${pos} && 
         ([string match ${cmd}* cget] || \
          [string match ${cmd}* configure])} {
         set prev [PreviousWord ${start} ${line}]
@@ -1871,11 +2023,11 @@
         if {-1 != [set found [lsearch -exact $options(switches) ${prev}]]} {
             if {![llength ${mod}]} {
                 return [list "[lindex $options(value) ${found}]"]
             }
         } else {
-            return [AttemptFromList ${mod} $options(switches)]
+            return [TryFromList ${mod} $options(switches)]
         }
     }
     return ""
 }
 
@@ -1882,14 +2034,14 @@
 proc complete(winfo) {text start end line pos mod} {
     set cmd [lindex ${line} 1]
     if {1 >= ${pos}} {
         set cmds [TrySubCmds winfo]
         if {[llength ${cmds}]} {
-            return [AttemptFromList ${mod} ${cmds}]
+            return [TryFromList ${mod} ${cmds}]
         }
     } elseif {2 == ${pos}} {
-        return [AttemptFromList ${mod} [WidgetList ${mod}]]
+        return [TryFromList ${mod} [WidgetList ${mod}]]
     }
     return ""
 }
 
 }; # namespace tclreadline