Added dxo-remove-unneeded-spaces.
[com-informatimago:emacs.git] / dxo.el
1 ;;;; -*- mode:emacs-lisp;coding:utf-8 -*-
2 ;;;;**************************************************************************
3 ;;;;FILE:               dxo.el
4 ;;;;LANGUAGE:           emacs lisp
5 ;;;;SYSTEM:             POSIX
6 ;;;;USER-INTERFACE:     NONE
7 ;;;;DESCRIPTION
8 ;;;;    
9 ;;;;    Emacs configuration used at DxO Labs / Optics Pro Mac team.
10 ;;;;    
11 ;;;;AUTHORS
12 ;;;;    <PJB> Pascal Bourguignon <pbourguignon@dxo.com>
13 ;;;;MODIFICATIONS
14 ;;;;    2012-11-15 <PJB> Created.
15 ;;;;BUGS
16 ;;;;LEGAL
17 ;;;;    GPL3
18 ;;;;    
19 ;;;;    Copyright Pascal Bourguignon 2012 - 2012
20 ;;;;    
21 ;;;;    This program is free software: you can redistribute it and/or modify
22 ;;;;    it under the terms of the GNU General Public License as published by
23 ;;;;    the Free Software Foundation, either version 3 of the License, or
24 ;;;;    (at your option) any later version.
25 ;;;;    
26 ;;;;    This program is distributed in the hope that it will be useful,
27 ;;;;    but WITHOUT ANY WARRANTY; without even the implied warranty of
28 ;;;;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
29 ;;;;    GNU General Public License for more details.
30 ;;;;    
31 ;;;;    You should have received a copy of the GNU General Public License
32 ;;;;    along with this program.  If not, see <http://www.gnu.org/licenses/>.
33 ;;;;**************************************************************************
34 (require 'cl) ; always
35 (require 'cc-mode)
36
37
38 (setf auto-mode-alist (append '(("OpticsProMac.*\\.h$" . objc-mode)
39                                 ("\\.m$"  . objc-mode)
40                                 ("\\.mm$" . objc-mode))
41                               auto-mode-alist))
42
43
44 (c-add-style
45  "dxo"
46  '((c-backslash-column             .  72)
47    
48    (c-backslash-max-column         . 128)
49    
50    (c-basic-offset                 .   2)
51    
52    (c-block-comment-prefix         . "* ")
53    
54    (c-cleanup-list                 . (list-close-comma
55                                       scope-operator))
56    
57    (c-comment-only-line-offset     . (0 . 0))
58    
59    ;; (c-comment-prefix-regexp)
60
61    (c-doc-comment-style            . javadoc)
62
63    (c-hanging-braces-alist         . (
64                                       ;; (statement-cont)
65                                       ;; (brace-list-intro)
66                                       (inexpr-class-open    . (before after))
67                                       (inexpr-class-close   . (before after))
68                                       
69                                       (defun-open           . (before after)) ; Brace that opens a function definition.
70                                       (defun-close          . (before after)) ; Brace that closes a function definition.
71                                       (class-open           . (before after)) ; Brace that opens a class definition.
72                                       (class-close          . (before after)) ; Brace that closes a class definition.
73                                       (inline-open          . (before after)) ; Brace that opens an in-class inline method.
74                                       (inline-close         . (before after)) ; Brace that closes an in-class inline method. 
75                                       (block-open           . (before after)) ; Statement block open brace.
76                                       (block-close          . (before after)) ; Statement block close brace.
77                                       (brace-list-open      . (before after)) ; Open brace of an enum or static array list.
78                                       (brace-list-close     . (before after)) ; Close brace of an enum or static array list.
79                                       (brace-entry-open     . (before after)) ; Subsequent lines in an enum or static array
80                                       (statement-case-open  . (before after)) ; The first line in a case block starting with brace.
81                                       (substatement-open    . (before after)) ; The brace that opens a substatement block.
82                                       (extern-lang-open     . (before after)) ; Brace that opens an "extern" block.
83                                       (extern-lang-close    . (before after)) ; Brace that closes an "extern" block.
84                                       (namespace-open       . (before after))
85                                       (namespace-close      . (before after))
86                                       (module-open          . (before after))
87                                       (module-close         . (before after))
88                                       (composition-open     . (before after))
89                                       (composition-close)   . (before after)))
90
91    (c-hanging-colons-alist         . ((case-label           . (after))
92                                       (label                . (after))
93                                       (access-label         . (after))
94                                       (member-init-intro    . ())
95                                       (inher-intro          . ())))
96    
97    (c-hanging-semi&comma-criteria  . ())
98    
99    ;; (c-indent-comment-alist)
100
101    (c-indent-comments-syntactically-p . nil)
102    
103    (c-label-minimum-indentation       . 2)
104
105    (c-offsets-alist                   . (
106                                          (string             . 0)                 
107                                          ;; Inside multi-line string.
108                                          (c                  . 1)                      
109                                          ;; Inside a multi-line C style block comment.
110                                          (defun-open         . 0)             
111                                          ;; Brace that opens a function definition.
112                                          (defun-close        . 0)            
113                                          ;; Brace that closes a function definition.
114                                          (defun-block-intro  . +)      
115                                          ;; The first line in a top-level defun.
116                                          (class-open         . 0)             
117                                          ;; Brace that opens a class definition.
118                                          (class-close        . 0)            
119                                          ;; Brace that closes a class definition.
120                                          (inline-open        . 0)            
121                                          ;; Brace that opens an in-class inline method.
122                                          (inline-close       . 0)           
123                                          ;; Brace that closes an in-class inline method.
124                                          (func-decl-cont     . +)         
125                                          ;; The region between a function definition's
126                                          ;; argument list and the function opening brace
127                                          ;; (excluding K&R argument declarations).  In C, you
128                                          ;; cannot put anything but whitespace and comments
129                                          ;; between them; in C++ and Java, throws declarations
130                                          ;; and other things can appear in this context.
131                                          (knr-argdecl-intro     . +)      
132                                          ;; First line of a K&R C argument declaration.
133                                          (knr-argdecl           . +)            
134                                          ;; Subsequent lines in a K&R C argument declaration.
135                                          (topmost-intro         . 0)
136                                          ;; The first line in a topmost construct definition.
137                                          (topmost-intro-cont    . 0)     
138                                          ;; Topmost definition continuation lines.
139                                          (member-init-intro     . +)      
140                                          ;; First line in a member initialization list.
141                                          (member-init-cont      . ++)       
142                                          ;; Subsequent member initialization list lines.
143                                          (inher-intro           . +)            
144                                          ;; First line of a multiple inheritance list.
145                                          (inher-cont            . ++)             
146                                          ;; Subsequent multiple inheritance lines.
147                                          (block-open            . 0)             
148                                          ;; Statement block open brace.
149                                          (block-close           . 0)            
150                                          ;; Statement block close brace.
151                                          (brace-list-open       . 0)        
152                                          ;; Open brace of an enum or static array list.
153                                          (brace-list-close      . 0)       
154                                          ;; Close brace of an enum or static array list.
155                                          (brace-list-intro      . +)       
156                                          ;; First line in an enum or static array list.
157                                          (brace-list-entry      . 0)       
158                                          ;; Subsequent lines in an enum or static array list.
159                                          (brace-entry-open      . +)       
160                                          ;; Subsequent lines in an enum or static array
161                                          ;; list that start with an open brace.
162                                          (statement             . 0)
163                                          ;; A C (or like) statement.
164                                          (statement-cont        . ++)         
165                                          ;; A continuation of a C (or like) statement.
166                                          (statement-block-intro . +)  
167                                          ;; The first line in a new statement block.
168                                          (statement-case-intro  . +)   
169                                          ;; The first line in a case "block".
170                                          (statement-case-open   . +)    
171                                          ;; The first line in a case block starting with brace.
172                                          (substatement          . 0)           
173                                          ;; The first line after an if/while/for/do/else.
174                                          (substatement-open     . 0)
175                                          ;; The brace that opens a substatement block.
176                                          (substatement-label    . /)     
177                                          ;; Labelled line after an if/while/for/do/else.
178                                          (case-label            . +)             
179                                          ;; A "case" or "default" label.
180                                          (access-label          . 0)           
181                                          ;; C++ private/protected/public access label.
182                                          (label                 . /)                  
183                                          ;; Any ordinary label.
184                                          (do-while-closure      . 0)       
185                                          ;; The "while" that ends a do/while construct.
186                                          (else-clause           . 0)            
187                                          ;; The "else" of an if/else construct.
188                                          (catch-clause          . 0)           
189                                          ;; The "catch" or "finally" of a try/catch construct.
190                                          (comment-intro         . 0)          
191                                          ;; A line containing only a comment introduction.
192                                          (arglist-intro         . +)          
193                                          ;; The first line in an argument list.
194                                          (arglist-cont          . +)           
195                                          ;; Subsequent argument list lines when no
196                                          ;; arguments follow on the same line as the
197                                          ;; arglist opening paren.
198                                          (arglist-cont-nonempty . +)  
199                                          ;; Subsequent argument list lines when at
200                                          ;; least one argument follows on the same
201                                          ;; line as the arglist opening paren.
202                                          (arglist-close         . 0)          
203                                          ;; The solo close paren of an argument list.
204                                          (stream-op             . +)              
205                                          ;; Lines continuing a stream operator construct.
206                                          (inclass               . +)                
207                                          ;; The construct is nested inside a class definition.
208                                          ;; Used together with e.g. `topmost-intro'.
209                                          (cpp-macro             . [0])              
210                                          ;; The start of a C preprocessor macro definition.
211                                          (cpp-macro-cont        . [8])         
212                                          ;; Inside a multi-line C preprocessor macro definition.
213                                          (friend                . 0)                 
214                                          ;; A C++ friend declaration.
215                                          (objc-method-intro     . [0])      
216                                          ;; The first line of an Objective-C method definition.
217                                          (objc-method-args-cont . 0)  
218                                          ;; Lines continuing an Objective-C method definition.
219                                          (objc-method-call-cont . ++)  
220                                          ;; Lines continuing an Objective-C method call.
221                                          (extern-lang-open      . 0)       
222                                          ;; Brace that opens an "extern" block.
223                                          (extern-lang-close     . 0)      
224                                          ;; Brace that closes an "extern" block.
225                                          (inextern-lang         . +)          
226                                          ;; Analogous to the `inclass' syntactic symbol,
227                                          ;; but used inside "extern" blocks.
228                                          (namespace-open        . 0)
229                                          (namespace-close       . 0)
230                                          (innamespace           . +)
231                                          ;; Similar to the three `extern-lang' symbols, but for
232                                          ;; C++ "namespace" blocks.
233                                          (module-open           . 0)
234                                          (module-close          . 0)
235                                          (inmodule              . +)
236                                          ;; Similar to the three `extern-lang' symbols, but for
237                                          ;; CORBA IDL "module" blocks.
238                                          (composition-open      . 0)
239                                          (composition-close     . 0)
240                                          (incomposition         . +)
241                                          ;; Similar to the three `extern-lang' symbols, but for
242                                          ;; CORBA CIDL "composition" blocks.
243                                          (template-args-cont    . +)     
244                                          ;; C++ template argument list continuations.
245                                          (inlambda              . +)               
246                                          ;; In the header or body of a lambda function.
247                                          (lambda-intro-cont     . ++)      
248                                          ;; Continuation of the header of a lambda function.
249                                          (inexpr-statement      . +)       
250                                          ;; The statement is inside an expression.
251                                          (inexpr-class          . +)           
252                                          ;; The class is inside an expression.  Used e.g. for
253                                          ;; Java anonymous classes.
254                                          ))
255    ;; Only called when c-syntactic-indentation is non nil.
256    ;; (c-special-indent-hook . user-fun)
257
258    
259    (tab-width                     . 4)  ; the true one!
260
261    (c-indent-level                . 2)  ; Indentation of C statements with
262                                         ; respect to containing block.
263
264    (c-brace-imaginary-offset      . 0)  ; Imagined indentation of a C open brace
265                                         ; that actually follows a statement.
266
267    (c-brace-offset                . 0)  ; Extra indentation for braces, compared
268                                         ; with other text in same context.
269
270    (c-argdecl-indent              . +)  ; Indentation level of declarations of
271                                         ; C function arguments.
272
273    (c-label-offset                . -)  ; Offset of C label lines and case
274                                         ; statements relative to usual 
275                                         ; indentation.
276
277    (c-continued-statement-offset  . 4)  ; Extra indent for lines not starting
278                                         ; new statements.
279
280    (c-continued-brace-offset      . 0)  ; Extra indent for substatements that
281                                         ; start with open-braces.
282
283
284    (c-auto-newline                . t)  ; Non-nil means automatically newline
285                                         ; before and after braces, and after
286                                         ; colons and semicolons, inserted in C
287                                         ; code. If you do not want a leading
288                                         ; newline before braces then use:
289                                         ; (define-key c-mode-map \"{\"
290                                         ;          'electric-c-semi)"
291
292    (c-tab-always-indent           . t)  ; Non-nil means TAB in C mode should
293                                         ; always reindent the current line,
294                                         ; regardless of where in the line point
295                                         ; is when the TAB command is used.
296    ))
297
298
299
300 (defun dxo-c-mode-common-meat ()
301   (interactive)
302   (c-set-style "dxo")
303   (c-toggle-auto-newline 1))
304
305 (add-hook 'c-mode-common-hook 'dxo-c-mode-common-meat)
306
307
308
309 (defun dxo-company-name ()
310   "Substitute __MyCompanyName__ by DxO Consumer in the whole current buffer."
311   (interactive)
312   (goto-char (point-min))
313   (while (re-search-forward "__MyCompanyName__" nil t)
314     (delete-region (match-beginning 0) (match-end 0))
315     (insert "DxO Labs"))
316   (goto-char (point-min))
317   (message "Did you mind setting the company name in XCode preferences?"))
318
319 (defun dxo-remove-unneeded-spaces (start end)
320   "Remove duplicate spaces in the region."
321   (interactive "r")
322   (goto-char start)
323   (with-marker (end end)
324    (while (< (point) end)
325      (cond
326
327        ((looking-at "\"\\([^\\\"]\\|\\.\\)*\"")
328         (message "string ")
329         ;; skip over strings
330         (goto-char (match-end 0)))
331
332        ((looking-at "//.*\n")
333         (message "//comment ")
334         ;; skip over // comments
335         (goto-char (match-end 0)))
336
337        ((looking-at "/\\*\\(.\\|\n\\)*?\\*/")
338         (message "/*comment ")
339         ;; skip over C comments..
340         (goto-char (match-end 0)))
341
342        ((looking-at "  +")
343         (message "whitespaces ")
344         (delete-region (1+ (match-beginning 0)) (match-end 0)))
345
346        (t
347         (message ". ")
348         (forward-char 1))))))
349
350
351
352 (provide 'dxo)
353 ;;;; THE END ;;;;
354