;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:30 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/progmodes/tcl.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\302\303\304\305\306\307\310\311&\210\312\313\314\315\316\317\310\303&\210\320\313\321\322#\210\312\323\314\324\316\317\310\303&\210\320\323\321\322#\210\312\325\304\326\316\327\310\303&\210\312\330\331\332\316\333\310\303&\210\312\334\304\335\316\336\310\303&\210\312\337\304\340\316\341\310\303&\210\312\342\343\344\316\327\310\303&\210\312\345\346\347\316\350\310\303&\210\312\351\304\352\316\353\310\303&\210\312\354\355\356\316\357\310\303&\210\312\360\361\362\316\350\310\303&\210\363\364\365\366\310\303\367\370&\207" [require comint custom-declare-group tcl nil "Major mode for editing Tcl source in Emacs." :link (custom-group-link :tag "Font Lock Faces group" font-lock-faces) :group languages custom-declare-variable tcl-indent-level 4 "Indentation of Tcl statements with respect to containing block." :type integer put safe-local-variable integerp tcl-continued-indent-level "Indentation of continuation line relative to first line of command." tcl-auto-newline "Non-nil means automatically newline before and after braces you insert." boolean tcl-tab-always-indent tab-always-indent "Control effect of TAB key.\nIf t (the default), always indent current line.\nIf nil and point is not in the indentation area at the beginning of\nthe line, a TAB is inserted.\nOther values cause the first possible action from the following list\nto take place:\n\n  1. Move from beginning of line to correct indentation.\n  2. Delete an empty comment.\n  3. Move forward to start of comment, indenting if necessary.\n  4. Move forward to end of line, indenting if necessary.\n  5. Create an empty comment.\n  6. Move backward to start of comment, indenting if necessary." (choice (const :tag "Always" t) (const :tag "Beginning only" nil) (const :tag "Maybe move or make or delete comment" 'tcl)) tcl-electric-hash-style "Style of electric hash insertion to use.\nPossible values are `backslash', meaning that `\\' quoting should be\ndone; `quote', meaning that `\"' quoting should be done; `smart',\nmeaning that the choice between `backslash' and `quote' should be\nmade depending on the number of hashes inserted; or nil, meaning that\nno quoting should be done.  Any other value for this variable is\ntaken to mean `smart'.  The default is nil." (choice (const backslash) (const quote) (const smart) (const nil)) tcl-help-directory-list "List of topmost directories containing TclX help files." (repeat directory) tcl-use-smart-word-finder t "If not nil, use smart way to find current word, for Tcl help feature." tcl-application "wish" "Name of Tcl program to run in inferior Tcl mode." string tcl-command-switches "List of switches to supply to the `tcl-application' program." (repeat string) tcl-prompt-regexp "^\\(% \\|\\)" "If not nil, a regexp that will match the prompt in the inferior process.\nIf nil, the prompt is the name of the application with \">\" appended.\n\nThe default is \"^\\(% \\|\\)\", which will match the default primary\nand secondary prompts for tclsh and wish." regexp inferior-tcl-source-command "source %s\n" "Format-string for building a Tcl command to load a file.\nThis format string should use `%s' to substitute a file name\nand should result in a Tcl expression that will command the\ninferior Tcl to load that file.  The filename will be appropriately\nquoted for Tcl." custom-declare-face tcl-escaped-newline ((t :inherit font-lock-string-face)) "Face used for (non-escaped) backslash at end of a line in Tcl mode." :version "22.1"] 8)
#@28 Keymap used in `tcl-mode'.
(defvar tcl-mode-map (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\304#\210\302\310\304#\210\302\311\304#\210\302\312\313#\210\302\314\315#\210\302\316\317#\210\302\320\321#\210\302\322\323#\210\302\324\325#\210\302\326\323#\210\302\327\330#\210\302\331\332#\210\302\333\334#\210\302\335\336#\210)\207" [map make-sparse-keymap define-key "{" tcl-electric-char "}" tcl-electric-brace "[" "]" ";" "#" tcl-electric-hash "" tcl-indent-exp "" backward-delete-char-untabify "	" tcl-indent-command "\230" tcl-eval-defun "	" tcl-help-on-word "" "" tcl-load-file "" inferior-tcl "" tcl-eval-region "" switch-to-tcl] 4) (#$ . 4069))
#@44 Syntax table in use in `tcl-mode' buffers.
(defvar tcl-mode-syntax-table (byte-code "\301 \302\303\304#\210\302\305\304#\210\302\306\304#\210\302\307\304#\210\302\310\304#\210\302\311\304#\210\302\312\304#\210\302\313\304#\210\302\314\304#\210\302\315\304#\210\302\316\304#\210\302\317\304#\210\302\320\304#\210\302\321\304#\210\302\322\304#\210\302\323\304#\210\302\324\325#\210\302\326\327#\210\302\330\331#\210\302\332\333#\210\302\334\335#\210)\207" [st make-syntax-table modify-syntax-entry 37 "_" 64 38 42 43 45 46 58 33 36 47 126 60 61 62 124 40 "()" 41 ")(" 59 "." 10 ">" 35 "<"] 4) (#$ . 4771))
#@37 Keymap used in `inferior-tcl-mode'.
(defvar inferior-tcl-mode-map (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\302\315\312#\210\302\316\317#\210\302\320\321#\210\302\322\323#\210\302\324\325#\210)\207" [map make-sparse-keymap define-key "	" comint-dynamic-complete "\277" comint-dynamic-list-filename-completions "" backward-delete-char-untabify "\230" tcl-eval-defun "	" tcl-help-on-word "" "" tcl-load-file "" inferior-tcl "" tcl-eval-region "" switch-to-tcl] 4) (#$ . 5404))
#@26 Menu used in `tcl-mode'.
(defvar tcl-mode-menu nil (#$ . 5970))
(easy-menu-do-define 'tcl-mode-menu tcl-mode-map "Menu used in `tcl-mode'." '("Tcl" ["Beginning of function" beginning-of-defun t] ["End of function" end-of-defun t] ["Mark function" mark-defun t] ["Indent region" indent-region (mark t)] ["Comment region" comment-region (mark t)] ["Uncomment region" uncomment-region (mark t)] "----" ["Show Tcl process buffer" inferior-tcl t] ["Send function to Tcl process" tcl-eval-defun (and inferior-tcl-buffer (get-buffer inferior-tcl-buffer))] ["Send region to Tcl process" tcl-eval-region (and inferior-tcl-buffer (get-buffer inferior-tcl-buffer))] ["Send file to Tcl process" tcl-load-file (and inferior-tcl-buffer (get-buffer inferior-tcl-buffer))] ["Restart Tcl process with file" tcl-restart-with-file t] "----" ["Tcl help" tcl-help-on-word tcl-help-directory-list]))
#@1641 The current inferior-tcl process buffer.

MULTIPLE PROCESS SUPPORT
===========================================================================
To run multiple Tcl processes, you start the first up with
\[inferior-tcl].  It will be in a buffer named `*inferior-tcl*'.
Rename this buffer with \[rename-buffer].  You may now start up a new
process with another \[inferior-tcl].  It will be in a new buffer,
named `*inferior-tcl*'.  You can switch between the different process
buffers with \[switch-to-buffer].

Commands that send text from source buffers to Tcl processes -- like
`tcl-eval-defun' or `tcl-load-file' -- have to choose a process to
send to, when you have more than one Tcl process around.  This is
determined by the global variable `inferior-tcl-buffer'.  Suppose you
have three inferior Lisps running:
    Buffer              Process
    foo                 inferior-tcl
    bar                 inferior-tcl<2>
    *inferior-tcl*      inferior-tcl<3>
If you do a \[tcl-eval-defun] command on some Lisp source code, what
process do you send it to?

- If you're in a process buffer (foo, bar, or *inferior-tcl*),
  you send it to that process.
- If you're in some other buffer (e.g., a source file), you
  send it to the process attached to buffer `inferior-tcl-buffer'.
This process selection is performed by function `inferior-tcl-proc'.

Whenever \[inferior-tcl] fires up a new process, it resets
`inferior-tcl-buffer' to be the new process's buffer.  If you only run
one process, this does the right thing.  If you run multiple
processes, you can change `inferior-tcl-buffer' to another process
buffer with \[set-variable].
(defvar inferior-tcl-buffer nil (#$ . 6856))
#@623 Hook run on entry to Tcl mode.

Several functions exist which are useful to run from your
`tcl-mode-hook' (see each function's documentation for more
information):

  `tcl-guess-application'
    Guesses a default setting for `tcl-application' based on any
    "#!" line at the top of the file.
  `tcl-hashify-buffer'
    Quotes all "#" characters that don't correspond to actual
    Tcl comments.  (Useful when editing code not originally created
    with this mode).
  `tcl-auto-fill-mode'
    Auto-filling of Tcl comments.

Add functions to the hook with `add-hook':

   (add-hook 'tcl-mode-hook 'tcl-guess-application)
(defvar tcl-mode-hook nil (#$ . 8548))
#@205 List of commands whose first argument defines something.
This exists because some people (eg, me) use `defvar' et al.
Call `tcl-set-proc-regexp' and `tcl-set-font-lock-keywords'
after changing this list.
(defvar tcl-proc-list '("proc" "method" "itcl_class" "body" "configbody" "class") (#$ . 9216))
#@43 Regexp to use when matching proc headers.
(defvar tcl-proc-regexp nil (#$ . 9521))
#@128 List of Tcl keywords denoting "type".  Used only for highlighting.
Call `tcl-set-font-lock-keywords' after changing this list.
(defvar tcl-typeword-list '("global" "upvar" "inherit" "public" "protected" "private" "common" "itk_option" "variable") (#$ . 9611))
#@154 List of Tcl keywords.  Used only for highlighting.
Default list includes some TclX keywords.
Call `tcl-set-font-lock-keywords' after changing this list.
(defvar tcl-keyword-list '("if" "then" "else" "elseif" "for" "foreach" "break" "continue" "while" "eval" "case" "in" "switch" "default" "exit" "error" "proc" "return" "uplevel" "constructor" "destructor" "itcl_class" "loop" "for_array_keys" "for_recursive_glob" "for_file" "method" "body" "configbody" "class" "chain") (#$ . 9878))
#@203 List of Tcl commands.  Used only for highlighting.
Call `tcl-set-font-lock-keywords' after changing this list.
This list excludes those commands already found in `tcl-proc-list' and
`tcl-keyword-list'.
(defvar tcl-builtin-list '("after" "append" "array" "bgerror" "binary" "catch" "cd" "clock" "close" "concat" "console" "dde" "encoding" "eof" "exec" "expr" "fblocked" "fconfigure" "fcopy" "file" "fileevent" "flush" "format" "gets" "glob" "history" "incr" "info" "interp" "join" "lappend" "lindex" "linsert" "list" "llength" "load" "lrange" "lreplace" "lsort" "namespace" "open" "package" "pid" "puts" "pwd" "read" "regexp" "registry" "regsub" "rename" "scan" "seek" "set" "socket" "source" "split" "string" "subst" "tell" "time" "trace" "unknown" "unset" "vwait") (#$ . 10370))
#@213 Keywords to highlight for Tcl.  See variable `font-lock-keywords'.
This variable is generally set from `tcl-proc-regexp',
`tcl-typeword-list', and `tcl-keyword-list' by the function
`tcl-set-font-lock-keywords'.
(defvar tcl-font-lock-keywords nil (#$ . 11157))
#@36 Syntactic keywords for `tcl-mode'.
(defconst tcl-syntax-propertize-function #[(start end) "b\210`	W\205\"\302\303	\304#\205\"\305\224\203\306\305\224\305\225\307\310$\210\202\207" [start end re-search-forward "[^;[{ 	\n][ 	]*\\(#\\)" t 1 put-text-property syntax-table (1)] 5] (#$ . 11424))
#@791 Alist that controls indentation.
(Actually, this really only controls what happens on continuation lines).
Each entry looks like `(KEYWORD TYPE ...)'.
Each type entry describes a sexp after the keyword, and can be one of:
* nil, meaning that this sexp has no particular type.
* tcl-expr, meaning that this sexp is an arithmetic expression.
* tcl-commands, meaning that this sexp holds Tcl commands.
* a string, which must exactly match the string at the corresponding
  position for a match to be made.

For example, the entry for the "loop" command is:

   ("loop" nil tcl-expr tcl-commands)

This means that the "loop" command has three arguments.  The first
argument is ignored (for indentation purposes).  The second argument
is a Tcl expression, and the last argument is Tcl commands.
(defvar tcl-type-alist '(("proc" nil tcl-expr tcl-commands) ("method" nil tcl-expr tcl-commands) ("destructor" tcl-commands) ("constructor" tcl-commands) ("expr" tcl-expr) ("catch" tcl-commands) ("if" tcl-expr "then" tcl-commands) ("elseif" tcl-expr "then" tcl-commands) ("elseif" tcl-expr tcl-commands) ("if" tcl-expr tcl-commands) ("while" tcl-expr tcl-commands) ("for" tcl-commands tcl-expr tcl-commands tcl-commands) ("foreach" nil nil tcl-commands) ("for_file" nil nil tcl-commands) ("for_array_keys" nil nil tcl-commands) ("for_recursive_glob" nil nil nil tcl-commands) ("loop" nil tcl-expr tcl-expr tcl-commands) ("loop" nil tcl-expr tcl-commands)) (#$ . 11729))
#@67 If non-nil, debugging message will be printed during indentation.
(defvar tcl-explain-indentation nil (#$ . 13195))
(defconst tcl-omit-ws-regexp "^[^]\" 	\n#}][^\n\"#]+[ 	]+")
#@54 Set `tcl-proc-regexp' from variable `tcl-proc-list'.
(defalias 'tcl-set-proc-regexp #[nil "\302\303\304\"\305Q\211\207" [tcl-proc-list tcl-proc-regexp "^\\s-*" regexp-opt t "[ 	]+"] 4 (#$ . 13377)])
#@88 Set `tcl-font-lock-keywords'.
Uses variables `tcl-proc-regexp' and `tcl-keyword-list'.
(defalias 'tcl-set-font-lock-keywords #[nil "\305P\306\307E\310\311	\312\"\313Q\306\314E\315\311\n\312\"\316Q\317\320E\321\322\323\324\325\315\311\312\"\316Q\317B\257	\211\207" [tcl-proc-regexp tcl-typeword-list tcl-builtin-list tcl-keyword-list tcl-font-lock-keywords "\\([^ 	\n]+\\)" 2 font-lock-function-name-face "\\(\\s-\\|^\\)" regexp-opt t "\\(\\s-\\|$\\)" font-lock-type-face "\\_<" "\\_>" 1 font-lock-builtin-face ("\\${\\([^}]+\\)}" 1 font-lock-variable-name-face) ("\\$\\(\\(?:::\\)?\\(?:[[:alnum:]_]+::\\)*[[:alnum:]_]+\\)" 1 font-lock-variable-name-face) ("\\(?:\\s-\\|^\\|\\[\\)set\\s-+{\\([^}]+\\)}" 1 font-lock-variable-name-face keep) ("\\(?:\\s-\\|^\\|\\[\\)set\\s-+\\(\\(?:::\\)?\\(?:[[:alnum:]_]+::\\)*[[:alnum:]_]+\\)" 1 font-lock-variable-name-face keep) ("\\(^\\|[^\\]\\)\\(\\\\\\\\\\)*\\(\\\\\\)$" 3 'tcl-escaped-newline)] 12 (#$ . 13584)])
(byte-code "\204\302 \210	\204\303 \210\302\207" [tcl-proc-regexp tcl-font-lock-keywords tcl-set-proc-regexp tcl-set-font-lock-keywords] 1)
#@75 Imenu generic expression for `tcl-mode'.  See `imenu-generic-expression'.
(defvar tcl-imenu-generic-expression (byte-code "\301\302P\303BBC\207" [tcl-proc-regexp nil "\\([-A-Za-z0-9_:+*]+\\)" (2)] 3) (#$ . 14690))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [tcl-mode-hook variable-documentation put purecopy "Hook run when entering Tcl mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp tcl-mode-map definition-name tcl-mode] 5)
(defvar tcl-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [tcl-mode-map variable-documentation put purecopy "Keymap for `tcl-mode'." boundp tcl-mode-syntax-table definition-name tcl-mode] 5)
(defvar tcl-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [tcl-mode-syntax-table variable-documentation put purecopy "Syntax table for `tcl-mode'." tcl-mode-abbrev-table definition-name tcl-mode] 5)
(defvar tcl-mode-abbrev-table (progn (define-abbrev-table 'tcl-mode-abbrev-table nil) tcl-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [tcl-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `tcl-mode'." tcl-mode derived-mode-parent prog-mode] 5)
#@1039 Major mode for editing Tcl code.
Expression and list commands understand all Tcl brackets.
Tab indents for Tcl code.
Paragraphs are separated by blank lines only.
Delete converts tabs to spaces as it moves back.

Variables controlling indentation style:
  `tcl-indent-level'
    Indentation of Tcl statements within surrounding block.
  `tcl-continued-indent-level'
    Indentation of continuation line relative to first line of command.

Variables controlling user interaction with mode (see variable
documentation for details):
  `tcl-tab-always-indent'
    Controls action of TAB key.
  `tcl-auto-newline'
    Non-nil means automatically newline before and after braces, brackets,
    and semicolons inserted in Tcl code.
  `tcl-use-smart-word-finder'
    If not nil, use a smarter, Tcl-specific way to find the current
    word when looking up help on a Tcl command.

Turning on Tcl mode runs `tcl-mode-hook'.  Read the documentation for
`tcl-mode-hook' to see what kinds of interesting hook functions
already exist.

\{tcl-mode-map}
(defalias 'tcl-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324>\325\"\204V>?=\204V\326>\325?C#\210\327!\210\330\f!\210>?\331\332!\203m\204t\306\333!\210\307\306\334!\210\335\306\336!\210\337\306\340!\210\341 \306\342!\210\343\"\306\344!\210\345$\306\346!\210\347&\306\350!\210\351(\306\352!\210\353*\306\354!\210@,\306\355!\210A-\306\356!\210\357.\306\360!\210\3570\306\361!\210\3621\306\363!\210\3643\306\365!\210\3075\306\366!\210B6\306\367!\210\3707\371C!\210\331\372!\203

\n\373PCB:)\374\375!\207" [delay-mode-hooks major-mode mode-name tcl-mode-map tcl-mode-syntax-table parent make-local-variable t prog-mode tcl-mode "Tcl" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table boundp filladapt-mode paragraph-ignore-fill-prefix indent-line-function tcl-indent-line comment-indent-function tcl-comment-indent comment-start "# " comment-start-skip "\\(\\(^\\|[;{[]\\)\\s-*\\)#+ *" comment-end "" outline-regexp "." outline-level tcl-outline-level font-lock-defaults (tcl-font-lock-keywords nil nil nil beginning-of-defun) syntax-propertize-function imenu-generic-expression dabbrev-case-fold-search nil dabbrev-case-replace dabbrev-abbrev-skip-leading-regexp "[$!]" dabbrev-abbrev-char-regexp "\\sw\\|\\s_" parse-sexp-ignore-comments defun-prompt-regexp add-log-current-defun-function tcl-add-log-defun easy-menu-add mode-popup-menu " Mode Commands" run-mode-hooks tcl-mode-hook tcl-mode-abbrev-table local-abbrev-table tcl-syntax-propertize-function tcl-imenu-generic-expression tcl-omit-ws-regexp tcl-mode-menu] 6 (#$ . 16136) nil])
#@50 Insert character and correct line's indentation.
(defalias 'tcl-electric-char #[(arg) "\303 \210\304!\210	\205\n\305U\205\306 \210\303 \207" [arg tcl-auto-newline last-command-event tcl-indent-line self-insert-command 59 newline] 2 (#$ . 19046) "p"])
#@50 Insert character and correct line's indentation.
(defalias 'tcl-electric-brace #[(arg) "\203*\212\303\304x\210n)\204\305 \210\306 \210	\307V\203.\nc\210\305 \210\306 \210	S\211\202\310	!\210\305 \207" [tcl-auto-newline arg last-command-event " 	" nil tcl-indent-line newline 0 self-insert-command] 3 (#$ . 19308) "p"])
#@688 Indent current line as Tcl code, or in some cases insert a tab character.
If `tcl-tab-always-indent' is t (the default), always indent current line.
If `tcl-tab-always-indent' is nil and point is not in the indentation
area at the beginning of the line, a TAB is inserted.
Other values of `tcl-tab-always-indent' cause the first possible action
from the following list to take place:

  1. Move from beginning of line to correct indentation.
  2. Delete an empty comment.
  3. Move forward to start of comment, indenting if necessary.
  4. Move forward to end of line, indenting if necessary.
  5. Create an empty comment.
  6. Move backward to start of comment, indenting if necessary.
(defalias 'tcl-indent-command #[(&optional _arg) "\305>\203
\306\307!)\207`\310\210`\311 \n\312 U\2035\313 \210\314 \210`\312 U\2030\310\202}\315 \202}\f\203L\316\317!\203L\320u\210\321\310x\210`|\202}\f\203^\n`W\203^\314 \210\322 \202}\nU\204lb\210\314 \202}\f\204x\314 \210\323 \202}\314 \210\322 +\207" [tcl-tab-always-indent tab-always-indent ipoint eolpoint comment-p (nil t) call-interactively indent-for-tab-command nil tcl-in-comment line-beginning-position beginning-of-line tcl-indent-line back-to-indentation looking-at "[ 	]*$" -1 " 	;" indent-for-comment comment-indent] 2 (#$ . 19642) "p"])
#@80 Indent current line as Tcl code.
Return the amount the indentation changed by.
(defalias 'tcl-indent-line #[nil "\306\307!\307\211\211d`Z\211\204\310\202p\311 \210`\312\307w\210\f<\203'\f@g\313U\2034\f
Z\202=g\314U\203=\fS\312\307w\210\fiZ\315\n!\203[dZ`V\203odZb\210\202o`|\210\fj\210dZ`V\203odZb\210\n-\207" [pos case-fold-search shift-amt beg indent tcl-indent-level tcl-calculate-indent nil noindent beginning-of-line " 	" 125 93 zerop] 7 (#$ . 20966)])
#@207 Determine type of sexp at point.
This is either `tcl-expr', `tcl-commands', or nil.  Puts point at start
of sexp that indicates types.

See documentation for variable `tcl-type-alist' for more information.
(defalias 'tcl-figure-type #[nil "\304\305\211\211\306W\203	\204\305\307\310\217\210\nT\211\202\203%\311\312	\"\210	+\207" [word-stack result count tcl-explain-indentation 0 nil 5 (byte-code "\306 \210\307\310!\203_\311\312 B\n\203[\f\204[\n@\nA\313	\203G
\fX\203G	@;\203>	@
8\230\204>\311	A
T\202\"
\fV\203W	@;\204W	@)\202*\202c\311B\311\207" [tcl-type-alist entry list word-stack result index backward-sexp looking-at "[a-zA-Z_]+" nil tcl-word-no-props 0 count] 3) ((error)) message "Indentation type %s"] 4 (#$ . 21457)])
#@184 Return appropriate indentation for current line as Tcl code.
In usual case returns an integer: the column to indent to.
Returns nil if line starts inside a string, t if in a comment.
(defalias 'tcl-calculate-indent #[(&optional parse-start) "\212\306 \210`\307\212o?\205\310u\210h\311U)\211\203\202\312\307\211\307\2034b\210\2027\313 \210`W\203N`\314`\312#\211A@\2027\315
8\204Z\316
8\203`\316
8\202\373\204i\f\202\373b\210\317 \211\320=\321=`b\210\307u\210`W\203\252\322\323!\203\252\307y\210`W\203\252\322\323!\203\252\324\307y\210\202\225\n\204\273f\325U\203\273\203\325`Y\203\313b\210\307u\210\202\317\326\307w\210i\f\\\202\372`W\203\345\203\345\327 \202\372\203\361b\210\202\365b\210\327 \\,.\207" [indent-point case-fold-search continued-line tcl-continued-indent-level continued-indent-value state beginning-of-line nil -1 92 0 beginning-of-defun parse-partial-sexp 3 4 tcl-figure-type tcl-expr tcl-commands looking-at "[ 	]*\\(#.*\\)?$" t 123 " 	" current-indentation containing-sexp found-next-line parse-start sexpr-type expr-p commands-p expr-start tcl-indent-level] 5 (#$ . 22237)])
#@55 Indent each line of the Tcl grouping following point.
(defalias 'tcl-indent-exp #[nil "\306C`C\306\211\211\211\211\211\211\307\306\212\310\311!\210)\212\306m?\205U
?\205U
	\306\204sm\203G\312\211\204s
\313`\306\210`\306\211
%\211@\314\f8\203`\315 \210\316
8\203l\311y\210\2027\312\211\203<	\307X\203|\312\204'\317
8V\203\232AAS\211\202\202	W\203\263\306B\306BT\211\202\233@\204\312
A@\206\310\212\310\320!\210`)\240\210\311y\210\212\320u\210h\321U)\322\306w\210l\204'@\203\363@\307Y\203\363@\202\f
\323@\205\376@[!\211\240\210\306)\247\203(
g\324U\203
Z\202(
g\325U\203(
S\203'i\n\2038
\\\2029
U\204'`\326 \210`|\210\n\203O
\\\202P
j\210\202'.\f\207" [last-depth next-depth continued-line this-indent ostate state nil 0 forward-sexp 1 t parse-partial-sexp 4 tcl-indent-line 3 6 -1 92 " 	" tcl-calculate-indent 125 93 beginning-of-line inner-loop-done outer-loop-done case-fold-search contain-stack indent-stack val tcl-indent-level] 12 (#$ . 23429) nil])
#@50 Return name of Tcl function point is in, or nil.
(defalias 'tcl-add-log-defun #[nil "\212\301\210\302\303P\301\304#\205\305\306!)\207" [tcl-proc-regexp nil re-search-backward "\\([^ 	\n{]+\\)" t match-string 2] 4 (#$ . 24512)])
(defalias 'tcl-outline-level #[nil "\212\300\301w\210i)\207" [" 	" nil] 2])
(defvar inferior-tcl-delete-prompt-marker nil)
(defalias 'tcl-filter #[(proc string) "\304r\305	!q\210\306\n!\203\307	!\n|\210\n\310\211\223\210*\311	\"\207" [inhibit-quit proc inferior-tcl-delete-prompt-marker string t process-buffer marker-buffer process-mark nil comint-output-filter] 3])
(defalias 'tcl-send-string #[(proc string) "r\304!q\210\305!b\210\306y\210\307	!\203\n`\310\223\210)\311\"\207" [proc comint-prompt-regexp inferior-tcl-delete-prompt-marker string process-buffer process-mark 0 looking-at nil comint-send-string] 3])
(defalias 'tcl-send-region #[(proc start end) "r\305!q\210\306!b\210\307y\210\310	!\203\n`\311\223\210)\312\f#\207" [proc comint-prompt-regexp inferior-tcl-delete-prompt-marker start end process-buffer process-mark 0 looking-at nil comint-send-region] 4])
#@90 Switch to inferior Tcl process buffer.
With argument, positions cursor at end of buffer.
(defalias 'switch-to-tcl #[(eob-p) "\302!\203
\303!\210\202\304\305!\210	\205\306 \210db\207" [inferior-tcl-buffer eob-p get-buffer pop-to-buffer error "No current inferior Tcl buffer" push-mark] 2 (#$ . 25639) "P"])
#@74 Return current inferior Tcl process.
See variable `inferior-tcl-buffer'.
(defalias 'inferior-tcl-proc #[nil "\302\303\304!\203p\202\f!\211\206\305\306!)\207" [inferior-tcl-buffer proc get-buffer-process derived-mode-p inferior-tcl-mode error "No Tcl process; see variable `inferior-tcl-buffer'"] 4 (#$ . 25958)])
#@113 Send the current region to the inferior Tcl process.
Prefix argument means switch to the Tcl buffer afterwards.
(defalias 'tcl-eval-region #[(start end &optional and-go) "\304 \305\212	b\210\306\307w\210`)\212\nb\210\306\307x\210`)#\210\310\311\"\210\205'\312\313!)\207" [proc start end and-go inferior-tcl-proc tcl-send-region " 	\n" nil tcl-send-string "\n" switch-to-tcl t] 5 (#$ . 26285) "r\nP"])
#@112 Send the current defun to the inferior Tcl process.
Prefix argument means switch to the Tcl buffer afterwards.
(defalias 'tcl-eval-defun #[(&optional and-go) "\212\302 \210`\303 \210\304`\"\210*	\205\305\306!\207" [end and-go end-of-defun beginning-of-defun tcl-eval-region switch-to-tcl t] 3 (#$ . 26698) "P"])
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [inferior-tcl-mode-hook variable-documentation put purecopy "Hook run when entering Inferior Tcl mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp inferior-tcl-mode-map definition-name inferior-tcl-mode] 5)
(defvar inferior-tcl-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [inferior-tcl-mode-map variable-documentation put purecopy "Keymap for `inferior-tcl-mode'." boundp inferior-tcl-mode-syntax-table definition-name inferior-tcl-mode] 5)
(defvar inferior-tcl-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [inferior-tcl-mode-syntax-table variable-documentation put purecopy "Syntax table for `inferior-tcl-mode'." inferior-tcl-mode-abbrev-table definition-name inferior-tcl-mode] 5)
(defvar inferior-tcl-mode-abbrev-table (progn (define-abbrev-table 'inferior-tcl-mode-abbrev-table nil) inferior-tcl-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [inferior-tcl-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `inferior-tcl-mode'." inferior-tcl-mode derived-mode-parent comint-mode] 5)
#@800 Major mode for interacting with Tcl interpreter.

You can start a Tcl process with \[inferior-tcl].

Entry to this mode runs the normal hooks `comint-mode-hook' and
`inferior-tcl-mode-hook', in that order.

You can send text to the inferior Tcl process from other buffers
containing Tcl source.

Variables controlling Inferior Tcl mode:
  `tcl-application'
    Name of program to run.
  `tcl-command-switches'
    Command line arguments to `tcl-application'.
  `tcl-prompt-regexp'
    Matches prompt.
  `inferior-tcl-source-command'
    Command to use to read Tcl file in running application.
  `inferior-tcl-buffer'
    The current inferior Tcl process buffer.  See variable
    documentation for details on multiple-process support.

The following commands are available:
\{inferior-tcl-mode-map}
(defalias 'inferior-tcl-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324&\325\"\204V&'=\204V\326&\325'C#\210\327!\210\330\f!\210&'\306\331!\210(\206r\332\333)!\334Q\335*+'\330,!\210\306\336!\210-\306\337!\210\340 \341\342p!\343\"\210)\344\345!\207" [delay-mode-hooks major-mode mode-name inferior-tcl-mode-map inferior-tcl-mode-syntax-table parent make-local-variable t comint-mode inferior-tcl-mode "Inferior Tcl" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table comint-prompt-regexp "^" regexp-quote ">" (": %s") defun-prompt-regexp inferior-tcl-delete-prompt-marker make-marker set-process-filter get-buffer-process tcl-filter run-mode-hooks inferior-tcl-mode-hook inferior-tcl-mode-abbrev-table local-abbrev-table tcl-prompt-regexp tcl-application mode-line-process tcl-mode-abbrev-table tcl-mode-syntax-table tcl-omit-ws-regexp] 6 (#$ . 28426) nil])
#@151 Run inferior Tcl process.
Prefix arg means enter program name interactively.
See documentation for function `inferior-tcl-mode' for more information.
(defalias 'inferior-tcl #[(cmd) "\304\305!\204\306\307\310\311	%q\210\312 \210\313\314 !\204\315\314 \316\"\210\317\302!\210\305\320\305!\207" [cmd tcl-command-switches tcl-application inferior-tcl-buffer comint-check-proc "*inferior-tcl*" apply make-comint "inferior-tcl" nil inferior-tcl-mode process-tty-name inferior-tcl-proc tcl-send-string "set ::tcl_interactive 1; concat\n" make-local-variable pop-to-buffer] 6 (#$ . 30399) (list (if current-prefix-arg (read-string "Run Tcl: " tcl-application) tcl-application))])
(defalias 'run-tcl 'inferior-tcl)
#@191 Return nil if point is not at the beginning of a command.
A command is the first word on an otherwise empty line, or the
first word following a semicolon, opening brace, or opening bracket.
(defalias 'tcl-real-command-p #[nil "\212\300\301x\210o\203
\302\202n\203\303u\210h\304=?\202h\305>)\207" [" 	" nil t -1 92 (59 123 91)] 2 (#$ . 31121)])
#@303 Return t if point is just after the `#' beginning a real comment.
Does not check to see if previous char is actually `#'.
A real comment is either at the beginning of the buffer,
preceded only by whitespace on the line, or has a preceding
semicolon, opening brace, or opening bracket on the same line.
(defalias 'tcl-real-comment-p #[nil "\212\300u\210\301 )\207" [-1 tcl-real-command-p] 1 (#$ . 31479)])
#@232 Determine if point is in a comment.
Returns a list of the form `(FLAG . STATE)'.  STATE can be used
as input to future invocations.  FLAG is nil if not in comment,
t otherwise.  If in comment, leaves point at beginning of comment.
(defalias 'tcl-hairy-scan-for-comment #[(state end always-stop) "\212b\210\306 )\307\211	\204J`W\203J\307\310`\307\211\f\311&\312\f8\203\f
\203.`\313 \211\203A`V\203=`\314\315!\210\312\f\233\307\240\210\202\f	\203Q	b\210\n\f+B\207" [end last-cstart real-comment bol state always-stop line-beginning-position nil parse-partial-sexp t 4 tcl-real-comment-p beginning-of-line 2] 8 (#$ . 31891)])
#@77 Return t if point is in a comment, and leave point at beginning of comment.
(defalias 'tcl-in-comment #[nil "`\301 \210\302\303\303#@)\207" [save beginning-of-defun tcl-hairy-scan-for-comment nil] 4 (#$ . 32541)])
#@115 Saved help directories.
If `tcl-help-directory-list' changes, this allows `tcl-help-on-word'
to update the alist.
(defvar tcl-help-saved-dirs nil (#$ . 32764))
#@59 Alist with command names as keys and filenames as values.
(defvar tcl-help-alist nil (#$ . 32930))
#@61 Recursively add all pairs (FILE . PATH) under DIR to ALIST.
(defalias 'tcl-files-alist #[(dir &optional alist) "\304\305\"\306\211\2033\n@\307	!\204\310	!	BB\202,\310	!\311\235\204,\312	\"\nA\211\204\306*\207" [dir file --dolist-tail-- alist directory-files t nil file-directory-p file-name-nondirectory ("." "..") tcl-files-alist] 4 (#$ . 33035)])
#@41 Return alist of commands and filenames.
(defalias 'tcl-help-snarf-commands #[(dirlist) "\304	\304\211\203@\305\n!\203\306\n\"A\211\204\n\304+\207" [alist dirlist dir --dolist-tail-- nil file-directory-p tcl-files-alist] 4 (#$ . 33408)])
#@42 Set up to re-read files, and then do it.
(defalias 'tcl-reread-help-files #[nil "\303\304!\210\305!\303\306!\207" [tcl-help-directory-list tcl-help-saved-dirs tcl-help-alist message "Building Tcl help file index..." tcl-help-snarf-commands "Building Tcl help file index...done"] 2 (#$ . 33667) nil])
#@45 Like `current-word', but strips properties.
(defalias 'tcl-word-no-props #[nil "\301 \302\303G\304$\210)\207" [word current-word set-text-properties 0 nil] 5 (#$ . 33977)])
#@139 Return current command word, or nil.
If FLAG is nil, just uses `current-word'.
Otherwise scans backward for most likely Tcl command word.
(defalias 'tcl-current-word #[(flag) "\203\301\302\303\"\203\304\305\306\217\207\307 \207" [flag derived-mode-p tcl-mode inferior-tcl-mode nil (byte-code "\212o\204o\204\301 \204\302 \210\202\303\304 \"\205\304 )\207" [tcl-help-alist tcl-real-command-p backward-sexp assoc tcl-word-no-props] 3) ((error)) tcl-word-no-props] 3 (#$ . 34161)])
#@120 Get help on Tcl command.  Default is word at point.
Prefix argument means invert sense of `tcl-use-smart-word-finder'.
(defalias 'tcl-help-on-word #[(command &optional arg) "	\232\204	\306 \210\n\307\230\203\310\203\f?\202\f!\311\312!\313\n\"\211\205.A
q\210ed|\210\203J\314\n\315\261\210\316!\210\202\\\n\307\230\203V\317c\210\202\\\320\n\321\261\210\322\323!\210eb\210\324
!+\207" [tcl-help-directory-list tcl-help-saved-dirs command arg tcl-use-smart-word-finder help tcl-reread-help-files "" tcl-current-word get-buffer-create "*Tcl help*" assoc "*** " "\n\n" insert-file-contents "Magical Pig!" "Tcl command " " not in help\n" set-buffer-modified-p nil display-buffer tcl-help-alist cell file] 4 (#$ . 34663) (list (progn (if (not (equal tcl-help-directory-list tcl-help-saved-dirs)) (tcl-reread-help-files)) (let ((word (tcl-current-word (if current-prefix-arg (not tcl-use-smart-word-finder) tcl-use-smart-word-finder)))) (completing-read (if (or (null word) (string= word "")) "Help on Tcl command: " (format "Help on Tcl command (default %s): " word)) tcl-help-alist nil t nil nil word))) current-prefix-arg)])
#@150 Record last directory and file used in loading.
This holds a cons cell of the form `(DIRECTORY . FILE)'
describing the last `tcl-load-file' command.
(defvar tcl-previous-dir/file nil (#$ . 35820))
#@107 Load a Tcl file into the inferior Tcl process.
Prefix argument means switch to the Tcl buffer afterwards.
(defalias 'tcl-load-file #[(file &optional and-go) "\304!\210\305!\306!B\307\310 \311\n\312!\"\"\210\205\313\314!\207" [file tcl-previous-dir/file inferior-tcl-source-command and-go comint-check-source file-name-directory file-name-nondirectory tcl-send-string inferior-tcl-proc format tcl-quote switch-to-tcl t] 6 (#$ . 36024) (list (car (comint-get-source "Load Tcl file: " (or (and (derived-mode-p 'tcl-mode) (buffer-file-name)) tcl-previous-dir/file) '(tcl-mode) t)) current-prefix-arg)])
#@147 Restart inferior Tcl with file.
If an inferior Tcl process exists, it is killed first.
Prefix argument means switch to the Tcl buffer afterwards.
(defalias 'tcl-restart-with-file #[(file &optional and-go) "\306\307!\203\np\202\211\205\310	!	\203\311	!\204)\312!\210\313\f
\"\202`\314	!\2035\315\316!\205`\212\317\f!\210\320\f!\321\f!B\322\323	!\n\203Q\324\n!\202R\325\f%\210
\205_\326\327!)*\207" [inferior-tcl-buffer buf proc tcl-application file and-go derived-mode-p inferior-tcl-mode get-process get-buffer inferior-tcl tcl-load-file comint-check-proc yes-or-no-p "A Tcl process is running, are you sure you want to reset it? " comint-check-source file-name-directory file-name-nondirectory comint-exec get-buffer-create process-name "inferior-tcl" switch-to-tcl t tcl-previous-dir/file tcl-command-switches] 7 (#$ . 36638) (list (car (comint-get-source "Restart with Tcl file: " (or (and (derived-mode-p 'tcl-mode) (buffer-file-name)) tcl-previous-dir/file) '(tcl-mode) t)) current-prefix-arg)])
#@68 Like `auto-fill-mode', but sets `comment-auto-fill-only-comments'.
(defalias 'tcl-auto-fill-mode #[(&optional arg) "\303!\210	\203\304\302!\210\305\211\207\306\302!\207" [arg auto-fill-function comment-auto-fill-only-comments auto-fill-mode make-local-variable t kill-local-variable] 2 (#$ . 37668) "P"])
#@175 Insert a `#' and quote if it does not start a real comment.
Prefix arg is number of `#'s to insert.
See variable `tcl-electric-hash-style' for description of quoting
styles.
(defalias 'tcl-electric-hash #[(&optional count) "\204\305\306V\205l	\307=\203 \310V\203\311\202!\312\202!	\313\211\203g\212\314c\210\315 )\316\305!\210\f\203=\317\320\n\"\210\311=\203M\n\204g\321c\210\202g\312=\203g\n\204g\306V\203g\322c\210S\211\202X\323\324\"*\207" [count tcl-electric-hash-style comment type tcl-explain-indentation 1 0 smart 3 quote backslash nil "#" tcl-in-comment delete-char message "comment: %s" "\"" "\\#" insert-char 35] 4 (#$ . 37984) "p"])
#@60 Quote all `#'s in current buffer that aren't Tcl comments.
(defalias 'tcl-hashify-buffer #[nil "\212eb\210\302\211`dW\2055\303	d\304#\211@\203 \305\306!\210\202/\307u\210g\310=\203,\311c\210\302u\210A\202+\207" [result state nil tcl-hairy-scan-for-comment t beginning-of-line 2 -1 35 "\\"] 5 (#$ . 38664) nil])
#@72 Return the desired indentation, but be careful to add a `;' if needed.
(defalias 'tcl-comment-indent #[nil "\212\300\301x\210n\204\302 \204\303c\210\301f\304>\203\305\306!\210)\307\310! \207" [" 	" nil tcl-real-command-p ";" (9 32) delete-char 1 default-value comment-indent-function] 2 (#$ . 38992)])
#@120 Attempt to guess Tcl application by looking at first line.
The first line is assumed to look like "#!.../program ...".
(defalias 'tcl-guess-application #[nil "\212eb\210\301\302!\205\303\300!\210\304\305!\211)\207" [tcl-application looking-at "#![^ 	]*/\\([^ 	\n/]+\\)\\([ 	]\\|$\\)" make-local-variable match-string 1] 2 (#$ . 39307)])
(defalias 'tcl-popup-menu #[(_e) "\301!\207" [tcl-mode-menu popup-menu] 2 nil "@e"])
#@38 Quote STRING according to Tcl rules.
(defalias 'tcl-quote #[(string) "\301\302\303#\207" [string mapconcat #[(char) "\301>\203\f\302\303!P\207\303!\207" [char (91 93 123 125 92 34 36 32 59) "\\" char-to-string] 3] ""] 4 (#$ . 39739)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\210\300\307\310\"\210\300\311\312\"\210\300\313\314\"\210\300\315\316\"\210\300\317\320\"\207" [defalias tcl-uncomment-region uncomment-region tcl-indent-for-comment comment-indent add-log-tcl-defun tcl-add-log-defun indent-tcl-exp tcl-indent-exp calculate-tcl-indent tcl-calculate-indent tcl-beginning-of-defun beginning-of-defun tcl-end-of-defun end-of-defun tcl-mark-defun mark-defun] 3)
(defalias 'tcl-mark #[nil "\300\301!\207" [mark t] 2])
(provide 'tcl)