Download
(require 'cl)
(add-to-list 'load-path "~/.emacs.d/extension/")
(add-to-list 'load-path "~/.emacs.d/site-lisp")
(load "utils")
(load "extensions-bundle")
(defvar pre-23.2
(version-list-<
(version-to-list emacs-version)
'(23 2))
"this variable is t if emacs version is < 23.2")
(defvar hostname
(or (getenv "HOSTNAME") (getenv "COMPUTERNAME") "unknown")
"hostname of this machine")
(defvar in-windows
(equal window-system 'w32)
"t if emacs is running in windows")
(defvar has-x
(equal window-system 'x)
"if X is running. When X is running, some initial settings are done in X resources and do not need to repeat in init file.")
(and in-windows
(load "~/.emacs.d/startup/windows"))
(setq require-final-newline t)
(show-paren-mode 1)
(global-set-key (kbd "M-w") 'copy-region-as-kill)
(setq make-backup-files nil)
(setq inhibit-startup-message t)
(setq inhibit-startup-echo-area-message "sylecn")
(setq initial-scratch-message nil)
(unless has-x
(blink-cursor-mode -1)
(if (fboundp 'scroll-bar-mode) (scroll-bar-mode -1))
(if (fboundp 'tool-bar-mode) (tool-bar-mode -1))
(if (fboundp 'menu-bar-mode) (menu-bar-mode -1))
)
(setq visible-bell nil)
(setq ring-bell-function 'ignore)
(setq use-dialog-box nil)
(defvar use-session nil
"use session or not.
If non-nil use session, else use saveplace and savehist.")
(setq use-session nil)
(if use-session
(progn
(require 'session)
(add-hook 'after-init-hook 'session-initialize))
(progn
(require 'saveplace)
(setq save-place-file "~/.emacs.d/.emacs-places")
(setq-default save-place t)
(savehist-mode 1)))
(require 'ido)
(ido-mode 'buffers)
(setq ido-max-window-height 1)
(setq ido-save-directory-list-file "~/.emacs.d/.ido.last")
(setq mouse-yank-at-point t)
(setq message-log-max 5000)
(require 'pp-c-l)
(pretty-control-l-mode 1)
(setq pp^L-^L-string "")
(display-time-mode 1)
(setq display-time-format "%I:%M%p %b%d %a")
(setq display-time-use-mail-icon t)
(defvar use-color-theme nil
"set to t to use color-theme feature if it's available.
set to nil to disable all color/face customization.
set to other symbol to use that theme. I prefix my themes with \"my\", to distinguish themes in color-theme package.")
(if in-windows
(setq use-color-theme 'my-white-on-win7-blue)
(setq use-color-theme 'my-white-on-dark-green))
(case use-color-theme
(my-white-on-dark-green
(unless has-x
(set-background-color "#003c3c")
(set-foreground-color "#FFFFFF")
(set-face-background 'fringe "#253c3c")
(set-face-background 'cursor "#FFFFFF")
(set-face-foreground 'ido-only-match "cyan")
(set-face-background 'region "gray25")
))
(my-white-on-gray
(set-background-color "gray35")
(set-foreground-color "AntiqueWhite1")
(set-face-background 'fringe "gray35")
(set-face-foreground 'ido-only-match "cyan")
(set-face-foreground 'font-lock-comment-face "gold")
)
(my-white-on-win7-blue
(set-background-color "#0A3B76")
(set-foreground-color "#FFFFFF")
(set-cursor-color "gray")
(set-face-background 'fringe "#003070")
)
(none
(set-face-background 'region "#ddddbb")
)
(t (load "~/.emacs.d/startup/color-theme")))
(auto-image-file-mode 1)
(eval-after-load 'image-mode
'(define-key image-mode-map (kbd "g")
'revert-buffer))
(require 'hl-line+)
(toggle-hl-line-when-idle 1)
(hl-line-when-idle-interval 20)
(setq hl-line-inhibit-highlighting-for-modes
'(Info-mode help-mode view-mode Man-mode))
(load "~/.emacs.d/startup/need-for-keys")
(load "~/.emacs.d/startup/compile")
(load "~/.emacs.d/startup/use-clipboard")
(defvar auto-mode-alist-init
auto-mode-alist "emacs default value for `auto-mode-alist'.")
(setq auto-mode-alist
(append '(
("\\.git/COMMIT_EDITMSG\\'" . gcm-mode)
("\\.acl2\\'" . myacl2-mode)
("acl2-customization.lisp\\'" . myacl2-mode)
("\\.m\\'" . octave-mode)
("\\.flex\\'" . flex-mode)
("\\.l\\'" . flex-mode)
("\\.bison\\'" . bison-mode)
("\\.y\\'" . bison-mode)
("/scripts/" . shell-script-mode)
("\\.cmd\\'" . dos-mode)
("\\.cs\\'" . csharp-mode)
("mutt-[a-z]+-[^-]+-[0-9]+.*" . mail-mode)
("\\.mail\\'" . mail-mode)
("\\.bash.*" . shell-script-mode)
("\\.\\(xsessionrc\\|Xresources\\)" . shell-script-mode)
("crontab" . conf-mode)
("fromsource/yasnippet-snippets-active/" . snippet-mode)
("non-lisp-data/yasnippets/" . snippet-mode)
("yasnippet/snippets/" . snippet-mode)
("CMakeLists\\.txt\\'" . cmake-mode)
("\\.cmake\\'" . cmake-mode)
("SConscript\\'" . python-mode)
("SConstruct\\'" . python-mode)
("\\.po\\'" . po-mode)
("\\.html\\'" . html-mode)
("\\.\\(rng\\|xml\\)\\'" . nxml-mode)
("\\.js\\'" . js-mode)
("\\.dbl\\'" . js-mode)
("\\.json\\'" . json-mode)
("blogs.*\\.txt" . html-mode)
("\\.inc\\'" . php-mode)
("\\.php[34]?\\'\\|\\.phtml\\'" . php-mode)
("www\\.emacswiki\\.org\\..*\\.txt" . really-simple-wiki-mode)
("code\\.google\\.com\\..*\\.txt" . really-simple-wiki-mode)
("\\.org\\'" . org-mode)
("\\.dot\\'" . graphviz-dot-mode)
("species/.*_program.txt" . linum-mode)
("google-project-hosting.*/.*\\.h\\'" . c++-mode)
("proj./.*\\.h\\'" . c++-mode)
("\\.manpage\\'" . Man-mode)
)
auto-mode-alist-init))
(dolist (d (directory-files "~/.emacs.d/site-lisp" t))
(or (string-match "\\(/\\.\\.?\\|\\.el\\)$" d)
(and (file-directory-p d)
(add-to-list 'load-path d))))
(add-to-list 'load-path "~/lisp/elisp/dog")
(defvar myfiles
(cond
((equal hostname "sylecn")
'("todo" "low"
"~/texts/bugs/bugs"
"learnlinux"
"notes" "log" "progress" "url"
"kemacs"
"projects/lword/words"
"texts/lword"
".emacs.d/.emacs"
))
((string-match "cs.utexas.edu" hostname)
'("notes-cs" "cs_my" ".emacs"))
((string-match "PERSONAL-C51A67" hostname)
'(".emacs"
"wintext/notes" "wintext/learnwin" "wintext/kemacs"
"wintext/log"
"wintext/progress"
"wintext/tvlog" "wintext/zylog"
"wintext/todo" "wintext/low"
"wintext/movielog" "wintext/tvlog"
"wintext/gamelog" "wintext/music"
"wintext/wecn"
"d:/Projects/PESIndex/wecnindex.xml"
))
(t nil))
"My important daily files, which will be opened (and protected) when emacs starts.
By convention, emacs will look for files not start with / under ~/ and ~/texts/, in that order.")
(defvar myfilesex
'(("~/.mutt/muttrc")
(html-notes . "~/helps/html/my-html-notes")
("~/texts/book-list"))
"a list of my most often used files. element can be a string or a cons.
if element is a string, it is the filename with path.
if element is a cons, the car is a alias for the file, the cdr is the filename with path.")
(defalias 'cal 'calendar)
(defvar completion-ignored-extensions-init
completion-ignored-extensions)
(setq completion-ignored-extensions
(cons "TAGS" completion-ignored-extensions-init))
(setq frame-title-format
'(multiple-frames "%b"
("" invocation-name "@" system-name " | %M")))
(defun insert-word-under-point ()
"insert word under point.
For minibuffer ordinary input, like M-x occur"
(interactive)
(insert (with-current-buffer (window-buffer (minibuffer-selected-window))
(thing-at-point 'symbol))))
(defun insert-buffer-filename (&optional arg)
"insert `buffer-file-name'. With prefix, insert file name with full path.
For minibuffer ordinary input, like M-x shell-command"
(interactive "P")
(let ((fn (buffer-file-name (window-buffer (minibuffer-selected-window)))))
(insert (if arg fn (file-name-nondirectory fn)))))
(define-key minibuffer-local-map (kbd "M-.")
'insert-word-under-point)
(define-key minibuffer-local-map (kbd "M-,")
'insert-buffer-filename)
(defalias 'debug-on-error 'toggle-debug-on-error)
(setq copyright-limit 500)
(defalias 'wrap 'toggle-truncate-lines)
(setq bookmark-default-file "~/.emacs.d/bookmarks")
(require 'uniquify)
(setq uniquify-buffer-name-style 'post-forward)
(setq save-interprogram-paste-before-kill t)
(defun my-find-file-hook ()
(cond
((string-equal (buffer-file-name) "/usr/share/doc/aptitude/README")
(rename-buffer "*aptitude*"))
((and buffer-file-name
(string-match "/\\(fromsource\\|site-lisp\\)/" (buffer-file-name)))
(view-mode 1))
((eq major-mode 'fundamental-mode) (org-mode))
(t nil)))
(add-hook 'find-file-hook 'my-find-file-hook)
(setq browse-url-browser-function 'browse-url-generic)
(case window-system
(x (setq browse-url-generic-program "firefox4"
browse-url-generic-args (list "-P" "v4")))
(w32 (setq browse-url-generic-program "C:\\Program Files (x86)\\Mozilla Firefox4\\firefox.exe")
(t (setq browse-url-generic-program "firefox"))))
(defun wsclean-for-some-mode ()
"do `whitespace-cleanup' for modes in `wsclean-mode-list'"
(if (member major-mode '(java-mode c-mode emacs-lisp-mode
makefile-gmake-mode
python-mode
html-mode js-mode js2-mode nxml-mode
sh-mode))
(whitespace-cleanup))
nil)
(add-hook 'write-file-functions 'wsclean-for-some-mode)
(add-to-list 'safe-local-variable-values '(org-odd-levels-only . nil))
(add-to-list 'safe-local-variable-values '(org-odd-levels-only . t))
(defvar safe-local-eval-forms-init
safe-local-eval-forms "emacs default value for `safe-local-eval-forms'.")
(setq safe-local-eval-forms
(cons '(auto-fill-mode -1)
safe-local-eval-forms-init))
(setq sentence-end "[.?!]\s*")
(put 'upcase-region 'disabled nil)
(put 'downcase-region 'disabled nil)
(setq view-read-only t)
(setq tags-revert-without-query t)
(setq-default truncate-lines nil)
(setq scroll-preserve-screen-position t)
(add-hook 'before-save-hook 'time-stamp)
(setq time-stamp-format "%:y-%02m-%02d")
(add-hook 'before-save-hook 'copyright-update)
(add-to-list 'same-window-regexps '("\\*Man.*"))
(xterm-mouse-mode 1)
(setq hippie-expand-try-functions-list
'(
yas/hippie-try-expand
try-complete-file-name
try-expand-list
try-expand-dabbrev-all-buffers
try-expand-dabbrev-from-kill
try-complete-lisp-symbol-partially
try-complete-lisp-symbol
try-expand-all-abbrevs
))
(if pre-23.2
(setq default-major-mode 'fundamental-mode))
(setq-default major-mode 'fundamental-mode)
(setq-default fill-column 78)
(setq default-input-method "chinese-py")
(load "~/.emacs.d/startup/fonts")
(load "~/.emacs.d/startup/org-mode")
(setq comint-scroll-show-maximum-output nil)
(load "~/.emacs.d/startup/shell-mode")
(load "~/.emacs.d/startup/flymake-ex")
(setq vc-follow-symlinks t)
(setcar (cdr (assq 'auto-fill-function minor-mode-alist)) " F")
(defun my-fundamental-mode-hook ()
(interactive)
(setq mode-name "F"))
(add-hook 'fundamental-mode-hook 'my-fundamental-mode-hook)
(eval-after-load 'diff-mode
'(progn
(set-face-attribute 'diff-hunk-header nil
:foreground "cyan"
:bold nil)
(set-face-foreground 'diff-hunk-header "cyan")
(set-face-foreground 'diff-added "green")
(set-face-foreground 'diff-changed "yellow")
(case use-color-theme
(my-white-on-dark-green
(set-face-foreground 'diff-removed "VioletRed1"))
(t (set-face-foreground 'diff-removed "red")))))
(defun my-Man-mode-search-option (arg)
"search command line option in Man page."
(interactive "sSearch Option: ")
(when (null (let ((case-fold-search nil))
(occur (concat "^[ \t]*" arg))))
(next-error)
(other-window 1)
(bury-buffer)
(delete-window)))
(defun my-Man-mode-hook ()
(interactive)
(define-key Man-mode-map (kbd "o")
'my-Man-mode-search-option)
)
(add-hook 'Man-mode-hook 'my-Man-mode-hook)
(defun my-grep-mode-hook ()
(interactive)
(setq truncate-lines t))
(add-hook 'grep-mode-hook 'my-grep-mode-hook)
(setq dired-listing-switches "-alh")
(setq dired-recursive-deletes 'always)
(defvar dired-regexp-binary-files nil
"a regexp to match binary files, which when open will call run-mailcap instead of `find-file'")
(setq dired-regexp-binary-files
(concat "\\." (regexp-opt (list "flv" "pdf" "mp3" "mov" "rmvb" "wmv"
"mp4" "avi" "rm" "mkv")) "$"))
(defun my-dired-find-file ()
"like `dired-find-file', but use see (part of run-mailcap) to open file for file types in `dired-regexp-binary-files'."
(interactive)
(let ((find-file-run-dired t))
(let ((f (dired-get-file-for-visit)))
(if (string-match dired-regexp-binary-files f)
(start-process "my-dired-find-file" "*see*" "see" f)
(find-file f)))))
(defun my-dired-mouse-find-file-other-window (event)
"In Dired, visit the file or directory name you click on.
Like `dired-mouse-find-file-other-window', but honors `dired-regexp-binary-files'."
(interactive "e")
(let (window pos file)
(save-excursion
(setq window (posn-window (event-end event))
pos (posn-point (event-end event)))
(if (not (windowp window))
(error "No file chosen"))
(set-buffer (window-buffer window))
(goto-char pos)
(setq file (dired-get-file-for-visit)))
(if (file-directory-p file)
(or (and (cdr dired-subdir-alist)
(dired-goto-subdir file))
(progn
(select-window window)
(dired-other-window file)))
(select-window window)
(if (string-match dired-regexp-binary-files file)
(start-process "my-dired-find-file" " *see*" "see" file)
(find-file-other-window (file-name-sans-versions file t))))))
(defun my-dired-mode-hook ()
(interactive)
(define-key dired-mode-map [remap dired-find-file]
'my-dired-find-file)
(define-key dired-mode-map [remap dired-mouse-find-file-other-window]
'my-dired-mouse-find-file-other-window)
)
(add-hook 'dired-mode-hook 'my-dired-mode-hook)
(setq woman-fill-column (if (< fill-column 70) 78 fill-column))
(defun w3-html-validator (&optional synchronous)
"run w3 html validator http://validator.w3.org/ on current buffer.
Show result in *w3-validator* buffer. You can jump to error like in *compile-log* buffer.
For XHTML file, you can use nxml-mode, which can verify XHTML offline."
)
(defun my-html-mode-hook ()
(interactive)
(require 'find-file)
(add-to-list 'ff-other-file-alist
'("\\.html\\'" (".js")))
(require 'multi-web-mode)
(setq mweb-default-major-mode 'html-mode)
(setq mweb-tags '((php-mode "<\\?php\\|<\\? \\|<\\?=" "\\?>")
(js-mode "<script +\\(type=\"text/javascript\"\\|language=\"javascript\"\\)[^>]*>" "</script>")
(css-mode "<style +type=\"text/css\"[^>]*>" "</style>")))
(setq mweb-filename-extensions
'("php" "htm" "html" "ctp" "phtml" "php4" "php5"))
(multi-web-global-mode 1)
)
(add-hook 'html-mode-hook 'my-html-mode-hook)
(setq python-check-command "flymake-python")
(defun python-unit-test-filep (filename)
"return non-nil if given filename is a python unit test"
(let ((case-fold-search t))
(string-match "test" filename)))
(defun python-find-other-file ()
"toggle between unit test file and source file. create the other file if needed."
(interactive)
(let ((filename (file-name-nondirectory (buffer-file-name))))
(if (python-unit-test-filep filename)
(let ((src-file (cond
((string-match "^\\(test_\\|Test\\)\\(.*\\)" filename)
(match-string 2 filename))
((string-match "\\(.*\\)_test\\(\\.py\\)$" filename)
(concat (match-string 1) (match-string 2))))))
(find-file src-file))
(let* ((prefix (file-name-sans-extension filename))
(suffix (file-name-extension filename))
(test-file (or (first-existing-file
(list
(concat "Test" filename)
(concat prefix "Test." suffix)
(concat prefix "_test." suffix)))
(concat "test_" filename))))
(find-file test-file)))))
(defun my-inferior-python-mode-hook ()
(interactive)
)
(add-hook 'inferior-python-mode-hook 'my-inferior-python-mode-hook)
(defun my-python-mode-hook ()
(interactive)
(setq python-indent-offset 4)
(define-key python-mode-map (kbd "C-; a")
'python-find-other-file)
(define-key python-mode-map (kbd "C-; t")
'python-find-other-file)
)
(add-hook 'python-mode-hook 'my-python-mode-hook)
(defun my-log-edit-done-hook ()
(interactive)
(let ((buf (get-buffer "*vc-diff*")))
(and buf
(bury-buffer buf))))
(add-hook 'log-edit-done-hook 'my-log-edit-done-hook)
(require 'autoinsert)
(setq auto-insert-directory "~/.emacs.d/non-lisp-data/skeletons")
(setq auto-insert-query nil)
(defvar auto-insert-alist-init
auto-insert-alist "emacs default value for `auto-insert-alist'.")
(setq auto-insert-alist
(append
'(
((".+Test\\.java$" . "insert java unit test") .
'(nil "tf"))
(("\\.java$" . "insert java class") .
'(nil "class"))
(("test_.*\\.py$" . "insert python unit test") .
'(nil "tf"))
(("_test\\.py$" . "insert python unit test") .
'(nil "tf"))
(("\\.py$" . "insert python standard header") .
'(nil "sh"))
(("\\.\\(h\\|hpp\\)$" . "insert c/c++ header guard") .
'(nil "once" '(yas/expand)))
(("_test\\.\\(cc\\|cpp\\)$" . "insert c++ gtest") .
'(nil "gtest"))
(("_test\\.c$" . "insert c check test") .
'(nil "check"))
(("build\\.xml$" . "insert default ant build file, build.xml") .
'(nil "ant"))
(("CMakeLists\\.txt$" . "insert default cmake build file") .
"CMakeLists.txt")
(("\\.el\\'" . "Emacs Lisp header") .
'(nil "el"))
(("\\.html\\'" . "insert HTML5 header") .
'(nil "html"))
(("\\.tex\\'" . "insert std latex header") .
'(nil "tex" '(yas/expand)))
)
auto-insert-alist-init))
(add-hook 'find-file-hook 'auto-insert)
(require 'whitespace)
(setq whitespace-style
'(trailing))
(setq whitespace-global-modes
'(python-mode
))
(set-face-background 'whitespace-trailing "grey50")
(defun my-text-mode-hook ()
(interactive)
(let ((filename (buffer-file-name)))
(if filename
(cond ((string-match "长安乱.txt" filename)
(view-mode 1))
(t nil)))))
(add-hook 'text-mode-hook 'my-text-mode-hook)
(autoload 'linum "linum")
(setq cal-html-directory "~/life/calendar")
(setq gnus-dribble-directory "~/.emacs.d/gnus")
(setq gnus-inhibit-startup-message t)
(setq gnus-select-method '(nntp "news.gmane.org"))
(setq gnus-secondary-select-methods '((nntp "cu.mi.it")))
(setq gnus-expert-user t)
(defun my-gnus-started-hook ()
(interactive)
(gnus-topic-mode nil t))
(add-hook 'gnus-started-hook 'my-gnus-started-hook)
(defun my-makefile-mode-hook ()
(interactive)
(yas/minor-mode 1)
(auto-fill-mode -1)
)
(add-hook 'makefile-mode-hook 'my-makefile-mode-hook)
(defun my-c-mode-common-hook ()
(interactive)
(abbrev-mode -1)
(auto-fill-mode 1)
(define-key c-mode-map (kbd "C-c C-k")
'kill-compilation)
(define-key c++-mode-map (kbd "C-c C-k")
'kill-compilation)
(define-key java-mode-map (kbd "C-c C-k")
'kill-compilation)
)
(defun four ()
"use four space for indentation."
(interactive)
(setq c-basic-offset 4)
(setq indent-tabs-mode nil))
(add-hook 'c-mode-common-hook 'my-c-mode-common-hook)
(defun is-c-test-file (filename)
"return non-nil if given file is a C test file."
(string-match "_test\\.c" filename))
(defun c-find-test-file ()
"find test file for current c file or vice versa.
for foo.* find foo_test.c;
for foo_test.c find foo.h"
(interactive)
(let ((fn (buffer-file-name)))
(if (is-c-test-file fn)
(message "already at test file.")
(let ((base (file-name-sans-extension fn)))
(find-file (concat base "_test.c"))))))
(defun c-register-test-case ()
"auto register test case at point for check"
(interactive)
(save-excursion
(end-of-line)
(if (search-backward-regexp "START_TEST(\\(test_.*\\))")
(let* ((func (match-string 1))
(reg-stmt (concat "tcase_add_test(tc, " func ");")))
(if (search-forward-regexp reg-stmt nil t)
(message "test %s already registered." func)
(if (search-forward-regexp "/\\* REGISTER ")
(progn
(end-of-line)
(newline-and-indent)
(insert reg-stmt)
(message "%s added in tc." func))
(message "register test failed. can't find insert anchor."))))
(message "register test failed. can't get function name."))))
(defun check-sync-test-case-and-registration ()
"C check unit test. register new test case, remove deleted test case in reg section"
(interactive)
)
(defun my-c-mode-hook ()
(interactive)
(define-key c-mode-map (kbd "C-; t")
'c-find-test-file)
(define-key c-mode-map (kbd "C-; u")
'c-register-test-case)
(require 'find-file)
(add-to-list 'cc-other-file-alist
'("_test\\.c" (".h")))
)
(add-hook 'c-mode-hook 'my-c-mode-hook)
(add-hook 'c++-mode-hook 'my-c-mode-common-hook)
(require 'c++-extensions)
(defun remove-test-suffix (basefn)
"abc_test -> abc"
(if (string-match "\\(.*\\)_test" basefn)
(match-string 1 basefn)
basefn))
(defun c++-register-test ()
"register current test file in Makefile.
Makefile has special markers to help this function. see yasnippet template cpp"
(interactive)
(require 'ucompile)
(let* ((fn (file-name-nondirectory (buffer-file-name)))
(basefn (file-name-sans-extension fn))
(ext (file-name-extension fn))
(makefile (get-makefile-for-edit)))
(if (null makefile)
(message "Error: No Makefile found.")
(let ((buf (get-file-buffer makefile)))
(with-current-buffer (or buf (find-file makefile))
(save-excursion
(goto-char (point-min))
(if (null (search-forward-regexp "^TESTS =" nil t))
(message "Error: no TESTS variable found in Makefile")
(end-of-line)
(insert " " basefn)
(if (null (search-forward-regexp "^# TESTS" nil t))
(message "Error: no \"# TESTS marker found in Makefile\"")
(forward-line 1)
(insert (format "%s: %s.o %s.o" basefn basefn (remove-test-suffix basefn) "\n"))))))))))
(defun first-existing-file (l)
"return the first existing file in given file name list"
(interactive)
(cond
((null l) nil)
((file-exists-p (car l)) (car l))
(t (first-existing-file (cdr l)))))
(defun is-cpp-test-file (filename)
"return non-nil if given file is a cpp test file"
(string-match "_test\\.c\\(c\\|pp\\)" filename))
(defun c++-find-test-file ()
"find test file for current c++ file or vice versa.
For foo.* find finds foo_test.cc foo_test.cpp, in that order."
(interactive)
(let ((filename (buffer-file-name)))
(if (is-cpp-test-file filename)
(message "already at test file.")
(let ((ext (file-name-extension filename))
(base (file-name-sans-extension filename)))
(let ((testfile (first-existing-file
(list
(concat base "_test.cc")
(concat base "_test.cpp")))))
(cond
(testfile (find-file testfile))
((string-match "^h\\(pp\\)?$" ext)
(find-file (concat base "_test.cc")))
(t (find-file (concat base "_test." ext)))))))))
(defun my-c++-mode-hook ()
(interactive)
(auto-fill-mode 1)
(define-key c++-mode-map (kbd "C-c a")
'c++-register-test)
(define-key c++-mode-map (kbd "C-c k f")
'c++-generate-definition-as-kill)
(define-key c++-mode-map (kbd "C-y")
'c++-yank)
(define-key c++-mode-map (kbd "C-; t")
'c++-find-test-file)
(require 'find-file)
(add-to-list 'cc-other-file-alist
'("_test\\.cc" (".h" ".hpp" ".hh")))
)
(add-hook 'c++-mode-hook 'my-c++-mode-hook)
(setq speedbar-default-position 'left)
(put 'speedbar-mode 'mode-class 'special)
(defun my-speedbar-edit-line ()
"call `speedbar-edit-line'. and fix the bug above."
(interactive)
(speedbar-edit-line)
(recenter 1))
(defun my-speedbar-refresh ()
"call `speedbar-refresh'. also check whether `default-directory' has changed in assoc frame."
(interactive)
(let ((af (selected-frame)))
(dframe-select-attached-frame speedbar-frame)
(if (window-minibuffer-p (selected-window))
nil
(let ((dir default-directory))
(select-frame af)
(setq default-directory dir)
(speedbar-refresh)))))
(defun my-speedbar-mode-hook ()
(interactive)
(setcdr (assoc 'width speedbar-frame-parameters) 30)
(speedbar-disable-update)
(define-key speedbar-key-map (kbd "q")
'speedbar-get-focus)
(define-key speedbar-key-map (kbd "Q")
'dframe-close-frame)
(define-key speedbar-file-key-map (kbd "e")
'my-speedbar-edit-line)
(define-key speedbar-buffers-key-map (kbd "e")
'my-speedbar-edit-line)
(define-key speedbar-key-map (kbd "<return>")
'my-speedbar-edit-line)
(define-key speedbar-file-key-map (kbd "g")
'my-speedbar-refresh)
)
(add-hook 'speedbar-mode-hook 'my-speedbar-mode-hook)
(defun java-unit-test-filep (filename)
"return non-nil if given file name is a unit test file"
(string-match "Test.java$" filename))
(defun java-find-other-file ()
"toggle between unit test file and source file. create the other file and dir if needed."
(interactive)
(let ((filename (buffer-file-name)))
(if (java-unit-test-filep filename)
(progn
(let* ((fn1 (replace-regexp-in-string "/test/" "/src/" filename))
(fn2 (replace-regexp-in-string "Test\\.java" ".java" fn1))
(dir (file-name-directory fn2)))
(unless (file-exists-p dir)
(mkdir dir t))
(find-file fn2)))
(let* ((fn1 (replace-regexp-in-string "/src/" "/test/" filename))
(fn2 (replace-regexp-in-string "\\.java" "Test.java" fn1))
(dir (file-name-directory fn2)))
(unless (file-exists-p dir)
(mkdir dir t))
(find-file fn2)))))
(defun my-java-mode-hook ()
(interactive)
(require 'java-project)
(setq c-basic-offset 4)
(abbrev-mode -1)
(define-key java-mode-map (kbd "C-; a")
'java-find-other-file)
(define-key java-mode-map (kbd "C-c C-f")
'java-project-find-file)
(define-key java-mode-map (kbd "C-c C-n")
'java-project-new)
)
(add-hook 'java-mode-hook 'my-java-mode-hook)
(defun my-flyspell-mode-hook ()
(interactive)
(local-unset-key (kbd "C-;")))
(defun css-electric-brace (c)
"'self-insert-command` then indent"
(interactive "P")
(self-insert-command 1)
(indent-according-to-mode))
(defun my-css-mode-hook ()
(interactive)
(define-key css-mode-map (kbd "}")
'css-electric-brace)
(define-key css-mode-map (kbd ";")
'css-electric-brace))
(add-hook 'css-mode-hook 'my-css-mode-hook)
(setq nxml-sexp-element-flag t)
(defun bf-pretty-print-xml-region (begin end)
"Pretty format XML markup in region. You need to have nxml-mode
http://www.emacswiki.org/cgi-bin/wiki/NxmlMode installed to do
this. The function inserts linebreaks to separate tags that have
nothing but whitespace between them. It then indents the markup
by using nxml's indentation rules."
(interactive "r")
(save-excursion
(nxml-mode)
(goto-char begin)
(while (search-forward-regexp "\>[ \\t]*\<" nil t)
(backward-char) (insert "\n"))
(indent-region begin end))
(message "Ah, much better!"))
(defadvice rng-xsd-check-pattern (around do-case-sensitive-match)
"nxml should do case sensitive match"
(let (case-fold-search)
ad-do-it))
(defun my-nxml-mode-hook ()
(interactive)
(setq comment-start "<!-- ")
(setq comment-end " -->")
(ad-activate 'rng-xsd-check-pattern)
)
(add-hook 'nxml-mode-hook 'my-nxml-mode-hook)
(if (equal emacs-major-version 22)
(setq sendmail-program "/usr/sbin/sendmail"))
(setq user-full-name "Yuanle Song")
(setq user-mail-address "sylecn@gmail.com")
(setq mail-default-directory "~/Mail/emacs-compose/")
(setq mail-archive-file-name "~/Mail/sent-emacs")
(setq mail-user-agent 'sendmail-user-agent)
(defun my-kill-mail-buffer ()
"kill mail buffer"
(interactive)
(if server-buffer-clients
(server-buffer-done (current-buffer))
(kill-buffer)))
(defun my-send-mail ()
"if doing emacsclient edit, do save and `server-done'; otherwise, do `mail-send-and-exit'"
(interactive)
(if server-buffer-clients
(progn
(basic-save-buffer)
(server-done))
(mail-send-and-exit)))
(defun my-mail-move-point ()
"move point to the first none empty line"
(interactive)
(search-forward-regexp "^$" nil t 1)
(and (< (point-max) 200)
(forward-line)))
(defun my-mail-mode-hook ()
(interactive)
(auto-fill-mode 1)
(flyspell-mode 1)
(footnote-mode 1)
(abbrev-mode -1)
(setq fill-column 72)
(define-key mail-mode-map (kbd "C-c C-k")
'my-kill-mail-buffer)
(define-key mail-mode-map (kbd "C-c C-c")
'my-send-mail)
(my-mail-move-point)
)
(add-hook 'mail-mode-hook 'my-mail-mode-hook)
(setq rmail-file-name "~/Mail/RMAIL")
(defun my-view-mode-hook ()
(interactive)
(define-key view-mode-map (kbd "j")
'next-line)
(define-key view-mode-map (kbd "k")
'previous-line)
(define-key view-mode-map (kbd "l")
'forward-char)
(define-key view-mode-map (kbd "h")
'backward-char)
(define-key view-mode-map (kbd "s")
'View-search-regexp-forward)
(define-key view-mode-map (kbd "/")
'View-search-regexp-forward)
(define-key view-mode-map (kbd "?")
'View-search-regexp-backward)
(define-key view-mode-map (kbd "0")
'beginning-of-line)
(define-key view-mode-map (kbd "^")
'back-to-indentation)
(define-key view-mode-map (kbd "$")
'end-of-line)
(define-key view-mode-map (kbd "b")
'backward-word)
(define-key view-mode-map (kbd "o")
'hs-toggle-hiding)
)
(add-hook 'view-mode-hook 'my-view-mode-hook)
(defun my-lisp-new-test ()
"insert new test case for lisp"
(interactive)
(insert "(mytest )")
(forward-char -1))
(defun insert-star-pair ()
"insert a star pair"
(interactive)
(insert "**")
(forward-char -1))
(defun my-lisp-mode-hook ()
(interactive)
(define-key lisp-mode-map (kbd "C-c ;")
'my-lisp-new-test)
(define-key lisp-mode-map (kbd "C-M-;")
'my-toggle-comment-sexp)
(define-key lisp-mode-map (kbd "8")
'insert-star-pair)
)
(add-hook 'lisp-mode-hook 'my-lisp-mode-hook)
(defun eval-defvar-as-setq ()
"eval defvar at point as if it were setq."
(interactive)
(save-excursion
(beginning-of-defun)
(let ((start (point)))
(forward-char)
(forward-sexp 3)
(let ((code (concat (buffer-substring-no-properties start (point)) ")")))
(eval-expression
(read (replace-regexp-in-string "(defvar" "(setq" code)))))))
(defun my-comment-sexp ()
"comment sexp at point"
(interactive)
(comment-region (point) (save-excursion
(forward-sexp)
(point))))
(defun my-uncomment-line ()
(uncomment-region (line-beginning-position) (line-end-position)))
(require 'thingatpt)
(defun sexp-at-point-p (pos)
(save-excursion
(goto-char pos)
(condition-case nil
(progn (forward-sexp)
t)
(error nil))))
(defun my-uncomment-sexp ()
"uncommon sexp at point"
(interactive)
(let* ((beg (line-beginning-position))
(end (save-excursion
(comment-forward (point-max))
(point))))
(save-restriction
(narrow-to-region beg end)
(my-uncomment-line)
(while (not (sexp-at-point-p beg))
(forward-line 1)
(my-uncomment-line))
(goto-char beg))))
(defun my-toggle-comment-sexp ()
(interactive)
(let ((beg (line-beginning-position))
(end (line-end-position)))
(funcall (if (save-excursion
(goto-char beg)
(forward-comment (point-max))
(<= end (point)))
'my-uncomment-sexp 'my-comment-sexp))))
(defun my-emacs-lisp-mode-hook ()
(interactive)
(setq mode-name "EL")
(define-key emacs-lisp-mode-map (kbd "C-c C-c")
'eval-defvar-as-setq)
(define-key emacs-lisp-mode-map (kbd "C-c C-r")
'eval-region)
(define-key emacs-lisp-mode-map (kbd "C-c C-b")
'eval-buffer)
(define-key emacs-lisp-mode-map (kbd "C-M-;")
'my-toggle-comment-sexp)
(define-key emacs-lisp-mode-map (kbd "C-c .")
'find-function-other-window)
(if (featurep 'slime)
(define-key emacs-lisp-mode-map (kbd "]")
'slime-close-all-parens-in-sexp))
)
(add-hook 'emacs-lisp-mode-hook 'my-emacs-lisp-mode-hook)
(defun my-lisp-interaction-mode-hook ()
(interactive)
(define-key lisp-interaction-mode-map (kbd "C-c C-b")
'eval-buffer)
(define-key emacs-lisp-mode-map (kbd "C-c C-r")
'eval-region)
)
(add-hook 'lisp-interaction-mode-hook 'my-lisp-interaction-mode-hook)
(setq Info-directory-list Info-default-directory-list)
(defun my-Info-copy-current-node-name ()
"like `Info-copy-current-node-name', but prepend 'info: ' at beginning."
(interactive)
(Info-copy-current-node-name)
(kill-new (concat "Info: " (current-kill 0)) t))
(defun my-Info-mode-hook ()
(interactive)
(protect-buffer-from-kill-mode 1 (current-buffer))
(define-key Info-mode-map (kbd "c")
'my-Info-copy-current-node-name)
(define-key Info-mode-map (kbd "j")
'next-line)
(define-key Info-mode-map (kbd "k")
'previous-line)
)
(add-hook 'Info-mode-hook 'my-Info-mode-hook)
(defun alias-to-function ()
"convert sh alias at point to function"
(interactive)
(forward-line 0)
(when (or (looking-at "^[ \t]*alias \\(.*\\)=\\([^ \t]*\\) *\n")
(looking-at "^[ \t]*alias \\(.*\\)=['\"]\\(.*\\)['\"] *\n"))
(let ((name (match-string-no-properties 1))
(body (match-string-no-properties 2)))
(kill-line 1)
(let ((start (point)))
(insert (format "%s() {\n%s $*\n}\n" name body))
(indent-region start (point))))))
(setq-default sh-basic-offset 8)
(defun my-sh-mode-hook ()
(interactive)
(setq sh-indent-comment t)
(auto-fill-mode -1)
(define-key sh-mode-map (kbd "C-x C-e")
'sh-send-last-command)
(define-key sh-mode-map (kbd "C-M-e")
'sh-eval-defun)
(define-key sh-mode-map (kbd "C-c C-b")
'sh-eval-buffer)
(define-key sh-mode-map (kbd "C-c C-z")
'switch-to-shell-buffer-other-window)
(define-key sh-mode-map (kbd "C-c k f")
'sh-copy-function-at-point)
)
(add-hook 'sh-mode-hook 'my-sh-mode-hook)
(defun term-toggle-mode ()
"Toggle between term-char-mode and term-line-mode."
(interactive)
(if (term-in-line-mode)
(progn
(term-char-mode)
(term-send-raw-string "\C-e"))
(term-line-mode)))
(defun my-term-mode-hook ()
(interactive)
(define-key term-mode-map (kbd "C-c C-j")
'term-toggle-mode)
(define-key term-mode-map (kbd "C-c j")
'term-toggle-mode)
)
(add-hook 'term-mode-hook 'my-term-mode-hook)
(setq-default c-basic-offset 8)
(c-set-offset 'innamespace 0)
(defvar my-hs-hide-all-flag nil
"if t means all blocks are hided")
(defun hs-toggle-hide-all ()
"do `hs-hide-all' or `hs-show-all' depending on current status"
(interactive)
(if my-hs-hide-all-flag
(progn
(hs-show-all)
(setq my-hs-hide-all-flag nil))
(hs-hide-all)
(setq my-hs-hide-all-flag t)))
(require 'protbuf)
(load "~/.emacs.d/startup/highlight-fixme")
(load "~/.emacs.d/startup/slime")
(load "~/.emacs.d/startup/rcirc")
(load "~/.emacs.d/startup/w3m")
(autoload 'csharp-mode "csharp-mode-0.8.5.el" "Major mode for editing C# code." t)
(defun my-csharp-mode-hook ()
(interactive)
(flymake-mode -1)
(setq c-basic-offset 4)
(define-key csharp-mode-map (kbd "{")
'self-insert-command)
)
(add-hook 'csharp-mode-hook 'my-csharp-mode-hook)
(require 'scim-bridge)
(add-hook 'after-init-hook 'scim-mode-on)
(scim-define-common-key (kbd "<f12>") t)
(scim-define-common-key (kbd "C-SPC") nil)
(scim-define-common-key (kbd "C-/") nil)
(scim-define-common-key (kbd "C-.") nil)
(scim-define-common-key (kbd "C-,") nil)
(setq scim-cursor-color "red")
(setq scim-mode-line-string " IM")
(autoload 'graphviz-dot-mode "graphviz-dot-mode" nil t)
(autoload 'auto-install-from-emacswiki "auto-install" nil t)
(autoload 'auto-install-batch "auto-install" nil t)
(setq auto-install-directory "~/.emacs.d/site-lisp/"
auto-install-save-confirm nil
auto-install-replace-confirm t)
(require 'pastebin)
(defun my-octave-mode-hook ()
(interactive)
(define-key octave-mode-map (kbd "C-x C-e")
'sh-send-last-command)
)
(add-hook 'octave-mode-hook 'my-octave-mode-hook)
(autoload 'dos-mode "dos" "Edit Dos scripts." t)
(require 'json-mode)
(eval-after-load 'js
'(progn
(setq js--regexp-literal-fix
"[^=][=(,:]\\(?:\\s-\\|\n\\)*\\(/\\)\\(?:\\\\.\\|[^/*\\]\\)\\(?:\\\\.\\|[^/\\]\\)*\\(/\\)"
)
(setq js-font-lock-syntactic-keywords-fix
`((,js--regexp-literal-fix (1 "|") (2 "|"))))
(setq js-font-lock-syntactic-keywords js-font-lock-syntactic-keywords-fix)
))
(defun my-js-mode-hook ()
(interactive)
(setq comment-multi-line t)
(define-key js-mode-map [remap indent-new-comment-line]
'c-indent-new-comment-line)
(define-key js-mode-map (kbd ",")
'self-insert-command)
)
(add-hook 'js-mode-hook 'my-js-mode-hook)
(autoload 'js2-mode "js2" nil t)
(defun my-js2-mode-hook ()
(interactive)
(setq js2-basic-offset 4)
(define-key js2-mode-map (kbd "C-j")
'newline-and-indent)
)
(add-hook 'js2-mode-hook 'my-js2-mode-hook)
(require 'dict-search)
(setq dict-search-function 'longman-dict-search)
(autoload 'dog-cmd-play "dog-shell"
"for shell mp command" t nil)
(autoload 'dog-cmd-add-file "dog-shell"
"for shell mpa command" t nil)
(autoload 'learnlinux-mode "learnlinux-mode"
"major mode for editing a special ini like files." t nil)
(defun my-learnlinux-mode-hook ()
(interactive)
(define-key learnlinux-mode-map (kbd "C-c l")
'll-jump-to-section)
(define-key learnlinux-mode-map (kbd "M-;")
'comment-dwim)
(define-key learnlinux-mode-map (kbd "C-c c")
'll-formalize-pasted)
)
(add-hook 'learnlinux-mode-hook 'my-learnlinux-mode-hook)
(require 'fullscreen)
(require 'copy-kill-thing)
(autoload 'flex-mode "flex-mode")
(autoload 'bison-mode "bison-mode")
(autoload 'cmake-mode "cmake-mode")
(defun my-cmake-mode-hook ()
(interactive)
(yas/minor-mode 1))
(add-hook 'cmake-mode-hook 'my-cmake-mode-hook)
(autoload 'php-mode "php-mode")
(autoload 'really-simple-wiki "really-simple-wiki")
(defalias 'wiki-mode 'really-simple-wiki-mode)
(autoload 'highlight-parentheses-mode "highlight-parentheses")
(defvar *acl2-user-map-interface*
'((inferior-acl2-mode-map keys)
(shell-mode-map keys)
(acl2-mode-map keys)
(prooftree-mode-map keys)))
(autoload 'myacl2-mode "myacl2-mode.el"
"major mode for editing acl2 files" t)
(defun my-myacl2-ediff-subgoal ()
"do a `ediff-regions-linewise' on subgoal at point.
A subgoal looks like:
(IMPLIES
(...)
(EQUAL
(sexp1)
(sexp2)))"
(interactive)
(let (beg-A end-A beg-B end-B)
(save-excursion
(forward-word)
(forward-sexp)
(forward-word)
(forward-line)
(setq beg-A (point))
(forward-sexp)
(setq end-A (point))
(forward-line)
(setq beg-B (point))
(forward-sexp)
(setq end-B (point)))
(ediff-regions-internal
(current-buffer) beg-A end-A
(current-buffer) beg-B end-B
nil 'ediff-regions-linewise nil nil)
))
(defun my-myacl2-mode-hook ()
(interactive)
(define-key myacl2-mode-map (kbd "C-c d")
'acl2-describe-sym)
(slime-mode -1)
(if (featurep 'slime)
(define-key myacl2-mode-map (kbd "]")
'slime-close-all-parens-in-sexp))
)
(add-hook 'myacl2-mode-hook 'my-myacl2-mode-hook)
(when (file-exists-p "~/fromsource/git")
(require 'git)
(require 'git-blame)
(defun git-status-current-dir ()
"call git-status with current dir. Don't ask."
(interactive)
(git-status default-directory))
(defalias 'gs 'git-status))
(autoload 'gcm-mode "gcm"
"Major mode for editing (or highlighting) git commit messages." t nil)
(defun inhibit-save-place-for-git-commit-msg ()
"save-place is useless and annoying for COMMIT_EDITMSG buffer."
(let ((filename (buffer-file-name)))
(and filename
(string-equal "COMMIT_EDITMSG" (file-name-nondirectory filename))
(setq save-place nil))))
(add-hook 'find-file-hook 'inhibit-save-place-for-git-commit-msg 'append)
(autoload 'po-mode
"po-mode" "Major mode for translators to edit PO files" t)
(add-hook 'po-subedit-mode-hook '(lambda () (longlines-mode 1)))
(add-hook 'po-subedit-exit-hook '(lambda () (longlines-mode 0)))
(defun my-po-mode-hook ()
(interactive)
(view-mode -1)
)
(eval-after-load 'po-mode
'(progn
(define-key po-mode-map (kbd "'")
'po-show-percent)
(define-key po-mode-map (kbd "`")
'po-wrap)
))
(defun po-wrap ()
"Filter current po-mode buffer through `msgcat' tool to wrap all lines."
(interactive)
(if (eq major-mode 'po-mode)
(let ((tmp-file (make-temp-file "po-wrap."))
(tmp-buf (generate-new-buffer "*temp*")))
(unwind-protect
(progn
(write-region (point-min) (point-max) tmp-file nil 1)
(if (zerop
(call-process
"msgcat" nil tmp-buf t (shell-quote-argument tmp-file)))
(let ((saved (point))
(inhibit-read-only t))
(delete-region (point-min) (point-max))
(insert-buffer-substring tmp-buf)
(goto-char (min saved (point-max))))
(with-current-buffer tmp-buf
(error (buffer-string)))))
(kill-buffer tmp-buf)
(delete-file tmp-file)))))
(defun po-show-percent ()
(interactive)
(if (eq major-mode 'po-mode)
(shell-command (format "msgpercent %s" (buffer-file-name)))))
(require 'yasnippet)
(yas/global-mode 1)
(load "~/.emacs.d/startup/yasnippet-functions")
(setq yas/root-directory "~/.emacs.d/non-lisp-data/yasnippets")
(yas/load-directory yas/root-directory)
(require 'dropdown-list)
(setq yas/prompt-functions '(yas/dropdown-prompt))
(defun my-yas/load-snippet-buffer ()
"don't change point pos when C-c C-c"
(interactive)
(save-excursion
(yas/load-snippet-buffer)))
(defun my-snippet-mode-hook ()
(interactive)
(define-key snippet-mode-map (kbd "C-c C-c")
'my-yas/load-snippet-buffer)
)
(add-hook 'snippet-mode-hook 'my-snippet-mode-hook)
(require 'server)
(setq server-socket-file
(expand-file-name server-name (or server-socket-dir server-auth-dir)))
(or (file-exists-p server-socket-file)
(server-start))
(dolist (file myfiles)
(let ((fn (myfiles-file-name file)))
(if (file-exists-p fn)
(progn
(find-file fn)
(protect-buffer-from-kill-mode 1 (get-buffer fn)))
(message "warning: myfiles file doesn't exist: %s" fn))))
(start-shell-in-home-dir default-shell-buffer)
(protect-buffer-from-kill-mode 1 (get-buffer default-shell-buffer))
(setq custom-file "~/.emacs.d/custom.el")
(load "~/.emacs.d/custom")
(defun show-init-time ()
(message "My .emacs loaded in %s" (emacs-init-time)))
(add-hook 'after-init-hook 'show-init-time)
(put 'narrow-to-page 'disabled nil)
(put 'narrow-to-region 'disabled nil)