.emacs.d.git - Gitblit

;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.
 
;;; This file contains utf-8 non-ASCII characters,
;;; and so cannot be loaded into Emacs 22 or earlier.
(and (boundp 'emacs-version)
     (< (aref emacs-version (1- (length emacs-version))) ?A)
     (string-lessp emacs-version "23")
     (error "`%s' was compiled for Emacs 23 or later" #$))
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
(byte-code "\301\302!\210\301\303!\210\301\304!\210\301\305!\210\301\306!\210\301\307!\210\301\310!\210\301\311!\210\301\312!\210\313\314\"\2042\301\315!\210\202A\316\317\320\"\210\316\321\322\"\210\316\323\324\"\210\313\325\"\203M\316\326\327\"\210\301\207" [emacs-version require cl-lib cc-mode semantic semantic/tag-ls semantic/bovine/c semantic/format semantic/doc srecode/semantic srefactor-ui version< "24.4" subr-x defalias string-empty-p #[(string) "\301\230\207" [string #1=""] 2 "Check whether STRING is empty."] string-trim-left #[(string) "\301\302\"\203\303\304\305\211$\207\207" [string string-match "\\`[     \n ]+" replace-match #1# t] 5 "Remove leading whitespace from STRING."] string-trim-right #[(string) "\301\302\"\203\303\304\305\211$\207\207" [string string-match "[     \n ]+\\'" replace-match #1# t] 5 "Remove trailing whitespace from STRING."] "25" semantic-documentation-comment-preceding-tag semantic-documentation-comment-preceeding-tag] 3)
#@33 Current local variable at point
(defvar srefactor--current-local-var nil (#$ . 1389))
(byte-code "\300\301\302\303\304\305%\210\300\306\307\303\304\305%\210\300\310\311\312\304\305%\210\300\313\314\315\304\305\316\317&\207" [custom-declare-variable srefactor--getter-prefix "get_" "Prefix for inserting getter." :group srefactor srefactor--setter-prefix "set_" srefactor--getter-setter-removal-prefix "" "Prefix for removing getter and setter." srefactor--getter-setter-capitalize-p nil "Whether getter and setter should be capitalized." :type boolean] 8)
#@41 Use experimental SRecode tag insertion 
(defvar srefactor-use-srecode-p nil (#$ . 1952))
(defalias 'srefactor--is-proto '(macro . #[(type) "\301\302BB\207" [type eq ('gen-func-proto)] 3]))
(defalias 'srefactor--add-menu-item '(macro . #[(label operation-type file-options) "\303\304\305\306    D\nFE\207" [label operation-type file-options add-to-list 'menu-item-list list quote] 6]))
#@146 Offer contextual menu with actions based on current tag in scope.
 
Each menu item added returns a token for what type of refactoring
to perform.
(defalias 'srefactor-refactor-at-point #[nil "\306\307 \310\311!\312 \313\314\315\316#\317\320 5\321!\2035\322\323\nE\2116 \235\203/ \210\20246 B)\324!\203R\325\326\nE\2117 \235\203L \210\202Q7 B)\327!\203o\330\331\nE\2118 \235\203i \210\202n8 B)\332!\203\214\333\334\nE\2119 \235\203\206 \210\202\2139 B)\335!\203\327\336\337\nE\211: \235\203\243 \210\202\250: B)\340\341\nE\211; \235\203\272 \210\202\277; B)\342\343\nE\211< \235\203\321 \210\202\326< B)5\203\3665\344\345\346E\211= \235\203\360 \210\202\365= B)\347 \203\350\351\nE\211> \235\203\f \210\202> B)\352 \203.\353\354\317E\211? \235\203( \210\202-? B)\355\f\356 #\210\355\f\357\360#\210\355\f\361#\210\355\f\362\363#\210\364\f!.\207" [semanticdb-find-default-throttle refresh srefactor--file-options tag menu menu-item-list (file) semantic-parse-changes-default srefactor-ui--return-option-list file srefactor--copy-tag make-instance srefactor-ui-menu :name "menu" nil srefactor--menu-add-rename-local-p srefactor--menu-add-function-implementation-p "Generate Function Implementation (Other file)" gen-func-impl srefactor--menu-add-function-proto-p "Generate Function Prototype (Other file)" gen-func-proto srefactor--menu-add-function-pointer-p "Generate Function Pointer (Current file)" gen-func-ptr srefactor--menu-add-getters-setters-p "Generate Getters and Setters (Current file)" gen-getters-setters srefactor--menu-add-getter-setter-p "Generate Setter (Current file)" gen-setter "Generate Getter (Current file)" gen-getter "Generate Getter and Setter (Current file)" gen-getter-setter "Rename local variable (Current file)" rename-local-var ("(Current file)") srefactor--menu-add-move-p "Move (Current file)" move region-active-p "Extract function (Current file)" extract-function eieio-oset :items :action srefactor-ui--refactor-action :context :shortcut-p t srefactor-ui-create-menu srefactor--current-local-var #1=#:x #2=#:x #3=#:x #4=#:x #5=#:x #6=#:x #7=#:x #8=#:x #9=#:x #10=#:x] 5 (#$ . 2343) nil])
#@287 Filter TAGS based on PREDICATE that satisfies TAG-CLASSES-OR-NAMES.
 
TAG-CLASSES-OR-NAMES can be a list of Semantic tag classes, or a
list of Semantic tag names, but not both.
 
Based on the type of list passed above, either use
`semantic-tag-class' or `semantic-tag-name' as PREDICATE.
(defalias 'srefactor--tag-filter #[(predicate tag-classes-or-names tags) "\306    \306\211\203 @\f\n! \235\203\nBA\211\204\n\306+\207" [l tags tag --dolist-tail-- predicate tag-classes-or-names nil] 3 (#$ . 4549)])
(defalias 'srefactor--c-tag-start-with-comment #[(tag) "\212\211\3028)\303    !\203\304    !\202    \305H*b\210\306\307\310\311#\2037\312!\2037\313\314!\2037\315 \210`\202P\211\3028)\303    !\203L\304    !\202O    \305H*)\207" [tag o 4 semantic-overlay-p semantic-overlay-start 0 search-backward-regexp "/\\*" nil t semantic-documentation-comment-preceding-tag looking-at "^[ ]*\\/\\*" beginning-of-line] 5])
#@53 Take the current tag, and place it in the tag ring.
(defalias 'srefactor--copy-tag #[nil "\304 \210\305 \211\203n\306    \"\210\307\310!\211\311\n8)\312!\203)\313!\202,\314H*#\210\315\211\311\n8)\312!\203E\316!\202H\317H*\211\311\n8)\312!\203^\313!\202a\314H*\"\210\320\321!\203n\322\323!\210)\207" [ft senator-tag-ring tag o semantic-fetch-tags semantic-current-tag ring-insert semantic-tag-set-bounds srefactor--c-tag-start-with-comment 4 semantic-overlay-p semantic-overlay-end 1 kill-ring-save semantic-overlay-start 0 called-interactively-p interactive message "Use C-y to yank text.  Use `senator-yank-tag' for prototype insert."] 6 (#$ . 5480)])
#@166 Refactor based on current tag in context.
 
OPERATION is a refactoring type user selected from the menu.
FILE-OPTION is a file destination associated with OPERATION.
(defalias 'srefactor--refactor-based-on-tag-class #[(operation &optional file-option) "\306 \211\211A@)\211\307\267\202R\310\267\202\232\311\312!\202S\313 \314 \211\211\315    8)-\316-!\203:\317-!\202>-\320H*. \211\315    8)-\316-!\203Y\321-!\202]-\322H*/\3230\324\216\3251\223\326\f./#1\327\f1\330$\210\331\332\f\211@)\"0\333\f1\3340!$)0\202\225\210\323.\202S\3352!3\336\3373!\340$)\202S\341\267\202\322\3422\"\210\343\344!\202S\3352!3\336\3373!\340$)\202S\345\337\3352!!\"\202S\346\267\202<\337\3352!!4\347\340\2114$\210)\343\344!\202S\337\3352!!4\347\340\3234$\210)\343\350!\202S\337\3352!!4\347\323\3404$\210)\343\351!\202S\3352!3\336\3373!\340$)\202S\323\202S\343\352!\202S\343\353!\202S\343\354!\202S\340*\207" [refactor-tag tag class operation local-var function-tag srefactor--copy-tag #s(hash-table size 6 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (function 16 type 173 variable 222 package 320 include 326 label 332)) #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (extract-function 22 rename-local-var 28)) srefactor--extract-region function srefactor--tag-at-point semantic-current-tag 4 semantic-overlay-p semantic-overlay-start 0 semantic-overlay-end 1 nil #[nil "\300 \207" [remove-overlays] 1] (error) srefactor--collect-tag-occurrences srefactor--highlight-tag match format "Replace (%s) with: " srefactor--rename-local-var read-from-minibuffer srefactor--select-file srefactor--refactor-tag srefactor--contextual-open-file t #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (gen-getters-setters 179 move 191)) srefactor-insert-class-getters-setters message "Getter and setter generated." srefactor--refactor-type #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (gen-getter-setter 228 gen-getter 251 gen-setter 274 move 297)) srefactor--variable-insert-getter-setter "Getter generated." "Setter generated." "FIXME: 'package refactoring is not yet implemented." "FIXME: 'include refactoring is not yet implemented." "FIXME: 'label refactoring is not yet implemented." o search-start search-end prompt tag-occurrences file-option other-file buffer] 7 (#$ . 6171)])
#@51 Return a file based on OPTION selected by a user.
(defalias 'srefactor--select-file #[(option) "\305\306\211\211\307\310!\203l\311\312\313\314$\203l\f\315\230\203W\3161O\317\320 \321 \306#\211G\322 \323V\203;\324\325\n\"\202H\323U\203F\n@\202H\326 P\2110\202S\210\202l\210\202l\f\327\230\203l\307\310!\203l\322 \324\325\321 \"P\f\330\230\203v\320p!\f\331\230\203\207r\332\333!q\210\320p!)    ,\207" [l file other-files projectile-func-list option (projectile-get-other-files projectile-current-project-files projectile-project-root projectile-find-file) nil featurep projectile cl-reduce #[(acc f) "\302!\205    \207" [f acc fboundp] 2] :initial-value t "(Other file)" (error) projectile-get-other-files buffer-file-name projectile-current-project-files projectile-project-root 1 completing-read "Select a file: " projectile-find-file "(Project file)" "(Current file)" "(File)" call-interactively find-file-other-window] 6 (#$ . 8638)])
#@30 Move to a tag when executed.
(defalias 'srefactor--tag-persistent-action #[nil "\306 \210\203\307!\210\310\211\212\311\312\313 \314#\203!\315`\316\"\202&\315`\316\")\n\205\303\317\n!<\205\303\317\n!@\3201b    :\205^    @;\205^    A@9\205^    A@\205^\321    8<\205^\322    8<0\202d\210\310)\205\303\323!r\324\216\325\f@\326\"\210\317\n!@\317\n!@\205\302\327    !\210\330    \211\331    8)\332 !\203\233\333 !\202\236 \334H*    \211\331    8)\332 !\203\264\335 !\202\267 \336H*\"\211\337 \340\341#)+*\207" [srefactor-ui--current-active-tag-overlay tag link srefactor-ui--current-active-window save-selected-window--state o back-to-indentation delete-overlay nil search-forward ":" line-end-position t get-pos-property button widget-value (error) 2 3 internal--before-with-selected-window #[nil "\301!\207" [save-selected-window--state internal--after-with-selected-window] 2] select-window norecord semantic-go-to-tag make-overlay 4 semantic-overlay-p semantic-overlay-start 0 semantic-overlay-end 1 overlay-put face region] 5 (#$ . 9606)])
#@267 Refactor a tag.
 
BUFFER is a buffer from opening selected file chosen from the menu.
 
REFACTOR-TAG is selected tag to be refactored.
 
FUNC-TYPE is a refactoring action to be performed.
 
ASK-PLACE-P, if true, asks user to select a tag in BUFFER to insert next to it.
(defalias 'srefactor--refactor-tag #[(buffer refactor-tag func-type &optional ask-place-p) "\306\307 \237\nr\fq\210 \203E\203E\310\311#\210\310\312\313#\210\310\314\306#\210\310\315\316#\210\310\317\320#\210\310\321\322#\210\323!\202K\324\306\n#+\207" [tag-list dest-tag func-type srefactor-ui--func-type buffer ask-place-p nil srefactor--fetch-candidates eieio-oset :items :action srefactor-ui--tag-action :shortcut-p :persistent-action srefactor--tag-persistent-action :post-handler #[nil "\305!\306\307\310!rq\210\311\216\312\313\n\306\211#+\314\315    !d\316#\210\317 *\207" [srefactor-ui--current-active-menu tag-string tag #1=#:temp-buffer major-mode context nil generate-new-buffer " *temp*" #[nil "\301!\205    \302!\207" [#1# buffer-name kill-buffer] 2] c++-mode semantic-format-tag-summarize search-forward-regexp regexp-quote t back-to-indentation] 4] :keymap #[nil "\302\303\304!\210\305!\210    \306!\210    \307!*\207" [#2=#:--cl-next-- #3=#:--cl-previous-- #[(key) "\302    \303#\207" [srefactor-ui-menu-mode-map key define-key #[nil "\300\301!\210\302 \207" [widget-forward 1 srefactor--tag-persistent-action] 2 nil nil]] 4] #[(key) "\302    \303#\207" [srefactor-ui-menu-mode-map key define-key #[nil "\300\301!\210\302 \207" [widget-backward 1 srefactor--tag-persistent-action] 2 nil nil]] 4] "n" "j" "p" "k"] 2] srefactor-ui-create-menu srefactor--insert-tag srefactor-ui--current-active-menu refactor-tag] 4 (#$ . 10657)])
#@239 Generate function implementations for all functions in a
class, including functions in nested classes.
 
DEST-BUFFER is the destination buffer to insert generated code.
REFACTOR-TAG is a Semantic tag that holds information of a C++ class.
(defalias 'srefactor--refactor-type #[(dest-buffer refactor-tag) "\211\306\307    \310    8)\n\"+r\fq\210\311 )\312 \313\314$\211\315\211\205b@\211\211A@)\316=\203H\317    !\203H\320\f    \321#\210\202X    \211A@)\322=\203X\323\f    \"\210A\211\204*\315-\207" [refactor-tag tag attribute members dest-buffer dest-buffer-tags :members plist-get 2 semantic-fetch-tags set-difference :test semantic-equivalent-tag-p nil function semantic-tag-prototype-p srefactor--refactor-tag gen-func-impl type srefactor--refactor-type diff --dolist-tail--] 6 (#$ . 12395)])
#@402 Insert a Semantic TAG to current buffer.
 
REFACTOR-TAG is selected Semantic tag to be refactored.
 
DEST-TAG is destination tag for refactored tag to be inserted
next to it. If nil, insert at the end of file.
 
POS is specific relative position to be inserted. POS is one of
the option "Before|Inside|After" that appears when a
destination tag can have its own members, such as a class or a
namespace.
 
(defalias 'srefactor--insert-tag #[(refactor-tag dest-tag insert-type &optional pos) "\306!\211A@)\307=\211A@)\310\2119\203\200\311!\210\n\203*\312!\210\202\316:\313\230\2038\314\315!\210\202l:\316\230\203J\317\320!\210\321\315!\210\202l\211\322    8);\323;!\203b\324;!\202f;\315H*b\210\315y\210<\325=\203\200\326!\210\327 \210\330 \210\202\316<\331=\204\216<\332=\203\251\333 \203\240\334\335\336\337 \340 \"\"\210\202\316\341<\"\210\202\316\342!\203\270\343\344!!\210\202\316<\345=\203zr\346!q\210\212\211\322    8);\323;!\203\336\347;!\202\342;\350H*b\210\211\322    8);\323;!\203\375\347;!\202;\350H*\211\322    8);\323;!\203\324;!\202;\315H*|\210\351 \210*\352!\2043\352\353!!\203K\f\307=\203K=\354=\203K\355!c\210\356c\210\202\316\357 \210\f\307=\203f\341\360!\203`\332\202a\332\"\210\202\316`\361 \210\362c\210`9\363 9\"\210\202\316\364 \210\202\316db\210<\325=\203\221\326!\210\202\316<\331=\203\240\341\331\"\210\202\316<\332=\203\257\341\332\"\210\202\316\365>\366    \367    8)>\"*\203\313\343\344!!\210\202\316\364 \210\370 ,\207" [dest-tag tag parent-is-func-p refactor-tag class beg semantic-tag-calculate-parent function nil semantic-go-to-tag srefactor--insert-function-as-parameter "(Before)" open-line 1 "(Inside)" search-forward "{" newline 4 semantic-overlay-p semantic-overlay-end gen-func-ptr srefactor--insert-function-pointer newline-and-indent recenter gen-func-impl gen-func-proto region-active-p mapc #[(f-t) "\302    \"\207" [f-t insert-type srefactor--insert-function] 3] semantic-parse-region region-beginning region-end srefactor--insert-function srefactor--tag-pointer semantic-insert-foreign-tag srefactor--function-pointer-to-function move semantic-tag-buffer semantic-overlay-start 0 delete-blank-lines srefactor--tag-struct-p srefactor--calculate-parent-tag c-mode srefactor--function-to-function-pointer ";" delete-trailing-whitespace semantic-tag-prototype-p yank "\n" indent-region senator-yank-tag :function-pointer plist-get 2 indent-according-to-mode end pos o insert-type major-mode attribute] 6 (#$ . 13208)])
#@183 If the current buffer is also the selected file, don't open
the file in another window but use the current buffer and window
instead.
 
OTHER-FILE is the selected file from the menu.
(defalias 'srefactor--contextual-open-file #[(other-file) "\203\301!\203\fp\207\302p!\232\203\303!\207\304!\210p\207\305\306\211\"\210p\207" [other-file srefactor--switch-to-window buffer-file-name find-file find-file-other-window ff-find-other-file t] 3 (#$ . 15769)])
#@73 Insert getter-setter of a class TAG into file specified in FILE-OPTION.
(defalias 'srefactor-insert-class-getters-setters #[(tag file-option) "\306 \210\307 \310\311!!\211\211A@)\312=\205\207\n\211A@)\312=\205\207\313\314\315\n\211\316\317\n\320\n8)\"+#\313\314\321\f#\n\211\322\n8)\323!\203U\324!\202Y\325H* \326\211\203\203@\327!\203z\330\331\211    $\210A\211\204f*\332 +*\207" [file-option buffer tag attribute members variables semantic-fetch-tags-fast semantic-current-tag srefactor--contextual-open-file srefactor--select-file type srefactor--tag-filter semantic-tag-class (variable label) :members plist-get 2 (variable) 4 semantic-overlay-p semantic-overlay-start 0 nil srefactor--tag-private-p srefactor--variable-insert-getter-setter t recenter o tag-start v --dolist-tail--] 7 (#$ . 16237)])
#@67 Insert getter for TAG.
Add NEWLINE-BEFORE and NEWLINE-AFTER if t.
(defalias 'srefactor--insert-getter #[(tag &optional newline-before newline-after prototype-p) "\306!\307!\310\311\211`\fp=\204\312!\203$\313!\210\211\314\315\3168)\"+<\204M\317\315\3168)\"*\203c\320\315\3168)\"*\204c\321c\210 c\210\322 \310\211@)#\323!\"\203\200\324\n!\202\201\nRc\210\325c\210#\203\222\326c\210\202\270\327c\210\330\331!\210\332\323\211@)\326Rc\210\330\331!\210\333c\210\334 \210$\203\270\313$!\210\335    `\"-\207" [tag beg tag-name tag-parent-string tag-buffer tag-type srefactor--tag-type-string semantic-tag-buffer "" nil srefactor--tag-parents-string newline :type plist-get 2 :pointer :constant-flag "const " replace-regexp-in-string " " capitalize "() const" ";" " {" srefactor--indent-and-newline 1 "return" "}" indent-according-to-mode indent-region newline-before attribute srefactor--getter-setter-removal-prefix srefactor--getter-prefix srefactor--getter-setter-capitalize-p prototype-p newline-after] 6 (#$ . 17091)])
#@67 Insert setter for TAG.
Add NEWLINE-BEFORE and NEWLINE-AFTER if t.
(defalias 'srefactor--insert-setter #[(tag newline-before newline-after &optional prototype-p) "\203\306!\210\307    !\307    !\310    !    \211@)\307    !\311    !\312\211\211!\"#$$` p=\2049\313    !\314c\210\315%\316    \211@)#\317\f&'\203V\320!\202WRc\210\321c    \211\322(\323    \324    8)(\"+?\205s\325$\211<\205\201#?\205\201\326\317\"\327\260c\210)\203\224\330c\210\202\272\331c\210\332\333!\210\334\"\335\"\330\260c\210\332\333!\210\336c\210\337 \210*\203\272\306*!\210\340\n`\".    \207" [newline-before tag beg modified-tag-name tag-parent-string tag-buffer newline srefactor--tag-type-string srefactor--tag-pointer semantic-tag-buffer nil srefactor--tag-parents-string "void" replace-regexp-in-string "" " " capitalize "(" :constant-flag plist-get 2 "const " "&" ")" ";" " {" srefactor--indent-and-newline 1 "this->" " = " "}" indent-according-to-mode indent-region tag-type-string tag-name tag-pointer tag-type srefactor--getter-setter-removal-prefix srefactor--setter-prefix srefactor--getter-setter-capitalize-p attribute prototype-p newline-after] 10 (#$ . 18175)])
#@112 Check if TAG is a class or struct.
If so, check if any public label exists, jump to it.
Otherwise, insert one.
(defalias 'srefactor--jump-or-insert-public-label #[(tag) "\211A@)\306=\205\276\211\3078)\310    !\203 \311    !\202#    \312H*b\210\313\314\315\316\211\317\320\3218)\"+#\314\322\323\f#@\211\203\224\311 \3078)!\203\213 \211\3078)\310    !\203h\324    !\202k    \325H*b\210 \211\3078)\310    !\203\203\311    !\202\206    \312H*\202\274\326\327!\210`\202\274\211\3078)\310    !\203\251\324    !\202\254    \325H*b\210\330\331!\210\332\325!\210\327c\210`\n+\207" [tag o label-pos attribute members public-label type 4 semantic-overlay-p semantic-overlay-start 0 nil srefactor--tag-filter semantic-tag-class (variable label) :members plist-get 2 semantic-tag-name ("public") semantic-overlay-end 1 search-forward "public:" search-backward "}" open-line] 7 (#$ . 19341)])
#@195 Insert getter if INSERT-GETTER-P is t, insert setter if INSERT-SETTER-P is t.
TAG is the current variable at point.
BUFFER is the destination buffer from file user selects from contextual menu.
(defalias 'srefactor--variable-insert-getter-setter #[(insert-getter-p insert-setter-p tag buffer) "rq\210\305\212    \211\306    8)\307\n!\203\310\n!\202\n\311H*b\210\312 )!\204+db\210\313    !=\204rr\313    !q\210\305\212    \211\306    8)\307\n!\203P\310\n!\202S\n\311H*b\210\312 )!\210\203f\314    \315\211\316$\210\f\203q\317    \315\211\316$\210)\203|\314    \315\211#\210\f\205\205\317    \315\211#)\207" [buffer tag o insert-getter-p insert-setter-p srefactor--jump-or-insert-public-label 4 semantic-overlay-p semantic-overlay-start 0 semantic-current-tag-parent semantic-tag-buffer srefactor--insert-getter 1 t srefactor--insert-setter] 6 (#$ . 20240)])
#@28 Insert a tag using srecode
(defalias 'srefactor--insert-with-srecode #[(func-tag) "\306!\307!\211\310\nG\311ZO\312\313\312\211\211AA)\211:\2036\314\315@ #!\240\210,\210\316\211\211AA)\211:\203^\314\315@ #!\240\210,\210\317\320!\210\321\312\322#\211b\210\323c,\207" [func-tag copy parentstring1 parentstring endofinsert value semantic-tag-copy srefactor--tag-parents-string 0 2 nil :typemodifiers semantic-tag-make-plist plist-put :parent require srecode/semantic srecode-semantic-insert-tag #[(localtag) "\303\304!\204 \305!\203\306\202!\211\307\310    \311    8)\n\"+!\207" [copy tag attribute srefactor--insert-initial-content-based-on-return-type srefactor--tag-function-constructor srefactor--tag-function-destructor "" :type plist-get 2] 5] "\n\n" attribute tag plist-cdr] 7 (#$ . 21095)])
#@143 Insert function implementations for FUNC-TAG at point, a tag that is a function.
`type' is the operation to be done, not the type of the tag.
(defalias 'srefactor--insert-function #[(func-tag type) "\306 \210\307 \210\203\310    !\210\202\n\311=\204\312 \210\313    !\314    !    \3158\31688\31788) \"*\203:\320c\210\321    !\203h    \322\3239\2118\2118AA)\211::\203d:\324\325:@ 9#!\240\2108,\210\212;\326=\203y\203y\327!c\210\330    !c\210    \3318\31688\31788) \"*\203\226\332c\210\n\311=\203\237\333c\210);\334=\204\335\336\f!\337 \340#\210\341\336\f!\342 \340#\210\343    !\203\302\344u\210\345    !\204\331\n\311=\204\331\314    !\203\331\346    !c\210\347    !\203\350\351\352\2118\3538\31688\31788) \"+#<\354\355<\"\211<\203\337 b\210\356c\210\357\360<\"\210)*\n\311=?\205X\323\210\361c\210\306\362!\210\212\363\347    !\2043\343    !\2037\364\202L    \2118\3658\31688\31788) \"+!\210\366c\210\367 \210)\337 b\207" [srefactor-use-srecode-p func-tag type parent func-tag-name attribute newline left-char srefactor--insert-with-srecode gen-func-proto newline-and-indent srefactor--tag-name srefactor--calculate-parent-tag :constant-flag plist-get 2 "const " srefactor--tag-function-modifiers :typemodifiers nil semantic-tag-make-plist plist-put c++-mode srefactor--tag-templates-declaration-string srefactor--tag-function-string :methodconst-flag " const" ";\n" c-mode search-forward-regexp regexp-quote line-end-position t search-backward-regexp line-beginning-position srefactor--tag-function-destructor -1 srefactor--tag-friend-p srefactor--tag-parents-string srefactor--tag-function-constructor srefactor--tag-filter semantic-tag-class (variable) :members remove-if-not #[(v) "\301\302\303!\"\207" [v string-match "const" srefactor--tag-type-string] 4] ":" mapc #[(v) "\302\303\304!\"\205\211@)c\210\305c\207" [v tag string-match "const" srefactor--tag-type-string "()"] 5] " {" 1 srefactor--insert-initial-content-based-on-return-type "" :type "}" indent-according-to-mode tag value plist-cdr major-mode variables] 7 (#$ . 21949)])
#@45 Insert function pointer definition for TAG.
(defalias 'srefactor--insert-function-pointer #[(tag) "\303\304!\305\306\307!\310\211@)\311\306\260    c\210\312\313\211\314\315\3168)    \"+\317#\211c\210\320c)\207" [tag attribute param-str "typedef " srefactor--tag-type-string " " "(" srefactor--tag-parents-string "*" ")" mapconcat #[(tag) "\303!\304!\305!*\207" [tag ref-level ptr-level srefactor--tag-pointer srefactor--tag-reference srefactor--tag-type-string] 3] :arguments plist-get 2 ", " ");"] 10 (#$ . 24026)])
#@119 Insert TAG that is a function as a function parameter.
This means, the function is converted into a function pointer.
(defalias 'srefactor--insert-function-as-parameter #[(tag) "\301!c\210\302c\207" [tag srefactor--function-to-function-pointer ", "] 2 (#$ . 24561)])
#@31 Extract function from region.
(defalias 'srefactor--insert-new-function-from-region #[nil "\306 \210\307\310 !\210\311 \310 Z\312\310 \311 \"\313 \314 \315\211\211\211\211\2116789\316\216\3171\364`\320\321!:r:q\210\322\216\315\211\323c\210\324c\210\325c\210\326\327!\210`8c\210`\326\327!\210\330c\210\315\211;<\331 \210*=\203y\332=!\203y\333\225b\210\334\335d\336#\2106\315>\211?\203\246?@>\337>\n#\203\235> B?A\211?\204\212\315> \210*\340 !c\210\312ed\"-8\341 \210\342 \210`8c\210\343\344!\210`\345\346\315\336#\210\327u\210\347 \210\350\351!\345\346\315\336#\203\346\352    !\210\353\354 \210`\355 \210`\"0\202\375@\336\356\357\360\")\210)\203\204\n\203\n|\210\361\344!\210\fb\210\362 \210A@b\210A@A@9\\|\210`    c\210\335c\210 \315>\211?\203S?@\211>\2117@)\363Pc\210?A\211?\204;*\364c\210\353`\"\210\345\363\315\336#\203h\352\365!\210\362 .\n\207" [has-error name p2 p1 orig l semantic-force-refresh push-mark region-beginning region-end buffer-substring-no-properties semantic-current-tag semantic-get-all-local-variables nil #[nil "\300\207" [nil] 1] (error) generate-new-buffer " *temp*" #[nil "\301!\205    \302!\207" [#1=#:temp-buffer buffer-name kill-buffer] 2] "void new_function" "()" " {" newline 1 "}" beginning-of-defun looking-at 0 search-forward "(" t srefactor--var-in-region-p srefactor--tag-function-parameters-string beginning-of-defun-raw recenter-top-bottom open-line 2 re-search-backward "new_function" srefactor--mark-symbol-at-point read-from-minibuffer "Enter function name: " replace-match indent-region c-beginning-of-defun c-end-of-defun message "%s" "The selected region is malformed." kill-line pop-mark ", " ");" "" local-vars tag region reg-diff #1# end-of-defun-function beginning-of-defun-function defun-prompt-regexp v --dolist-tail-- e mark-ring] 11 (#$ . 24835)])
#@118 Insert initial content of function implementations.
 
TAG-TYPE is the return type such as int, long, float, double...
(defalias 'srefactor--insert-initial-content-based-on-return-type #[(tag-type) "<\203\211@)\302\261\210\303 \210\304\305!\210\306c\210\303 \210\202d\307\310\"\2043\307\311\"\2043\307\312\"\2039\313c\210\202d\307\314\"\204G\307\315\"\203M\316c\210\202d\307\317\"\203Z\320c\210\202d\307\321\"\203d\322c\210\323\324!\207" [tag-type tag " b;" indent-according-to-mode newline 2 "return b;" string-match "int" "short" "long" "return 0;" "double" "float" "return 0.0;" "bool" "return true;" "char" "return 'a';" srefactor--indent-and-newline 1] 4 (#$ . 26712)])
#@26 Assume region is marked.
(defalias 'srefactor--insert-new-macro-from-region #[nil "\306 \307 {\306 \307 \310    \n\"\311V\312\313!\314    \n\315#\210\f\316Pc\210\317 \211\320 8)\"\321\"!\203;\322\"!\202?\"\323H*b\210\324\325!\210\326\311!\210\327\311!\210`\330\f\203Z\331\202[\332Qc\210c\210\333y\210`    b\210\334\335!\210\nb\210\335#\336 \210\203~\337\340!\210`\341    \n\"\210\335\211$-\207" [region beg end multiline-p name tag region-beginning region-end count-lines 1 read-from-minibuffer "Enter a macro name: " filter-buffer-substring t "()" semantic-current-tag 4 semantic-overlay-p semantic-overlay-start 0 search-backward-regexp "^$" newline open-line "#define " "\n" " " 2 set-mark-command nil recenter call-interactively c-backslash-region indent-region o deactivate-mark mark-active] 5 (#$ . 27415)])
#@79 Rename the variable instances in TAG-OCCURRENCES in FUNCTION-TAG to NEW-NAME.
(defalias 'srefactor--rename-local-var #[(tag tag-occurrences function-tag new-name) "\212\211\306    8)\307\n!\203\310\n!\202\n\311H*b\210G    \211@)GZ \312\311 GS\312:\203x@X\203x:\203_@\313_\\AB\202f\f_\\BAT\2027\237-\314\315\"\210\316\317\320G    \211@)$!+\207" [function-tag tag o new-name distance tag-occurrences 4 semantic-overlay-p semantic-overlay-start 0 nil 14 mapc #[(c) "b\210\305\306    !\n\211\307    8)\310!\203\311!\202\312H*\313#\210\314\f\313\211\315\312%\207" [c tag function-tag o new-name search-forward-regexp srefactor--local-var-regexp 4 semantic-overlay-p semantic-overlay-end 1 t replace-match nil] 7] message format "Renamed %d occurrences of %s to %s" #1=#:--cl-var-- v i #2=#:--cl-var-- #3=#:--cl-var-- var-list] 7 (#$ . 28247)])
#@41 Indent than insert a NUMBER of newline.
(defalias 'srefactor--indent-and-newline #[(&optional number) "\301 \210\302\203\f\202 \303!\207" [number indent-according-to-mode newline 1] 2 (#$ . 29158)])
#@99 Return a list of parent tags of a TAG.
The closer to the end of the list, the higher the parents.
(defalias 'srefactor--get-all-parents #[(tag) "\303!\304\211\3058)\306\n!\203\307\n!\202\n\310H*    \203&    \202'p\"\237A)\207" [tag tag-buffer o semantic-tag-buffer semantic-find-tag-by-overlay 4 semantic-overlay-p semantic-overlay-start 0] 4 (#$ . 29367)])
#@123 Return parent prefix string of a TAG.
 
It is used for prepending to function or variable name defined
outside of a scope.
(defalias 'srefactor--tag-parents-string #[(tag) "\306!\307 \310\311    \"\310\312\n\"\313\f\314\315$\316\317 \237\320#\320P-\207" [tag parents parents-at-point parents-str-lst parents-at-point-str-lst diff srefactor--get-all-parents semantic-find-tag-by-overlay mapcar #[(tag) "\211@)\301!P\207" [tag srefactor--tag-templates-parameters-string] 4] #[(tag) "\211@)\301!P\207" [tag srefactor--tag-templates-parameters-string] 4] set-difference :test string-equal mapconcat identity "::"] 5 (#$ . 29739)])
#@259 Return function parameter string of a function.
 
MEMBERS is a list of tags that are parameters of a function.  The
parameters are retrieved by the function `semantic-tag-function-arguments'.
 
The returned string is formatted as "param1, param2, param3,...".
(defalias 'srefactor--tag-function-parameters-string #[(members) "\301\302\303#\304\305\306\206 \307\310Q\"\203\311\312\313\211$\207\207" [members mapconcat #[(m) "\302!\303\211@)Q\207" [m tag srefactor--tag-type-string " "] 4] ", " nil string-match "\\(?:" "[     \n ]+" "\\)\\'" replace-match "" t] 7 (#$ . 30382)])
#@70 Return a complete string representation of a TAG that is a function.
(defalias 'srefactor--tag-function-string #[(tag) "\306!\211\307\310\3118)    \"+\312!\313!\n\206\"?\205) \314P\n\205.\315\316!\317\320\f!\321\260\322\323\324\206@\325\326Q\"\203R\327\330\331\211$\266\202\202U\266\202,\207" [tag attribute is-destructor is-constructor members return-type srefactor--tag-type-string :arguments plist-get 2 srefactor--tag-function-constructor srefactor--tag-function-destructor " " "~" srefactor--tag-name "(" srefactor--tag-function-parameters-string ")" nil string-match "\\`\\(?:" "[     \n ]+" "\\)" replace-match "" t] 8 (#$ . 30972)])
#@61 Return a list of templates as a list of strings from a TAG.
(defalias 'srefactor--tag-template-string-list #[(tag) "\302!\211\204\302\303!!    \205\304\305    \")\207" [tag templates semantic-c-tag-template srefactor--calculate-parent-tag mapcar car] 4 (#$ . 31640)])
#@201 An alternative version of `semantic-tag-calculate-parent'.
 
It is the same except does not check if a TAG is in current
buffer.  If such check is performed, even if a TAG has parent, nil
is returned.
(defalias 'srefactor--calculate-parent-tag #[(tag) "\303!r    \203     \202pq\210\212\211\3048)\305\n!\203&\306\n!\202)\n\307H*b\210\310 +\207" [tag tag-buffer o semantic-tag-buffer 4 semantic-overlay-p semantic-overlay-start 0 semantic-current-tag-parent] 3 (#$ . 31917)])
#@124 Return a string with all template parameters from a TAG.
 
The returned string is formatted as "<class T1, class T2, ...>".
(defalias 'srefactor--tag-templates-parameters-string #[(tag) "\302!\211\203\303\304\305    \306#\307Q\202\310)\207" [tag tmpl-list srefactor--tag-template-string-list "<" mapconcat identity ", " ">" ""] 6 (#$ . 32404)])
#@161 Return a string with all template declarations from a TAG.
 
The returned string is formatted as:
 
"template <class T1, class T2>"
"template <class T3>"
"....".
(defalias 'srefactor--tag-templates-declaration-string #[(tag) "\3031\304!0\202 \210\305\306!\211\203.    \203 \307    !\202!\310\311\312\313\n\314#\315\316RP\202/\310*\207" [tag parent tmpl-list (error) srefactor--calculate-parent-tag nil srefactor--tag-template-string-list srefactor--tag-templates-declaration-string "" "template <" mapconcat #[(T) "\301P\207" [T "class "] 2] ", " ">" "\n"] 7 (#$ . 32758)])
#@49 Convert a function pointer from a function TAG.
(defalias 'srefactor--function-pointer-to-function #[(tag) "\306!\211\211\307\310\3118)\n\"+\312\313\314\"\210    \211\211@)\211 \240*\210\315    \316\317#\210    \320\321\211\211AA)\211:\203Q\322\323@\n#!\240\210,\210    +\207" [tag new-tag attribute args i name semantic-tag-copy :arguments plist-get 2 1 mapc #[(arg) "\304\305    !P\211\n\240*\210    T\211\207" [arg i name tag "a" number-to-string] 5] semantic--tag-put-property :foreign-flag t :function-pointer nil semantic-tag-make-plist plist-put value plist-cdr] 7 (#$ . 33342)])
#@51 Convert a function to function pointer from a TAG
(defalias 'srefactor--function-to-function-pointer #[(tag) "\305!\306\211@)\307Q\211\310\311\3128)\"+    \313\n\313\314\315\316\f\317#\307\260+\207" [tag type-string tag-name attribute args srefactor--tag-type-string "(*" ")" :arguments plist-get 2 " " "(" mapconcat #[(arg) "\301!\207" [arg srefactor--tag-type-string] 2] ", "] 10 (#$ . 33950)])
#@45 Return `:typemodifiers' attribute of a TAG.
(defalias 'srefactor--tag-function-modifiers #[(tag) "\302\303\3048)    \"*\207" [tag attribute :typemodifiers plist-get 2] 3 (#$ . 34366)])
#@72 Return `:destructor-flag' attribute of a TAG, that is either t or nil.
(defalias 'srefactor--tag-function-destructor #[(tag) "\302\303\3048)    \"*\207" [tag attribute :destructor-flag plist-get 2] 3 (#$ . 34560)])
#@73 Return `:constructor-flag' attribute of a TAG, that is either t or nil.
(defalias 'srefactor--tag-function-constructor #[(tag) "\302\303\3048)    \"*\207" [tag attribute :constructor-flag plist-get 2] 3 (#$ . 34784)])
#@49 Return regexp for seraching local variable TAG.
(defalias 'srefactor--local-var-regexp #[(tag) "\301\302\303\211@)!\"\207" [tag format "\\(\\_<%s\\)[ ]*\\([^[:alnum:]_]\\)" regexp-quote] 5 (#$ . 35011)])
#@39 Return `:pointer' attribute of a TAG.
(defalias 'srefactor--tag-pointer #[(tag) "\302\303\3048)    \"*\207" [tag attribute :pointer plist-get 2] 3 (#$ . 35223)])
#@39 Return `:typedef' attribute of a TAG.
(defalias 'srefactor--tag-typedef #[(tag) "\302\303\3048)    \"*\207" [tag attribute :typedef plist-get 2] 3 (#$ . 35394)])
#@228 Return `:reference' attribute of a TAG.
 
If it does not exist, perform additional check to make sure it
does not, since the actual text in buffer has it but for some
complicated language construct, Semantic cannot retrieve it.
(defalias 'srefactor--tag-reference #[(tag) "\306\307\3108)    \"*\311!\211\3128)\313\n!\203&\314\n!\202)\n\315H*\211\3128)\313\n!\203?\316\n!\202B\n\317H*\320\211\211\211\203Z\202\225\212r\203f\202gpq\210b\210\212\321 \210`)\211b\210\322\323\324#b\210\322\325\324#\211\205\224 \205\224\f ZT*.\207" [tag attribute o statement-beg ref-end ref-start :reference plist-get 2 semantic-tag-buffer 4 semantic-overlay-p semantic-overlay-start 0 semantic-overlay-end 1 nil c-beginning-of-statement-1 re-search-forward "&" t "[&]+" tag-end tag-start tag-buffer reference] 8 (#$ . 35566)])
#@40 Return TAG name and handle edge cases.
(defalias 'srefactor--tag-name #[(tag) "\211@)r\303!q\210    \211\304\230\262\2040\305\306\3078)\n\"*\203,\310    P\2021    \2021\304*\207" [tag tag-name attribute semantic-tag-buffer "" :operator-flag plist-get 2 "operator "] 4 (#$ . 36430)])
#@51 Return a complete return type of a TAG as string.
(defalias 'srefactor--tag-type-string #[(tag) "\306!\307!    \203\310    \311\"\202\312\n\203 \310\n\313\"\202!\312\211\314\315\3168) \"+\211\317\315\3168) \"+\3201t:\205p@;\205pA@9\205pA@\205p\3168<\205p\3218<0\202v\210\322)\205~\323!\211\324\315\3168) \"+\203\227\312\202\203\350\325\326\327\211\317\315\3168) \"+\205\263\330\331!\205\272\332\211\314\315\3168) \"+@\333\334!\327    \203\331\202\342\n\203\341\f\202\342\312\260#\202<\203\205\364\330\331!\205\373\332@\n\203\f\202    \205R\202.\207" [tag ptr-level ref-level ptr-string ref-string attribute srefactor--tag-pointer srefactor--tag-reference make-string 42 "" 38 :type plist-get 2 :constant-flag (error) 3 nil semantic-c-tag-template-specifier :constructor-flag replace-regexp-in-string ",>" ">" "const " srefactor--tag-struct-p "struct " "<" srefactor--tag-type-string-inner-template-list tag-type const-p template-specifier] 11 (#$ . 36725)])
(defalias 'srefactor--tag-type-string-inner-template-list #[(tmpl-spec-list) "\301\302\303#\207" [tmpl-spec-list mapconcat #[(tmpl) "\302!<\203@\202    \203     <\203 \303\304    !P\202!\305    \205&\306Q)\207" [tmpl templates semantic-c-tag-template-specifier "<" srefactor--tag-type-string-inner-template-list "," "> "] 4] ""] 4])
#@73 Extract region based on type.
 
EXTRACT-TYPE can be 'function or 'macro.
(defalias 'srefactor--extract-region #[(extract-type) "\301 \203*\302\216\212\303 \304 }\210\305 \210\306 \210)~\210\307\267\202'\310 \202(\311 \202(\312)\207\313\314!\207" [extract-type region-active-p #[nil "~\207" [] 1] region-beginning region-end c-beginning-of-defun c-end-of-defun #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (function 29 macro 34)) srefactor--insert-new-function-from-region srefactor--insert-new-macro-from-region t error "No active region."] 2 (#$ . 38126)])
#@38 Activate mark for a symbol at point.
(defalias 'srefactor--mark-symbol-at-point #[nil "\301\302!\210\303\304!\210\301\305!\210\304\211\207" [deactivate-mark forward-sexp -1 set-mark-command nil 1] 2 (#$ . 38734) nil])
#@219 Return a list of candidates in current buffer.
 
Each candidate is a list '(DISPLAY TAG OPTIONS).  This is a
wrapper for `srefactor--fetch-candidates-helper'.  See
`srefactor--fetch-candidates-helper' for more details.
(defalias 'srefactor--fetch-candidates #[nil "\300\301 \302\303#\207" [srefactor--fetch-candidates-helper semantic-fetch-tags 0 nil] 4 (#$ . 38960)])
#@411 Return a list of lists '(DISPLAY TAG OPTIONS).
 
This function is intended to be used with `srefactor-ui-create-menu' to
be displayed as a list of menu items.
 
DISPLAY is the string to bepresented to user, TAG is a semantic
tag and OPTIONS is a list of possible choices for each menu item.
 
 TAGS are collection of Semantic tags in current buffer.
 DEPTH is current recursion depth.
 CLASS is the parent class.
(defalias 'srefactor--fetch-candidates-helper #[(tags depth &optional class) "\306\307_\310\"\311\312!\306\313\314\"    \315\211\211\315\n\211 \203\326 @\211\n<\203\315\n\211\nA@)\211!\316!\317\"\203\235\f\320=\"\321V\203S\"\203U\315    \204^\202e\322\323 \324$\325\n\315\326#\f\320=\205r\327Q\"\203}\n@\n\f\320=\205\210E\nB\330\331\332\n!T    #\n\")\202\314\316!\333\"\203\314\334\n!\211#\203\271\322\323 \324$\202\273\325\n\315\326#P\211\n\315E\nB*) A\211 \204%*\n.\207" [depth class tag-list display cur-type dashes make-string 3 32 srefactor-ui--return-option-list tag 1 45 nil memql #'type type 0 format "%s|%s%s" "►" semantic-format-tag-summarize t " (Inside)" append srefactor--fetch-candidates-helper semantic-tag-components (package include label variable) semantic-tag-calculate-parent srefactor--tag-options spaces tags --dolist-tail-- #1=#:temp type-p parent-tag] 8 (#$ . 39335)])
#@71 Check whether to add generate function prototype menu item for a TAG.
(defalias 'srefactor--menu-add-function-proto-p #[(tag) "\211A@)\211\303=\205*\304!?\205*\305!?\205*\306!?\205*\307 ?\205*\n?)\207" [tag class srefactor--current-local-var function semantic-tag-prototype-p srefactor--tag-function-constructor srefactor--tag-function-destructor region-active-p] 3 (#$ . 40708)])
#@76 Check whether to add generate function implementation menu item for a TAG.
(defalias 'srefactor--menu-add-function-implementation-p #[(tag) "\211A@)\211\303=\204    \304=\205!\305!\205!\306 ?\205!\n?)\207" [tag class srefactor--current-local-var type function semantic-tag-prototype-p region-active-p] 3 (#$ . 41106)])
#@40 Check whether to add rename menu item.
(defalias 'srefactor--menu-add-rename-local-p #[nil "\306 \307 \310\211\310\2057    \211A@)\311=\2057\312 \237@    \211@)\232?\2057\313    !?\2057\314 ?\2057-\207" [local-var cur-tag cur-tag-start cur-tag-end tag-name tag srefactor--tag-at-point semantic-current-tag nil function semantic-ctxt-current-symbol semantic-tag-prototype-p region-active-p] 3 (#$ . 41437)])
#@69 Check whether to add generate function pointer menu item for a TAG.
(defalias 'srefactor--menu-add-function-pointer-p #[(tag) "\211A@)\303=\2053\304\305\3068)    \"*?\2053\307!?\2053\310!?\2053\311 ?\2053\n?\207" [tag attribute srefactor--current-local-var function :pointer plist-get 2 srefactor--tag-function-constructor srefactor--tag-function-destructor region-active-p] 4 (#$ . 41855)])
#@72 Check whether to add generate getters and setters menu item for a TAG.
(defalias 'srefactor--menu-add-getters-setters-p #[(tag) "\211A@)\302=\205%\303\304\305\211\306\307\3108)    \"+#\205%\311 ?\207" [tag attribute type srefactor--tag-filter semantic-tag-class (variable) :members plist-get 2 region-active-p] 7 (#$ . 42265)])
#@70 Check whether to add generate getter and setter menu item for a TAG.
(defalias 'srefactor--menu-add-getter-setter-p #[(tag) "\211A@)\301=\205\302 \211A@)\303=\205\304 ?\207" [tag variable semantic-current-tag-parent type region-active-p] 3 (#$ . 42607)])
#@33 Check whether to add move menu.
(defalias 'srefactor--menu-add-move-p #[nil "\300 \205\301 ?\207" [semantic-current-tag region-active-p] 1 (#$ . 42875)])
#@41 Retrieve current variable tag at piont.
(defalias 'srefactor--tag-at-point #[nil "\301`!\211\205\302!)\207" [ctxt semantic-analyze-current-context semantic-analyze-interesting-tag] 3 (#$ . 43037)])
#@36 Activate a region from BEG to END.
(defalias 'srefactor--activate-region #[(beg end) "b\210\303\304!\210    b\210\304\211\207" [beg end deactivate-mark set-mark-command nil] 2 (#$ . 43245) nil])
#@56 Check whether to add exclusive menu item for a region.
(defalias 'srefactor--menu-for-region-p #[nil "\300 \207" [region-active-p] 1 (#$ . 43445)])
#@63 Check if a local variable TAG is in a region from BEG to END.
(defalias 'srefactor--var-in-region-p #[(tag beg end) "\212b\210\303\304    !\n\305#)\207" [beg tag end search-forward-regexp srefactor--local-var-regexp t] 4 (#$ . 43599)])
#@29 Check if TAG is a C struct.
(defalias 'srefactor--tag-struct-p #[(tag) "\3061T\211\307\310\3118)    \"+\312!\313\211\2032\211\307\310\3118)    \"+ \204P\n\211\307\310\3118)    \"+\211;\205O\f\314\230 ,0\207\210\313\207" [tag attribute type-tag typedef-tag type-type-tag struct-p (error) :type plist-get 2 srefactor--tag-typedef nil "struct"] 4 (#$ . 43839)])
#@44 Check whether a TAG is a private variable.
(defalias 'srefactor--tag-private-p #[(tag) "\306\307\310\311!\211\312\313\3148)    \"+#\306\307\315\n#\306\316\317#@\306\316\320#@\205L\211\3218)\322!\203G\323!\202K\324H* \205o \211\3218)\322!\203j\323!\202n\324H*\f\205\222\f\211\3218)\322!\203\215\323!\202\221\324H* \205\321\f\205\321 \203\264V\203\264\f\203\264W\206\321\f\205\321V\205\321 \205\321V\205\321V.\207" [tag attribute members labels public-label private-label srefactor--tag-filter semantic-tag-class (variable label) semantic-tag-calculate-parent :members plist-get 2 (label) semantic-tag-name ("public") ("private") 4 semantic-overlay-p semantic-overlay-start 0 o tag-start private-pos public-pos] 7 (#$ . 44228)])
#@42 Check whether a TAG is an auto variable.
(defalias 'srefactor--tag-auto-p #[(tag) "\211\303\304\3058)    \"+\211<\205\n@\306\230)\207" [tag attribute type :type plist-get 2 "auto"] 4 (#$ . 45052)])
#@41 Check whether TAG is a lambda function.
(defalias 'srefactor--tag-lambda-p #[(tag) "\3021F\212\211\3038)\304    !\203\305    !\202    \306H*b\210\307!\205C\310\311\211\3038)\304    !\203=\312    !\202@    \313H*\314#)0\207\210\315\207" [tag o (error) 4 semantic-overlay-p semantic-overlay-start 0 srefactor--tag-auto-p search-forward-regexp "=[ ]*\\[.*\\][ ]*(.*)[ ]*" semantic-overlay-end 1 t nil] 5 (#$ . 45263)])
#@46 Check whether a TAG is a friend to everyone.
(defalias 'srefactor--tag-friend-p #[(tag) "\3051L\211\3068)\307    !\203\310    !\202    \311H*\211\3068)\307    !\2032\312    !\2025    \313H*\314!r\nq\210\212\fb\210\315\316\317#-0\207\210\320\207" [tag o tag-buffer tag-end tag-start (error) 4 semantic-overlay-p semantic-overlay-start 0 semantic-overlay-end 1 semantic-tag-buffer search-forward-regexp "friend" t nil] 5 (#$ . 45686)])
#@57 Check whether a symbol at point is an unknown variable.
(defalias 'srefactor--unknown-symbol-at-point-p #[nil "\300 \205\301 ?\205\f\302\207" [semantic-ctxt-current-symbol srefactor--tag-at-point t] 1 (#$ . 46130)])
(defalias 'srefactor--introduce-variable-at-point #[nil "\212\212\304 \210\305 )\306\211\204\307 \310\311    \"\312\313 !@\211\314\n8)\315!\2030\316!\2023\317H*b\210\320 \210\321Pc+\207" [var-string var tag o c-end-of-statement semantic-ctxt-current-assignment nil semantic-ctxt-current-symbol read-from-minibuffer "New variable: " last semantic-get-all-local-variables 4 semantic-overlay-p semantic-overlay-end 1 newline-and-indent ";"] 4])
#@117 Collect all TAG occurrences.
PARENT-TAG is the tag that contains TAG, such as a function or a class or a namespace.
(defalias 'srefactor--collect-tag-occurrences #[(tag beg end &optional with-content) "\212\306!\307\211\fb\210\310 \311#\203C\312\224\212\nb\210\313\314 \"\204+\313\315 \"\203?\203;\n\316\317 \320 \"B\202<\n    B)\202\f    \237,\207" [tag positions p local-var-regexp beg end srefactor--local-var-regexp nil re-search-forward t 0 semantic-equivalent-tag-p srefactor--tag-at-point semantic-current-tag buffer-substring-no-properties line-beginning-position line-end-position with-content] 4 (#$ . 46810)])
#@58 Highlight tag in TAG-OCCURRENCES in SCOPE-TAG with FACE.
(defalias 'srefactor--highlight-tag #[(tag tag-occurrences &optional scope-tag face) "\303\211\304\305\n\"*\207" [end beg tag-occurrences nil mapc #[(p) "\212b\210\302\303\304!\210`\"\305    \306\307#*\207" [p overlay make-overlay forward-sexp 1 overlay-put face match] 4]] 3 (#$ . 47448)])
#@50 Switch to window that contains FILE-PATH string.
(defalias 'srefactor--switch-to-window #[(file-path) "\3032-\304 \305\211\205+    @\n\306\307!!\232\203#\310!\210\311\303\312\"\210    A\211\204 \305*0\207" [w --dolist-tail-- file-path found window-list nil buffer-file-name window-buffer select-window throw "Found window."] 5 (#$ . 47804)])
(provide 'srefactor)