经验总结：实用的Emacs配置文件搜罗

以下的Emacs配置文件是我多年积累起来的，它们在我历次整理配置文件（.emacs）的过程中幸存了下来，经过了时间考验，所以现在我决定发出 来和大家分享一下。虽然某些功能很有可能已经有更好的实现方法了，但是这些例子对读者学习emacs lisp还是会有帮助的。

成都创新互联专注为客户提供全方位的互联网综合服务，包含不限于网站设计制作、成都网站制作、抚州网络推广、小程序定制开发、抚州网络营销、抚州企业策划、抚州品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们最大的嘉奖；成都创新互联为所有大学生创业者提供抚州建站搭建服务，24小时服务热线：18980820575，官方网址：www.cdcxhl.com

在一些文本的末尾添加递增的数字

inc-num-region把一段文本中重复出现的数字替换成递增的数字

 
 
 
    
  
  
  
  1. (defun inc-num-region (p m) 
    2. 
  
  
  
  2.   "Increments the numbers in a given region" 
    3. 
  
  
  
  3.   (interactive "r") 
    4. 
  
  
  
  4.   (save-restriction 
    5. 
  
  
  
  5.     (save-excursion 
    6. 
  
  
  
  6.       (narrow-to-region p m)    
    7. 
  
  
  
  7.       (goto-char (point-min))   
    8. 
  
  
  
  8.       (forward-line) 
    9. 
  
  
  
  9.       (let ((counter 1)) 
    10. 
  
  
  
  10.         (while (not (eq (point) 
    11. 
  
  
  
  11.                         (point-max))) 
    12. 
  
  
  
  12.           (goto-char (point-at-eol)) 
    13. 
  
  
  
  13.           (search-backward-regexp "[0-9]+" (point-at-bol) t) 
    14. 
  
  
  
  14.           (let* ((this-num (string-to-number (match-string 0))) 
    15. 
  
  
  
  15.                  (new-num-str (number-to-string (+ this-num 
    16. 
  
  
  
  16.                                                    counter)))) 
    17. 
  
  
  
  17.             (replace-match new-num-str) 
    18. 
  
  
  
  18.             (incf counter) 
    19. 
  
  
  
  19.             (forward-line))))))) 
    20.

比如在emacs选中如下的文本区域

 
 
 
    
  
  
  
  1. 1foo 
    2. 
  
  
  
  2. 1foo 
    3. 
  
  
  
  3. 1foo 
    4. 
  
  
  
  4. 1foo 
    5.

执行该函数，那么上述文本在缓冲区中变成

 
 
 
    
  
  
  
  1. 1foo 
    2. 
  
  
  
  2. 2foo 
    3. 
  
  
  
  3. 3foo 
    4. 
  
  
  
  4. 4foo 
    5.

再比如选中如下的文本区域

 
 
 
    
  
  
  
  1. foo3 
    2. 
  
  
  
  2.  foo3 
    3. 
  
  
  
  3.  foo3 
    4. 
  
  
  
  4.  foo3 
    5.

执行给函数，得到

 
 
 
    
  
  
  
  1. foo3 
    2. 
  
  
  
  2. foo4 
    3. 
  
  
  
  3. foo5 
    4. 
  
  
  
  4. foo6 
    5.

给代码做笔记

在我们公司使用reviewboard之前，代码审查都是面对面进行的。我曾经使用下面这个函数来帮助记录意见所对应的源文件和行号。

 
 
 
    
  
  
  
  1. defun add-code-review-note () 
    2. 
  
  
  
  2.    "Add note for current file and line number" 
    3. 
  
  
  
  3.    (interactive) 
    4. 
  
  
  
  4.    (let ((file-name (buffer-file-name)) 
    5. 
  
  
  
  5.          (file-line (line-number-at-pos))) 
    6. 
  
  
  
  6.      (switch-to-buffer-other-window (get-buffer-create "NOTES")) 
    7. 
  
  
  
  7.      (goto-char (point-min)) 
    8. 
  
  
  
  8.      (when (not (search-forward "-*- mode:compilation-shell-minor" 
    9. 
  
  
  
  9.                                 nil t)) 
    10. 
  
  
  
  10.        (compilation-shell-minor-mode 1) 
    11. 
  
  
  
  11.        (insert "-*- mode:compilation-shell-minor -*-\n\n")) 
    12. 
  
  
  
  12.      (goto-char (point-max)) 
    13. 
  
  
  
  13.      (if (/= (current-column) 0) 
    14. 
  
  
  
  14.          (newline)) 
    15. 
  
  
  
  15.      (insert file-name ":" (number-to-string file-line) ": "))) 
    16.

