.emacs.d.git - Gitblit

Chizi123

2018-11-21 5ddac8bd2392ec5b64392e8750d725029bf5aa79

commit \| author \| age
5cb5f7	1	;;; srefactor.el --- A refactoring tool based on Semantic parser framework
C	2	;;
	3	;; Filename: srefactor.el
	4	;; Description: A refactoring tool based on Semantic parser framework
	5	;; Author: Tu, Do Hoang <tuhdo1710@gmail.com>
	6	;; URL : https://github.com/tuhdo/semantic-refactor
	7	;; Maintainer: Tu, Do Hoang
	8	;; Created: Wed Feb 11 21:25:51 2015 (+0700)
	9	;; Version: 0.3
	10	;; Package-Requires: ((emacs "24.4"))
	11	;; Last-Updated: Wed Feb 11 21:25:51 2015 (+0700)
	12	;; By: Tu, Do Hoang
	13	;; Update #: 1
	14	;; URL:
	15	;; Doc URL:
	16	;; Keywords: c, languages, tools
	17	;; Compatibility: GNU Emacs: 24.3+
	18	;;
	19	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	20	;;
	21	;;; Commentary:
	22	;;
	23	;; Semantic is a package that provides a framework for writing
	24	;; parsers. Parsing is a process of analyzing source code based on
	25	;; programming language syntax. This package relies on Semantic for
	26	;; analyzing source code and uses its results to perform smart code
	27	;; refactoring that based on code structure of the analyzed language,
	28	;; instead of plain text structure.
	29	;;
	30	;; To use this package, user only needs to use this single command:
	31	;; `srefactor-refactor-at-point'
	32	;;
	33	;; This package includes the following features:
	34	;;
	35	;; - Context-sensitive menu: when user runs the command, a menu
	36	;; appears and offer refactoring choices based on current scope of
	37	;; semantic tag. For example, if the cursor is inside a class, the
	38	;; menu lists choices such as generate function implementations for
	39	;; the class, generate class getters/setters... Each menu item also
	40	;; includes its own set of options, such as perform a refactoring
	41	;; option in current file or other file.
	42	;;
	43	;; - Generate class implementation: From the header file, all function
	44	;; prototypes of a class can be generated into corresponding empty
	45	;; function implementation in a source file. The generated function
	46	;; implementations also include all of their (nested) parents as
	47	;; prefix in the names, if any. If the class is a template, then the
	48	;; generated functions also includes all templates declarations and in
	49	;; the parent prefix properly.
	50	;;
	51	;; - Generate function implementation: Since all function
	52	;; implementations can be generated a class, this feature should be
	53	;; present.
	54	;;
	55	;; - Generate function prototype: When the cursor is in a function
	56	;; implementation, a function prototype can be generated and placed in
	57	;; a selected file. When the prototype is moved into, its prefix is
	58	;; stripped.
	59	;;
	60	;; - Convert function to function pointer: Any function can be
	61	;; converted to a function pointer with typedef. The converted
	62	;; function pointer can also be placed as a parameter of a function.
	63	;; In this case, all the parameter names of the function pointer is
	64	;; stripped.
	65	;;
	66	;; - Move semantic units: any meaningful tags recognized by Semantic
	67	;; (class, function, variable, namespace...) can be moved relative to
	68	;; other tags in current file or any other file.
	69	;;
	70	;; - Extract function: select a region and turn it into a function,
	71	;; with relevant variables turned into function parameters and
	72	;; preserve full type information.
	73	;;
	74	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	75	;;
	76	;; This program is free software: you can redistribute it and/or modify
	77	;; it under the terms of the GNU General Public License as published by
	78	;; the Free Software Foundation, either version 3 of the License, or (at
	79	;; your option) any later version.
	80	;;
	81	;; This program is distributed in the hope that it will be useful, but
	82	;; WITHOUT ANY WARRANTY; without even the implied warranty of
	83	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	84	;; General Public License for more details.
	85	;;
	86	;; You should have received a copy of the GNU General Public License
	87	;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
	88	;;
	89	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	90	;;
	91	;;; Code:
	92
	93	(require 'cl-lib)
	94	(require 'cc-mode)
	95	(require 'semantic)
	96	(require 'semantic/tag-ls)
	97	(require 'semantic/bovine/c)
	98	(require 'semantic/format)
	99	(require 'semantic/doc)
	100	(require 'srecode/semantic)
	101	(require 'srefactor-ui)
	102
	103	(if (not (version< emacs-version "24.4"))
	104	(require 'subr-x)
	105	(defun string-empty-p (string)
	106	"Check whether STRING is empty."
	107	(string= string ""))
	108
	109	(defun string-trim-left (string)
	110	"Remove leading whitespace from STRING."
	111	(if (string-match "\\`[ \t\n\r]+" string)
	112	(replace-match "" t t string)
	113	string))
	114
	115	(defun string-trim-right (string)
	116	"Remove trailing whitespace from STRING."
	117	(if (string-match "[ \t\n\r]+\\'" string)
	118	(replace-match "" t t string)
	119	string)))
	120
	121	(when (version< emacs-version "25")
	122	(defalias 'semantic-documentation-comment-preceding-tag 'semantic-documentation-comment-preceeding-tag))
	123
	124	(defvar srefactor--current-local-var nil
	125	"Current local variable at point")
	126	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	127	;; User options
	128	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	129	(defcustom srefactor--getter-prefix "get_"
	130	"Prefix for inserting getter."
	131	:group 'srefactor)
	132
	133	(defcustom srefactor--setter-prefix "set_"
	134	"Prefix for inserting getter."
	135	:group 'srefactor)
	136
	137	(defcustom srefactor--getter-setter-removal-prefix ""
	138	"Prefix for removing getter and setter."
	139	:group 'srefactor)
	140
	141	(defcustom srefactor--getter-setter-capitalize-p nil
	142	"Whether getter and setter should be capitalized."
	143	:group 'srefactor
	144	:type 'boolean)
	145
	146	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	147	;; Developer Options
	148	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	149
	150	(defvar srefactor-use-srecode-p nil
	151	"Use experimental SRecode tag insertion ")
	152
	153	;; MACROS
	154	(defmacro srefactor--is-proto (type)
	155	`(eq ,type 'gen-func-proto))
	156
	157	(defmacro srefactor--add-menu-item (label operation-type file-options)
	158	`(add-to-list 'menu-item-list (list ,label
	159	',operation-type
	160	,file-options)))
	161	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	162	;; Commands - only one currently
	163	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	164
	165	;;;###autoload
	166	(defun srefactor-refactor-at-point ()
	167	"Offer contextual menu with actions based on current tag in scope.
	168
	169	Each menu item added returns a token for what type of refactoring
	170	to perform."
	171	(interactive)
	172	(let* ((semanticdb-find-default-throttle '(file))
	173	(refresh (semantic-parse-changes-default))
	174	(srefactor--file-options (srefactor-ui--return-option-list 'file))
	175	(tag (srefactor--copy-tag))
	176	(menu (make-instance 'srefactor-ui-menu :name "menu"))
	177	menu-item-list)
	178	(setq srefactor--current-local-var (srefactor--menu-add-rename-local-p))
	179	(when (srefactor--menu-add-function-implementation-p tag)
	180	(srefactor--add-menu-item "Generate Function Implementation (Other file)"
	181	gen-func-impl
	182	srefactor--file-options))
	183	(when (srefactor--menu-add-function-proto-p tag)
	184	(srefactor--add-menu-item "Generate Function Prototype (Other file)"
	185	gen-func-proto
	186	srefactor--file-options))
	187	(when (srefactor--menu-add-function-pointer-p tag)
	188	(srefactor--add-menu-item "Generate Function Pointer (Current file)"
	189	gen-func-ptr
	190	srefactor--file-options))
	191	(when (srefactor--menu-add-getters-setters-p tag)
	192	(srefactor--add-menu-item "Generate Getters and Setters (Current file)"
	193	gen-getters-setters
	194	srefactor--file-options))
	195	(when (srefactor--menu-add-getter-setter-p tag)
	196	(srefactor--add-menu-item "Generate Setter (Current file)"
	197	gen-setter
	198	srefactor--file-options)
	199	(srefactor--add-menu-item "Generate Getter (Current file)"
	200	gen-getter
	201	srefactor--file-options)
	202	(srefactor--add-menu-item "Generate Getter and Setter (Current file)"
	203	gen-getter-setter
	204	srefactor--file-options))
	205	(when srefactor--current-local-var
	206	(setq tag srefactor--current-local-var)
	207	(srefactor--add-menu-item "Rename local variable (Current file)"
	208	rename-local-var
	209	'("(Current file)")))
	210	(when (srefactor--menu-add-move-p)
	211	(srefactor--add-menu-item "Move (Current file)"
	212	move
	213	srefactor--file-options))
	214	(when (region-active-p)
	215	(srefactor--add-menu-item "Extract function (Current file)"
	216	extract-function
	217	nil))
	218	(oset menu :items menu-item-list)
	219	(oset menu :action #'srefactor-ui--refactor-action)
	220	(oset menu :context tag)
	221	(oset menu :shortcut-p t)
	222	(srefactor-ui-create-menu menu)))
	223
	224	(defun srefactor--tag-filter (predicate tag-classes-or-names tags)
	225	"Filter TAGS based on PREDICATE that satisfies TAG-CLASSES-OR-NAMES.
	226
	227	TAG-CLASSES-OR-NAMES can be a list of Semantic tag classes, or a
	228	list of Semantic tag names, but not both.
	229
	230	Based on the type of list passed above, either use
	231	`semantic-tag-class' or `semantic-tag-name' as PREDICATE."
	232	(let (l)
	233	(dolist (tag tags l)
	234	(when (member (funcall predicate tag) tag-classes-or-names)
	235	(setq l (cons tag l))))))
	236
	237	(defun srefactor--c-tag-start-with-comment (tag)
	238	(save-excursion
	239	(goto-char (semantic-tag-start tag))
	240	(if (and (search-backward-regexp "/\\*" nil t)
	241	(semantic-documentation-comment-preceding-tag tag)
	242	(looking-at "^[ ]\\/\\"))
	243	(progn
	244	(beginning-of-line)
	245	(point))
	246	(semantic-tag-start tag))))
	247
	248	(defun srefactor--copy-tag ()
	249	"Take the current tag, and place it in the tag ring."
	250	(semantic-fetch-tags)
	251	(let ((ft (semantic-current-tag)))
	252	(when ft
	253	(ring-insert senator-tag-ring ft)
	254	(semantic-tag-set-bounds ft
	255	(srefactor--c-tag-start-with-comment ft)
	256	(semantic-tag-end ft))
	257	(kill-ring-save (semantic-tag-start ft)
	258	(semantic-tag-end ft))
	259	(when (called-interactively-p 'interactive)
	260	(message "Use C-y to yank text. \
	261	Use `senator-yank-tag' for prototype insert.")))
	262	ft))
	263
	264	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	265	;; High level functions that select action to make
	266	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	267	(defun srefactor--refactor-based-on-tag-class (operation &optional file-option)
	268	"Refactor based on current tag in context.
	269
	270	OPERATION is a refactoring type user selected from the menu.
	271	FILE-OPTION is a file destination associated with OPERATION."
	272	(let* ((refactor-tag (srefactor--copy-tag))
	273	(class (semantic-tag-class refactor-tag)))
	274	(cond
	275	((eq class 'function)
	276	(cond
	277	((eq operation 'extract-function)
	278	(srefactor--extract-region 'function))
	279	((eq operation 'rename-local-var)
	280	(let* ((local-var (srefactor--tag-at-point))
	281	(function-tag (semantic-current-tag))
	282	(search-start (semantic-tag-start function-tag))
	283	(search-end (semantic-tag-end function-tag))
	284	prompt)
	285	(unwind-protect
	286	(condition-case nil
	287	(let ((tag-occurrences (srefactor--collect-tag-occurrences local-var
	288	search-start
	289	search-end)))
	290	(srefactor--highlight-tag local-var tag-occurrences refactor-tag 'match)
	291	(setq prompt (format "Replace (%s) with: " (semantic-tag-name local-var)))
	292	(srefactor--rename-local-var local-var
	293	tag-occurrences
	294	refactor-tag
	295	(read-from-minibuffer prompt)))
	296	(error nil))
	297	(remove-overlays))))
	298	(t
	299	(let ((other-file (srefactor--select-file file-option)))
	300	(srefactor--refactor-tag (srefactor--contextual-open-file other-file)
	301	refactor-tag
	302	operation
	303	t)))))
	304	((eq class 'type)
	305	(cond
	306	((eq operation 'gen-getters-setters)
	307	(srefactor-insert-class-getters-setters refactor-tag file-option)
	308	(message "Getter and setter generated."))
	309	((eq operation 'move)
	310	(let ((other-file (srefactor--select-file file-option)))
	311	(srefactor--refactor-tag (srefactor--contextual-open-file other-file)
	312	refactor-tag
	313	operation
	314	t)))
	315	(t (srefactor--refactor-type (srefactor--contextual-open-file
	316	(srefactor--select-file file-option))
	317	refactor-tag))))
	318	((eq class 'variable)
	319	(cond
	320	((eq operation 'gen-getter-setter)
	321	(let ((buffer (srefactor--contextual-open-file (srefactor--select-file file-option))))
	322	(srefactor--variable-insert-getter-setter t t refactor-tag buffer))
	323	(message "Getter and setter generated."))
	324	((eq operation 'gen-getter)
	325	(let ((buffer (srefactor--contextual-open-file (srefactor--select-file file-option))))
	326	(srefactor--variable-insert-getter-setter t nil refactor-tag buffer))
	327	(message "Getter generated."))
	328	((eq operation 'gen-setter)
	329	(let ((buffer (srefactor--contextual-open-file (srefactor--select-file file-option))))
	330	(srefactor--variable-insert-getter-setter nil t refactor-tag buffer))
	331	(message "Setter generated."))
	332	((eq operation 'move)
	333	(let ((other-file (srefactor--select-file file-option)))
	334	(srefactor--refactor-tag (srefactor--contextual-open-file other-file)
	335	refactor-tag
	336	operation
	337	t)))
	338	(t nil)))
	339	((eq class 'package)
	340	(message "FIXME: 'package refactoring is not yet implemented."))
	341	((eq class 'include)
	342	(message "FIXME: 'include refactoring is not yet implemented."))
	343	((eq class 'label)
	344	(message "FIXME: 'label refactoring is not yet implemented."))
	345	(t))))
	346
	347	(defun srefactor--select-file (option)
	348	"Return a file based on OPTION selected by a user."
	349	(let ((projectile-func-list '(projectile-get-other-files
	350	projectile-current-project-files
	351	projectile-project-root
	352	projectile-find-file))
	353	other-files file l)
	354	(when (and (featurep 'projectile)
	355	(cl-reduce (lambda (acc f)
	356	(and (fboundp f) acc))
	357	projectile-func-list
	358	:initial-value t))
	359	(cond
	360	((string-equal option "(Other file)")
	361	(condition-case nil
	362	(progn
	363	(setq other-files (projectile-get-other-files (buffer-file-name)
	364	(projectile-current-project-files)
	365	nil))
	366	(setq l (length other-files))
	367	(setq file (concat (projectile-project-root)
	368	(cond ((> l 1)
	369	(completing-read "Select a file: "
	370	other-files))
	371	((= l 1)
	372	(car other-files))
	373	(t (projectile-find-file))))))
	374	(error nil)))
	375	((and (string-equal option "(Project file)")
	376	(featurep 'projectile))
	377	(setq file (concat (projectile-project-root)
	378	(completing-read "Select a file: "
	379	(projectile-current-project-files)))))
	380	))
	381
	382	(when (string-equal option "(Current file)")
	383	(setq file (buffer-file-name (current-buffer))))
	384
	385	(when (string-equal option "(File)")
	386	(setq file (with-current-buffer (call-interactively 'find-file-other-window)
	387	(buffer-file-name (current-buffer)))))
	388	file))
	389
	390	(defun srefactor--tag-persistent-action ()
	391	"Move to a tag when executed."
	392	(back-to-indentation)
	393	(when srefactor-ui--current-active-tag-overlay
	394	(delete-overlay srefactor-ui--current-active-tag-overlay))
	395	(let (link tag)
	396	(save-excursion
	397	(if (search-forward ":" (line-end-position) t)
	398	(setq link (get-pos-property (point) 'button))
	399	(setq link (get-pos-property (point) 'button))))
	400	(when (and link
	401	(listp (widget-value link))
	402	(semantic-tag-p (car (widget-value link))))
	403	(with-selected-window srefactor-ui--current-active-window
	404	(setq tag (car (widget-value link)))
	405	(when (car (widget-value link))
	406	(semantic-go-to-tag tag)
	407	(let ((o (make-overlay (semantic-tag-start tag)
	408	(semantic-tag-end tag))))
	409	(setq srefactor-ui--current-active-tag-overlay o)
	410	(overlay-put o 'face 'region)))))))
	411
	412	(defun srefactor--refactor-tag (buffer refactor-tag func-type &optional ask-place-p)
	413	"Refactor a tag.
	414
	415	BUFFER is a buffer from opening selected file chosen from the menu.
	416
	417	REFACTOR-TAG is selected tag to be refactored.
	418
	419	FUNC-TYPE is a refactoring action to be performed.
	420
	421	ASK-PLACE-P, if true, asks user to select a tag in BUFFER to insert next to it."
	422	(let (dest-tag
	423	(tag-list (nreverse (srefactor--fetch-candidates))))
	424	(setq srefactor-ui--func-type func-type)
	425	(with-current-buffer buffer
	426	(if (and ask-place-p tag-list)
	427	(progn
	428	(oset srefactor-ui--current-active-menu :items tag-list)
	429	(oset srefactor-ui--current-active-menu :action #'srefactor-ui--tag-action)
	430	(oset srefactor-ui--current-active-menu :shortcut-p nil)
	431	(oset srefactor-ui--current-active-menu :persistent-action 'srefactor--tag-persistent-action)
	432	(oset srefactor-ui--current-active-menu :post-handler
	433	(lambda ()
	434	(let ((tag (context srefactor-ui--current-active-menu))
	435	tag-string)
	436	(with-temp-buffer
	437	(setq major-mode 'c++-mode)
	438	(setq tag-string (semantic-format-tag-summarize tag nil nil)))
	439	(search-forward-regexp (regexp-quote tag-string) (point-max) t)
	440	(back-to-indentation))))
	441	(oset srefactor-ui--current-active-menu :keymap
	442	(lambda ()
	443	(cl-flet ((next (key)
	444	(define-key srefactor-ui-menu-mode-map key
	445	(lambda ()
	446	(interactive)
	447	(widget-forward 1)
	448	(srefactor--tag-persistent-action))))
	449	(previous (key)
	450	(define-key srefactor-ui-menu-mode-map key
	451	(lambda ()
	452	(interactive)
	453	(widget-backward 1)
	454	(srefactor--tag-persistent-action)))))
	455	(next "n")
	456	(next "j")
	457	(previous "p")
	458	(previous "k"))))
	459	(srefactor-ui-create-menu srefactor-ui--current-active-menu))
	460	(srefactor--insert-tag refactor-tag nil func-type)))))
	461
	462	(defun srefactor--refactor-type (dest-buffer refactor-tag)
	463	"Generate function implementations for all functions in a
	464	class, including functions in nested classes.
	465
	466	DEST-BUFFER is the destination buffer to insert generated code.
	467	REFACTOR-TAG is a Semantic tag that holds information of a C++ class."
	468	(let* ((members (semantic-tag-type-members refactor-tag))
	469	(dest-buffer-tags (with-current-buffer dest-buffer
	470	(semantic-fetch-tags)))
	471	(diff (set-difference members
	472	dest-buffer-tags
	473	:test #'semantic-equivalent-tag-p))
	474	)
	475	(dolist (tag diff)
	476	(cond
	477	((and (eq (semantic-tag-class tag) 'function)
	478	(semantic-tag-prototype-p tag))
	479	(srefactor--refactor-tag dest-buffer tag 'gen-func-impl))
	480	((eq (semantic-tag-class tag) 'type)
	481	(srefactor--refactor-type dest-buffer tag))
	482	(t)))))
	483
	484	(defun srefactor--insert-tag (refactor-tag dest-tag insert-type &optional pos)
	485	"Insert a Semantic TAG to current buffer.
	486
	487	REFACTOR-TAG is selected Semantic tag to be refactored.
	488
	489	DEST-TAG is destination tag for refactored tag to be inserted
	490	next to it. If nil, insert at the end of file.
	491
	492	POS is specific relative position to be inserted. POS is one of
	493	the option \"Before\|Inside\|After\" that appears when a
	494	destination tag can have its own members, such as a class or a
	495	namespace.
	496	"
	497	(let* ((parent-is-func-p (eq (semantic-tag-class (semantic-tag-calculate-parent dest-tag))
	498	'function))
	499	(class (semantic-tag-class refactor-tag))
	500	beg end)
	501
	502	;; if refactor-tag dest-tag is nil, just insert at end of file
	503	(if dest-tag
	504	(progn
	505	(semantic-go-to-tag dest-tag)
	506
	507	(if parent-is-func-p
	508	(srefactor--insert-function-as-parameter refactor-tag)
	509
	510	;; Handle selected position
	511	(cond
	512	((string-equal pos "(Before)")
	513	(open-line 1))
	514	((string-equal pos "(Inside)")
	515	(search-forward "{")
	516	(newline 1))
	517	(t (goto-char (semantic-tag-end dest-tag))
	518	(forward-line 1)))
	519
	520	;; handle insert type
	521	(cond
	522	((eq insert-type 'gen-func-ptr)
	523	(srefactor--insert-function-pointer refactor-tag)
	524	(newline-and-indent)
	525	(recenter))
	526	((or (eq insert-type 'gen-func-impl) (eq insert-type 'gen-func-proto))
	527	(if (region-active-p)
	528	(mapc (lambda (f-t)
	529	(srefactor--insert-function f-t insert-type))
	530	(semantic-parse-region (region-beginning) (region-end)))
	531	(srefactor--insert-function refactor-tag insert-type)))
	532	((srefactor--tag-pointer refactor-tag)
	533	(semantic-insert-foreign-tag (srefactor--function-pointer-to-function refactor-tag)))
	534	((eq insert-type 'move)
	535	(with-current-buffer (semantic-tag-buffer refactor-tag)
	536	(save-excursion
	537	(goto-char (semantic-tag-start refactor-tag))
	538	(delete-region (semantic-tag-start refactor-tag)
	539	(semantic-tag-end refactor-tag))
	540	(delete-blank-lines)))
	541	(if (and (or (srefactor--tag-struct-p dest-tag)
	542	(srefactor--tag-struct-p
	543	(srefactor--calculate-parent-tag dest-tag)))
	544	(eq class 'function)
	545	(eq major-mode 'c-mode))
	546	(progn
	547	(insert (srefactor--function-to-function-pointer refactor-tag))
	548	(insert ";"))
	549	(delete-trailing-whitespace)
	550	(if (eq class 'function)
	551	(srefactor--insert-function refactor-tag (if (semantic-tag-prototype-p refactor-tag)
	552	'gen-func-proto
	553	'gen-func-proto))
	554	(setq beg (point))
	555	(yank)
	556	(insert "\n")
	557	(setq end (point))
	558	(indent-region beg end))))
	559	(t (senator-yank-tag)))))
	560	(goto-char (point-max))
	561	(cond
	562	((eq insert-type 'gen-func-ptr)
	563	(srefactor--insert-function-pointer refactor-tag))
	564	((eq insert-type 'gen-func-impl)
	565	(srefactor--insert-function refactor-tag 'gen-func-impl))
	566	((eq insert-type 'gen-func-proto)
	567	(srefactor--insert-function refactor-tag 'gen-func-proto))
	568	((semantic-tag-get-attribute refactor-tag :function-pointer)
	569	(semantic-insert-foreign-tag (srefactor--function-pointer-to-function refactor-tag)))
	570	(t (senator-yank-tag))))
	571
	572	;; indent after inserting refactor-tag
	573	(indent-according-to-mode)
	574	))
	575
	576	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	577	;; Functions - IO
	578	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	579	(defun srefactor--contextual-open-file (other-file)
	580	"If the current buffer is also the selected file, don't open
	581	the file in another window but use the current buffer and window
	582	instead.
	583
	584	OTHER-FILE is the selected file from the menu."
	585	(if other-file
	586	(cond
	587	((srefactor--switch-to-window other-file)
	588	(current-buffer))
	589	((equal other-file (buffer-file-name (current-buffer)))
	590	(find-file other-file))
	591	(t (find-file-other-window other-file)
	592	(current-buffer)))
	593	;; use ff-find-other-file when no file is chosen,
	594	;; it means that user selected (Other file) option, but
	595	;; does not install Projectile so he cannot use its function to
	596	;; return the filename of other file. In this case, he simply gets
	597	;; nil, which mean it's the job for `ff-find-other-file'. This needs
	598	;; fixing in the future
	599	(ff-find-other-file t t)
	600
	601	;; `ff-find-other-file' does not return a buffer but switching to
	602	;; the opened buffer instantly. We must return a buffer from this
	603	;; function otherwise things go wrong
	604	(current-buffer)))
	605
	606	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	607	;; Functions that insert actual text or modify text
	608	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	609
	610	;;
	611	;; CLASS
	612	;;
	613	(defun srefactor-insert-class-getters-setters (tag file-option)
	614	"Insert getter-setter of a class TAG into file specified in FILE-OPTION."
	615	(semantic-fetch-tags-fast)
	616	(let ((tag (semantic-current-tag))
	617	(buffer (srefactor--contextual-open-file (srefactor--select-file file-option))))
	618	(when (eq (semantic-tag-class tag) 'type)
	619	(when (eq (semantic-tag-class tag) 'type)
	620	(let* ((members (srefactor--tag-filter 'semantic-tag-class
	621	'(variable label)
	622	(semantic-tag-type-members tag)))
	623	(variables (srefactor--tag-filter 'semantic-tag-class '(variable) members))
	624	(tag-start (semantic-tag-start tag)))
	625	(dolist (v variables)
	626	(when (srefactor--tag-private-p v)
	627	(srefactor--variable-insert-getter-setter t t v buffer)))
	628	(recenter))))))
	629
	630	(defun srefactor--insert-getter (tag &optional newline-before newline-after prototype-p)
	631	"Insert getter for TAG.
	632	Add NEWLINE-BEFORE and NEWLINE-AFTER if t."
	633	(let ((tag-type (srefactor--tag-type-string tag))
	634	(tag-buffer (semantic-tag-buffer tag))
	635	(tag-parent-string "")
	636	tag-name beg)
	637	(setq beg (point))
	638	(unless (eq tag-buffer (current-buffer))
	639	(setq tag-parent-string (srefactor--tag-parents-string tag)))
	640	(when newline-before
	641	(newline newline-before))
	642	(when (and (or (listp (semantic-tag-type tag))
	643	(semantic-tag-get-attribute tag :pointer))
	644	(not (semantic-tag-get-attribute tag :constant-flag)))
	645	(insert "const "))
	646	(insert tag-type)
	647	(setq tag-name (replace-regexp-in-string srefactor--getter-setter-removal-prefix
	648	""
	649	(semantic-tag-name tag)))
	650	(insert (concat " "
	651	tag-parent-string
	652	srefactor--getter-prefix
	653	(if srefactor--getter-setter-capitalize-p
	654	(capitalize tag-name)
	655	tag-name)))
	656	(insert "() const")
	657	(if prototype-p
	658	(insert ";")
	659	(insert " {")
	660	(srefactor--indent-and-newline 1)
	661	(insert (concat "return"
	662	" "
	663	(semantic-tag-name tag) ";"))
	664	(srefactor--indent-and-newline 1)
	665	(insert "}")
	666	(indent-according-to-mode)
	667	(when newline-after
	668	(newline newline-after)))
	669	(indent-region beg (point))))
	670
	671	(defun srefactor--insert-setter (tag newline-before newline-after &optional prototype-p)
	672	"Insert setter for TAG.
	673	Add NEWLINE-BEFORE and NEWLINE-AFTER if t."
	674	(when newline-before
	675	(newline newline-before))
	676	(let ((tag-type (srefactor--tag-type-string tag))
	677	(tag-type (srefactor--tag-type-string tag))
	678	(tag-pointer (srefactor--tag-pointer tag))
	679	(tag-name (semantic-tag-name tag))
	680	(tag-type-string (srefactor--tag-type-string tag))
	681	(tag-buffer (semantic-tag-buffer tag))
	682	tag-parent-string modified-tag-name beg)
	683	(setq beg (point))
	684	(unless (eq tag-buffer (current-buffer))
	685	(setq tag-parent-string (srefactor--tag-parents-string tag)))
	686	(insert "void")
	687	(setq modified-tag-name (replace-regexp-in-string srefactor--getter-setter-removal-prefix
	688	""
	689	(semantic-tag-name tag)))
	690	(insert (concat " "
	691	tag-parent-string
	692	srefactor--setter-prefix
	693	(if srefactor--getter-setter-capitalize-p
	694	(capitalize modified-tag-name)
	695	modified-tag-name)))
	696	(insert (concat (insert "(")
	697	(unless (semantic-tag-variable-constant-p tag)
	698	"const ")
	699	tag-type
	700	(when (and (listp tag-type)
	701	;; (srefactor--tag-reference tag)
	702	(not tag-pointer))
	703	"&")
	704	" "
	705	tag-name
	706	")"))
	707	(if prototype-p
	708	(insert ";")
	709	(insert " {")
	710	(srefactor--indent-and-newline 1)
	711	(insert (concat "this->" tag-name " = " tag-name ";"))
	712	(srefactor--indent-and-newline 1)
	713	(insert "}")
	714	(indent-according-to-mode)
	715	(when newline-after
	716	(newline newline-after)))
	717	(indent-region beg (point))))
	718
	719	(defun srefactor--jump-or-insert-public-label (tag)
	720	"Check if TAG is a class or struct.
	721	If so, check if any public label exists, jump to it.
	722	Otherwise, insert one."
	723	(when (eq (semantic-tag-class tag) 'type)
	724	(goto-char (semantic-tag-start tag))
	725	(let* (label-pos
	726	(members (srefactor--tag-filter 'semantic-tag-class
	727	'(variable label)
	728	(semantic-tag-type-members tag)))
	729	(public-label (car (srefactor--tag-filter 'semantic-tag-name
	730	'("public")
	731	members))))
	732	(if public-label
	733	(progn
	734	(if (semantic-overlay-start (semantic-tag-overlay public-label))
	735	(progn
	736	(goto-char (semantic-tag-end public-label))
	737	(setq label-pos (semantic-tag-start public-label)))
	738	(search-forward "public:")
	739	(setq label-pos (point))))
	740	(goto-char (semantic-tag-end tag))
	741	(search-backward "}")
	742	(open-line 1)
	743	(insert "public:")
	744	(setq label-pos (point)))
	745	label-pos)))
	746
	747	(defun srefactor--variable-insert-getter-setter (insert-getter-p insert-setter-p tag buffer)
	748	"Insert getter if INSERT-GETTER-P is t, insert setter if INSERT-SETTER-P is t.
	749	TAG is the current variable at point.
	750	BUFFER is the destination buffer from file user selects from contextual menu."
	751	(with-current-buffer buffer
	752	(unless (srefactor--jump-or-insert-public-label (save-excursion
	753	(goto-char (semantic-tag-start tag))
	754	(semantic-current-tag-parent)))
	755	(goto-char (point-max)))
	756	(unless (eq buffer (semantic-tag-buffer tag))
	757	(with-current-buffer (semantic-tag-buffer tag)
	758	(srefactor--jump-or-insert-public-label (save-excursion
	759	(goto-char (semantic-tag-start tag))
	760	(semantic-current-tag-parent)))
	761	(when insert-getter-p (srefactor--insert-getter tag 1 1 t))
	762	(when insert-setter-p (srefactor--insert-setter tag 1 1 t))))
	763	(when insert-getter-p (srefactor--insert-getter tag 1 1))
	764	(when insert-setter-p (srefactor--insert-setter tag 1 1))))
	765
	766	;;
	767	;; FUNCTION
	768	;;
	769	(defun srefactor--insert-with-srecode (func-tag)
	770	"Insert a tag using srecode"
	771	(let* ((copy (semantic-tag-copy func-tag))
	772	;; (parent (semantic-tag-calculate-parent func-tag))
	773	;; TODO - below srefactor fcn should be a part of semantic or srecode.
	774	(parentstring1 (srefactor--tag-parents-string func-tag))
	775	(parentstring (substring parentstring1 0 (- (length parentstring1) 2)))
	776	(endofinsert nil))
	777	;; Copied this line from original
	778	(semantic-tag-put-attribute func-tag :typemodifiers nil)
	779	(semantic-tag-put-attribute func-tag :parent parentstring)
	780	;; Insert the tag
	781	(require 'srecode/semantic)
	782	;; TODO - does it need any special dictionary entries?
	783	(setq endofinsert
	784	(srecode-semantic-insert-tag
	785	func-tag
	786	nil ;; Style
	787	(lambda (localtag)
	788	(srefactor--insert-initial-content-based-on-return-type
	789	(if (or (srefactor--tag-function-constructor copy)
	790	(srefactor--tag-function-destructor copy))
	791	""
	792	(semantic-tag-type copy)))
	793	) ;; Callbck for function body.
	794	;; Dictionary entries go here.
	795	))
	796	(goto-char endofinsert)
	797	(insert "\n\n")))
	798
	799	(defun srefactor--insert-function (func-tag type)
	800	"Insert function implementations for FUNC-TAG at point, a tag that is a function.
	801	`type' is the operation to be done, not the type of the tag."
	802	(newline)
	803	(left-char)
	804	(if srefactor-use-srecode-p
	805	;; Try using SRecode as the mechanism for inserting a tag.
	806	(srefactor--insert-with-srecode func-tag)
	807	;; official routine
	808	;; add 2 newlines before insert the function
	809	;; (newline-and-indent)
	810	(unless (srefactor--is-proto type)
	811	(newline-and-indent))
	812
	813	(let ((func-tag-name (srefactor--tag-name func-tag))
	814	(parent (srefactor--calculate-parent-tag func-tag)))
	815	;; insert const if return a const value
	816	(when (semantic-tag-get-attribute func-tag :constant-flag)
	817	(insert "const "))
	818
	819	(when (srefactor--tag-function-modifiers func-tag)
	820	(semantic-tag-put-attribute func-tag :typemodifiers nil))
	821	(save-excursion
	822	(when (and (eq major-mode 'c++-mode)
	823	parent)
	824	(insert (srefactor--tag-templates-declaration-string parent)))
	825	(insert (srefactor--tag-function-string func-tag))
	826
	827	;; insert const modifer for method
	828	(when (semantic-tag-get-attribute func-tag :methodconst-flag)
	829	(insert " const"))
	830
	831	(when (srefactor--is-proto type)
	832	(insert ";\n")))
	833	(unless (eq major-mode 'c-mode)
	834	(search-forward-regexp (regexp-quote func-tag-name) (line-end-position) t)
	835	(search-backward-regexp (regexp-quote func-tag-name) (line-beginning-position) t)
	836
	837	(when (srefactor--tag-function-destructor func-tag)
	838	(forward-char -1))
	839
	840	;; insert tag parent if any
	841	(unless (or (srefactor--tag-friend-p func-tag)
	842	(eq type 'gen-func-proto)
	843	;; check if parent exists for a tag
	844	(null (srefactor--calculate-parent-tag func-tag)))
	845	(insert (srefactor--tag-parents-string func-tag)))
	846
	847	(when (srefactor--tag-function-constructor func-tag)
	848	(let ((variables (srefactor--tag-filter #'semantic-tag-class
	849	'(variable)
	850	(semantic-tag-type-members parent))))
	851	(setq variables
	852	(remove-if-not (lambda (v)
	853	(string-match "const" (srefactor--tag-type-string v)))
	854	variables))
	855	(when variables
	856	(goto-char (line-end-position))
	857	(insert ":")
	858	(mapc (lambda (v)
	859	(when (string-match "const" (srefactor--tag-type-string v))
	860	(insert (semantic-tag-name v))
	861	(insert "()")))
	862	variables)))))))
	863
	864	;; post content insertion based on context
	865	(unless (srefactor--is-proto type)
	866	(end-of-line)
	867	(insert " {")
	868	(newline 1)
	869	(save-excursion
	870	(srefactor--insert-initial-content-based-on-return-type
	871	(if (or (srefactor--tag-function-constructor func-tag)
	872	(srefactor--tag-function-destructor func-tag))
	873	""
	874	(semantic-tag-type func-tag)))
	875	(insert "}")
	876	(indent-according-to-mode))
	877	(goto-char (line-end-position))))
	878
	879	(defun srefactor--insert-function-pointer (tag)
	880	"Insert function pointer definition for TAG."
	881	(insert (concat "typedef "
	882	(srefactor--tag-type-string tag)
	883	" "
	884	"("
	885	(srefactor--tag-parents-string tag)
	886	"*"
	887	(semantic-tag-name tag)
	888	")"
	889	"("))
	890	(let ((param-str (mapconcat
	891	(lambda (tag)
	892	(let ((ptr-level (srefactor--tag-pointer tag))
	893	(ref-level (srefactor--tag-reference tag)))
	894	(srefactor--tag-type-string tag)))
	895	(semantic-tag-function-arguments tag)
	896	", ")))
	897	(insert param-str)
	898	(insert ");")))
	899
	900	(defun srefactor--insert-function-as-parameter (tag)
	901	"Insert TAG that is a function as a function parameter.
	902	This means, the function is converted into a function pointer."
	903	(insert (srefactor--function-to-function-pointer tag))
	904	(insert ", "))
	905
	906	(defun srefactor--insert-new-function-from-region ()
	907	"Extract function from region."
	908	(semantic-force-refresh)
	909	(push-mark (region-beginning))
	910	(let ((reg-diff (- (region-end) (region-beginning)))
	911	(region (buffer-substring-no-properties (region-beginning) (region-end)))
	912	(tag (semantic-current-tag))
	913	(local-vars (semantic-get-all-local-variables))
	914	l orig p1 p2 name has-error)
	915	(unwind-protect
	916	(condition-case e
	917	(progn
	918	(setq orig (point))
	919	(setq region (with-temp-buffer
	920	(let (p1 p2)
	921	(insert (concat "void" " " "new_function"))
	922	(insert "()")
	923	(insert " {")
	924	(newline 1)
	925	(setq p1 (point))
	926	(insert region)
	927	(setq p2 (point))
	928	(newline 1)
	929	(insert "}")
	930	(c-beginning-of-defun-1)
	931	(search-forward "(" (point-max) t)
	932	(dolist (v local-vars l)
	933	(when (srefactor--var-in-region-p v p1 p2)
	934	(push v l)))
	935	(insert (srefactor--tag-function-parameters-string l))
	936	(buffer-substring-no-properties (point-min) (point-max)))))
	937	(beginning-of-defun-raw)
	938	(recenter-top-bottom)
	939	(setq p1 (point))
	940	(insert region)
	941	(open-line 2)
	942	(setq p2 (point))
	943	(re-search-backward "new_function" nil t)
	944	(forward-char 1)
	945	(srefactor--mark-symbol-at-point)
	946	(setq name (read-from-minibuffer "Enter function name: "))
	947	(when (re-search-backward "new_function" nil t)
	948	(replace-match name))
	949	(indent-region (progn
	950	(c-beginning-of-defun)
	951	(point))
	952	(progn
	953	(c-end-of-defun)
	954	(point))))
	955	(error "malform"
	956	(setq has-error t)
	957	(message "%s" "The selected region is malformed."))))
	958	(when has-error
	959	(unless (and (null p1) (null p2))
	960	(delete-region p1 p2))
	961	(kill-line 2)
	962	(goto-char orig)
	963	(pop-mark))
	964	(goto-char (car mark-ring))
	965	(delete-region (car mark-ring) (+ (car mark-ring) reg-diff))
	966	(setq p1 (point))
	967	(insert name)
	968	(insert "(")
	969	(dolist (v l)
	970	(insert (concat (semantic-tag-name v) ", ")))
	971	(insert ");")
	972	(indent-region p1 (point))
	973	(when (re-search-backward ", " nil t)
	974	(replace-match ""))
	975	(pop-mark)))
	976
	977	(defun srefactor--insert-initial-content-based-on-return-type (tag-type)
	978	"Insert initial content of function implementations.
	979
	980	TAG-TYPE is the return type such as int, long, float, double..."
	981	(cond
	982	((listp tag-type)
	983	(insert (semantic-tag-name tag-type) " b;" )
	984	(indent-according-to-mode)
	985	(newline 2)
	986	(insert "return b;")
	987	(indent-according-to-mode))
	988	((or (string-match "int" tag-type)
	989	(string-match "short" tag-type)
	990	(string-match "long" tag-type))
	991	(insert "return 0;"))
	992	((or (string-match "double" tag-type)
	993	(string-match "float" tag-type))
	994	(insert "return 0.0;"))
	995	((string-match "bool" tag-type)
	996	(insert "return true;"))
	997	((string-match "char" tag-type)
	998	(insert "return 'a';"))
	999	(t))
	1000	(srefactor--indent-and-newline 1))
	1001
	1002	;; TODO: work on this in next release
	1003	(defun srefactor--insert-new-macro-from-region ()
	1004	"Assume region is marked."
	1005	(let* ((region (buffer-substring (region-beginning) (region-end)))
	1006	(beg (region-beginning))
	1007	(end (region-end))
	1008	(multiline-p (> (count-lines beg end) 1))
	1009	(name (read-from-minibuffer "Enter a macro name: ")))
	1010	(filter-buffer-substring beg end t)
	1011	(insert (concat name "()"))
	1012	(goto-char (semantic-tag-start (semantic-current-tag)))
	1013	(search-backward-regexp "^$")
	1014	(newline 1)
	1015	(open-line 1)
	1016	;; (setq mark-active nil)
	1017	(setq beg (point))
	1018	(insert (concat "#define " name (if multiline-p "\n" " ")))
	1019	(insert region)
	1020	(forward-line 2)
	1021	(setq end (point))
	1022	(goto-char beg)
	1023	(set-mark-command nil )
	1024	(goto-char end)
	1025	(setq deactivate-mark nil)
	1026	(recenter)
	1027	(when multiline-p
	1028	(call-interactively 'c-backslash-region))
	1029	(setq end (point))
	1030	(indent-region beg end)
	1031	(setq mark-active nil)))
	1032
	1033	;;
	1034	;; VARIABLE
	1035	;;
	1036	(defun srefactor--rename-local-var (tag tag-occurrences function-tag new-name)
	1037	"Rename the variable instances in TAG-OCCURRENCES in FUNCTION-TAG to NEW-NAME."
	1038	(save-excursion
	1039	(goto-char (semantic-tag-start function-tag))
	1040	(let* ((distance (- (length new-name)
	1041	(length (semantic-tag-name tag))))
	1042	(var-list (loop for v in tag-occurrences
	1043	for i from 0 upto (1- (length tag-occurrences))
	1044	collect (if (consp v)
	1045	(cons (+ (car v) (* 14 i)) (cdr v))
	1046	(+ v (* distance i))))))
	1047	(mapc (lambda (c)
	1048	(goto-char c)
	1049	(search-forward-regexp (srefactor--local-var-regexp tag)
	1050	(semantic-tag-end function-tag)
	1051	t)
	1052	(replace-match new-name t t nil 1))
	1053	var-list)
	1054	(message (format "Renamed %d occurrences of %s to %s" (length var-list) (semantic-tag-name tag) new-name)))))
	1055
	1056	;;
	1057	;; GENERAL
	1058	;;
	1059
	1060	(defun srefactor--indent-and-newline (&optional number)
	1061	"Indent than insert a NUMBER of newline."
	1062	(indent-according-to-mode)
	1063	(newline (if number number 1)))
	1064
	1065	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	1066	;; Functions that operate on a Semantic tag and return information
	1067	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	1068	(defun srefactor--get-all-parents (tag)
	1069	"Return a list of parent tags of a TAG.
	1070	The closer to the end of the list, the higher the parents."
	1071	(let* ((tag-buffer (semantic-tag-buffer tag))
	1072	(parents (cdr (nreverse
	1073	(semantic-find-tag-by-overlay (semantic-tag-start tag)
	1074	(if tag-buffer
	1075	tag-buffer
	1076	(current-buffer)))))))
	1077	parents))
	1078
	1079	(defun srefactor--tag-parents-string (tag)
	1080	"Return parent prefix string of a TAG.
	1081
	1082	It is used for prepending to function or variable name defined
	1083	outside of a scope."
	1084	(let* ((parents (srefactor--get-all-parents tag))
	1085	(parents-at-point (semantic-find-tag-by-overlay))
	1086	(parents-str-lst (mapcar (lambda (tag)
	1087	(concat (semantic-tag-name tag)
	1088	(srefactor--tag-templates-parameters-string tag)))
	1089	parents))
	1090	(parents-at-point-str-lst (mapcar (lambda (tag)
	1091	(concat (semantic-tag-name tag)
	1092	(srefactor--tag-templates-parameters-string tag)))
	1093	parents-at-point))
	1094	(diff (set-difference parents-str-lst
	1095	parents-at-point-str-lst
	1096	:test #'string-equal)))
	1097	(concat (mapconcat #'identity (nreverse diff) "::") "::")))
	1098
	1099	(defun srefactor--tag-function-parameters-string (members)
	1100	"Return function parameter string of a function.
	1101
	1102	MEMBERS is a list of tags that are parameters of a function. The
	1103	parameters are retrieved by the function `semantic-tag-function-arguments'.
	1104
	1105	The returned string is formatted as \"param1, param2, param3,...\"."
	1106	(string-trim-right
	1107	(mapconcat (lambda (m)
	1108	(concat (srefactor--tag-type-string m)
	1109	" "
	1110	(semantic-tag-name m)
	1111	))
	1112	members
	1113	", ")))
	1114
	1115	(defun srefactor--tag-function-string (tag)
	1116	"Return a complete string representation of a TAG that is a function."
	1117	(let ((return-type (srefactor--tag-type-string tag))
	1118	(members (semantic-tag-function-arguments tag))
	1119	(is-constructor (srefactor--tag-function-constructor tag))
	1120	(is-destructor (srefactor--tag-function-destructor tag)))
	1121	(string-trim-left (concat (unless (or is-destructor is-constructor)
	1122	(concat return-type " "))
	1123	(when is-destructor "~")
	1124	(srefactor--tag-name tag)
	1125	"("
	1126	(srefactor--tag-function-parameters-string members)
	1127	")"))))
	1128
	1129	(defun srefactor--tag-template-string-list (tag)
	1130	"Return a list of templates as a list of strings from a TAG."
	1131	(let ((templates (semantic-c-tag-template tag)))
	1132	(unless templates
	1133	(setq templates (semantic-c-tag-template (srefactor--calculate-parent-tag tag))))
	1134	(when templates
	1135	(mapcar #'car templates))))
	1136
	1137	(defun srefactor--calculate-parent-tag (tag)
	1138	"An alternative version of `semantic-tag-calculate-parent'.
	1139
	1140	It is the same except does not check if a TAG is in current
	1141	buffer. If such check is performed, even if a TAG has parent, nil
	1142	is returned."
	1143	(let ((tag-buffer (semantic-tag-buffer tag)))
	1144	(with-current-buffer (if tag-buffer
	1145	tag-buffer
	1146	(current-buffer))
	1147	(save-excursion
	1148	(goto-char (semantic-tag-start tag))
	1149	(semantic-current-tag-parent)))))
	1150
	1151	(defun srefactor--tag-templates-parameters-string (tag)
	1152	"Return a string with all template parameters from a TAG.
	1153
	1154	The returned string is formatted as \"<class T1, class T2, ...>\"."
	1155	(let ((tmpl-list (srefactor--tag-template-string-list tag)))
	1156	(if tmpl-list
	1157	(concat "<"
	1158	(mapconcat #'identity tmpl-list ", ")
	1159	">")
	1160	""))
	1161	)
	1162
	1163	(defun srefactor--tag-templates-declaration-string (tag)
	1164	"Return a string with all template declarations from a TAG.
	1165
	1166	The returned string is formatted as:
	1167
	1168	\"template <class T1, class T2>\"
	1169	\"template <class T3>\"
	1170	\"....\"."
	1171	(let* ((parent (condition-case nil
	1172	(srefactor--calculate-parent-tag tag)
	1173	(error nil)))
	1174	(tmpl-list (srefactor--tag-template-string-list tag)))
	1175	(if tmpl-list
	1176	(concat (if parent
	1177	(srefactor--tag-templates-declaration-string parent)
	1178	"")
	1179	(concat "template <"
	1180	(mapconcat (lambda (T)
	1181	(concat "class " T))
	1182	tmpl-list
	1183	", ")
	1184	">"
	1185	"\n"))
	1186	"")))
	1187
	1188	(defun srefactor--function-pointer-to-function (tag)
	1189	"Convert a function pointer from a function TAG."
	1190	(let* ((new-tag (semantic-tag-copy tag))
	1191	(args (semantic-tag-function-arguments new-tag))
	1192	(i 1))
	1193	(mapc (lambda (arg)
	1194	(semantic-tag-set-name arg (concat "a" (number-to-string i)))
	1195	(setq i (+ i 1)))
	1196	args)
	1197	(semantic-tag-set-name new-tag (semantic-tag-name new-tag))
	1198	(semantic--tag-put-property new-tag :foreign-flag t)
	1199	(semantic-tag-put-attribute new-tag :function-pointer nil)
	1200	new-tag))
	1201
	1202	(defun srefactor--function-to-function-pointer (tag)
	1203	"Convert a function to function pointer from a TAG"
	1204	(let* ((type-string (srefactor--tag-type-string tag))
	1205	(tag-name (concat "(*" (semantic-tag-name tag) ")"))
	1206	(args (semantic-tag-function-arguments tag)))
	1207	(concat type-string
	1208	" "
	1209	tag-name
	1210	" "
	1211	"("
	1212	(mapconcat (lambda (arg)
	1213	(srefactor--tag-type-string arg))
	1214	args
	1215	", ")
	1216	")")))
	1217
	1218	(defun srefactor--tag-function-modifiers (tag)
	1219	"Return `:typemodifiers' attribute of a TAG."
	1220	(semantic-tag-get-attribute tag :typemodifiers))
	1221
	1222	(defun srefactor--tag-function-destructor (tag)
	1223	"Return `:destructor-flag' attribute of a TAG, that is either t or nil."
	1224	(semantic-tag-get-attribute tag :destructor-flag))
	1225
	1226	(defun srefactor--tag-function-constructor (tag)
	1227	"Return `:constructor-flag' attribute of a TAG, that is either t or nil."
	1228	(semantic-tag-get-attribute tag :constructor-flag))
	1229
	1230	(defun srefactor--local-var-regexp (tag)
	1231	"Return regexp for seraching local variable TAG."
	1232	(format (concat "\$\\_\<%s\$[ ]*\\([^[:alnum:]_"
	1233	;; (unless (srefactor--tag-lambda-p tag) "(")
	1234	"]\\)")
	1235	(regexp-quote (semantic-tag-name tag))))
	1236
	1237	(defun srefactor--tag-pointer (tag)
	1238	"Return `:pointer' attribute of a TAG."
	1239	(semantic-tag-get-attribute tag :pointer))
	1240
	1241	(defun srefactor--tag-typedef (tag)
	1242	"Return `:typedef' attribute of a TAG."
	1243	(semantic-tag-get-attribute tag :typedef))
	1244
	1245	(defun srefactor--tag-reference (tag)
	1246	"Return `:reference' attribute of a TAG.
	1247
	1248	If it does not exist, perform additional check to make sure it
	1249	does not, since the actual text in buffer has it but for some
	1250	complicated language construct, Semantic cannot retrieve it."
	1251	(let ((reference (semantic-tag-get-attribute tag :reference))
	1252	(tag-buffer (semantic-tag-buffer tag))
	1253	(tag-start (semantic-tag-start tag))
	1254	(tag-end (semantic-tag-end tag))
	1255	ref-start ref-end
	1256	statement-beg)
	1257	(if reference
	1258	reference
	1259	(save-excursion
	1260	(with-current-buffer (if tag-buffer
	1261	tag-buffer
	1262	;; only tag in current buffer does not
	1263	;; carry buffer information
	1264	(current-buffer))
	1265	(goto-char tag-end)
	1266	(setq statement-beg (save-excursion
	1267	(c-beginning-of-statement-1)
	1268	(point)))
	1269	(goto-char statement-beg)
	1270	(setq ref-start (re-search-forward "&"
	1271	tag-end
	1272	t))
	1273	(goto-char statement-beg)
	1274	(setq ref-end (re-search-forward "[&]+"
	1275	tag-end
	1276	t))
	1277	(when (and ref-end ref-start)
	1278	(1+ (- ref-end ref-start))))))))
	1279
	1280	(defun srefactor--tag-name (tag)
	1281	"Return TAG name and handle edge cases."
	1282	(let ((tag-name (semantic-tag-name tag)))
	1283	(with-current-buffer (semantic-tag-buffer tag)
	1284	(if (not (string-empty-p tag-name))
	1285	(if (semantic-tag-get-attribute tag :operator-flag)
	1286	(concat "operator " tag-name)
	1287	tag-name)
	1288	""))))
	1289
	1290	(defun srefactor--tag-type-string (tag)
	1291	"Return a complete return type of a TAG as string."
	1292	(let* ((ptr-level (srefactor--tag-pointer tag))
	1293	(ref-level (srefactor--tag-reference tag))
	1294	(ptr-string (if ptr-level
	1295	(make-string ptr-level ?\*)
	1296	""))
	1297	(ref-string (if ref-level
	1298	(make-string ref-level ?\&)
	1299	""))
	1300	(tag-type (semantic-tag-type tag))
	1301	(const-p (semantic-tag-variable-constant-p tag))
	1302	(template-specifier (when (semantic-tag-p tag-type)
	1303	(semantic-c-tag-template-specifier tag-type))))
	1304	(cond
	1305	((semantic-tag-function-constructor-p tag)
	1306	"")
	1307	(template-specifier
	1308	(replace-regexp-in-string ",>" ">"
	1309	(concat (when (semantic-tag-variable-constant-p tag)
	1310	"const ")
	1311	(when (srefactor--tag-struct-p tag)
	1312	"struct ")
	1313	(car (semantic-tag-type tag))
	1314	"<"
	1315	(srefactor--tag-type-string-inner-template-list template-specifier)
	1316	">"
	1317	(cond
	1318	(ptr-level
	1319	ptr-string)
	1320	(ref-level
	1321	ref-string)
	1322	(t "")))))
	1323	(t
	1324	(if (listp tag-type)
	1325	(concat (when const-p
	1326	"const ")
	1327	(when (srefactor--tag-struct-p tag)
	1328	"struct ")
	1329	(car tag-type)
	1330	(cond
	1331	(ref-level
	1332	ref-string)
	1333	(ptr-level
	1334	ptr-string)))
	1335	tag-type)))))
	1336
	1337	(defun srefactor--tag-type-string-inner-template-list (tmpl-spec-list)
	1338	(mapconcat (lambda (tmpl)
	1339	(let* ((templates (semantic-c-tag-template-specifier tmpl)))
	1340	(concat (if (listp tmpl)
	1341	(car tmpl)
	1342	tmpl)
	1343	(if (and (not (null templates)) (listp templates))
	1344	(concat "<" (srefactor--tag-type-string-inner-template-list templates)) ",")
	1345	(when templates "> "))))
	1346	tmpl-spec-list
	1347	""))
	1348
	1349	(defun srefactor--extract-region (extract-type)
	1350	"Extract region based on type.
	1351
	1352	EXTRACT-TYPE can be 'function or 'macro."
	1353	(if (region-active-p)
	1354	(unwind-protect
	1355	(progn
	1356	;; (narrow-to-region (region-beginning) (region-end))
	1357	;; (when (semantic-parse-region (region-beginning) (region-end))
	1358	;; (error "Please select a region that is not a declaration or an implementation."))
	1359	(save-excursion
	1360	(narrow-to-region (region-beginning) (region-end))
	1361	(c-beginning-of-defun)
	1362	(c-end-of-defun))
	1363	(widen)
	1364	(cond
	1365	((eq extract-type 'function)
	1366	(srefactor--insert-new-function-from-region))
	1367	((eq extract-type 'macro)
	1368	(srefactor--insert-new-macro-from-region))
	1369	(t)))
	1370	(widen))
	1371	(error "No active region.")))
	1372
	1373	(defun srefactor--mark-symbol-at-point ()
	1374	"Activate mark for a symbol at point."
	1375	(interactive)
	1376	(forward-sexp -1)
	1377	(set-mark-command nil)
	1378	(forward-sexp 1)
	1379	(setq deactivate-mark nil))
	1380
	1381	(defun srefactor--fetch-candidates ()
	1382	"Return a list of candidates in current buffer.
	1383
	1384	Each candidate is a list '(DISPLAY TAG OPTIONS). This is a
	1385	wrapper for `srefactor--fetch-candidates-helper'. See
	1386	`srefactor--fetch-candidates-helper' for more details."
	1387	(srefactor--fetch-candidates-helper (semantic-fetch-tags) 0 nil))
	1388
	1389	(defun srefactor--fetch-candidates-helper (tags depth &optional class)
	1390	"Return a list of lists '(DISPLAY TAG OPTIONS).
	1391
	1392	This function is intended to be used with `srefactor-ui-create-menu' to
	1393	be displayed as a list of menu items.
	1394
	1395	DISPLAY is the string to bepresented to user, TAG is a semantic
	1396	tag and OPTIONS is a list of possible choices for each menu item.
	1397
	1398	TAGS are collection of Semantic tags in current buffer.
	1399	DEPTH is current recursion depth.
	1400	CLASS is the parent class."
	1401	(let ((spaces (make-string (* depth 3) ?\s))
	1402	(srefactor--tag-options (srefactor-ui--return-option-list 'tag))
	1403	(dashes (make-string 1 ?\-))
	1404	(class class)
	1405	cur-type display tag-list)
	1406	(cl-dolist (tag tags)
	1407	(when (listp tag)
	1408	(cl-case (setq cur-type (semantic-tag-class tag))
	1409	((function type)
	1410	(let ((type-p (eq cur-type 'type)))
	1411	(unless (and (> depth 0) (not type-p))
	1412	(setq class nil))
	1413	(setq display (concat (if (null class)
	1414	spaces
	1415	(format "%s\|%s%s" spaces dashes "►"))
	1416	(semantic-format-tag-summarize tag nil t)
	1417	(if (eq cur-type 'type)
	1418	" (Inside)")))
	1419	(and type-p
	1420	(setq class (car tag)))
	1421	;; Recurse to children
	1422	(push (list display tag (if (eq cur-type 'type)
	1423	srefactor--tag-options
	1424	nil)) tag-list)
	1425	(setq tag-list (append (srefactor--fetch-candidates-helper (semantic-tag-components tag)
	1426	(1+ depth)
	1427	class)
	1428	tag-list))))
	1429
	1430	((package include label variable)
	1431	(let* ((parent-tag (semantic-tag-calculate-parent tag))
	1432	(display (concat (if parent-tag
	1433	(format "%s\|%s%s" spaces dashes "►")
	1434	spaces)
	1435	(semantic-format-tag-summarize tag nil t))))
	1436	(push (list display tag nil) tag-list)))
	1437	;; Catch-all
	1438	(t))))
	1439	tag-list))
	1440
	1441	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	1442	;; Functions - Predicates
	1443	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	1444	(defun srefactor--menu-add-function-proto-p (tag)
	1445	"Check whether to add generate function prototype menu item for a TAG."
	1446	(let ((class (semantic-tag-class tag)))
	1447	(and (eq class 'function)
	1448	(not (semantic-tag-prototype-p tag))
	1449	(and (not (srefactor--tag-function-constructor tag))
	1450	(not (srefactor--tag-function-destructor tag)))
	1451	(not (region-active-p))
	1452	(null srefactor--current-local-var) )))
	1453
	1454	(defun srefactor--menu-add-function-implementation-p (tag)
	1455	"Check whether to add generate function implementation menu item for a TAG."
	1456	(let ((class (semantic-tag-class tag)))
	1457	(and (or (eq class 'type)
	1458	(and (eq class 'function)
	1459	(semantic-tag-prototype-p tag)))
	1460	(not (region-active-p))
	1461	(null srefactor--current-local-var))))
	1462
	1463	(defun srefactor--menu-add-rename-local-p ()
	1464	"Check whether to add rename menu item."
	1465	(let* ((local-var (srefactor--tag-at-point))
	1466	(cur-tag (semantic-current-tag))
	1467	cur-tag-start cur-tag-end tag-name)
	1468	(when (and local-var
	1469	(eq (semantic-tag-class cur-tag) 'function)
	1470	(not (equal (car (nreverse (semantic-ctxt-current-symbol)))
	1471	(semantic-tag-name cur-tag)))
	1472	(not (semantic-tag-prototype-p cur-tag))
	1473	(not (region-active-p)))
	1474	local-var)))
	1475
	1476	(defun srefactor--menu-add-function-pointer-p (tag)
	1477	"Check whether to add generate function pointer menu item for a TAG."
	1478	(and (eq (semantic-tag-class tag) 'function)
	1479	(not (semantic-tag-get-attribute tag :pointer))
	1480	(and (not (srefactor--tag-function-constructor tag))
	1481	(not (srefactor--tag-function-destructor tag)))
	1482	(not (region-active-p))
	1483	(null srefactor--current-local-var)))
	1484
	1485	(defun srefactor--menu-add-getters-setters-p (tag)
	1486	"Check whether to add generate getters and setters menu item for a TAG."
	1487	(and (eq (semantic-tag-class tag) 'type)
	1488	(srefactor--tag-filter 'semantic-tag-class '(variable) (semantic-tag-type-members tag))
	1489	(not (region-active-p))))
	1490
	1491	(defun srefactor--menu-add-getter-setter-p (tag)
	1492	"Check whether to add generate getter and setter menu item for a TAG."
	1493	(and (eq (semantic-tag-class tag) 'variable)
	1494	(eq (semantic-tag-class (semantic-current-tag-parent)) 'type)
	1495	(not (region-active-p))))
	1496
	1497	(defun srefactor--menu-add-move-p ()
	1498	"Check whether to add move menu."
	1499	(and (semantic-current-tag)
	1500	(not (region-active-p))))
	1501
	1502	(defun srefactor--tag-at-point ()
	1503	"Retrieve current variable tag at piont."
	1504	(let* ((ctxt (semantic-analyze-current-context (point)))
	1505	(pf (when ctxt
	1506	;; The CTXT is an EIEIO object. The below
	1507	;; method will attempt to pick the most interesting
	1508	;; tag associated with the current context.
	1509	(semantic-analyze-interesting-tag ctxt))))
	1510	pf))
	1511
	1512	(defun srefactor--activate-region (beg end)
	1513	"Activate a region from BEG to END."
	1514	(interactive)
	1515	(goto-char beg)
	1516	(set-mark-command nil)
	1517	(goto-char end)
	1518	(setq deactivate-mark nil))
	1519
	1520	(defun srefactor--menu-for-region-p ()
	1521	"Check whether to add exclusive menu item for a region."
	1522	(region-active-p))
	1523
	1524	(defun srefactor--var-in-region-p (tag beg end)
	1525	"Check if a local variable TAG is in a region from BEG to END."
	1526	(save-excursion
	1527	(goto-char beg)
	1528	(search-forward-regexp (srefactor--local-var-regexp tag)
	1529	end t)))
	1530
	1531	(defun srefactor--tag-struct-p (tag)
	1532	"Check if TAG is a C struct."
	1533	(condition-case nil
	1534	(let* ((type-tag (semantic-tag-type tag))
	1535	(typedef-tag (srefactor--tag-typedef tag))
	1536	type-type-tag struct-p)
	1537	(when typedef-tag
	1538	(setq struct-p (semantic-tag-type typedef-tag)))
	1539	(unless struct-p
	1540	(setq type-type-tag (semantic-tag-type type-tag))
	1541	(setq struct-p (and (stringp type-type-tag)
	1542	(string-equal type-type-tag "struct"))))
	1543	struct-p)
	1544	(error nil)))
	1545
	1546	(defun srefactor--tag-private-p (tag)
	1547	"Check whether a TAG is a private variable."
	1548	(let* ((members (srefactor--tag-filter 'semantic-tag-class
	1549	'(variable label)
	1550	(semantic-tag-type-members (semantic-tag-calculate-parent tag))))
	1551	(labels (srefactor--tag-filter 'semantic-tag-class
	1552	'(label)
	1553	members))
	1554	(public-label (car (srefactor--tag-filter 'semantic-tag-name
	1555	'("public")
	1556	labels)))
	1557	(private-label (car (srefactor--tag-filter 'semantic-tag-name
	1558	'("private")
	1559	labels)))
	1560	(tag-start (when tag (semantic-tag-start tag)))
	1561	(private-pos (when private-label (semantic-tag-start private-label)))
	1562	(public-pos (when public-label (semantic-tag-start public-label))))
	1563	(when (and private-label public-label)
	1564	(or (and private-label (> tag-start private-pos)
	1565	public-label (< tag-start public-pos))
	1566	(and public-label (> tag-start public-pos)
	1567	private-label (> tag-start private-pos)
	1568	(> private-pos public-pos))))))
	1569
	1570	(defun srefactor--tag-auto-p (tag)
	1571	"Check whether a TAG is an auto variable."
	1572	(let ((type (semantic-tag-type tag)))
	1573	(and (listp type)
	1574	(string-equal "auto" (car type)))))
	1575
	1576	(defun srefactor--tag-lambda-p (tag)
	1577	"Check whether TAG is a lambda function."
	1578	(condition-case nil
	1579	(save-excursion
	1580	(goto-char (semantic-tag-start tag))
	1581	(and (srefactor--tag-auto-p tag)
	1582	(search-forward-regexp "=[ ]\\[.\\][ ](.)[ ]*" (semantic-tag-end tag) t)))
	1583	(error nil)))
	1584
	1585	(defun srefactor--tag-friend-p (tag)
	1586	"Check whether a TAG is a friend to everyone."
	1587	(condition-case nil
	1588	(let ((tag-start (semantic-tag-start tag))
	1589	(tag-end (semantic-tag-end tag))
	1590	(tag-buffer (semantic-tag-buffer tag)))
	1591	(with-current-buffer tag-buffer
	1592	(save-excursion
	1593	(goto-char tag-start)
	1594	(search-forward-regexp "friend" tag-end t))))
	1595	(error nil)))
	1596
	1597	(defun srefactor--unknown-symbol-at-point-p ()
	1598	"Check whether a symbol at point is an unknown variable."
	1599	(unless (and (semantic-ctxt-current-symbol)
	1600	(srefactor--tag-at-point))
	1601	t))
	1602
	1603	(defun srefactor--introduce-variable-at-point ()
	1604	(save-excursion
	1605	;;
	1606	(let ((var (save-excursion
	1607	(c-end-of-statement)
	1608	(semantic-ctxt-current-assignment)))
	1609	var-string)
	1610	(unless var
	1611	(setq var (semantic-ctxt-current-symbol)))
	1612	(setq var-string (read-from-minibuffer "New variable: " var))
	1613	(goto-char (semantic-tag-end (car (last (semantic-get-all-local-variables)))))
	1614	(newline-and-indent)
	1615	(insert (concat var-string ";")))))
	1616	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	1617	;; Functions - Utilities
	1618	;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	1619	(defun srefactor--collect-tag-occurrences (tag beg end &optional with-content)
	1620	"Collect all TAG occurrences.
	1621	PARENT-TAG is the tag that contains TAG, such as a function or a class or a namespace."
	1622	(save-excursion
	1623	(let ((local-var-regexp (srefactor--local-var-regexp tag))
	1624	p positions)
	1625	(goto-char beg)
	1626	(while (re-search-forward local-var-regexp end t)
	1627	(setq p (match-beginning 0))
	1628	;; must compare tag to avoid tags with the same name but are
	1629	;; different types and/or different scopes
	1630	(save-excursion
	1631	(goto-char p)
	1632	(when (or (semantic-equivalent-tag-p tag (srefactor--tag-at-point))
	1633	(semantic-equivalent-tag-p tag (semantic-current-tag)))
	1634	(push (if with-content
	1635	(cons p (buffer-substring-no-properties (line-beginning-position)
	1636	(line-end-position)))
	1637	p)
	1638	positions))))
	1639	(nreverse positions))))
	1640
	1641	(defun srefactor--highlight-tag (tag tag-occurrences &optional scope-tag face)
	1642	"Highlight tag in TAG-OCCURRENCES in SCOPE-TAG with FACE."
	1643	(let (beg end)
	1644	(mapc (lambda (p)
	1645	(save-excursion
	1646	(goto-char p)
	1647	(let ((overlay (make-overlay p (progn
	1648	(forward-sexp 1)
	1649	(point)))))
	1650	(overlay-put overlay 'face 'match))))
	1651	tag-occurrences)))
	1652
	1653	(defun srefactor--switch-to-window (file-path)
	1654	"Switch to window that contains FILE-PATH string."
	1655	(catch 'found
	1656	(dolist (w (window-list))
	1657	(when (equal file-path (buffer-file-name (window-buffer w)))
	1658	(select-window w)
	1659	(throw 'found "Found window.")))))
	1660
	1661	(provide 'srefactor)
	1662
	1663	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	1664	;;; srefactor.el ends here
	1665	;; Local Variables:
	1666	;; byte-compile-warnings: (not cl-functions)
	1667	;; End: