dot-emacs: comparison .emacs-my

equal deleted inserted replaced

-:c0c3d88cd779
+:ab33594a8189
 ;; 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))) )
 '("" ".el")))))
 (with-temp-buffer
 (insert-file-contents (locate-file library load-path '("" ".el")))
 (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)))
 (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) )
 (interactive)
 (let ( (grep-find-template "find . -type f <F> -exec zgrep <C> -nH -e <R> {} +") (grep-find-ignored-files nil) )
 (cl-flet ( (grep-compute-defaults () nil) )
 (call-interactively #'rgrep))))
+(ignore-errors (require 'ag))
 (defun my/ag (regex)
 "Search with ag from project roor without prefix and from
 `default-directory' with prefix."
 (interactive (list (ag/read-from-minibuffer "Search regex")))
 (if current-prefix-arg
 (let ((current-prefix-arg nil)) (ag-regexp regex default-directory))
 (ag-project-regexp regex)))
-(ignore-errors (require 'ag))
 (setq ag-highlight-search t)
 (when (featurep 'ag)
 (global-set-key [f7] 'my/ag))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (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 ?ˈ ?ˌ ?ː ?ǁ ?ʲ ?θ ?ð ?ŋ ?ɡ ?ʒ ?ʃ ?ʧ ?ə ?ɜ ?ɛ ?ʌ ?ɒ ?ɔ ?ɑ ?æ ?ʊ ?ɪ))
 (when (boundp 'char-script-table)       ; Absent in Emacs 22.
 (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
 ;; 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")
 (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)))
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (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 ()
 "Mark unmarked articles in current thread as read and move to
 next thread without selecting article."
 (interactive)
 (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))
-(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
 (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 ()
 (setq-local company-dabbrev-code-other-buffers 'code)
 (setq-local company-backends '((company-capf company-dabbrev-code company-files)))
 (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))
 ;; 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
 ;; (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))
 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") )) ))
 ;; 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 1490	ab33594a8189
parent 1489	c0c3d88cd779
child 1494	874f705f7be4