使用方法是，光标停在源代码的需要做批注的位置，然后执行该函数，emacs会创建一个新的叫做NOTES的缓冲区，其中记录源代码的路径和光标所在的行 号，用户在接下来的区域中输入笔记。这个函数的好处是，该新建的buffer的工作模式是compilation-shell-minor-mode。所 以可以直接点击其路径和行号，就可以直接打源文件跳到相应的行上去。比如

 
 
 
    
  
  
  
  1. #include 
    2. 
  
  
  
  2.   
    3. 
  
  
  
  3.  int main() 
    4. 
  
  
  
  4.  { 
    5. 
  
  
  
  5.    std::cout << "Hello Word!" << std::endl;  //光标停在这里 
    6. 
  
  
  
  6.    return 0; 
    7. 
  
  
  
  7.  } 
    8.

执行该函数，在新buffer中得到如下内容，在compilation-shell-minor-mode模式下，笔记前面的内容将呈现出一个链接，可以点击直接打开main.cpp

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

在我的.emacs中，我把这个函数和C-c、r做了绑定

自动给C代码头文件的首位添加ifndef和endif

get-include-guard函数在我们要编辑一个新头文件时,自动给文件添加上预处理指示符:ifndef和endif

 
 
 
    
  
  
  
  1. defun get-include-guard () 
    2. 
  
  
  
  2.    "Return a string suitable for use in a C/C++ include guard" 
    3. 
  
  
  
  3.    (let* ((fname (buffer-file-name (current-buffer))) 
    4. 
  
  
  
  4.           (fbasename (replace-regexp-in-string ".*/" "" fname)) 
    5. 
  
  
  
  5.           (inc-guard-base (replace-regexp-in-string "[.-]" 
    6. 
  
  
  
  6.                                                     "_" 
    7. 
  
  
  
  7.                                                     fbasename))) 
    8. 
  
  
  
  8.      (concat (upcase inc-guard-base) "_"))) 
    9. 
  
  
  
  9.   
    10. 
  
  
  
  10.  (add-hook 'find-file-not-found-hooks 
    11. 
  
  
  
  11.            '(lambda () 
    12. 
  
  
  
  12.               (let ((file-name (buffer-file-name (current-buffer)))) 
    13. 
  
  
  
  13.                 (when (string= ".h" (substring file-name -2)) 
    14. 
  
  
  
  14.                   (let ((include-guard (get-include-guard))) 
    15. 
  
  
  
  15.                     (insert "#ifndef " include-guard) 
    16. 
  
  
  
  16.                     (newline) 
    17. 
  
  
  
  17.                     (insert "#define " include-guard) 
    18. 
  
  
  
  18.                     (newline 4) 
    19. 
  
  
  
  19.                     (insert "#endif") 
    20. 
  
  
  
  20.                     (newline) 
    21. 
  
  
  
  21.                     (previous-line 3) 
    22. 
  
  
  
  22.                     (set-buffer-modified-p nil)))))) 
    23.

如果我们在emacs中要新建一个文件foo.h(C-x,C-f foo.h)，emacs新创建的foo.h缓冲区中看上去将是这样的

 
 
 
    
  
  
  
  1. #ifndef FOO_H_ 
    2. 
  
  
  
  2.  #define FOO_H_ 
    3. 
  
  
  
  3.   
    4. 
  
  
  
  4.  #endif 
    5.

在foo.cpp和foo.h之间自动的切换

