以下的Emacs配置文件是我多年積累起來的，它們在我歷次整理配置文件（.emacs）的過程中幸存了下來，經過了時間考驗，所以現在我決定發出 來和大家分享一下。雖然某些功能很有可能已經有更好的實現方法了，但是這些例子對讀者學習emacs lisp還是會有幫助的。

在一些文本的末尾添加遞增的數字

inc-num-region把一段文本中重復出現的數字替換成遞增的數字

(defun inc-num-region (p m) 
  "Increments the numbers in a given region" 
  (interactive "r") 
  (save-restriction 
    (save-excursion 
      (narrow-to-region p m)    
      (goto-char (point-min))   
      (forward-line) 
      (let ((counter 1)) 
        (while (not (eq (point) 
                        (point-max))) 
          (goto-char (point-at-eol)) 
          (search-backward-regexp "[0-9]+" (point-at-bol) t) 
          (let* ((this-num (string-to-number (match-string 0))) 
                 (new-num-str (number-to-string (+ this-num 
                                                   counter)))) 
            (replace-match new-num-str) 
            (incf counter) 
            (forward-line))))))) 

比如在emacs選中如下的文本區域

1foo 
1foo 
1foo 
1foo 

執行該函數，那么上述文本在緩沖區中變成

1foo 
2foo 
3foo 
4foo 

再比如選中如下的文本區域

foo3 
 foo3 
 foo3 
 foo3 

執行給函數，得到

foo3 
foo4 
foo5 
foo6 

給代碼做筆記

在我們公司使用reviewboard之前，代碼審查都是面對面進行的。我曾經使用下面這個函數來幫助記錄意見所對應的源文件和行號。

defun add-code-review-note () 
   "Add note for current file and line number" 
   (interactive) 
   (let ((file-name (buffer-file-name)) 
         (file-line (line-number-at-pos))) 
     (switch-to-buffer-other-window (get-buffer-create "NOTES")) 
     (goto-char (point-min)) 
     (when (not (search-forward "-*- mode:compilation-shell-minor" 
                                nil t)) 
       (compilation-shell-minor-mode 1) 
       (insert "-*- mode:compilation-shell-minor -*-\n\n")) 
     (goto-char (point-max)) 
     (if (/= (current-column) 0) 
         (newline)) 
     (insert file-name ":" (number-to-string file-line) ": "))) 

使用方法是，光標停在源代碼的需要做批注的位置，然后執行該函數，emacs會創建一個新的叫做NOTES的緩沖區，其中記錄源代碼的路徑和光標所在的行 號，用戶在接下來的區域中輸入筆記。這個函數的好處是，該新建的buffer的工作模式是compilation-shell-minor-mode。所 以可以直接點擊其路徑和行號，就可以直接打源文件跳到相應的行上去。比如

#include 
  
 int main() 
 { 
   std::cout << "Hello Word!" << std::endl;  //光標停在這里 
   return 0; 
 } 

執行該函數，在新buffer中得到如下內容，在compilation-shell-minor-mode模式下，筆記前面的內容將呈現出一個鏈接，可以點擊直接打開main.cpp

/home/iamxuxiao/main.cpp:5: miss spelling "word" 

在我的.emacs中，我把這個函數和C-c、r做了綁定

自動給C代碼頭文件的首位添加ifndef和endif

get-include-guard函數在我們要編輯一個新頭文件時,自動給文件添加上預處理指示符:ifndef和endif

defun get-include-guard () 
   "Return a string suitable for use in a C/C++ include guard" 
   (let* ((fname (buffer-file-name (current-buffer))) 
          (fbasename (replace-regexp-in-string ".*/" "" fname)) 
          (inc-guard-base (replace-regexp-in-string "[.-]" 
                                                    "_" 
                                                    fbasename))) 
     (concat (upcase inc-guard-base) "_"))) 
  
 (add-hook 'find-file-not-found-hooks 
           '(lambda () 
              (let ((file-name (buffer-file-name (current-buffer)))) 
                (when (string= ".h" (substring file-name -2)) 
                  (let ((include-guard (get-include-guard))) 
                    (insert "#ifndef " include-guard) 
                    (newline) 
                    (insert "#define " include-guard) 
                    (newline 4) 
                    (insert "#endif") 
                    (newline) 
                    (previous-line 3) 
                    (set-buffer-modified-p nil)))))) 

如果我們在emacs中要新建一個文件foo.h(C-x,C-f foo.h)，emacs新創建的foo.h緩沖區中看上去將是這樣的

#ifndef FOO_H_ 
 #define FOO_H_ 
  
 #endif 

在foo.cpp和foo.h之間自動的切換

如果一個文件夾中同時含有foo.h和foo.cpp兩個文件的話，下面的函數幫助你在這兩個文件之間切換

