%PDF- %PDF- Mini Shell
Mini Shell

Direktori : /usr/local/share/emacs/27.2/lisp/cedet/semantic/bovine/
Current File : //usr/local/share/emacs/27.2/lisp/cedet/semantic/bovine/el.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; 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\300\302!\210\300\303!\210\300\304!\210\300\305!\210\300\306!\210\300\307!\207" [require semantic semantic/bovine semantic/db-el find-func semantic/ctxt semantic/format thingatpt] 2)
#@185 A simple lexical analyzer for Emacs Lisp.
This lexer ignores comments and whitespace, and will return
syntax as specified by the syntax table.
See `semantic-lex' for more information.
(defalias 'semantic-emacs-lisp-lexer #[(start end &optional depth length) "\306\307\310	\n#\210`\306\211	@	A\311BC\206DE	\nBF\306G\ndV\2034\312\313\nd#\210\314 pHI\315\216\316J!\210	b\210`\nW\203!K\203X\fGKX\203!\317\320!\203e\311\225A\202\270\317\321!\203r\311\225A\202\270\317L!\203\241\322\311\224\311\225BB\fB\211@\211\211A@\247\204\225\211AA\262\202\231\211A\262A\262A\202\270\317\323!\203\363\324\311!\211\325M!\205\274\211;\205\274\326M\"\262\211\262\205\306\211J\262\206\314\327\311\224\311\225BB\fB\211@\211\211A@\247\204\347\211AA\262\202\353\211A\262A\262A\202\270\317\330!\203!\331\311\224\311\225BB\fB\211@\211\211A@\247\204\211AA\262\202\211A\262A\262A\202\270\317\332!\203\274E\2034BEW\203aBTB\333\311\224\311\225BB\fB\211@\211\211A@\247\204U\211AA\262\202Y\211A\262A\262A\202\270\334\311\224\212N\203wO\203w\335\336!\210`\202\230\3371\204\335\336!\210`0\202\230\210\334PF@FA#b\210`\211A\262)BB\fB\211@\211\211A@\247\204\260\211AA\262\202\264\211A\262A\262A\202\270\317\340!\203\357BSB\341\311\224\311\225BB\fB\211@\211\211A@\247\204\343\211AA\262\202\347\211A\262A\262A\202\270\317\342!\203O\343`\212N\203\nO\203\n\344\336!\210`\202+\3451\344\336!\210`0\202+\210\343PF@FA#b\210`\211A\262)BB\fB\211@\211\211A@\247\204C\211AA\262\202G\211A\262A\262A\202\270\317Q!\203\206`R\346\336!\210`R=\203m\347\350\351 \"\210\202tn\203t\352u\210`R=\203\312\353!\210`A)\202\270\317\354!\203\264\355\311\224\311\225BB\fB\211@\211\211A@\247\204\250\211AA\262\202\254\211A\262A\262A\202\270\312\356!\210A@=\203\310\312\357@\f@#\210A@Ab\210S\203\362\360 \204\354r\361T!q\210\212Tb\210\362 *\203\362\363S\364\"\210\f@U\205\306C\365\311\366\367\370!\371\"\372$\216\203\211\373!\240\210\374\375\376B#!)\262\266\202E+
\203b
\211A\242\211V\211W\203L\377\201XW@WA@#\210
\211A\242\211W\2044V@PF@FA#b\210`\211A\266*b\210\f\237.	\207" [semantic-lex-block-streams start end starting-position semantic-lex-token-stream semantic-lex-block-stack nil run-hook-with-args semantic-lex-reset-functions 0 error "semantic-emacs-lisp-lexer: end (%d) > point-max (%d)" syntax-table #[nil "rq\210\302	!)\207" [#1=#:buffer #2=#:table set-syntax-table] 2] set-syntax-table looking-at "\\s-+" "\\s-*\\(\n\\|\\s>\\)" number "\\(\\sw\\|\\s_\\)+" match-string obarrayp intern-soft symbol "\\s\\+" charquote "\\s(" open-paren semantic-list forward-list 1 (error) "\\s)" close-paren "\\s\"" string forward-sexp (error) forward-comment skip-syntax-forward "-.'" point-at-eol -1 "Strange comment syntax prevents lexical analysis" "\\(\\s.\\|\\s$\\|\\s'\\)" punctuation "Unmatched Text during Lexical Analysis" "semantic-emacs-lisp-lexer: endless loop at %d, after %S" input-pending-p marker-buffer accept-process-output throw lex make-byte-code "\300\242\205	\301\300\242!\207" vconcat vector [delete-overlay] 2 semantic-lex-highlight-token read-event format "%S :: Depth: %d :: SPC - continue" message tmp-start semantic-lex-end-point semantic-lex-current-depth depth semantic-lex-depth semantic-lex-maximum-depth semantic-lex-analysis-bounds parse-sexp-lookup-properties #1# #2# semantic-lex-syntax-table length semantic-lex-number-expression semantic-flex-keywords-obarray debug-on-error semantic-lex-debug-analyzers semantic-lex-unterminated-syntax-end-function semantic-lex-comment-regex comment-start-point semantic-current-input-throw-symbol semantic--on-input-start-marker semantic-lex-debug last blk "semantic-emacs-lisp-lexer: `%s' block from %S is unterminated"] 9 (#$ . 617)])
#@39 Top level bovination table for elisp.
(defvar semantic--elisp-parse-table (byte-code "\300\301\302DDC\207" [bovine-toplevel semantic-list #[(vals start end) "\304@!\211<\203C	@\30518	:\2054	@;\2054	A@9\2054	A@\2054\306	8<\2054\307	8<0\202:\210\310)\203C	\237\202\241	\211:\205\223	@\3111x	:\205t	@;\205t	A@9\205t	A@\205t\306	8<\205t\307	8<0\202z\210\310)\203\221\312	@\313	8)!\203\221	A\211\202K	?)\203\233	\202\241\314	\nD\")\207" [vals tag start end semantic-elisp-use-read (error) 2 3 nil (error) vectorp 4 append] 5]] 3) (#$ . 4470))
#@41 Convert symbols to strings for ARGLIST.
(defalias 'semantic-elisp-desymbolify #[(arglist) "\302	\2037	@9\203\303	@!\202-	@<\203(	@@9\203(\303	@@!\202-\304\305	@\"B	A\211\204\237)\207" [out arglist nil symbol-name format "%S"] 4 (#$ . 5045)])
#@41 Convert symbols to strings for ARGLIST.
(defalias 'semantic-elisp-desymbolify-args #[(arglist) "\305!\306\211\306\211\203#\f@\307\310\"\204	B\fA\211\204*	\237*\207" [arglist out in T --dolist-tail-- semantic-elisp-desymbolify nil string-match "^&"] 4 (#$ . 5307)])
#@43 For SLOT, a string representing PROPERTY.
(defalias 'semantic-elisp-clos-slot-property-string #[(slot property) "	\235\211\2051\nA\211@;\203\n@\2021\n@9\204(\n@<\204(\n@\247\2030\303\304\n@\"\2021\305)\207" [property slot p format "%S" nil] 4 (#$ . 5593)])
#@64 Convert a list of CLOS class slot PARTLIST to `variable' tags.
(defalias 'semantic-elisp-clos-args-to-semantic #[(partlist) "\306\211\211\203K@A\307	@!\310	\311\"\310	\312\"\313\310	\313\"\314\310	\315\"\316\232\317\310	\317\"\257\320\321\322\311\323
\f&,\211\nB\202\n\237+\207" [v part vars partlist attributes default-value nil symbol-name semantic-elisp-clos-slot-property-string :type :initform :protection :static-flag :allocation ":class" :documentation apply semantic-tag variable :default-value type name] 12 (#$ . 5867)])
#@199 After reading a form FORM, convert it to a doc string.
For Emacs Lisp, sometimes that string is non-existent.
Sometimes it is a form which is evaluated at compile time, permitting
compound strings.
(defalias 'semantic-elisp-form-to-doc-string #[(form) ";\203\207<\203@\301=\203A@;\203A@\207\302\207" [form concat nil] 2 (#$ . 6430)])
#@64 When non-nil, store documentation strings in the created tags.
(custom-declare-variable 'semantic-elisp-store-documentation-in-tag nil '(#$ . 6784) :type 'boolean :group 'semantic)
#@59 Return STR as a documentation string IF they are enabled.
(defalias 'semantic-elisp-do-doc #[(str) "\205\302	!\207" [semantic-elisp-store-documentation-in-tag str semantic-elisp-form-to-doc-string] 2 (#$ . 6971)])
#@417 Install the function PARSER as the form parser for SYMBOLS.
SYMBOLS is a list of symbols identifying the forms to parse.
PARSER is called on every forms whose first element (car FORM) is
found in SYMBOLS.  It is passed the parameters FORM, START, END,
where:

- FORM is an Elisp form read from the current buffer.
- START and END are the beginning and end location of the
  corresponding data in the current buffer.
(defalias 'semantic-elisp-setup-form-parser '(macro . #[(parser &rest symbols) "\303\304!\305\306	DD\307\310\311\nDFE)\207" [sym symbols parser make-symbol "sym" dolist quote put 'semantic-elisp-form-parser function] 7 (#$ . 7195)]))
(put 'semantic-elisp-setup-form-parser 'lisp-indent-function 1)
#@111 Reuse the form parser of SYMBOL for forms identified by SYMBOLS.
See also `semantic-elisp-setup-form-parser'.
(defalias 'semantic-elisp-reuse-form-parser '(macro . #[(symbol &rest symbols) "\304\305!\304\306!\307	\310\311\nD\312BBDC\313	\314\315\311\316\nDDEE\317\311DD\320\321	FEF*\207" [sym parser symbol symbols make-symbol "parser" "sym" let get quote ('semantic-elisp-form-parser) or signal 'wrong-type-argument semantic-elisp-form-parser dolist put 'semantic-elisp-form-parser] 9 (#$ . 7919)]))
#@70 Use `read' on the semantic list SL.
Return a bovination list to use.
(defalias 'semantic-elisp-use-read #[(sl) "@A\306\307	\n\"!\211@<\203(\310\311\211\312\313\314\315
\f&+\202[@\203E@9\203E@\316N\203E@\316N	\n#\202[\317\320@\"\311\211\312\313\314\315
\f&++\207" [sl start end form attributes detail read buffer-substring-no-properties "anonymous" nil apply semantic-tag code :detail semantic-elisp-form-parser format "%S" name] 8 (#$ . 8431)])
(byte-code "\306\307\211\203	@\310\311\312#\210	A\211\204*\313\307\211\2031	@\310\n\311\314#\210	A\211\204!*\315\307\211\203J	@\310\311\316#\210	A\211\204:*\317\307\211\203c	@\310\f\311\320#\210	A\211\204S*\321\307\211\203|	@\310
\311\322#\210	A\211\204l*\323\307+\211\203\230	@+\310+\311\324#\210	A\211\204\206*\325\307,\211\203\264	@,\310,\311\326#\210	A\211\204\242*\327\307-\211\203\320	@-\310-\311\330#\210	A\211\204\276*\331\307.\211\203\354	@.\310.\311\332#\210	A\211\204\332*\333\307/\211\203	@/\310/\311\334#\210	A\211\204\366*\335\3070\211\203$	@0\3100\311\336#\210	A\211\204*\337\3071\211\203@	@1\3101\311\340#\210	A\211\204.*\341\3072\211\203\\	@2\3102\311\342#\210	A\211\204J*\343\3073\211\203x	@3\3103\311\344#\210	A\211\204f*\345\3074\211\203\224	@4\3104\311\346#\210	A\211\204\202*\347\3075\211\203\260	@5\3105\311\350#\210	A\211\204\236*\351\3076\211\203\314	@6\3106\311\352#\210	A\211\204\272*\307\207" [#:sym --dolist-tail-- #:sym #:sym #:sym #:sym (semantic-elisp-setup-form-parser) nil put semantic-elisp-form-parser #[(form start end) "\305\3068!\307\310\311\312D\313\314\f\315\316\317\n	&,\207" [form attributes arg-list type name symbol-name 2 nil ("form" "start" "end") :form-parser t apply semantic-tag function :type :arguments] 9] (eval-and-compile eval-when-compile) #[(form start end) "\3061\307	\310\311$0\202\312\313\n\"\210)\310\211\242\3141E\f:\205A\f@;\205A\fA@9\205A\fA@\205A\315\f8<\205A\316\f8<0\202G\210\310)\203O\202i\317\320
@\"\310\211\321\322\323\324&+)\207" [start end foo tags tag form (error) semantic-parse-region nil 1 message "MUNGE: %S" (error) 2 3 format "%S" apply semantic-tag code :detail attributes detail name] 8] (defun defun* defsubst defmacro cl-defun cl-defsubst cl-defmacro define-overload define-overloadable-function) #[(form start end) "\305A@!\306\307\3108!\311\3128\242\313=\314\315\3168!\317@\320>\257\321\322\f\323\324\325\n	&,\207" [form attributes arg-list type name symbol-name nil semantic-elisp-desymbolify-args 2 :user-visible-flag 4 interactive :documentation semantic-elisp-do-doc 3 :overloadable (define-overload define-overloadable-function) apply semantic-tag function :type :arguments] 10] (defvar defconst defcustom) #[(form start end) "\306\3078!\310A@!\311\3128\313	\205 	G\314V\205 	\314H\315U\316@\317=\320\321	!\257\322\323
\324\325\f\326\n&-\207" [form doc attributes default-value type name semantic-elisp-form-to-doc-string 3 symbol-name nil 2 :user-visible-flag 0 42 :constant-flag defconst :documentation semantic-elisp-do-doc apply semantic-tag variable :type :default-value] 10] (defface) #[(form start end) "\306\3078!\310A@!\311\3128\313	\205 	G\314V\205 	\314H\315U\316\317	!F\320\321
\322\323\f\324\n&-\207" [form doc attributes default-value type name semantic-elisp-form-to-doc-string 3 symbol-name "face" 2 :user-visible-flag 0 42 :documentation semantic-elisp-do-doc apply semantic-tag variable :type :default-value] 9] (defimage defezimage) #[(form start end) "\306\3078!\310A@!\311\3128\313	\205 	G\314V\205 	\314H\315U\316\317	!F\320\321
\322\323\f\324\n&-\207" [form doc attributes default-value type name semantic-elisp-form-to-doc-string 3 symbol-name "image" 2 :user-visible-flag 0 42 :documentation semantic-elisp-do-doc apply semantic-tag variable :type :default-value] 9] (defgroup) #[(form start end) "\305\3068!\307A@!\310\311\3128\313\314\315\316	!\257\211\317\n!\320\211\257,\207" [form doc attributes class name semantic-elisp-form-to-doc-string 3 symbol-name customgroup :value 2 :user-visible-flag t :documentation semantic-elisp-do-doc semantic-tag-make-plist nil] 10] (autoload) #[(form start end) "\305A@A@!\306\211\307\3108\205\3108\306=?\311\312\313\314\3158!\257\316\317\f\320\321\322\n	&,\207" [form attributes arg-list type name symbol-name nil :user-visible-flag 4 :prototype-flag t :documentation semantic-elisp-do-doc 3 apply semantic-tag function :type :arguments] 11] (defmethod defgeneric) #[(form start end) "\3068\3078	<\203	\202\n	<\203\307\202\3108\311A@!\312@<\2039\311@@!\313A!B\202=\313A!\314@<\205J\311@A@!\315\316\f!F\317\320\321\322\323
&.\207" [form a2 a3 args doc attributes 2 3 4 symbol-name nil semantic-elisp-desymbolify-args :parent :documentation semantic-elisp-do-doc apply semantic-tag function :type :arguments arg-list type name] 9] (defadvice) #[(form start end) "\305A@!\306\307\3108!\306\311\312\f\313\314\315\n	&,\207" [form attributes arg-list type name symbol-name nil semantic-elisp-desymbolify 2 apply semantic-tag function :type :arguments] 9] (defclass) #[(form start end) "\306\233\307A@!\310\311\3128!\313\3148!\315\313	@;?\205	!\316\317	@;\203,	@\2021\316	>A@!F\320\321\305\322
\323\f\324@\325A\n&\f.\207" [form docpart attributes parents members type 4 symbol-name "class" semantic-elisp-clos-args-to-semantic 3 semantic-elisp-desymbolify 2 :typemodifiers :documentation semantic-elisp-do-doc apply semantic-tag :type :members :superclasses :interfaces name] 13] (defstruct cl-defstruct) #[(form start end) "AA\211@;\203
	A\306A@:\203A@@\202A@!\307\310	!\311\211B\311\312\313\305\314
\315\f\316@\317A\n&\f.\207" [form slots attributes parents members type symbol-name "struct" semantic-elisp-desymbolify nil apply semantic-tag :type :members :superclasses :interfaces name] 14] (define-lex) #[(form start end) "\305A@!\306\211\307\310\311\312\3138!F\314\315\f\316\317\320\n	&,\207" [form attributes arg-list type name symbol-name nil :lexical-analyzer-flag t :documentation semantic-elisp-do-doc 2 apply semantic-tag function :type :arguments] 9] (define-mode-overload-implementation define-mode-local-override) #[(form start end) "\3068\307A@!\310	<\205\311	!\312\313\314\307\3158!\316\317\3208!\257\321\322
\323\324\f\325\n&-\207" [form args attributes arg-list type name 3 symbol-name nil semantic-elisp-desymbolify :override-function-flag t :parent 2 :documentation semantic-elisp-do-doc 4 apply semantic-tag function :type :arguments] 11] (defvar-mode-local) #[(form start end) "\305\3068!\307\3108\311\312\313\305A@!\314\315\3168!\257\317\320\f\321\322\323\n	&,\207" [form attributes default-value type name symbol-name 2 nil 3 :override-variable-flag t :parent :documentation semantic-elisp-do-doc 4 apply semantic-tag variable :type :default-value] 11] (require) #[(form start end) "A@\304	\242\305=\203	A@\202	!\306\307\3108D\311\312	\313\314\n&,\207" [form name attributes system-flag symbol-name quote nil :directory 2 apply semantic-tag include :system-flag] 7] (provide) #[(form start end) "A@\304	\242\305=\203	A@\202	!\3068\307\310\311	\312\313\n&,\207" [form name attributes detail symbol-name quote 3 nil apply semantic-tag package :detail] 7] #:sym #:sym #:sym #:sym #:sym #:sym #:sym #:sym #:sym #:sym #:sym #:sym] 5)
#@120 Find the file BUFFER depends on described by TAG.

Override semantic-dependency-tag-file in `emacs-lisp-mode' buffers.
(defalias 'semantic-dependency-tag-file-emacs-lisp-mode #[(tag) "\304\305!\203\3061\305\211@)!0\207\210\307\310\211@)\"\207\311\211@)!\211\205,\312	!\211\313P\n\203?\314!\203?\202_\n\203Q\314\n\315P!\203Q\n\315P\202_\n\203^\307\310\n\313P\"\202_\316+\207" [tag lib name nameel fboundp find-library-name (error) message "semantic: cannot find source file %s" locate-library file-name-sans-extension ".el" file-exists-p ".el.gz" nil] 5 (#$ . 15996)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-dependency-tag-file-emacs-lisp-mode definition-name semantic-dependency-tag-file mode-local-bind ((semantic-dependency-tag-file . semantic-dependency-tag-file-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@170 Return the documentation string generated for overloadable functions.
Fetch the item for TAG.  Only returns info about what symbols can be
used to perform the override.
(defalias 'semantic-emacs-lisp-overridable-doc #[(tag) "\211A@)\302=\203&\303\304\3058)	\"*\203&\306\307\211@)!!\207\310\207" [tag attribute function :overloadable plist-get 2 mode-local--overload-docstring-extension intern ""] 4 (#$ . 16880)])
#@163 Indicate that TAG is a new name that has obsoleted some old name.
Unfortunately, this requires that the tag in question has been loaded
into Emacs Lisp's memory.
(defalias 'semantic-emacs-lisp-obsoleted-doc #[(tag) "\303\211@)!\304\211\205#\305\306!\210	\203\"\307\310	\211@)#\202#\311*\207" [tag obsoleter obsoletethis intern-soft nil mapatoms #[(a) "\304N\211\205	@\n=\205\211)\207" [a oi obsoletethis obsoleter byte-obsolete-info] 3] format "\n@obsolete{%s,%s}" ""] 5 (#$ . 17313)])
#@151 Return the documentation string for TAG.
Optional argument NOSNARF is ignored.

Override semantic-documentation-for-tag in `emacs-lisp-mode' buffers.
(defalias 'semantic-documentation-for-tag-emacs-lisp-mode #[(tag &optional nosnarf) "\305!\211\204\242\306!\203p\307r\310!q\210\211\3118)\312!\203+\313!\202.\314H*b\210\315\211\3118)\312!\203G\313!\202J\314H*\211\3118)\312!\203`\316!\202c\317H*B!)\305!)\202\242\320\211@)!\203\242\320\211@)!\211A@)\321=\203\224\322\f!\202\231\323\f\324\")	\203\242\325	P	\205\306\326	G\314V\203\275	\314H\327U\203\275\330	\317\"\202\276	!\331!\332!Q)\207" [tag d semantic-elisp-store-documentation-in-tag o sym semantic-tag-docstring semantic-tag-with-position-p t semantic-tag-buffer 4 overlayp overlay-start 0 semantic-elisp-use-read overlay-end 1 intern-soft function documentation documentation-property variable-documentation "System Doc: \n" substitute-command-keys 42 substring semantic-emacs-lisp-overridable-doc semantic-emacs-lisp-obsoleted-doc] 5 (#$ . 17823)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-documentation-for-tag-emacs-lisp-mode definition-name semantic-documentation-for-tag mode-local-bind ((semantic-documentation-for-tag . semantic-documentation-for-tag-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@163 Return the name of the tag with .el appended.
If there is a detail, prepend that directory.

Override semantic-tag-include-filename in `emacs-lisp-mode' buffers.
(defalias 'semantic-tag-include-filename-emacs-lisp-mode #[(tag) "\211@)\304\305\3068)	\"*\307\n\"\310P*\207" [tag attribute detail name :directory plist-get 2 expand-file-name ".el"] 5 (#$ . 19191)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-tag-include-filename-emacs-lisp-mode definition-name semantic-tag-include-filename mode-local-bind ((semantic-tag-include-filename . semantic-tag-include-filename-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@144 Insert TAG at point.
Attempts a simple prototype for calling or using TAG.

Override semantic-insert-foreign-tag in `emacs-lisp-mode' buffers.
(defalias 'semantic-insert-foreign-tag-emacs-lisp-mode #[(tag) "\302\211\211A@)	*=\203\303\211@)\304\261\210\305u\207\211@)c\207" [tag class function "(" " )" -1] 4 (#$ . 19861)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-insert-foreign-tag-emacs-lisp-mode definition-name semantic-insert-foreign-tag mode-local-bind ((semantic-insert-foreign-tag . semantic-insert-foreign-tag-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@154 Return the protection of TAG in PARENT.
Override function for `semantic-tag-protection'.

Override semantic-tag-protection in `emacs-lisp-mode' buffers.
(defalias 'semantic-tag-protection-emacs-lisp-mode #[(tag &optional parent) "\304\305\3068)	\"*\211\204\203\307\202T\n\310\230\203%\307\202T\n\311\230\203/\307\202T\n\312\230\2039\313\202T\n\314\230\203C\313\202T\n\315\230\203M\316\202T\n\317\230\205T\316)\207" [tag attribute prot parent :protection plist-get 2 public ":public" "public" ":private" private "private" ":protected" protected "protected"] 4 (#$ . 20483)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-tag-protection-emacs-lisp-mode definition-name semantic-tag-protection mode-local-bind ((semantic-tag-protection . semantic-tag-protection-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@153 Return non-nil if TAG is static in PARENT class.
Overrides `semantic-nonterminal-static'.

Override semantic-tag-static-p in `emacs-lisp-mode' buffers.
(defalias 'semantic-tag-static-p-emacs-lisp-mode #[(tag &optional parent) "\302\303\3048)	\"*\207" [tag attribute :static-flag plist-get 2] 3 (#$ . 21353)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-tag-static-p-emacs-lisp-mode definition-name semantic-tag-static-p mode-local-bind ((semantic-tag-static-p . semantic-tag-static-p-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@374 Move up one context in an Emacs Lisp function.
A Context in many languages is a block with its own local variables.
In Emacs, we will move up lists and stop when one starts with one of
the following context specifiers:
  `let', `let*', `defun', `with-slots'
Returns non-nil it is not possible to go up a context.

Override semantic-up-context in `emacs-lisp-mode' buffers.
(defalias 'semantic-up-context-emacs-lisp-mode #[(&optional point bounds-type) "\301 \302\303!\204\204\301 \202)\207" [last-up semantic-up-context-default looking-at "(\\(let\\*?\\|\\(?:cl-\\)?def\\(un\\|method\\|generic\\|define-mode-overload\\)\\|with-slots\\)"] 2 (#$ . 21932)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-up-context-emacs-lisp-mode definition-name semantic-up-context mode-local-bind ((semantic-up-context . semantic-up-context-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@132 Return a string which is the current function being called.

Override semantic-ctxt-current-function in `emacs-lisp-mode' buffers.
(defalias 'semantic-ctxt-current-function-emacs-lisp-mode #[(&optional point same-as-symbol-return) "\212\203b\210\202
`\3031*\212\304\305!\210\306\307!)\205&\212\304\310!\210\306\311!)0\202,\210\312?\205x\3131I\212\304\314!\210\315u\210\316`\317\315!\210`\")0\202K\210\312\211\205w\212\3201k\317\314!\210\306\321	!!\205g`	G\\X0\202m\210\322)\203u\n\202w	C))\207" [point fun same-as-symbol-return (error) up-list -2 looking-at "((" -3 "(let" nil (error) -1 1 buffer-substring-no-properties forward-sexp (error) regexp-quote t] 5 (#$ . 22853)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-ctxt-current-function-emacs-lisp-mode definition-name semantic-ctxt-current-function mode-local-bind ((semantic-ctxt-current-function . semantic-ctxt-current-function-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@237 Return a list of local variables for POINT.
Scan backwards from point at each successive function.  For all occurrences
of `let' or `let*', grab those variable names.

Override semantic-get-local-variables in `emacs-lisp-mode' buffers.
(defalias 'semantic-get-local-variables-emacs-lisp-mode #[(&optional point) "\306\211\212\307`\310C\"@\211\203\325	\311\267\202q\202\316\312\313!\210\314u\210\315\314!\210\316\306w\210\317\320`\212\321\314!\210`)\"!\211\203m\n@\2119\203E\202G@\322\f!\306\211\211\323\324\f\325\326\327
&,B*\nA\211\2049)\202\316	\330\230\203\316\312\313!\210\314u\210\331\314!\210\316\306w\210\317\320`\212\321\314!\210`)\"!\211\203\315@\322\f!\332H\333U\204\303\322\f!\306\211\211\323\324\f\325\326\327
&,B)A\211\204\230)\312\313!\210\202)\237*\207" [vars fn varlst oneelt name attributes nil semantic-ctxt-current-function-emacs-lisp-mode t #s(hash-table size 4 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (t 22 "let" 25 "let*" 25 "with-slots" 25)) up-list -1 1 forward-symbol "* 	\n" read buffer-substring-no-properties forward-sexp symbol-name apply semantic-tag variable :type :default-value "lambda" forward-word-strictly 0 38 default-value type arglst] 10 (#$ . 23848)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-get-local-variables-emacs-lisp-mode definition-name semantic-get-local-variables mode-local-bind ((semantic-get-local-variables . semantic-get-local-variables-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@174 Move cursor to the end of the current command.
In Emacs Lisp this is easily defined by parenthesis bounding.

Override semantic-end-of-command in `emacs-lisp-mode' buffers.
(defalias 'semantic-end-of-command-emacs-lisp-mode #[nil "\3001	\301\302!0\207\210\303\207" [(error) up-list 1 nil] 2 (#$ . 25418)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-end-of-command-emacs-lisp-mode definition-name semantic-end-of-command mode-local-bind ((semantic-end-of-command . semantic-end-of-command-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@186 Move cursor to the beginning of the current command.
In Emacs Lisp this is easily defined by parenthesis bounding.

Override semantic-beginning-of-command in `emacs-lisp-mode' buffers.
(defalias 'semantic-beginning-of-command-emacs-lisp-mode #[nil "\3001\f\301\302!\210\303u0\207\210\304\207" [(error) up-list -1 1 nil] 2 (#$ . 25997)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-beginning-of-command-emacs-lisp-mode definition-name semantic-beginning-of-command mode-local-bind ((semantic-beginning-of-command . semantic-beginning-of-command-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@99 List the symbol under point.

Override semantic-ctxt-current-symbol in `emacs-lisp-mode' buffers.
(defalias 'semantic-ctxt-current-symbol-emacs-lisp-mode #[(&optional point) "\212\203b\210\302\303!\210\304\305!\211\205	C*\207" [point sym require thingatpt thing-at-point symbol] 3 (#$ . 26630)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-ctxt-current-symbol-emacs-lisp-mode definition-name semantic-ctxt-current-symbol mode-local-bind ((semantic-ctxt-current-symbol . semantic-ctxt-current-symbol-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@125 What is the variable being assigned into at POINT?

Override semantic-ctxt-current-assignment in `emacs-lisp-mode' buffers.
(defalias 'semantic-ctxt-current-assignment-emacs-lisp-mode #[(&optional point) "\212\203b\210\305!`\211\203	@	\203p	\306\230\204%	\307\230\203p\212\3101j\311\312\211\313\314!\210\315\316!\210\317\316!\210`W\203_\fT\320\316!\210`\317\316!\210\f\321\246\316U\203<\322\n`\"\202<\205eC+0\202l\210\312)\202\237\3231\215\212\313\324!\210\325\326!)\205\211\212\313\327!\210\325\330!)0\202\221\210\202\236\203\236\212\331 \210\332 )\202\237\312+\207" [point fn start lastodd count semantic-ctxt-current-function "setq" "set" (error) 0 nil up-list -1 down-list 1 forward-sexp forward-comment 2 buffer-substring-no-properties (error) -2 looking-at "((" -3 "(let" semantic-beginning-of-command semantic-ctxt-current-symbol] 4 (#$ . 27225)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-ctxt-current-assignment-emacs-lisp-mode definition-name semantic-ctxt-current-assignment mode-local-bind ((semantic-ctxt-current-assignment . semantic-ctxt-current-assignment-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@133 Return the index into the argument the cursor is in, or nil.

Override semantic-ctxt-current-argument in `emacs-lisp-mode' buffers.
(defalias 'semantic-ctxt-current-argument-emacs-lisp-mode #[(&optional point) "\212\203b\210\302\303!\203\304u\210\305\3061 \307\310!\210\3110\202$\210\202-\203-	T\202	\305U\2037\305\2029	S*\207" [point count looking-at "\\<\\w" 1 0 (error) forward-sexp -1 t] 2 (#$ . 28423)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-ctxt-current-argument-emacs-lisp-mode definition-name semantic-ctxt-current-argument mode-local-bind ((semantic-ctxt-current-argument . semantic-ctxt-current-argument-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@387 Return a list of tag classes allowed at POINT.
Emacs Lisp knows much more about the class of the tag needed to perform
completion than some languages.  We distinctly know if we are to be a
function name, variable name, or any type of symbol.  We could identify
fields and such to, but that is for some other day.

Override semantic-ctxt-current-class-list in `emacs-lisp-mode' buffers.
(defalias 'semantic-ctxt-current-class-list-emacs-lisp-mode #[(&optional point) "\212\203b\210`\30217\303\304\305!\210\306u\210`W\203'	T\307\306!\210\202	\306U\2031\310\2022\311)0\2029\210\312)\207" [point count (error) 0 up-list -1 1 forward-sexp (function) (variable) (variable)] 2 (#$ . 29148)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-ctxt-current-class-list-emacs-lisp-mode definition-name semantic-ctxt-current-class-list mode-local-bind ((semantic-ctxt-current-class-list . semantic-ctxt-current-class-list-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@117 Return an abbreviated string describing tag.

Override semantic-format-tag-abbreviate in `emacs-lisp-mode' buffers.
(defalias 'semantic-format-tag-abbreviate-emacs-lisp-mode #[(tag &optional parent color) "\211A@)\305	\n#\211\306=\203\307\310Q\202\311	\n#*\207" [tag parent color name class semantic-format-tag-name function "(" ")" semantic-format-tag-abbreviate-default] 6 (#$ . 30156)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-format-tag-abbreviate-emacs-lisp-mode definition-name semantic-format-tag-abbreviate mode-local-bind ((semantic-format-tag-abbreviate . semantic-format-tag-abbreviate-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@364 Return a prototype string describing tag.
In Emacs Lisp, a prototype for something may start (autoload ...).
This is certainly not expected if this is used to display a summary.
Make up something else.  When we go to write something that needs
a real Emacs Lisp prototype, we can fix it then.

Override semantic-format-tag-prototype in `emacs-lisp-mode' buffers.
(defalias 'semantic-format-tag-prototype-emacs-lisp-mode #[(tag &optional parent color) "\211A@)\306	\n#\211\307=\203B\211\310\311\3128)
\"+\313\314\n#\315\2038\316\2029\317\320\260*\202G\321	\n#*\207" [tag parent color name class attribute semantic-format-tag-name function :arguments plist-get 2 semantic--format-tag-arguments identity "(" " " "" ")" semantic-format-tag-prototype-default args argstr] 6 (#$ . 30857)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-format-tag-prototype-emacs-lisp-mode definition-name semantic-format-tag-prototype mode-local-bind ((semantic-format-tag-prototype . semantic-format-tag-prototype-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@198 Return a concise prototype string describing tag.
See `semantic-format-tag-prototype' for Emacs Lisp for more details.

Override semantic-format-tag-concise-prototype in `emacs-lisp-mode' buffers.
(defalias 'semantic-format-tag-concise-prototype-emacs-lisp-mode #[(tag &optional parent color) "\303	\n#\207" [tag parent color semantic-format-tag-prototype] 4 (#$ . 31966)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-format-tag-concise-prototype-emacs-lisp-mode definition-name semantic-format-tag-concise-prototype mode-local-bind ((semantic-format-tag-concise-prototype . semantic-format-tag-concise-prototype-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@190 Return a uml prototype string describing tag.
See `semantic-format-tag-prototype' for Emacs Lisp for more details.

Override semantic-format-tag-uml-prototype in `emacs-lisp-mode' buffers.
(defalias 'semantic-format-tag-uml-prototype-emacs-lisp-mode #[(tag &optional parent color) "\303	\n#\207" [tag parent color semantic-format-tag-prototype] 4 (#$ . 32669)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-format-tag-uml-prototype-emacs-lisp-mode definition-name semantic-format-tag-uml-prototype mode-local-bind ((semantic-format-tag-uml-prototype . semantic-format-tag-uml-prototype-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode] 4)
#@120 Insert TAG into the current buffer based on completion.

Override semantic-ia-insert-tag in `emacs-lisp-mode' buffers.
(defalias 'semantic-ia-insert-tag-emacs-lisp-mode #[(tag) "\211@)c\210\211A@)\211\304\305\3068)	\"+\211\307=\2033\n\203.\310c\2024\311c\2024\312*\207" [tag attribute args tt :arguments plist-get 2 function " " ")" nil] 5 (#$ . 33344)])
(byte-code "\306\307\310\311#\210\312\313\314\315#\210\316\312\317BC\320\315#\210\321\322\315\"\210)\306\317\315\323!\324\204<	\211\262\204<\n\262\205:\325\"\262\203g\211\204g\303N\203V\325\303N\"\211\262\204<\211\326N\206`\211\327N\262\262\202<\266\203\330\324#\210\f\312\331
BC\320\315#\210\321\332\315\"\210)\306\331\315\323!\324\204\235	\211\262\204\235\n\262\205\233\325\"\262\203\310\211\204\310\303N\203\267\325\303N\"\211\262\204\235\211\326N\206\301\211\327N\262\262\202\235\266\203\330\324#\210\333,\312\334,BC\320\315#\210\321\335\315\"\210)\306\334\315\323!\324\204	\211\262\204\n\262\205\376\325\"\262\203+\211\204+\303N\203\325\303N\"\211\262\204\211\326N\206$\211\327N\262\262\202\266\203\330\324#\210\333-\312\336-BC\320\315#\210\321\337\315\"\210)\306\336\315\323!\324\204c	\211\262\204c\n\262\205a\325\"\262\203\216\211\204\216\303N\203}\325\303N\"\211\262\204c\211\326N\206\207\211\327N\262\262\202c\266\203\330\324#\210\340.\312\341.BC\320\315#\210\321\342\315\"\210)\306\341\315\323!\324\204\306	\211\262\204\306\n\262\205\304\325\"\262\203\361\211\204\361\303N\203\340\325\303N\"\211\262\204\306\211\326N\206\352\211\327N\262\262\202\306\266\203\330\324#\210\343/\312\344/BC\320\315#\210\321\345\315\"\210)\306\344\315\323!\324\204)	\211\262\204)\n\262\205'\325\"\262\203T\211\204T\303N\203C\325\303N\"\211\262\204)\211\326N\206M\211\327N\262\262\202)\266\203\330\324#\210\3460\312\3470BC\320\315#\210\321\350\315\"\210)\306\347\315\323!\324\204\214	\211\262\204\214\n\262\205\212\325\"\262\203\267\211\204\267\303N\203\246\325\303N\"\211\262\204\214\211\326N\206\260\211\327N\262\262\202\214\266\203\330\351#\210\352\315\306\326#\210\321\353\"\207" [#1=#:tmp0 mode-local-active-mode major-mode mode-local-symbol-table semantic--elisp-parse-table #2=#:tmp0 put semantic-ia-insert-tag-emacs-lisp-mode definition-name semantic-ia-insert-tag mode-local-bind ((semantic-ia-insert-tag . semantic-ia-insert-tag-emacs-lisp-mode)) (override-flag t) emacs-lisp-mode semantic-emacs-lisp-lexer semantic-lex-analyzer (mode-variable-flag t) mode-local-map-mode-buffers #[nil "\302\301!\210\211\207" [#1# semantic-lex-analyzer make-local-variable] 2] symbol-name nil intern-soft mode-local-parent derived-mode-parent variable-documentation semantic--parse-table #[nil "\302\301!\210\211\207" [#2# semantic--parse-table make-local-variable] 2] " " semantic-function-argument-separator #[nil "\302\301!\210\211\207" [#3=#:tmp0 semantic-function-argument-separator make-local-variable] 2] semantic-function-argument-separation-character #[nil "\302\301!\210\211\207" [#4=#:tmp0 semantic-function-argument-separation-character make-local-variable] 2] ((type . "Types") (variable . "Variables") (function . "Defuns") (include . "Requires") (package . "Provides")) semantic-symbol->name-assoc-list #[nil "\302\301!\210\211\207" [#5=#:tmp0 semantic-symbol->name-assoc-list make-local-variable] 2] semantic-create-imenu-index imenu-create-index-function #[nil "\302\301!\210\211\207" [#6=#:tmp0 imenu-create-index-function make-local-variable] 2] (function type variable) semantic-stickyfunc-sticky-classes #[nil "\302\301!\210\211\207" [#7=#:tmp0 semantic-stickyfunc-sticky-classes make-local-variable] 2] "Add variables.\nELisp variables can be pretty long, so track this one too." lisp-mode mode-local--activate-bindings #3# #4# #5# #6# #7#] 9)
#@56 Setup hook function for Emacs Lisp files and Semantic.
(defalias 'semantic-default-elisp-setup #[nil "\300\207" ["Setup hook function for Emacs Lisp files and Semantic."] 1 (#$ . 37280)])
(byte-code "\300\301\302\"\210\300\303\302\"\210\304\305\306\"\210\307\310!\207" [add-hook emacs-lisp-mode-hook semantic-default-elisp-setup lisp-mode-hook eval-after-load "semantic/db" #[nil "\300\301!\207" [require semantic/db-el] 2] provide semantic/bovine/el] 3)
Zerion Mini Shell 1.0