如果一个文件夹中同时含有foo.h和foo.cpp两个文件的话，下面的函数帮助你在这两个文件之间切换

 
 
 
    
  
  
  
  1. (defun next-file-with-basename () 
    2. 
  
  
  
  2.  "Cycles between files with the same basename as the given file. 
    3. 
  
  
  
  3.   Usefull for cycling between header .h/.cpp/.hpp files etc." 
    4. 
  
  
  
  4.  (interactive) 
    5. 
  
  
  
  5.  (let* ((buf-file-name (replace-regexp-in-string 
    6. 
  
  
  
  6.                         "^.*/" "" 
    7. 
  
  
  
  7.                         (buffer-file-name))) 
    8. 
  
  
  
  8.         (current-dir (replace-regexp-in-string 
    9. 
  
  
  
  9.                       "[a-zA-Z0-9._-]+$" "" 
    10. 
  
  
  
  10.                       (buffer-file-name))) 
    11. 
  
  
  
  11.         (no-basename (equal ?. (aref buf-file-name 0))) 
    12. 
  
  
  
  12.         (has-extension (find ?. buf-file-name))) 
    13. 
  
  
  
  13.    ;; If the file is a .dot-file or it doesn't have an 
    14. 
  
  
  
  14.    ;; extension, then there's nothing to do here. 
    15. 
  
  
  
  15.    (unless (or no-basename (not has-extension)) 
    16. 
  
  
  
  16.      (let* ((basename (replace-regexp-in-string 
    17. 
  
  
  
  17.                        "\\..*" "" 
    18. 
  
  
  
  18.                        buf-file-name)) 
    19. 
  
  
  
  19.             (files-with-basename (directory-files 
    20. 
  
  
  
  20.                                   current-dir f 
    21. 
  
  
  
  21.                                   (concat "^" basename "\\.")))) 
    22. 
  
  
  
  22.        ;; If there's only 1 file with this basename, nothing to 
    23. 
  
  
  
  23.        ;; do 
    24. 
  
  
  
  24.        (unless (= (length files-with-basename) 1) 
    25. 
  
  
  
  25.          ;; By making the list circular, we're guaranteed that 
    26. 
  
  
  
  26.          ;; there will always be a next list element (ie. no 
    27. 
  
  
  
  27.          ;; need for special case when file is at the end of 
    28. 
  
  
  
  28.          ;; the list). 
    29. 
  
  
  
  29.          (setf (cdr (last files-with-basename)) 
    30. 
  
  
  
  30.                files-with-basename) 
    31. 
  
  
  
  31.          (find-file (cadr (member (buffer-file-name) 
    32. 
  
  
  
  32.                                   files-with-basename)))))))) 
    33.

在我的.emacs中，我把这个函数和C-c,n做了绑定

注：Reddit网友提出ff-find-other-file实现了非常类似的功能

c-macro模板

我们在写C++代码的时候，经常要键入一些重复的操作，比如历遍容器，try catch等等。而这些代码的特点，可以归结成一个不变的模板+几个变化参数，下面的emacs函数自动帮你扩展这个模板，打印代码。

我们先描述该函数的效果，在C++代码中插入如下待扩展的句子

 
 
 
    
  
  
  
  1. (doit std::vector myContainer) 
    2.

然后在该行的末尾执行我们的函数，该行被自动替换成如下的C++代码

 
 
 
    
  
  
  
  1. for (std::vector::iterator it = myContainer.begin(); 
    2. 
  
  
  
  2.      it != myContainer.end(); 
    3. 
  
  
  
  3.      ++it) 
    4. 
  
  
  
  4. { 
    5. 
  
  
  
  5.    // 光标将停在这里 等待具体的编辑  
    6. 
  
  
  
  6. } 
    7.

该c-macro还可以接受变长参数，比如下面的模板接受两个参数

 
 
 
    
  
  
  
  1. (doit std::vector myIt myContainer) 
    2.

生成的代码如下：

 
 
 
    
  
  
  
  1. for (std::vector::iterator myIt = myContainer.begin(); 
    2. 
  
  
  
  2.       myIt != myContainer.end(); 
    3. 
  
  
  
  3.       ++myIt) 
    4. 
  
  
  
  4.  { 
    5. 
  
  
  
  5.     // 光标将停在这里 等待具体的编辑 
    6. 
  
  
  
  6.  } 
    7.