(defun next-file-with-basename () 
 "Cycles between files with the same basename as the given file. 
  Usefull for cycling between header .h/.cpp/.hpp files etc." 
 (interactive) 
 (let* ((buf-file-name (replace-regexp-in-string 
                        "^.*/" "" 
                        (buffer-file-name))) 
        (current-dir (replace-regexp-in-string 
                      "[a-zA-Z0-9._-]+$" "" 
                      (buffer-file-name))) 
        (no-basename (equal ?. (aref buf-file-name 0))) 
        (has-extension (find ?. buf-file-name))) 
   ;; If the file is a .dot-file or it doesn't have an 
   ;; extension, then there's nothing to do here. 
   (unless (or no-basename (not has-extension)) 
     (let* ((basename (replace-regexp-in-string 
                       "\\..*" "" 
                       buf-file-name)) 
            (files-with-basename (directory-files 
                                  current-dir f 
                                  (concat "^" basename "\\.")))) 
       ;; If there's only 1 file with this basename, nothing to 
       ;; do 
       (unless (= (length files-with-basename) 1) 
         ;; By making the list circular, we're guaranteed that 
         ;; there will always be a next list element (ie. no 
         ;; need for special case when file is at the end of 
         ;; the list). 
         (setf (cdr (last files-with-basename)) 
               files-with-basename) 
         (find-file (cadr (member (buffer-file-name) 
                                  files-with-basename)))))))) 

在我的.emacs中，我把這個函數和C-c,n做了綁定

注：Reddit網友提出ff-find-other-file實現了非常類似的功能

c-macro模板

我們在寫C++代碼的時候，經常要鍵入一些重復的操作，比如歷遍容器，try catch等等。而這些代碼的特點，可以歸結成一個不變的模板+幾個變化參數，下面的emacs函數自動幫你擴展這個模板，打印代碼。

我們先描述該函數的效果，在C++代碼中插入如下待擴展的句子

(doit std::vector myContainer) 

然后在該行的末尾執行我們的函數，該行被自動替換成如下的C++代碼

for (std::vector::iterator it = myContainer.begin(); 
     it != myContainer.end(); 
     ++it) 
{ 
   // 光標將停在這里 等待具體的編輯  
} 

該c-macro還可以接受變長參數，比如下面的模板接受兩個參數

(doit std::vector myIt myContainer) 

生成的代碼如下：

for (std::vector::iterator myIt = myContainer.begin(); 
      myIt != myContainer.end(); 
      ++myIt) 
 { 
    // 光標將停在這里 等待具體的編輯 
 } 

下面的macro將幫助用戶自己打印try catch block

(api-fn) 

擴展之后將變成

try 
{ 
    // 光標將停在這里 等待具體的編輯 
} 
catch(const std::exception& e) 
{ 
   TRACE("Unhandled exception in function %s: %s\n", 
         __func__, e.what()); 
   return -1; 
} 

下面的j-newline-and-indent是以上功能的入口函數，其將尋找光標前是否出現已定義的c-macro.在上面的例子中就是doit和api-fn。
如果出現了macro就做擴展，如果沒有出現，j-newline-and-indent等于內置的newline-and-indent函數:加入新行，并且indent

(defun j-newline-and-indent () 
   "Same as \"newline-and-indent\" except it also expands 
    c-macros if it sees one." 
   (interactive) 
   (if (and (equal (char-before) ?\)) 
            (macro-function (car (preceding-sexp)))) 
       ;; This is a c-macro 
       (expand-c-macro-in-place) 
     (newline-and-indent))) 
  
 (defun macro-function (name) 
   "Given a name, returns the c-macro-name symbol if it 
    exists as a function" 
   (let ((macro-sym (intern (concat "c-macro-" 
                                    (symbol-name name))))) 
     (if (fboundp macro-sym) 
         macro-sym 
       nil))) 
  
 (defun expand-c-macro-in-place () 
   "Given that point is at the end of a c-macro, expands 
    it in-place" 
   (let* ((sexp (preceding-sexp)) 
          (macro-name (car sexp)) 
          (replacement-text (apply (macro-function macro-name) 
                                   (cdr sexp))) 
          (jump-to (string-match "!!!BODY!!!;" replacement-text))) 
     ;; Delete macro invocation 
     (backward-list) 
     (let ((start-del (point))) 
       (forward-list) 
       (kill-region start-del (point)) 
  
      ;; Insert macro expansion and indent appropriately 
      (insert replacement-text) 
      (indent-region start-del (point)) 
      (when jump-to 
        (search-backward "!!!BODY!!!;") 
        (kill-line)))) 
  (c-indent-command)) 
 
下面是自定義的兩個模板c-macro，讀者可以根據需要定義自己的macro 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
14 
15 
16 
17 
18 
19 
20 
21 
22 
23 
24 
25 
26 
27 
28 
29 
     
(defun c-macro-doit (container-type arg1 &optional arg2) 
   "Emits code for iterating over an stl (or stl-like) structure" 
   (let ((iterator-name  (if arg2 arg1 "it")) 
         (container-name (if arg2 arg2 arg1))) 
     (format (concat "for (%s::iterator %s = %s.begin();\n" 
                     "     %s != %s.end();\n" 
                     "     ++%s)\n" 
                     "{\n" 
                     "   !!!BODY!!!;\n" 
                     "}\n") 
             container-type 
             iterator-name 
             container-name 
             iterator-name 
             container-name 
             iterator-name))) 
  
 (defun c-macro-api-fn () 
   "Emits code for wrapping an api function in a try/catch block" 
   (concat "try\n" 
           "{\n" 
           "   !!!BODY!!!;\n" 
           "}\n" 
           "catch(const std::exception& e)\n" 
           "{\n" 
           "   TRACE(\"Unhandled exception in function %s: %s\\n\",\n" 
           "         __func__, e.what());\n" 
           "   return -1;\n" 
           "}\n")) 

原文鏈接：http://blog.jobbole.com/47027/