dot-emacs: comparison .emacs-my

equal deleted inserted replaced

-:0da077ba84ab
+:1ce5595fe5f1
 ;; (setq recentf-menu-filter 'recentf-arrange-by-dir) ; Too slow with dir widgets.
 ;; Don't sort ``recentf-list`` so ``recentf-open-files`` show files in historical order!
 (setq recentf-menu-filter nil)
-(defun my/recentf-clean-project (dir)
+(defun my-recentf-clean-project (dir)
 "Remove from recentf all files that belong to DIR directory."
 (interactive (list (read-directory-name "Exclude all paths")))
 (let ( recentf-exclude )
 (setq recentf-exclude (list (concat "^" (regexp-quote (expand-file-name dir)))))
 (recentf-cleanup) ))
 ;; Prevent Emacs from loading 'default.el', which loaded after '.emacs'.
 ;; Also '-q' prevent loading your init file.
 (setq inhibit-default-init nil)         ; t/nil
-(defun my/debug (mode)
+(defun my-debug (mode)
 "With prefix enable enter to debuger and show backtrace when
 problems occur, with double prefix enable debugging on event and
 signal, else disable breaking to debugger."
 (interactive "P")
 (let ( (lvl1 (not (not mode))) (lvl2 (equal mode '(16))) )
 (cond
 (lvl2 (message "Debugging on quit/event/signal..."))
 (lvl1 (message "Debugging on quit..."))
 (t (message "Debugging disabled...")))))
-(defun my/eval-buffer ()
+(defun my-eval-buffer ()
 "Evaluate entire buffer with re-assigning values to `defvar' / `defcustom'.
 Useful during package development."
 (interactive)
 (save-excursion
 (goto-char (point-min))
 (while (not (eobp))
 (eval-defun nil)
 (end-of-defun))))
-(defun my/load-library (library)
+(defun my-load-library (library)
 "Evaluate entire library with re-assigning values to `defvar' / `defcustom'.
 Useful during package development."
 (interactive
 (list (completing-read "Load library: "
 (apply-partially 'locate-file-completion-table
 load-path
 '("" ".el")))))
 (with-temp-buffer
 (insert-file-contents (locate-file library load-path '("" ".el")))
-(my/eval-buffer)))
+(my-eval-buffer)))
-(my/debug nil)
+(my-debug nil)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "user info")
 (eval-when 'compile (require 'info))
 (when (boundp 'user-home-page) (concat ", " user-home-page))))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "my defun, defmacro, defvar")
-(defmacro my/filter (pred list)
+(defmacro my-filter (pred list)
 "Construct list with elements from LIST which satisfy PRED."
 (let ( (r (make-symbol "r_")) )
 `(let ( (,r (list nil)) )
 (mapc (lambda (item)
 (when (,pred item)
 (nconc ,r (cons item nil))))
 ,list)
 (cdr ,r))))
-(defun my/fold (f x list)
+(defun my-fold (f x list)
 "Recursively applies (F i j) to LIST starting with X.
 For example, (fold F X '(1 2 3)) computes (F (F (F X 1) 2) 3)."
 (let ((li list) (x2 x))
 (while li
 (setq x2 (funcall f x2 (pop li)))
 Otherwise, return result of last form in BODY."
 (declare (debug t) (indent 0))
 `(condition-case nil (progn ,@body) (error nil)))
 )
-(defun my/lookup-key (key)
+(defun my-lookup-key (key)
 "Search for KEY in all known keymaps."
 (let (result)
 (mapatoms (lambda (ob) (when (and (boundp ob)
 (keymapp (symbol-value ob))
 (functionp (lookup-key (symbol-value ob) key)))
 (add-hook 'emacs-lisp-mode-hook 'turn-on-eldoc-mode)
 (add-hook 'lisp-interaction-mode-hook 'turn-on-eldoc-mode)
 (add-hook 'ielm-mode-hook 'turn-on-eldoc-mode)
-(defun my/emacs-lisp-mode-hook ()
+(defun my-emacs-lisp-mode-hook ()
 (setq tab-width 8))
-(add-hook 'emacs-lisp-mode-hook 'my/emacs-lisp-mode-hook)
+(add-hook 'emacs-lisp-mode-hook 'my-emacs-lisp-mode-hook)
-(defun my/elisp-find-tag ()
+(defun my-elisp-find-tag ()
 (interactive)
 (require 'etags)
 (ring-insert find-tag-marker-ring (point-marker))
 (unless (find-variable-at-point)
 (find-function-at-point)
 ))
 ;; Goto elisp definition.
-(define-key emacs-lisp-mode-map (kbd "M-.") 'my/elisp-find-tag)
+(define-key emacs-lisp-mode-map (kbd "M-.") 'my-elisp-find-tag)
 (if (not (fboundp 'global-prettify-symbols-mode))
 ;; http://www.emacswiki.org/emacs/PrettyLambda
 (font-lock-add-keywords
 'emacs-lisp-mode
 `(("(\\<\\(lambda\\)\\>"
 (1 (progn (compose-region (match-beginning 1) (match-end 1) ,(make-char 'greek-iso8859-7 107)) font-lock-keyword-face)) )))
 (global-prettify-symbols-mode 1))
-(defun my/dump-funcs ()
+(defun my-dump-funcs ()
 "Dump all function calls in current buffer. Useful to explore
 elisp API from somebody else files."
 (interactive)
 (let* ( (cur-buffer (current-buffer)) (new-buffer (get-buffer-create (concat (buffer-name cur-buffer) "-funcs.el"))) symb )
 (while (search-forward-regexp "([[:alnum:]*]" nil t)
 ))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "mode groups")
-(defmacro my/defun-rename-symb-tree (name doc func)
+(defmacro my-defun-rename-symb-tree (name doc func)
 "Travel by TREE and applies FUNC to each symbol."
 `(defun ,name (tree)
 ,doc
 (cond
 ((symbolp tree)
 (mapcar ',name tree)
 )
 (t (error "Only tree of symbols allowed"))
 )))
-(my/defun-rename-symb-tree
+(my-defun-rename-symb-tree
-my/feature2mode
+my-feature2mode
 "Convert TREE of features to TREE of modes for these features. Single symbol allowed."
 (lambda (symb) (intern (concat (symbol-name symb) "-mode"))))
-(my/defun-rename-symb-tree
+(my-defun-rename-symb-tree
-my/mode2hook
+my-mode2hook
 "Convert TREE of modes to TREE of hooks for these modes. Single symbol allowed."
 (lambda (symb) (intern (concat (symbol-name symb) "-hook")))
 )
-(my/defun-rename-symb-tree
+(my-defun-rename-symb-tree
-my/mode2modemap
+my-mode2modemap
 "Convert TREE of modes to TREE of keymaps for these modes. Single symbol allowed."
 (lambda (symb) (intern (concat (symbol-name symb) "-map")))
 )
-(defvar my/devel-mode-list
+(defvar my-devel-mode-list
 '(
 sh-mode script-mode tcl-mode
 c-mode c++-mode java-mode js-mode
 python-mode perl-mode cperl-mode
 lisp-mode
 texinfo-mode
 gadict-mode
 )
 "List of development modes.")
-(defvar my/devel-mode-hook-list
+(defvar my-devel-mode-hook-list
-(my/mode2hook my/devel-mode-list)
+(my-mode2hook my-devel-mode-list)
 "List of development mode hooks.")
-(defvar my/scroll-margin-mode-list
+(defvar my-scroll-margin-mode-list
 '(
 vc-dir-mode
 recentf-dialog-mode
 org-agenda-grid-mode           ; XXX for this item not worked!
 log-view-mode
 compilation-mode
 conf-mode
 )
 "List of modes for enabling scroll margin.")
-(defvar my/scroll-margin-mode-hook-list
+(defvar my-scroll-margin-mode-hook-list
-(my/mode2hook my/scroll-margin-mode-list)
+(my-mode2hook my-scroll-margin-mode-list)
 "List of mode hooks for enabling scroll margin.")
-(defvar my/text-mode-list
+(defvar my-text-mode-list
 '(
 text-mode
 outline-mode
 rst-mode
 diff-mode
 dict-c5-mode
 )
 "List of text modes.")
-(defvar my/text-mode-hook-list
+(defvar my-text-mode-hook-list
-(my/mode2hook my/text-mode-list)
+(my-mode2hook my-text-mode-list)
 "List of text mode hooks.")
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "MS Windows, w32, win32")
 (eval-when 'compile (load-library "window"))
 (setq display-buffer-reuse-frames t)
-(defun my/maximize ()
+(defun my-maximize ()
 ;; Next code work with Emacs 21.4, 22.3, 23.1.
 (let (
 (px (display-pixel-width))
 (py (display-pixel-height))
 (fx (frame-char-width))
 (add-to-list 'initial-frame-alist (cons 'height ty)) ))
 (when window-system
 (if (fboundp 'toggle-frame-maximized)
 (toggle-frame-maximized)
-(my/maximize) ))
+(my-maximize) ))
 (menu-bar-mode -1)
 (when window-system
 (mouse-avoidance-mode 'animate)
 (scroll-bar-mode 1)
 (tool-bar-mode -1)
 (tooltip-mode -1)
 (setq-default line-spacing nil)
-(defun my/popup-menu ()
+(defun my-popup-menu ()
 "Menu from keyboard by emulating mouse event."
 (interactive)
 (mouse-popup-menubar
 (list (list (/ (display-pixel-width) 2) 10) (get-buffer-window (buffer-name)))
 nil) )
-(global-set-key [f10] 'my/popup-menu)
+(global-set-key [f10] 'my-popup-menu)
-(global-set-key [apps] 'my/popup-menu)
+(global-set-key [apps] 'my-popup-menu)
-(global-set-key [menu] 'my/popup-menu) )
+(global-set-key [menu] 'my-popup-menu) )
 ;; Prefer horizontal windows splitting.
 (when (>= emacs-major-version 23)
 (setq split-height-threshold nil)
 (setq split-width-threshold nil)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "shell, bash, Cygwin, MSYS")
 (eval-when 'compile (require 'shell))
-(defvar my/use-windows-shell nil
+(defvar my-use-windows-shell nil
 "If t 'cmdproxy.exe' will be used as shell.
 Affect on \\[shell] like commands. If nil, 'sh' will be used." )
 (defun follow-cygwin-symlink ()
 "Follow new-style (and also UCS-16) Cygwin symlinks."
 'utf-16-le)
 0 -1)                           ; -1 for stripping final \0.
 ))))
 (defvar cygwin-mount-table--internal)
-(defun my/dos2cygwin-path (path)
+(defun my-dos2cygwin-path (path)
 "Convert DOS path to Cygwin according to current mount table."
 (interactive (list (read-directory-name "Enter DOS path: ")))
 (setq path (replace-regexp-in-string "\\\\" "/" (expand-file-name path)))
 (let ( (table cygwin-mount-table--internal) item prefix )
 (while table
 (defun executable-find (command) (locate-file command exec-path exec-suffixes))
 )
 (ansi-color-for-comint-mode-on)
-(defun my/ansi-color (&optional beg end)
+(defun my-ansi-color (&optional beg end)
 "Interpret ANSI color esacape sequence by colorifying cotent.
 Operate on selected region on whole buffer."
 (interactive
 (if (use-region-p)
 (list (region-beginning) (region-end))
 (setq term-scroll-show-maximum-output t)
 (my--eval-after-load term
 (define-key term-mode-map [?\t] #'term-dynamic-complete)
-(defun my/term-send-delete-word-forward () (interactive) (term-send-raw-string "\ed"))
+(defun my-term-send-delete-word-forward () (interactive) (term-send-raw-string "\ed"))
-(defun my/term-send-delete-word-backward () (interactive) (term-send-raw-string "\e\C-h"))
+(defun my-term-send-delete-word-backward () (interactive) (term-send-raw-string "\e\C-h"))
-(define-key term-raw-map [C-delete] 'my/term-send-delete-word-forward)
+(define-key term-raw-map [C-delete] 'my-term-send-delete-word-forward)
-(define-key term-raw-map [C-backspace] 'my/term-send-delete-word-backward)
+(define-key term-raw-map [C-backspace] 'my-term-send-delete-word-backward)
-(defun my/term-send-forward-word () (interactive) (term-send-raw-string "\ef"))
+(defun my-term-send-forward-word () (interactive) (term-send-raw-string "\ef"))
-(defun my/term-send-backward-word () (interactive) (term-send-raw-string "\eb"))
+(defun my-term-send-backward-word () (interactive) (term-send-raw-string "\eb"))
-(define-key term-raw-map [C-left] 'my/term-send-backward-word)
+(define-key term-raw-map [C-left] 'my-term-send-backward-word)
-(define-key term-raw-map [C-right] 'my/term-send-forward-word)
+(define-key term-raw-map [C-right] 'my-term-send-forward-word)
-(defun my/term-send-m-right () (interactive) (term-send-raw-string "\e[1;3C"))
+(defun my-term-send-m-right () (interactive) (term-send-raw-string "\e[1;3C"))
-(defun my/term-send-m-left () (interactive) (term-send-raw-string "\e[1;3D"))
+(defun my-term-send-m-left () (interactive) (term-send-raw-string "\e[1;3D"))
-(define-key term-raw-map [M-right] 'my/term-send-m-right)
+(define-key term-raw-map [M-right] 'my-term-send-m-right)
-(define-key term-raw-map [M-left] 'my/term-send-m-left) )
+(define-key term-raw-map [M-left] 'my-term-send-m-left) )
-(defun my/term-mode-hook ()
+(defun my-term-mode-hook ()
 (goto-address-mode 1))
-(add-hook 'term-mode-hook #'my/term-mode-hook)
+(add-hook 'term-mode-hook #'my-term-mode-hook)
 (setq term-prompt-regexp "^[^#$%>\n]*[#$%>] *")
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "proced")
 (setq default-indicate-buffer-boundaries 'left)
 ;; (setq-default show-trailing-whitespace t)
 (setq whitespace-style '(face trailing tabs))
-(setq whitespace-global-modes (append my/devel-mode-list my/text-mode-list))
+(setq whitespace-global-modes (append my-devel-mode-list my-text-mode-list))
 (ignore-errors
 (require 'whitespace)
 (global-whitespace-mode 1))
 (setq next-line-add-newlines nil)
 (setq
 use-dialog-box t
 x-gtk-show-hidden-files t
 )
-(defun my/prevent-kill-buffer ()
+(defun my-prevent-kill-buffer ()
 (if (member (buffer-name) '("*scratch*" "NOTE.org")) nil t))
-(add-to-list 'kill-buffer-query-functions 'my/prevent-kill-buffer)
+(add-to-list 'kill-buffer-query-functions 'my-prevent-kill-buffer)
 (define-key global-map "\C-v" nil)
 (define-key global-map "\C-vt" (lambda nil (interactive) (switch-to-buffer "*scratch*")))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "scrolling")
-(defvar my/scroll-margin 4)
+(defvar my-scroll-margin 4)
 (setq-default
 ;; Set to zero as this recommend documentation.
 scroll-step 0
 ;; If the value is greater than 100, redisplay will never recenter point, but
 scroll-preserve-screen-position t
 )
 ;; Set margin only for desired modes! Do not frustrate calendar any more.
 (make-variable-buffer-local 'scroll-margin)
-(mapc (lambda (hook) (add-hook hook (lambda nil (setq scroll-margin my/scroll-margin))))
+(mapc (lambda (hook) (add-hook hook (lambda nil (setq scroll-margin my-scroll-margin))))
-(delete-dups (append my/text-mode-hook-list my/devel-mode-hook-list my/scroll-margin-mode-hook-list)) )
+(delete-dups (append my-text-mode-hook-list my-devel-mode-hook-list my-scroll-margin-mode-hook-list)) )
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "chars, unicode")
-(defun my/print-unicode (&optional start end)
+(defun my-print-unicode (&optional start end)
 "Print UNICODE table."
 (interactive "nstart: \nnend: ")
 (switch-to-buffer (get-buffer-create "*UNICODE*"))
 (erase-buffer)
 (let ( (i start) )
 (add-to-list 'grep-find-ignored-files "*TAGS")
 (add-to-list 'grep-find-ignored-files "GPATH")) )
 (global-set-key [M-f7] 'rgrep)
-(global-set-key [f7] 'my/ag)
+(global-set-key [f7] 'my-ag)
-(global-set-key [S-f7] 'my/ag-default-directory)
+(global-set-key [S-f7] 'my-ag-default-directory)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "highlighting")
 ;; Increase scrolling speed by defer consuming operation.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "highlighting current line")
 (require 'hl-line)
-(defun my/hl-line-range-function ()
+(defun my-hl-line-range-function ()
 (cons (line-end-position) (line-beginning-position 2)))
-(setq hl-line-range-function #'my/hl-line-range-function)
+(setq hl-line-range-function #'my-hl-line-range-function)
 (set-face-attribute 'hl-line nil :inherit nil :background "light yellow")
 (setq global-hl-line-sticky-flag t)
 (global-hl-line-mode 1)
 ;; cyrillic-jis-russian  for 567 is :,.
 ;; cyrillic-jcuken  for SHIFT 567 is :,.
 ;; russian-computer for SHIFT 567 is %^&
 (setq default-input-method 'russian-computer)
-(defun my/toggle-input-method (&optional arg)
+(defun my-toggle-input-method (&optional arg)
 (interactive "P")
 (if (numberp arg)
 (cond
 ((eq arg 1)
 (activate-input-method nil))
 (activate-input-method 'ipa-x-sampa))
 ((eq arg 6)
 (activate-input-method 'TeX)) )
 (toggle-input-method arg)) )
-(global-set-key (kbd "C-\\") 'my/toggle-input-method)
+(global-set-key (kbd "C-\\") 'my-toggle-input-method)
 ;; I found this more quick method to allow `forward-word' across pronunciation
 ;; as a whole word.
-(defconst my/ipa-chars (list ?ˈ ?ˌ ?ː ?ǁ ?ʲ ?θ ?ð ?ŋ ?ɡ ?ʒ ?ʃ ?ʧ ?ə ?ɜ ?ɛ ?ʌ ?ɒ ?ɔ ?ɑ ?æ ?ʊ ?ɪ))
+(defconst my-ipa-chars (list ?ˈ ?ˌ ?ː ?ǁ ?ʲ ?θ ?ð ?ŋ ?ɡ ?ʒ ?ʃ ?ʧ ?ə ?ɜ ?ɛ ?ʌ ?ɒ ?ɔ ?ɑ ?æ ?ʊ ?ɪ))
 (when (boundp 'char-script-table)       ; Absent in Emacs 22.
 (mapc (lambda (ch)
 (aset char-script-table ch 'latin)
 (modify-syntax-entry ch "w"))
-my/ipa-chars))
+my-ipa-chars))
 ;; Another option is to invent new category:
 ;;
-;; (defconst my/ipa-chars (list ?ˈ ?ˌ ?ː ?ǁ ?ʲ ?θ ?ð ?ŋ ?ɡ ?ʒ ?ʃ ?ʧ ?ə ?ɜ ?ɛ ?ʌ ?ɒ ?ɔ ?ɑ ?æ ?ʊ ?ɪ))
+;; (defconst my-ipa-chars (list ?ˈ ?ˌ ?ː ?ǁ ?ʲ ?θ ?ð ?ŋ ?ɡ ?ʒ ?ʃ ?ʧ ?ə ?ɜ ?ɛ ?ʌ ?ɒ ?ɔ ?ɑ ?æ ?ʊ ?ɪ))
 ;; (define-category ?p "Phonetic")
 ;; (mapc (lambda (ch)
 ;;         (cond
 ;;          ((eq (aref char-script-table ch) 'phonetic)
 ;;           (modify-category-entry ch ?p)
 ;;           (modify-category-entry ch ?l nil t))
 ;;          ((eq (aref char-script-table ch) 'latin)   ; (aref char-script-table ?ˌ) is 'latin but (char-category-set ?ˌ) is ".j"
 ;;           (modify-category-entry ch ?l))))
-;;       my/ipa-chars)
+;;       my-ipa-chars)
 ;; (add-to-list 'word-combining-categories '(?p . ?l))
 ;; (add-to-list 'word-combining-categories '(?l . ?p))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "mouse")
 (defun my--large-file-p ()
 "If buffer too large and my cause performance issue."
 (< large-file-warning-threshold (buffer-size)))
-(define-derived-mode my/large-file-mode fundamental-mode "LargeFile"
+(define-derived-mode my-large-file-mode fundamental-mode "LargeFile"
 "Fixes performance issues in Emacs for large files."
 ;; (setq buffer-read-only t)
 (setq bidi-display-reordering nil)
 (jit-lock-mode nil)
 (buffer-disable-undo)
 ;; (setq mode-line-format (delq 'mode-line-position 'mode-line-format))
 (set (make-local-variable 'global-hl-line-mode) nil)
 (set (make-local-variable 'line-number-mode) nil)
 (set (make-local-variable 'column-number-mode) nil) )
-(add-to-list 'magic-mode-alist (cons #'my--large-file-p #'my/large-file-mode))
+(add-to-list 'magic-mode-alist (cons #'my--large-file-p #'my-large-file-mode))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "helm")
 (eval-when 'compile
 (setq company-dabbrev-downcase nil)
 (setq company-dabbrev-ignore-case nil)
 ;; (setq company-backends (delete 'company-dabbrev company-backends))
-(defun my/company-filter-out-numbers (lst)
+(defun my-company-filter-out-numbers (lst)
 (cl-remove-if (lambda (str) (string-match-p "^[0-9]" str)) lst))
 (when (featurep 'company)
-(add-hook 'company-transformers #'my/company-filter-out-numbers))
+(add-hook 'company-transformers #'my-company-filter-out-numbers))
 (defun company-executable (command &optional arg &rest ignored)
 "Company completion for executable in PATH."
 (interactive (list 'interactive))
 (cl-case command
 (prefix (thing-at-point 'filename))
 (candidates (locate-file-completion-table exec-path exec-suffixes (thing-at-point 'filename) 'identity t))
 ;; (annotation (concat " " (locate-file arg exec-path exec-suffixes)))
 (meta (concat "Full path: " (locate-file arg exec-path exec-suffixes)))))
-(defun my/company-text-setup ()
+(defun my-company-text-setup ()
 (setq-local company-backends '((company-dabbrev company-files)))
 (company-mode 1))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "bookmark")
 ;; dangerous
 ;; (setq
 ;;  dired-recursive-copies 'top
 ;;  dired-recursive-deletes 'top)
-(defun my/dired-up-dir ()
+(defun my-dired-up-dir ()
 "'Reuse' buffer if enter to dir or open new buffer if enter to file."
 (interactive)
 ;; (dired-current-directory) always end with trailing '/' char.
 (let* ( (dir (dired-current-directory)) (i (- (length dir) 2)) upperdir )
 (while (and
 (when (file-directory-p upperdir)
 (find-alternate-file upperdir)
 (dired-goto-file dir)
 )
 ))
-(define-key dired-mode-map (kbd "<backspace>") 'my/dired-up-dir)
+(define-key dired-mode-map (kbd "<backspace>") 'my-dired-up-dir)
-(defun my/dired-enter-to-dir ()
+(defun my-dired-enter-to-dir ()
 "'Reuse' buffer if enter to dir or open new buffer if enter to file."
 (interactive)
 (let ( (file (dired-get-file-for-visit)) )
 (if (file-directory-p file)
 (find-alternate-file file)
 (find-file file)
 )))
 (define-key dired-mode-map (kbd "<return>")
-'my/dired-enter-to-dir)
+'my-dired-enter-to-dir)
 ;; Make behaviour same as in GUI.
 (unless window-system
-(define-key dired-mode-map (kbd "DEL") 'my/dired-up-dir)
+(define-key dired-mode-map (kbd "DEL") 'my-dired-up-dir)
-(define-key dired-mode-map (kbd "RET") 'my/dired-enter-to-dir))
+(define-key dired-mode-map (kbd "RET") 'my-dired-enter-to-dir))
 ;; Enable 'a' command.
 (put 'dired-find-alternate-file 'disabled nil)
 (defvar my--file-name-tmp-refex
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "url")
 ;; http://tools.ietf.org/html/rfc3986
 ;; http://en.wikipedia.org/wiki/Percent-encoding
-(defun my/percent-decode (str)
+(defun my-percent-decode (str)
 (decode-coding-string
 (let* ( (s (split-string str "%")) )
-(my/fold
+(my-fold
 'concat
 (car s)
 (mapcar
 (lambda (x)
 (concat (unibyte-string (string-to-number (substring x 0 2) 16)) (substring x 2)))
 (cdr s))
 )) 'utf-8))
-(defun my/percent-decode-region (beg end &optional arg)
+(defun my-percent-decode-region (beg end &optional arg)
 "Convert percent encoded string to native."
 (interactive "r\nP")
-(let ( (result (my/percent-decode (buffer-substring-no-properties beg end))) )
+(let ( (result (my-percent-decode (buffer-substring-no-properties beg end))) )
 (if (not arg)
 result
 (delete-region beg end)
 (insert result))
 ) )
-(defun my/percent-encode (str)
+(defun my-percent-encode (str)
 (apply 'concat
 (mapcar
 (lambda (ch) (if (or (and (<= ?a ch) (>= ?z ch))
 (and (<= ?A ch) (>= ?Z ch))
 (memq ch '(?- ?_ ?. ?~)))
 (char-to-string ch)
 (format "%%%02X" ch)))
 (encode-coding-string str 'utf-8) )))
-(defun my/percent-encode-region (beg end &optional arg)
+(defun my-percent-encode-region (beg end &optional arg)
 "Encode string to percent encoding."
 (interactive "r\nP")
-(let ( (result (my/percent-encode (buffer-substring-no-properties beg end))) )
+(let ( (result (my-percent-encode (buffer-substring-no-properties beg end))) )
 (if (not arg)
 result
 (delete-region beg end)
 (insert result))
 ) )
 ((boundp 'debian-emacs-flavor)
 (setq browse-url-browser-function 'browse-url-firefox))
 (t
 (setq browse-url-browser-function 'browse-url-mozilla)))
-(defun my/cygwin-search (str)
+(defun my-cygwin-search (str)
 "Search for Cygwin package on-line."
 (interactive (list (read-string "Search for Cygwin package on-line: ")))
 (browse-url (format "http://cygwin.com/cgi-bin2/package-grep.cgi?grep=%s" str))
 )
 (add-hook 'write-file-hooks 'time-stamp)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "logging, logs")
-(defun my/auto-revert-tail-mode-hook ()
+(defun my-auto-revert-tail-mode-hook ()
 (when (string-match "/logs?/\\|\\.\\(?:log\\|out\\)\\'\\|/.xsession-errors\\'"
 (buffer-file-name (current-buffer)))
 (auto-revert-tail-mode 1)
 (log4-hi-mode 1)
-(setq scroll-margin my/scroll-margin)
+(setq scroll-margin my-scroll-margin)
 ))
-(add-hook 'find-file-hook 'my/auto-revert-tail-mode-hook)
+(add-hook 'find-file-hook 'my-auto-revert-tail-mode-hook)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "auto-fill")
 (setq-default fill-column 78)
-(defvar my/fill-column 100
+(defvar my-fill-column 100
 "I use greater value then 78 for comment in prog source.")
 ;; By default used American convention - sentence and with two spaces. Change
 ;; it to one space. Has affect on filling and M-a, M-e commands.
 (setq sentence-end-double-space nil)
 (message "cacl, calculator")
 (setq-default calc-group-digits t)
 (setq-default calc-group-char "'")
-(defun my/calc-region (arg beg end)
+(defun my-calc-region (arg beg end)
 "Calculate the region and display the result in the echo area.
 With prefix ARG non-nil, insert the result at the end of region."
 (interactive "P\nr")
 (require 'calc)
 (let* ((expr (buffer-substring-no-properties beg end))
 (message "%s = %s" expr result)
 (goto-char end)
 (save-excursion
 (insert result)))))
-(defun my/calc-line (arg)
+(defun my-calc-line (arg)
 "Evaluate expression in current line and display the result in
 the echo area by skipping final '=' sign. With prefix ARG
 non-nil, insert the result at the end of line and space if
 necessary for delimiting."
 (interactive "P")
 (when (featurep 'flyspell)
 (add-hook 'rst-mode-hook #'flyspell-mode))
 (when (featurep 'company)
-(add-hook 'rst-mode-hook #'my/company-text-setup))
+(add-hook 'rst-mode-hook #'my-company-text-setup))
 ;; (add-hook 'rst-mode-hook #'abbrev-mode)
 ;; (remove-hook 'rst-mode-hook #'abbrev-mode)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (let ( (path-separator ":") )
 (require 'info)
 (info-initialize) ))
 ;; Info index nodes for automake under Debian.
-(defvar my/fix-for-automake-info-lookup
+(defvar my-fix-for-automake-info-lookup
 '(("(automake-1.11)Macro Index" nil
 "^`" "['(]")
 ("(automake-1.11)Variable Index" nil
 "^`" "['(]")
 ("(automake-1.11)General Index" nil
 "^`" "['(]")))
-;; Add `my/fix-for-automake-info-lookup' entries to the end of doc-spec for
+;; Add `my-fix-for-automake-info-lookup' entries to the end of doc-spec for
 ;; some modes.
 (my--eval-after-load info-look
 (mapc
 (lambda (mode)
 (let ( (doc-spec (info-lookup->doc-spec 'symbol mode)) )
 (mapc
 (lambda (doc-spec-item)
 (setcdr (last doc-spec) (list doc-spec-item)))
-my/fix-for-automake-info-lookup)))
+my-fix-for-automake-info-lookup)))
 '(makefile-mode autoconf-mode))
 (info-lookup-maybe-add-help
 :mode 'makefile-gmake-mode
 :other-modes '(makefile-mode)))
 (add-hook 'gadict-mode-hook 'whitespace-mode)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "figlet")
-(defun my/figlet-region (&optional b e)
+(defun my-figlet-region (&optional b e)
 (interactive "r")
 (shell-command-on-region b e "figlet" (current-buffer) t)
 (comment-region (mark) (point)))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (require 'org-agenda)
 (require 'org-archive))
 ;; XXX org-todo-keywords '((sequence "TODO" "START" "|" "DONE")) for org-version 4.67c
 (add-to-list 'auto-mode-alist '("\\.org$" . org-mode))
-(setq org-directory "~/my/gtd")
+(setq org-directory "~/my-gtd")
 (setq
 org-agenda-ndays 31
 org-deadline-warning-days 7
 org-agenda-show-all-dates t
 org-agenda-format-date "%Y-%m-%d, %A %e %B"
 org-reverse-note-order t
 org-hide-leading-stars t
 org-tags-column 64
 org-archive-save-context-info '(time file olpath todo itags)
 )
-(defvar my/org-agenda-todo-file (concat org-directory "/TODO.org"))
+(defvar my-org-agenda-todo-file (concat org-directory "/TODO.org"))
-(defvar my/org-agenda-note-file (concat org-directory "/NOTE.org"))
+(defvar my-org-agenda-note-file (concat org-directory "/NOTE.org"))
 (setq org-agenda-file-regexp "\\`[^.#].*[^_]\\.org\\'"
 org-agenda-files (list org-directory))
-;; (setq my/org-agenda-learning-file (concat org-directory "/LEARNING.org"))
+;; (setq my-org-agenda-learning-file (concat org-directory "/LEARNING.org"))
-;; (setq org-agenda-files `(,my/org-agenda-todo-file ,my/org-agenda-note-file ,my/org-agenda-learning-file))
+;; (setq org-agenda-files `(,my-org-agenda-todo-file ,my-org-agenda-note-file ,my-org-agenda-learning-file))
 (define-key global-map "\C-va" 'org-agenda)
-(define-key global-map "\C-ve" (lambda nil (interactive) (find-file my/org-agenda-note-file)))
+(define-key global-map "\C-ve" (lambda nil (interactive) (find-file my-org-agenda-note-file)))
 (setq org-todo-keywords '("|" "DONE"))
 ;; My tags for remember buffer.
 (setq org-tag-alist
 ;; `org-tag-alist' instead until bug fixed.
 (setq org-tag-persistent-alist nil)
 (setq org-support-shift-select t)
-(setq org-default-notes-file my/org-agenda-todo-file)
+(setq org-default-notes-file my-org-agenda-todo-file)
 (setq org-capture-templates
-'(("t" "Todo" entry (file my/org-agenda-todo-file) "* %?\n  SCHEDULED: %T")))
+'(("t" "Todo" entry (file my-org-agenda-todo-file) "* %?\n  SCHEDULED: %T")))
 (define-key global-map "\C-vr"
 (lambda () (interactive) (org-capture nil "t")))
 (when (featurep 'company)
-(add-hook 'org-mode-hook #'my/company-text-setup))
+(add-hook 'org-mode-hook #'my-company-text-setup))
-(defun my/org-archive-location (path)
+(defun my-org-archive-location (path)
 "For given PATH make path to archive. Currently add undescore
 before file extention. If file name doesn't match
 `org-agenda-file-regexp' or have no extention return `nil'."
 (if (and (file-name-extension path)
 (string-match org-agenda-file-regexp (file-name-nondirectory path)))
 (concat (file-name-sans-extension path) "_." (file-name-extension path))
 nil))
-(defun my/org-archive-file (path)
+(defun my-org-archive-file (path)
 "Move marked by `org-done-keywords' entries to archive file.
-Archive file name constructed by `my/org-archive-location'."
+Archive file name constructed by `my-org-archive-location'."
-(let ( (archive (my/org-archive-location path))
+(let ( (archive (my-org-archive-location path))
 entry-re entry-done-re
 entry-beg entry-end )
 (unless archive
 (error "'%s' looks like a non-org file..." path))
 (save-excursion
 (insert ?\n)
 (yank)
 (save-buffer))
 (save-buffer) )))))
-(defun my/org-archive (&optional prefix)
+(defun my-org-archive (&optional prefix)
 "Move all entries marked by `org-done-keywords' to archive
-files with name mangled by `my/org-archive-location'.
+files with name mangled by `my-org-archive-location'.
 Without prefix work on current file. With prefix work on
 `org-agenda-files'."
 (interactive "P")
 (loop for file in (if prefix (org-agenda-files) (list (buffer-file-name))) do
-(my/org-archive-file file)))
+(my-org-archive-file file)))
 (setq org-agenda-include-diary nil)
-(defun my/org-kill-by-tag (tag)
+(defun my-org-kill-by-tag (tag)
 "Put all entries that matches TAG from current org-file to `kill-ring'."
 (interactive (list (completing-read "Enter tag: " (org-get-buffer-tags))))
 (let ( rs (last-command 'kill-region) )
 (setq rs (org-scan-tags
 (lambda ()
 (apply #'kill-region r))))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "TODO, XXX, FIXME highlight")
-(dolist (mode (append my/devel-mode-list my/text-mode-list))
+(dolist (mode (append my-devel-mode-list my-text-mode-list))
 (font-lock-add-keywords
 mode
 `(
 ( ,(concat "\\<\\(" (regexp-opt '("TODO" "FIX" "FIXME" "HACK" "XXX")) ":?\\)\\>") 1 'font-lock-warning-face t)
 ;; 64 times, for highlight C-u C-u C-u <key>
-;; ("\\([^[:space:]]\\)\\1\\{63\\}" 0 'my/contrasty-face t)
+;; ("\\([^[:space:]]\\)\\1\\{63\\}" 0 'my-contrasty-face t)
 ))
 )
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "mail, message")
 (eval-when 'compile (require 'message))
 (setq mail-user-agent 'message-user-agent)
-(defun my/compose-mail ()
+(defun my-compose-mail ()
 (interactive)
 (compose-mail nil nil `(("Organization" . ,(getenv "ORGANIZATION")))))
-(global-set-key (kbd "C-x m") #'my/compose-mail)
+(global-set-key (kbd "C-x m") #'my-compose-mail)
 (setq message-citation-line-format "On %Y-%m-%d, %N wrote:
 ")
 (setq message-citation-line-function 'message-insert-formatted-citation-line)
 (my--eval-after-load message
 (require 'mailabbrev)
 (define-key message-mode-map "\e\t" 'mail-abbrev-complete-alias))
-(defun my/message-mode-hook ()
+(defun my-message-mode-hook ()
 (setq fill-column 78)
 (turn-on-auto-fill)
 (flyspell-mode 1))
-(add-hook 'message-mode-hook 'my/message-mode-hook)
+(add-hook 'message-mode-hook 'my-message-mode-hook)
 ;; Mark all my messages by "common" string in "Message-Id" field to simplify
 ;; lookup for followups to me.
 (setq message-user-fqdn "gavenkoa.example.com")
 gnus-backup-startup-file t
 gnus-use-dribble-file t
 gnus-save-killed-list t
 )
-(defun my/kill-gnus ()
+(defun my-kill-gnus ()
 "Kill Gnus when exiting Emacs."
 (let ( (gnus-interactive-exit nil) )
 (gnus-group-exit)
 ))
 (my--eval-after-load gnus
-(add-hook 'kill-emacs-hook 'my/kill-gnus))
+(add-hook 'kill-emacs-hook 'my-kill-gnus))
 (my--eval-after-load gnus-art
 (setq gnus-visible-headers (concat gnus-visible-headers "\\|^Archived-At:\\|^List-URL:\\|^Message-Id:")))
 ;; Store gnus specific files to '~/.gnus'.
 (eval-when-compile
 (ignore-errors
 ;; w3m-anchor is macros in newer Emacs, need definition during byte-compilation.
 (require 'w3m-util)))
-(defun my/w3m-view-url ()
+(defun my-w3m-view-url ()
 (interactive)
 (browse-url (w3m-anchor)))
 (my--eval-after-load w3m
-(define-key w3m-minor-mode-map (kbd "RET") #'my/w3m-view-url)
+(define-key w3m-minor-mode-map (kbd "RET") #'my-w3m-view-url)
 (define-key w3m-minor-mode-map (kbd "S-RET") #'w3m-safe-view-this-url)
 (define-key w3m-minor-mode-map (kbd "<left>") #'backward-char)
 (define-key w3m-minor-mode-map (kbd "<right>") #'forward-char)
 (define-key w3m-minor-mode-map (kbd "<up>") #'previous-line)
 (define-key w3m-minor-mode-map (kbd "<down>") #'next-line))
 ;; Increase the score for followups to a sent article.
 (my--eval-after-load gnus-score
 ;; (add-hook 'message-sent-hook 'gnus-score-followup-article)
 (add-hook 'message-sent-hook 'gnus-score-followup-thread))
-(defvar my/gnus-summary-kill-same-subject-min-len 8
+(defvar my-gnus-summary-kill-same-subject-min-len 8
 "Minimal length of subject string to ignore this subject.")
-(defun my/gnus-summary-kill-same-subject (&optional unmark)
+(defun my-gnus-summary-kill-same-subject (&optional unmark)
 "Add negative scores for all articles with same subject."
 (interactive "P")
 (when (or (not (integerp unmark)) (< 0 unmark))
 (let ( (subj (gnus-simplify-subject-fuzzy (gnus-summary-article-subject))) )
-(when (<= (length subj) my/gnus-summary-kill-same-subject-min-len)
+(when (<= (length subj) my-gnus-summary-kill-same-subject-min-len)
 (gnus-summary-score-entry
 "subject" subj
 's (- gnus-score-interactive-default-score) (current-time-string)))))
 (gnus-summary-kill-same-subject unmark))
 (my--eval-after-load gnus-sum
-(define-key gnus-summary-mode-map (kbd "C-k") #'my/gnus-summary-kill-same-subject))
+(define-key gnus-summary-mode-map (kbd "C-k") #'my-gnus-summary-kill-same-subject))
-(defun my/gnus-mark-thread-as-read ()
+(defun my-gnus-mark-thread-as-read ()
 "Mark unmarked articles in current thread as read and move to
 next thread without selecting article."
 (interactive)
 (gnus-summary-top-thread)
 (catch 'exit
 (when (eq (gnus-summary-article-mark (gnus-summary-article-number)) gnus-unread-mark)
 (gnus-summary-mark-article (gnus-summary-article-number) gnus-del-mark))
 (when (or (not (gnus-summary-search-forward)) (eq (gnus-summary-thread-level) 0))
 (throw 'exit nil)) )))
 (my--eval-after-load gnus-sum
-(define-key gnus-summary-mode-map (kbd "H-k") #'my/gnus-mark-thread-as-read))
+(define-key gnus-summary-mode-map (kbd "H-k") #'my-gnus-mark-thread-as-read))
-(defun my/gnus-thread-score-function (&rest scores)
+(defun my-gnus-thread-score-function (&rest scores)
 "If any followup have positive score assign greater available
 score to thread, else assign lesser available score."
 (let ( (max (apply 'max scores)) (min (apply 'min scores)) )
 (if (< 0 max) max min)))
-(setq gnus-thread-score-function #'my/gnus-thread-score-function)
+(setq gnus-thread-score-function #'my-gnus-thread-score-function)
-(defun my/gnus-thread-total-score ()
+(defun my-gnus-thread-total-score ()
 "Helper to debug `gnus-thread-score-function' function."
 (interactive)
 (message
 (int-to-string
 (gnus-thread-total-score
 (gnus-id-to-thread (mail-header-id (gnus-summary-article-header)))))))
 ;; Especially highlight my message and replays to me.
 (my--eval-after-load gnus-sum
-(defface my/gnus-own-unread-face nil
+(defface my-gnus-own-unread-face nil
 "Use this face to display own postings in Summary Buffer"
-:group 'my/gnus)
+:group 'my-gnus)
-(copy-face 'gnus-summary-high-unread-face 'my/gnus-own-unread-face)
+(copy-face 'gnus-summary-high-unread-face 'my-gnus-own-unread-face)
-(set-face-background 'my/gnus-own-unread-face "linen")
+(set-face-background 'my-gnus-own-unread-face "linen")
 (add-to-list 'gnus-summary-highlight
-'((and (> score 190) (eq mark gnus-unread-mark)) . my/gnus-own-unread-face))
+'((and (> score 190) (eq mark gnus-unread-mark)) . my-gnus-own-unread-face))
-(defface my/gnus-own-ancient-face nil
+(defface my-gnus-own-ancient-face nil
 "Use this face to display own postings in Summary Buffer"
-:group 'my/gnus)
+:group 'my-gnus)
-(copy-face 'gnus-summary-high-ancient-face 'my/gnus-own-ancient-face)
+(copy-face 'gnus-summary-high-ancient-face 'my-gnus-own-ancient-face)
-(set-face-background 'my/gnus-own-ancient-face "linen")
+(set-face-background 'my-gnus-own-ancient-face "linen")
 (add-to-list 'gnus-summary-highlight
-'((and (> score 190) (eq mark gnus-ancient-mark)) . my/gnus-own-ancient-face))
+'((and (> score 190) (eq mark gnus-ancient-mark)) . my-gnus-own-ancient-face))
-(defface my/gnus-own-ticked-face nil
+(defface my-gnus-own-ticked-face nil
 "Use this face to display own postings in Summary Buffer"
-:group 'my/gnus)
+:group 'my-gnus)
-(copy-face 'gnus-summary-high-ticked-face 'my/gnus-own-ticked-face)
+(copy-face 'gnus-summary-high-ticked-face 'my-gnus-own-ticked-face)
-(set-face-background 'my/gnus-own-ticked-face "linen")
+(set-face-background 'my-gnus-own-ticked-face "linen")
 (add-to-list 'gnus-summary-highlight
-'((and (> score 190) (or (eq mark gnus-dormant-mark) (eq mark gnus-ticked-mark))) . my/gnus-own-ticked-face))
+'((and (> score 190) (or (eq mark gnus-dormant-mark) (eq mark gnus-ticked-mark))) . my-gnus-own-ticked-face))
-(defface my/gnus-fup-face nil
+(defface my-gnus-fup-face nil
 "Use this face to display direct fups to my postings."
-:group 'my/gnus)
+:group 'my-gnus)
-(copy-face 'gnus-summary-high-unread-face 'my/gnus-fup-face)
+(copy-face 'gnus-summary-high-unread-face 'my-gnus-fup-face)
-(set-face-background 'my/gnus-fup-face "honeydew")
+(set-face-background 'my-gnus-fup-face "honeydew")
 (add-to-list 'gnus-summary-highlight
-'((and (<= 90 score) (<= score 110) (eq mark gnus-unread-mark)) . my/gnus-fup-face)) )
+'((and (<= 90 score) (<= score 110) (eq mark gnus-unread-mark)) . my-gnus-fup-face)) )
 ;; (setq gnus-home-score-file
 ;;       ;; All groups that match the regexp `"\\.emacs"'
 ;;       '(("\\.emacs" "emacs.SCORE")
 ;;         ;; All the comp groups in one score file
 (define-key gnus-summary-mode-map [(meta up)] '(lambda() (interactive) (scroll-other-window -1)))
 (define-key gnus-summary-mode-map [(meta down)] '(lambda() (interactive) (scroll-other-window 1)))
 (define-key gnus-summary-mode-map [(control down)] 'gnus-summary-next-thread)
 (define-key gnus-summary-mode-map [(control up)] 'gnus-summary-prev-thread))
-(defun my/gnus-search-web-by-message-id ()
+(defun my-gnus-search-web-by-message-id ()
 "Search for article archive by Message-Id in Google."
 (interactive)
 (let ( (msgid (message-fetch-field "Message-Id")) (subj (message-fetch-field "Subject")) )
 (setq msgid (replace-regexp-in-string "[<>]" "" msgid))
 (setq subj (replace-regexp-in-string "[\"#]" " " subj))
 (browse-url (format "https://www.google.com.ua/search?q=%s" (url-encode-url (format "%s OR \"%s\"" msgid subj))))
 (browse-url (format "http://mid.mail-archive.com/%s" (url-encode-url msgid)))))
 (my--eval-after-load gnus-art
-(define-key gnus-article-mode-map [(control return)] #'my/gnus-search-web-by-message-id))
+(define-key gnus-article-mode-map [(control return)] #'my-gnus-search-web-by-message-id))
 ;; (setq imap-log t)
 ;; (setq mail-user-agent 'mh-e-user-agent)
 (when (featurep 'fsm)
 (setq fsm-debug nil))               ; Disable *fsm-debug* buffer.
 ;; Handle Emacs exit.
 (add-hook 'kill-emacs-hook 'jabber-disconnect))
-(defvar my/chat-prompt "[%t] %n>\n")
+(defvar my-chat-prompt "[%t] %n>\n")
 (setq
-jabber-chat-foreign-prompt-format my/chat-prompt
+jabber-chat-foreign-prompt-format my-chat-prompt
-jabber-chat-local-prompt-format my/chat-prompt
+jabber-chat-local-prompt-format my-chat-prompt
-jabber-groupchat-prompt-format my/chat-prompt
+jabber-groupchat-prompt-format my-chat-prompt
 jabber-muc-private-foreign-prompt-format "[%t] %g/%n>\n")
 (let ( (mgs-list '("Я тутачки, а где Вы меня ожидали?"
 "Software Development == Church Development. Step 1. Build it. Step 2. Pray."
 "Great books aren't written – they're rewritten."
 (random t)
 (setq jabber-default-show (nth (random (length mgs-list)) mgs-list))
 (setq jabber-default-status (nth (random (length mgs-list)) mgs-list))
 )
-(defvar my/jabber-users nil
+(defvar my-jabber-users nil
 "Assoc list of jabber user group. Keys are strings, values are lists of JIDs.")
-(defun my/jabber-send (group)
+(defun my-jabber-send (group)
-"GROUP is keys from `my/jabber-users'"
+"GROUP is keys from `my-jabber-users'"
 (interactive
-(list (completing-read "Select group: " my/jabber-users))
+(list (completing-read "Select group: " my-jabber-users))
 )
 (let (
 (msg (if (use-region-p)
 (buffer-substring (region-beginning) (region-end))
 (buffer-string)))
 (deactivate-mark)
 (mapc
 (lambda (user)
 (jabber-send-message jc user "" msg "normal")
 )
-(cdr (assoc group my/jabber-users))
+(cdr (assoc group my-jabber-users))
 )
 )
 )
-(global-set-key (kbd "C-x C-j C-s") 'my/jabber-send)
+(global-set-key (kbd "C-x C-j C-s") 'my-jabber-send)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "erc")
 (eval-when 'compile
 (add-to-list 'magic-mode-alist '(my--c++-header-file-p . c++-mode))
 (setq-default comment-style (quote indent))
 (setq-default comment-column 44)
-(setq-default comment-fill-column my/fill-column)
+(setq-default comment-fill-column my-fill-column)
-(mapc (lambda (hook) (add-hook hook (lambda () (setq fill-column my/fill-column)) ))
+(mapc (lambda (hook) (add-hook hook (lambda () (setq fill-column my-fill-column)) ))
-(append my/devel-mode-hook-list my/text-mode-hook-list))
+(append my-devel-mode-hook-list my-text-mode-hook-list))
-(mapc (lambda (mode) (add-hook (my/mode2hook mode) #'hs-minor-mode))
+(mapc (lambda (mode) (add-hook (my-mode2hook mode) #'hs-minor-mode))
 '(c-mode c++-mode java-mode js-mode lisp-mode emacs-lisp-mode))
-(defun my/company-prog-mode-setup ()
+(defun my-company-prog-mode-setup ()
 (setq-local company-dabbrev-code-other-buffers 'code)
 (setq-local company-backends '((company-capf company-dabbrev-code company-files)))
 (company-mode 1))
 (when (featurep 'company)
-(add-hook 'prog-mode-hook #'my/company-prog-mode-setup))
+(add-hook 'prog-mode-hook #'my-company-prog-mode-setup))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "diff, patch, ediff, emerge")
 (eval-when 'compile (require 'ediff))
 (setq ediff-window-setup-function 'ediff-setup-windows-plain)
 (setq ediff-split-window-function 'split-window-vertically)
 ;; Disable: sometimes it take a long time to process large hunks.
 ;; Use C-c C-b on hunk by own.
-;; (defun my/diff-auto-refine-mode-on () (diff-auto-refine-mode 1))
+;; (defun my-diff-auto-refine-mode-on () (diff-auto-refine-mode 1))
-;; (add-hook 'diff-mode-hook 'my/diff-auto-refine-mode-on)
+;; (add-hook 'diff-mode-hook 'my-diff-auto-refine-mode-on)
 (when window-system
 (my--eval-after-load diff-mode
 (set-face-foreground 'diff-added-face "DarkGreen")
 (set-face-foreground 'diff-removed-face "DarkRed")
 ;; `-b' switch to ignore changes in whitespaces.
 ;; (setq vc-git-diff-switches "-b")
 ;; (setq vc-diff-switches "-b")
-(defun my/vc-root-diff (prefix)
+(defun my-vc-root-diff (prefix)
 "Same as `vc-root-diff' but for Hg with C-u show latest MQ patch and
 with C-u C-u show MQ patch and local changes."
 (interactive "P")
 (when (eq 'non-hg-mq
 (catch 'break
 (vc-diff-internal t (list 'Hg (list rootdir)) "qparent" "qtip"))
 ((equal prefix '(16))
 (vc-diff-internal t (list 'Hg (list rootdir)) "qparent" nil)) ))))
 (call-interactively 'vc-root-diff nil) ))
-(global-set-key (kbd "C-x v D") 'my/vc-root-diff)
+(global-set-key (kbd "C-x v D") 'my-vc-root-diff)
 (when window-system
 (setq
 vc-annotate-very-old-color "#0b5b20"
 vc-annotate-background "white"
 (320 . "#2780C6")
 (340 . "#1A00D3")
 (360 . "#0D80E0")))
 )
-(defun my/log-edit-mode-hook ()
+(defun my-log-edit-mode-hook ()
 (setq fill-column 78)
 )
-(add-hook 'log-edit-mode-hook 'my/log-edit-mode-hook t)
+(add-hook 'log-edit-mode-hook 'my-log-edit-mode-hook t)
 (eval-after-load 'log-edit
 '(remove-hook 'log-edit-hook 'log-edit-insert-message-template))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (add-to-list 'compilation-mode-font-lock-keywords '("\\(/[Oo][Uu][Tt]:[^[:blank:]]+\\)" . 1))
 (add-to-list 'compilation-mode-font-lock-keywords '("[[:blank:]]\\(/F[oe][^[:blank:]]+\\)" . 1))))
 (ignore-errors
 (require 'ansi-color)
-(defun my/colorize-compilation-buffer ()
+(defun my-colorize-compilation-buffer ()
 (when (eq major-mode 'compilation-mode)
 (ansi-color-apply-on-region compilation-filter-start (point-max))))
-(add-hook 'compilation-filter-hook 'my/colorize-compilation-buffer))
+(add-hook 'compilation-filter-hook 'my-colorize-compilation-buffer))
-(defvar my/comint-send-hist-list nil
+(defvar my-comint-send-hist-list nil
-"History list for `my/comint-send-string'."
+"History list for `my-comint-send-string'."
 )
-(defun my/comint-send-string (string)
+(defun my-comint-send-string (string)
 "Send string to comint buffers. Useful for *compilation* read-only buffer.
 Automaticaly append final newline."
 (interactive
-(list (read-string "Type string: " nil 'my/comint-send-hist-list))
+(list (read-string "Type string: " nil 'my-comint-send-hist-list))
 )
 (comint-send-string (get-buffer-process (current-buffer)) (concat string "\n"))
 )
 (my--eval-after-load compile
-(define-key compilation-mode-map [C-return] 'my/comint-send-string))
+(define-key compilation-mode-map [C-return] 'my-comint-send-string))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "scons")
 (add-to-list 'auto-mode-alist '("SConstruct\\'" . python-mode))
 (global-set-key "\M-." 'etags-select-find-tag)
 )
 (setq tags-add-tables t)
-(defvar my/ido-tag-history nil
+(defvar my-ido-tag-history nil
-"History of tags selected using `my/ido-complete-tag'.")
+"History of tags selected using `my-ido-complete-tag'.")
-(defun my/ido-complete-tag (&optional substr)
+(defun my-ido-complete-tag (&optional substr)
 "Find a tag using ido."
 (tags-completion-table)
 (let ( tag-names )
 (mapatoms (lambda (x) (push (symbol-name x) tag-names)) tags-completion-table)
-(ido-completing-read "Tag: " tag-names nil t substr 'my/ido-tag-history)))
+(ido-completing-read "Tag: " tag-names nil t substr 'my-ido-tag-history)))
-(defun my/complete-tag (prefix point)
+(defun my-complete-tag (prefix point)
 (interactive "P\nd")
 (if prefix
 (funcall #'complete-tag)
 (let ( (bounds (find-tag-default-bounds)) tag )
 (if (or (not bounds) (< point (car bounds)) (< (cdr bounds) point))
-(setq tag (my/ido-complete-tag))
+(setq tag (my-ido-complete-tag))
-(setq tag (my/ido-complete-tag (buffer-substring (car bounds) (cdr bounds))))
+(setq tag (my-ido-complete-tag (buffer-substring (car bounds) (cdr bounds))))
 (delete-region (car bounds) (cdr bounds)))
 (insert tag))))
-(global-set-key [M-return] #'my/complete-tag)
+(global-set-key [M-return] #'my-complete-tag)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "CEDET, semantic, SRecord")
 ;; For debug use 'semantic-debug-idle-function' and 'semantic-debug-idle-work-function'.
 (defvar srecode-map-load-path nil)
 (add-to-list 'srecode-map-load-path (locate-user-emacs-file "srecode/"))
 (global-srecode-minor-mode 1)
 (add-hook 'prog-mode-hook 'srecode-minor-mode)
-(defun my/srecode-reload-templates ()
+(defun my-srecode-reload-templates ()
 "Reload all templates under `srecode-map-load-path'. Useful
 during template developing."
 (interactive)
 (setq srecode-mode-table-list nil
 srecode-current-map nil)
 ;; (add-to-list 'ede-locate-setup-options 'ede-locate-idutils)
 ;; (add-to-list 'ede-locate-setup-options 'ede-locate-global)
 ;; (ignore-errors (require 'cedet-idutils))
-(defun my/c-mode-cedet-hook ()
+(defun my-c-mode-cedet-hook ()
 ;; (local-set-key [C-return] 'semantic-complete-symbol)
 ;; (local-set-key [C-return] 'semantic-complete-analyze-inline)
 ;; (local-set-key "." 'semantic-complete-self-insert)
 ;; (local-set-key ">" 'semantic-complete-self-insert)
 )
-(add-hook 'c-mode-common-hook 'my/c-mode-cedet-hook)
+(add-hook 'c-mode-common-hook 'my-c-mode-cedet-hook)
 (ignore-errors
 (require 'semantic/ia)
 (define-key semantic-mode-map (kbd "C-c , .") 'semantic-ia-fast-jump)
 (define-key semantic-mode-map (kbd "C-c , d") 'semantic-ia-show-doc)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "imenu")
 (require 'imenu)
-(defun my/imenu-to-menubar ()
+(defun my-imenu-to-menubar ()
 "Force imenu building when (menu-bar-mode -1)."
 (when imenu-generic-expression
 (imenu-add-menubar-index)
 (run-hooks 'menu-bar-update-hook) ))
-(mapc (lambda (hook) (add-hook hook 'my/imenu-to-menubar))
+(mapc (lambda (hook) (add-hook hook 'my-imenu-to-menubar))
-my/devel-mode-hook-list)
+my-devel-mode-hook-list)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "windows inf files for driver installin")
 (add-to-list 'auto-mode-alist '("\\.inf\\'" . conf-mode))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "makefile, make")
 (add-to-list 'auto-mode-alist '("\\(Makefile\\|Makefile\\..+\\)\\'" . makefile-gmake-mode) t)
-(defun my/makefile-setup ()
+(defun my-makefile-setup ()
 (add-hook 'completion-at-point-functions 'comint-filename-completion nil t))
-(add-hook 'makefile-mode-hook #'my/makefile-setup)
+(add-hook 'makefile-mode-hook #'my-makefile-setup)
-(defun my/makefile-company-setup ()
+(defun my-makefile-company-setup ()
 "Limit search for symbols to Makefiles."
 (setq-local company-dabbrev-code-other-buffers t)
 (setq-local company-backends '((company-capf company-dabbrev-code company-files company-executable)))
 (company-mode 1))
 (when (featurep 'company)
-(add-hook 'makefile-mode-hook #'my/makefile-company-setup))
+(add-hook 'makefile-mode-hook #'my-makefile-company-setup))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "asm, assembler")
 ;; (setq-default asm-comment-char 59)
 ;; Minor mode that highlights suspicious C and C++ constructions.
 (global-cwarn-mode 1)
 (setq c-echo-syntactic-information-p t)
-(defun my/c-mode-common-hook ()
+(defun my-c-mode-common-hook ()
 ;; Automatically inserte newlines after special characters such as brace, comma, semi-colon, and colon.
 (c-toggle-auto-newline -1)
 ;; Delete all preceding whitespace by DEL.
 (c-toggle-hungry-state -1)
 ;; Auto indent after typing colon according to `c-hanging-colons-alist'.
 (c-toggle-electric-state 1)
 )
-(add-hook 'c-mode-common-hook 'my/c-mode-common-hook)
+(add-hook 'c-mode-common-hook 'my-c-mode-common-hook)
-(defconst my/c-style
+(defconst my-c-style
 '((c-tab-always-indent . t)
 (c-comment-only-line-offset . 4)
 (c-hanging-braces-alist
 . (
 (brace-list-open)
 (c-report-syntactic-errors . t)
 ;; Echo syntactic information on TAB in message buffer.
 (c-echo-syntactic-information-p . t))
 "My C Programming Style")
-(defun my/c-mode-style-hook ()
+(defun my-c-mode-style-hook ()
-(c-add-style "my" my/c-style t)
+(c-add-style "my" my-c-style t)
 ;; If set 'c-default-style' before 'c-add-style'
 ;; "Undefined style: my" error occured from 'c-get-style-variables'.
 (setq c-default-style
 '(
 (java-mode . "my") (c-mode . "my") (csharp-mode . "my") (c++-mode . "my") (objc-mode . "my")
 (idl-mode . "my")
 (awk-mode . "awk")
 (other . "my")
 ))
 )
-(add-hook 'c-mode-common-hook 'my/c-mode-style-hook)
+(add-hook 'c-mode-common-hook 'my-c-mode-style-hook)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "python, python-mode")
 (eval-when 'compile
 (add-to-list 'python-shell-setup-codes 'my-python/eldoc-setup-code) ; Used inside (python-shell-send-setup-code)
 (define-key python-mode-map "\C-c\C-d" 'my-python/eldoc-at-point)
 (define-key python-mode-map "\C-c\C-g" 'my-python/eldoc-at-point2)
 (define-key python-mode-map [?\C-c ?\C-h] 'my-python/send-paragraph))
-(defgroup my/python nil
+(defgroup my-python nil
 "My Python extentions in Emacs."
 :group 'python)
 (defvar my-python/pylint-command "pylint"
 "Command to run pylint executable.")
 (pyflakes3 . (my-python/pyflakes3-command my-python/pyflakes3-args)))
 "Known Python source code checkers.")
 (defcustom my-python/default-checker 'pyflakes
 "Default Python source code checker. See `my-python/checker-alist' for full alist."
-:group 'my/python
+:group 'my-python
 :type (cons 'choice (mapcar (lambda (e) (cons 'const e)) my-python/checker-alist)))
 (defvar my-python/check-history nil)
 (defun my-python/check (&optional checker)
 ;; (pymacs-load "ropemacs" "rope-")
 )
 ;; Automatically save project python buffers before refactorings
 (setq ropemacs-confirm-saving 'nil)
-(defun my/python-add-to-path (path)
+(defun my-python-add-to-path (path)
 (interactive (list (read-directory-name "Enter new path for PYTHONPATH: ")))
 (when (featurep 'cygwin-mount)
-(setq path (my/dos2cygwin-path path)))
+(setq path (my-dos2cygwin-path path)))
 (python-send-string (format "import sys; sys.path.append(\"%s\")" (expand-file-name path))) )
-(defun my/python-django-fix (path)
+(defun my-python-django-fix (path)
 "XXX not work on Cygwin + naive Emacs."
 (interactive (list (read-directory-name "Enter new path for PYTHONPATH: ")))
 (when (featurep 'cygwin-mount)
-(setq path (my/dos2cygwin-path path))
+(setq path (my-dos2cygwin-path path))
 )
 (let ((file (concat path "manage.py")))
 (if (file-exists-p file)
 (python-send-string (format "import os; os.chdir(\"%s\"); execfile(\"%s\")" path file))
 (error (format "file '%s' does not exist" file))
 ;; Disable in flavor of Semantic and perfomance reason.
 ;; (when (>= emacs-major-version 22)
 ;;   (add-hook 'python-mode-hook 'turn-on-eldoc-mode)
-(defun my/python-mode-hook ()
+(defun my-python-mode-hook ()
 (when (and (eq window-system 'w32) (fboundp 'prettify-symbols-mode))
 (prettify-symbols-mode -1)))
-(add-hook 'python-mode-hook 'my/python-mode-hook)
+(add-hook 'python-mode-hook 'my-python-mode-hook)
 (when (equal window-system 'w32)
 (add-to-list 'process-coding-system-alist '("python" cp1251-unix . cp1251-unix)))
 (add-to-list 'auto-mode-alist '("/requirements.txt\\'" . conf-mode))
 ;; (add-to-list 'auto-mode-alist '("\\.js$" . c++-mode))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "json")
-(defun my/json-mode-hook ()
+(defun my-json-mode-hook ()
 (set (make-local-variable 'js-indent-level) 2))
-(add-hook 'json-mode-hook #'my/json-mode-hook)
+(add-hook 'json-mode-hook #'my-json-mode-hook)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "bat file, batch")
 ;; loaded from 'generic-x.el'
 (when (fboundp 'subword-mode)
 (add-hook 'java-mode-hook #'subword-mode))
 (add-hook 'java-mode-hook #'auto-revert-mode)
-(defun my/company-java-setup ()
+(defun my-company-java-setup ()
 (setq-local company-dabbrev-code-other-buffers t)
 (setq-local company-backends '((company-semantic company-capf company-dabbrev-code)))
 (company-mode 1))
 (when (and (featurep 'semantic) (featurep 'company))
-(add-hook 'java-mode-hook #'my/company-java-setup))
+(add-hook 'java-mode-hook #'my-company-java-setup))
-(defvar my/java-exeption-dirs nil
+(defvar my-java-exeption-dirs nil
-"List of dirs to look by `my/java-exeption'.")
+"List of dirs to look by `my-java-exeption'.")
-(defun my/java-exeption ()
+(defun my-java-exeption ()
-"Look at current line if it like Java exaption and try find file using `my/java-exeption-dirs'"
+"Look at current line if it like Java exaption and try find file using `my-java-exeption-dirs'"
 (interactive)
 (save-excursion
 (let ( path file line end )
 (forward-line 1)
 (backward-char 1)
 (setq path (replace-regexp-in-string (concat "\\." file ".*") "" path))
 (setq path (replace-regexp-in-string "\\." "/" path))
 (setq path (cl-some (lambda (dir)
 (let ((full-path (format "%s/%s/%s.java" dir path file)))
 (when (file-exists-p full-path) full-path)))
-my/java-exeption-dirs))
+my-java-exeption-dirs))
 (if (not path)
 (message "Can't find file %s.java" file)
 (find-file-other-window path)
 (goto-line (string-to-int line)))))))
 (my--eval-after-load log4-hi-mode
-(define-key log4-hi-mode-map [C-return] #'my/java-exeption))
+(define-key log4-hi-mode-map [C-return] #'my-java-exeption))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "Pascal")
 (eval-when 'compile (require 'pascal))
 htmlize-convert-nonascii-to-entities nil)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "html")
-(defun my/html-charref-escape-region (start end)
+(defun my-html-charref-escape-region (start end)
 (interactive "r")
 (save-excursion
 (save-restriction
 (narrow-to-region start end)
 (goto-char (point-min))
 (while (search-forward "<") (replace-match "&lt;"))
 (goto-char (point-min))
 (while (search-forward ">") (replace-match "&gt;"))
 )))
-(defun my/html-charref-from-char (char)
+(defun my-html-charref-from-char (char)
 (format "&#%d;" char)
 )
-(defun my/html-charref-from-string (string)
+(defun my-html-charref-from-string (string)
 (let ((res ""))
 (mapc
-(lambda (char) (setq res (concat res (my/html-charref-from-char char))))
+(lambda (char) (setq res (concat res (my-html-charref-from-char char))))
 string)
 res
 ) )
-(defun my/html-charref-escape-region2 (begin end &optional prefix)
+(defun my-html-charref-escape-region2 (begin end &optional prefix)
 (interactive "r\nP")
 (if prefix
 (save-excursion
 (goto-char begin)
-(insert (my/html-charref-from-string (delete-and-extract-region begin end))))
+(insert (my-html-charref-from-string (delete-and-extract-region begin end))))
-(my/html-charref-from-string (buffer-substring begin end))
+(my-html-charref-from-string (buffer-substring begin end))
 ))
-(defun my/html-charref-to-string (html)
+(defun my-html-charref-to-string (html)
 "Return string with replaced decimal/hex and string charrefs by
 correcponding UTF-8 symbol."
 (let (str)
 (with-temp-buffer
 (insert html)
 (replace-match "\"" t t))
 ((equal str "amp")
 (replace-match "&" t t)))) ))
 (buffer-string))))
-(defun my/html-charref-unescape-region (begin end &optional prefix)
+(defun my-html-charref-unescape-region (begin end &optional prefix)
 (interactive "r\nP")
 (if prefix
 (save-excursion
 (goto-char begin)
-(insert (my/html-charref-to-string (delete-and-extract-region begin end))))
+(insert (my-html-charref-to-string (delete-and-extract-region begin end))))
-(my/html-charref-to-string (buffer-substring begin end))
+(my-html-charref-to-string (buffer-substring begin end))
 ))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "nxml")
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "psgml")
 (eval-when 'compile (require 'psgml nil t))
-(defvar my/html-template
+(defvar my-html-template
 '("html"
 (nil
 "\n<head>" \n
 "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=" (read-string "Charset: ") "\">" \n
 "<title>" (setq str (read-string "Title: ")) "</title>\n"
 (my--eval-after-load sgml-mode
 (unless (featurep 'psgml)
 (setq html-tag-alist
 (cons
-my/html-template
+my-html-template
-(my/filter
+(my-filter
 (lambda (item) (not (equal (car item) "html")))
 html-tag-alist)))
 (add-to-list 'html-tag-alist '("script" (\n) ("type" "text/javascript") ))
 (add-to-list 'html-tag-alist '("style" (\n) ("type" "text/css") )) ))
 (setq sh-basic-offset 2)
 (add-to-list 'auto-mode-alist '("\\.cygport\\'" . shell-script-mode))
-(defun my/sh-company-setup ()
+(defun my-sh-company-setup ()
 (setq-local company-backends '((company-capf company-files company-dabbrev-code)))
 (setq-local company-dabbrev-code-other-buffers t)
 (company-mode 1))
 (when (featurep 'company)
-(add-hook 'sh-mode-hook #'my/sh-company-setup))
+(add-hook 'sh-mode-hook #'my-sh-company-setup))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "pg, Proof General")
 (eval-when 'compile (require 'proof nil t))
 ;; This enable "define" and "&var" syntax.
 (setq sql-oracle-scan-on nil)
 (add-hook 'sql-interactive-mode-hook (lambda () (toggle-truncate-lines 1)))
-(defun my/sql-explain-paragraph ()
+(defun my-sql-explain-paragraph ()
 "Send the current paragraph to the SQL process with \"explain \" keyword.
 Works at least for MySql/MariaDB."
 (interactive)
 (let ((start (save-excursion
 (backward-paragraph)
 (forward-paragraph)
 (point))))
 (sql-send-string (concat "explain " (buffer-substring-no-properties start end)))))
 (my--eval-after-load sql
-(define-key sql-mode-map (kbd "C-c C-e") 'my/sql-explain-paragraph))
+(define-key sql-mode-map (kbd "C-c C-e") 'my-sql-explain-paragraph))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (message "backuping")
 (setq

changeset 1514	1ce5595fe5f1
parent 1507	6f939639c52a
child 1527	ff6e296d2b21