下面的macro将帮助用户自己打印try catch block

 
 
 
    
  
  
  
  1. (api-fn) 
    2.

扩展之后将变成

 
 
 
    
  
  
  
  1. try 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.     // 光标将停在这里 等待具体的编辑 
    4. 
  
  
  
  4. } 
    5. 
  
  
  
  5. catch(const std::exception& e) 
    6. 
  
  
  
  6. { 
    7. 
  
  
  
  7.    TRACE("Unhandled exception in function %s: %s\n", 
    8. 
  
  
  
  8.          __func__, e.what()); 
    9. 
  
  
  
  9.    return -1; 
    10. 
  
  
  
  10. } 
    11.

下面的j-newline-and-indent是以上功能的入口函数，其将寻找光标前是否出现已定义的c-macro.在上面的例子中就是doit和api-fn。
如果出现了macro就做扩展，如果没有出现，j-newline-and-indent等于内置的newline-and-indent函数:加入新行，并且indent

 
 
 
    
  
  
  
  1. (defun j-newline-and-indent () 
    2. 
  
  
  
  2.    "Same as \"newline-and-indent\" except it also expands 
    3. 
  
  
  
  3.     c-macros if it sees one." 
    4. 
  
  
  
  4.    (interactive) 
    5. 
  
  
  
  5.    (if (and (equal (char-before) ?\)) 
    6. 
  
  
  
  6.             (macro-function (car (preceding-sexp)))) 
    7. 
  
  
  
  7.        ;; This is a c-macro 
    8. 
  
  
  
  8.        (expand-c-macro-in-place) 
    9. 
  
  
  
  9.      (newline-and-indent))) 
    10. 
  
  
  
  10.   
    11. 
  
  
  
  11.  (defun macro-function (name) 
    12. 
  
  
  
  12.    "Given a name, returns the c-macro-name symbol if it 
    13. 
  
  
  
  13.     exists as a function" 
    14. 
  
  
  
  14.    (let ((macro-sym (intern (concat "c-macro-" 
    15. 
  
  
  
  15.                                     (symbol-name name))))) 
    16. 
  
  
  
  16.      (if (fboundp macro-sym) 
    17. 
  
  
  
  17.          macro-sym 
    18. 
  
  
  
  18.        nil))) 
    19. 
  
  
  
  19.   
    20. 
  
  
  
  20.  (defun expand-c-macro-in-place () 
    21. 
  
  
  
  21.    "Given that point is at the end of a c-macro, expands 
    22. 
  
  
  
  22.     it in-place" 
    23. 
  
  
  
  23.    (let* ((sexp (preceding-sexp)) 
    24. 
  
  
  
  24.           (macro-name (car sexp)) 
    25. 
  
  
  
  25.           (replacement-text (apply (macro-function macro-name) 
    26. 
  
  
  
  26.                                    (cdr sexp))) 
    27. 
  
  
  
  27.           (jump-to (string-match "!!!BODY!!!;" replacement-text))) 
    28. 
  
  
  
  28.      ;; Delete macro invocation 
    29. 
  
  
  
  29.      (backward-list) 
    30. 
  
  
  
  30.      (let ((start-del (point))) 
    31. 
  
  
  
  31.        (forward-list) 
    32. 
  
  
  
  32.        (kill-region start-del (point)) 
    33. 
  
  
  
  33.   
    34. 
  
  
  
  34.       ;; Insert macro expansion and indent appropriately 
    35. 
  
  
  
  35.       (insert replacement-text) 
    36. 
  
  
  
  36.       (indent-region start-del (point)) 
    37. 
  
  
  
  37.       (when jump-to 
    38. 
  
  
  
  38.         (search-backward "!!!BODY!!!;") 
    39. 
  
  
  
  39.         (kill-line)))) 
    40. 
  
  
  
  40.   (c-indent-command)) 
    41. 
  
  
  
  41.  
    42. 
  
  
  
  42. 下面是自定义的两个模板c-macro，读者可以根据需要定义自己的macro 
    43. 
  
  
  
  43. 1 
    44. 
  
  
  
  44. 2 
    45. 
  
  
  
  45. 3 
    46. 
  
  
  
  46. 4 
    47. 
  
  
  
  47. 5 
    48. 
  
  
  
  48. 6 
    49. 
  
  
  
  49. 7 
    50. 
  
  
  
  50. 8 
    51. 
  
  
  
  51. 9 
    52. 
  
  
  
  52. 10 
    53. 
  
  
  
  53. 11 
    54. 
  
  
  
  54. 12 
    55. 
  
  
  
  55. 13 
    56. 
  
  
  
  56. 14 
    57. 
  
  
  
  57. 15 
    58. 
  
  
  
  58. 16 
    59. 
  
  
  
  59. 17 
    60. 
  
  
  
  60. 18 
    61. 
  
  
  
  61. 19 
    62. 
  
  
  
  62. 20 
    63. 
  
  
  
  63. 21 
    64. 
  
  
  
  64. 22 
    65. 
  
  
  
  65. 23 
    66. 
  
  
  
  66. 24 
    67. 
  
  
  
  67. 25 
    68. 
  
  
  
  68. 26 
    69. 
  
  
  
  69. 27 
    70. 
  
  
  
  70. 28 
    71. 
  
  
  
  71. 29 
    72. 
  
  
  
  72.      
    73. 
  
  
  
  73. (defun c-macro-doit (container-type arg1 &optional arg2) 
    74. 
  
  
  
  74.    "Emits code for iterating over an stl (or stl-like) structure" 
    75. 
  
  
  
  75.    (let ((iterator-name  (if arg2 arg1 "it")) 
    76. 
  
  
  
  76.          (container-name (if arg2 arg2 arg1))) 
    77. 
  
  
  
  77.      (format (concat "for (%s::iterator %s = %s.begin();\n" 
    78. 
  
  
  
  78.                      "     %s != %s.end();\n" 
    79. 
  
  
  
  79.                      "     ++%s)\n" 
    80. 
  
  
  
  80.                      "{\n" 
    81. 
  
  
  
  81.                      "   !!!BODY!!!;\n" 
    82. 
  
  
  
  82.                      "}\n") 
    83. 
  
  
  
  83.              container-type 
    84. 
  
  
  
  84.              iterator-name 
    85. 
  
  
  
  85.              container-name 
    86. 
  
  
  
  86.              iterator-name 
    87. 
  
  
  
  87.              container-name 
    88. 
  
  
  
  88.              iterator-name))) 
    89. 
  
  
  
  89.   
    90. 
  
  
  
  90.  (defun c-macro-api-fn () 
    91. 
  
  
  
  91.    "Emits code for wrapping an api function in a try/catch block" 
    92. 
  
  
  
  92.    (concat "try\n" 
    93. 
  
  
  
  93.            "{\n" 
    94. 
  
  
  
  94.            "   !!!BODY!!!;\n" 
    95. 
  
  
  
  95.            "}\n" 
    96. 
  
  
  
  96.            "catch(const std::exception& e)\n" 
    97. 
  
  
  
  97.            "{\n" 
    98. 
  
  
  
  98.            "   TRACE(\"Unhandled exception in function %s: %s\\n\",\n" 
    99. 
  
  
  
  99.            "         __func__, e.what());\n" 
    100. 
  
  
  
  100.            "   return -1;\n" 
    101. 
  
  
  
  101.            "}\n")) 
    102.

网站栏目：经验总结：实用的Emacs配置文件搜罗
本文地址：http://www.gawzjz.com/qtweb2/news0/4950.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

关键词优化知识

分类信息网

广安网站建设　　 　成都主机托管　　 　兴宏源活动板房　　 　营销网站建设　　 　成都花箱　　 　华泰海航　　 　遂宁海缘科技　　 　研学实践　　 　微信服务号订阅号开发　　 　企业官网建设　　 　成都茶叶销售　　 　营山网站建设　　 　机柜租用　　 　金羊影视传媒　　 　主机租用　　 　尊格展览　　 　成都网站推广　　 　成都网站推广　　 　雅安主机托管　　 　绵阳服务器托管