merged.

Pascal J. Bourguignon [2016-06-13 14:08]
merged.
Filename
insulte.el
pjb-animate.el
pjb-emacs.el
trustonic.el
diff --git a/insulte.el b/insulte.el
new file mode 100644
index 0000000..cbb37f5
--- /dev/null
+++ b/insulte.el
@@ -0,0 +1,322 @@
+;;;; -*- mode:emacs-lisp;coding:utf-8;lexical-binding:t -*-
+;;;;**************************************************************************
+;;;;FILE:               insulte.el
+;;;;LANGUAGE:           emacs lisp
+;;;;SYSTEM:             POSIX
+;;;;USER-INTERFACE:     NONE
+;;;;DESCRIPTION
+;;;;
+;;;;    Captain Haddock's insults generator.
+;;;;
+;;;;AUTHORS
+;;;;    <PJB> Pascal J. Bourguignon <pjb@informatimago.com>
+;;;;MODIFICATIONS
+;;;;    2016-06-05 <PJB> Added distinction between ga and gap.
+;;;;    2015-06-17 <PJB> Translated from Common Lisp.
+;;;;BUGS
+;;;;LEGAL
+;;;;    AGPL3
+;;;;
+;;;;    Copyright Pascal J. Bourguignon 2015 - 2016
+;;;;
+;;;;    This program is free software: you can redistribute it and/or modify
+;;;;    it under the terms of the GNU Affero General Public License as published by
+;;;;    the Free Software Foundation, either version 3 of the License, or
+;;;;    (at your option) any later version.
+;;;;
+;;;;    This program is distributed in the hope that it will be useful,
+;;;;    but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;;;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;;;    GNU Affero General Public License for more details.
+;;;;
+;;;;    You should have received a copy of the GNU Affero General Public License
+;;;;    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+;;;;**************************************************************************
+
+(require 'cl)
+(defvar *insulte-insults*)
+(defvar *insulte-nm*)
+(defvar *insulte-nf*)
+(defvar *insulte-ad*)
+
+(setf *insulte-insults* '(
+                          ("accapareur" (nm))
+                          ("aérolithe" (nm))
+                          ("amiral de bateau­lavoir" (gnm))
+                          ("amphitryon" (nm))
+                          ("anacoluthe" (nf))
+                          ("analphabète" (n a))
+                          ("anthracite" (nm))
+                          ("anthropophage" (nm a))
+                          ("anthropopithèque" (nm))
+                          ("apache" (nm))
+                          ("apprenti dictateur à la noix de coco" (gnm))
+                          ("arlequin" (nm))
+                          ("astronaute d'eau douce" (gn))
+                          ("athlète complet" (n))
+                          ("autocrate" (nm))
+                          ("autodidacte" (n a))
+                          ("azteque" (nm))
+                          ("babouin" (nm))
+                          ("bachi­bouzouk" (nm))
+                          ("bande de" (|...|))
+                          ("bandit" (nm))
+                          ("bayadère" (nf))
+                          ("bibendum" (nm))
+                          ("boit­sans­soif" (ni))
+                          ("brontosaure" (nm))
+                          ("bougre de" (|...|))
+                          ("brute" (nf))
+                          ("bulldozer à réaction" (gnm))
+                          ("vieux" (a p))
+                          ("cachalot" (nm))
+                          ("canaille" (nf))
+                          ("canaque" (nm a))
+                          ("cannibale" (nm))
+                          ("carnaval" (nm))
+                          ("catachrèse" (nf))
+                          ("cataplasme" (nm))
+                          ("cercopithèque" (nm))
+                          ("chauffard" (nm))
+                          ("chenapan" (nm))
+                          ("choléra" (nm))
+                          ("chouette mal empaillée" (gnf))
+                          ("cloporte" (nm))
+                          ("clysopompe" (nm))
+                          ("coléoptère" (nm))
+                          ("coloquinte" (nf))
+                          ("coquin" (n a))
+                          ("cornemuse" (nf))
+                          ("cornichon" (nm))
+                          ("corsaire" (nm))
+                          ("coupe­jarret" (nm))
+                          ("cow­boy de la route" (gnm))
+                          ("crétin des Alpes" (gnm))
+                          ("Cro­magnon" (np))
+                          ("cyanure" (nm))
+                          ("cyclone" (nm))
+                          ("cyclotron" (nm))
+                          ("Cyrano à quatre pattes" (gnm))
+                          ("diablesse" (nf))
+                          ("diplodocus" (nm))
+                          ("doryphore" (nm))
+                          ("dynamiteur" (nm))
+                          ("ecornifleur" (nm))
+                          ("ecraseur" (nm))
+                          ("ectoplasme" (nm))
+                          ("egoïste" (nm))
+                          ("emplatre" (nm))
+                          ("empoisonneur" (nm a))
+                          ("enragé" (nm a))
+                          ("épouvantail" (nm))
+                          ("équilibriste" (nm))
+                          ("esclavagiste" (nm))
+                          ("escogriffe" (nm))
+                          ("espèce de" (|...|))
+                          ("extrait de" (|...|))
+                          ("faux jeton" (nm))
+                          ("flibustier" (nm))
+                          ("forban" (nm))
+                          ("frères de la côte" (gnm))
+                          ("froussard" (nm a))
+                          ("galopin" (nm))
+                          ("gangster" (nm))
+                          ("garde­côte à la mie de pain" (gnm))
+                          ("gargarisme" (nm))
+                          ("garnement" (nm))
+                          ("gibier de potence" (nm))
+                          ("goujat" (nm))
+                          ("gredin" (nm))
+                          ("grenouille" (nf))
+                          ("gros plein de soupe" (gnm))
+                          ("gyroscope" (nm))
+                          ("hérétique" (n a))
+                          ("hors­la­loi" (nm))
+                          ("huluberlu" (nm))
+                          ("hydrocarbure" (nm))
+                          ("iconoclaste" (nm a))
+                          ("incas de carnaval" (gnmp))
+                          ("individou de général" (gnm))
+                          ("invertébré" (nm))
+                          ("ivrogne" (n))
+                          ("jet d'eau ambulant" (gnm))
+                          ("jocrisse" (nm))
+                          ("judas" (nm))
+                          ("jus de réglisse" (gnm))
+                          ("kroumir" (nm))
+                          ("ku klux klan" (gnm))
+                          ("lâche" (nm))
+                          ("lépidoptère" (nm))
+                          ("logarithme" (nm))
+                          ("loup­garou à la graisse de renoncule" (gnm))
+                          ("macaque" (nm))
+                          ("macrocéphale" (nm))
+                          ("malappris" (n a))
+                          ("malotru" (n))
+                          ("mamelouk" (nm))
+                          ("marchand de guano" (gnm))
+                          ("marchand de tapis" (gnm))
+                          ("marin d'eau douce" (gnm))
+                          ("marmotte" (nf))
+                          ("mégalomane" (nm a))
+                          ("mégacycle" (nm))
+                          ("mercanti" (nm))
+                          ("mercenaire" (nm a))
+                          ("mérinos" (nm))
+                          ("mille sabords" (gnmp))
+                          ("misérable" (a))
+                          ("mitrailleur à bavette" (gnm))
+                          ("moratorium" (nm))
+                          ("moricaud" (nm a))
+                          ("mouchard" (nm))
+                          ("moujik" (nm))
+                          ("moule à gaufres" (gnm))
+                          ("moussaillon" (nm))
+                          ("mrkrpxzkrmtfrz" (nm))
+                          ("mufle" (nm))
+                          ("Mussolini de carnaval" (nm))
+                          ("naufrageur" (nm))
+                          ("négrier" (nm))
+                          ("noix de coco" (gnm))
+                          ("nyctalope" (n a))
+                          ("olibrius" (nm))
+                          ("ophicléïde" (nm))
+                          ("ornithorynque" (nm))
+                          ("oryctérope" (nm))
+                          ("ostrogoth" (n a))
+                          ("ours mal lèché" (gnm))
+                          ("pacte à quatre" (gnm))
+                          ("paltoquet" (nm))
+                          ("pantoufle" (nf))
+                          ("Papous" (nm))
+                          ("paranoïaque" (nm a))
+                          ("parasite" (nm a))
+                          ("Patagon" (nm))
+                          ("patapouf" (nm))
+                          ("patate" (nf))
+                          ("péronnelle" (nf))
+                          ("perruche bavarde" (gnf))
+                          ("phénomène" (nm))
+                          ("phlébotome" (nm))
+                          ("phylactère" (nm))
+                          ("phylloxéra" (nm))
+                          ("pignouf" (nm))
+                          ("pirate" (nm))
+                          ("Polichinelle" (nm))
+                          ("polygraphe" (nm))
+                          ("porc­épic mal embouché" (gnm))
+                          ("potentat emplumé" (gnm))
+                          ("poussière" (nf))
+                          ("profiteur" (nm))
+                          ("projectile guidé" (gnm))
+                          ("protozoaire" (nm))
+                          ("pyromane" (nm))
+                          ("pyrophore" (nm))
+                          ("rapace" (nm))
+                          ("rat" (nm))
+                          ("Ravachol" (nm))
+                          ("renégat" (nm))
+                          ("rhizopode" (nm))
+                          ("Rocambole" (nm))
+                          ("sacripant" (nm))
+                          ("sajou" (nm))
+                          ("saltimbanque" (nm))
+                          ("sapajou" (nm))
+                          ("satané bazar de fourbi de truc" (gnm))
+                          ("satrape" (nm))
+                          ("sauvage" (n a))
+                          ("scélérat" (nm))
+                          ("schizophrène" (n a))
+                          ("scolopendre" (nf))
+                          ("scorpion" (nm))
+                          ("serpent" (nm))
+                          ("simili martien à la graisse de cabestan" (gnm))
+                          ("sinapisme" (nm))
+                          ("soulographe" (nm))
+                          ("squatter" (nm))
+                          ("tchouk­tchouk­nougat" (nm))
+                          ("technocrate" (nm))
+                          ("tête de lard" (gnf))
+                          ("tête de mule" (gnf))
+                          ("tigresse" (nf))
+                          ("tonnerre de Brest" (gnm))
+                          ("topinanbour" (nm))
+                          ("tortionnaire" (nm))
+                          ("traficant de chair humaine" (gnm))
+                          ("traine­potence" (nm))
+                          ("traitre" (nm a))
+                          ("troglodyte" (nm))
+                          ("trompe­la­mort" (nm))
+                          ("vampire" (nm))
+                          ("vandale" (nm a))
+                          ("va­nu­pieds" (nm))
+                          ("vaurien" (nm))
+                          ("végétarien" (nm))
+                          ("Vercingétorix de carnaval" (nm))
+                          ("ver de terre" (gnm))
+                          ("vermicelle" (nm))
+                          ("vermine" (nm))
+                          ("vipère" (nf))
+                          ("vivisectionniste" (nm))
+                          ("voleur" (nm))
+                          ("wisigoth" (n a))
+                          ("zapotèque" (nm))
+                          ("zèbre" (nm))
+                          ("zigomar" (nm))
+                          ("zouave" (nm))
+                          ("Zoulou" (nm))
+                          )
+      *insulte-nm* (remove-if-not (lambda (x) (intersection '(n np nm gnm) (second x))) *insulte-insults*)
+      *insulte-nf* (remove-if-not (lambda (x) (intersection '(nf np) (second x))) *insulte-insults*)
+      *insulte-ad* (remove-if-not (lambda (x) (member 'a (second x))) *insulte-insults*))
+
+(defun insulte ()
+  (let* ((a   (elt *insulte-ad* (random (length *insulte-ad*))))
+         (ad  (first a))
+         (gn (let ((n (random (+ (length *insulte-nf*) (length *insulte-nm*)))))
+               (if (>= n (length *insulte-nm*))
+                   (prog1
+                       (first (elt *insulte-nf* (- n (length *insulte-nm*))))
+                     (cond
+                       ((= 0 (length ad)))
+                       ((string= "e"     (subseq ad   (- (length ad) 1)) ))
+                       ((string= "eux"   (subseq ad   (- (length ad) 3)))
+                        (setf ad (concat (subseq ad 0 (- (length ad) 2)) "ille")))
+                       ((string= "eur"   (subseq ad   (- (length ad) 3)))
+                        (setf ad (concat (subseq ad 0 (- (length ad) 1)) "se")))
+                       (t
+                        (setf ad (concat ad "e")))))
+                   (first (elt *insulte-nm* n)))))
+         (ga  (if (member 'p (second a))
+                  ""
+                  (format " %s" ad)))
+         (gap (if (member 'p (second a))
+                  (format "%s " ad)
+                  ""))
+         (conj (if (position (aref (concat gap gn) 0) "aeiouyh") "d'" "de "))
+         (ins  (case (random 4)
+                 ((0)       (concat "espèce " conj gap gn ga))
+                 ((1)       (concat "bande "  conj gap gn ga))
+                 (otherwise (concat gap gn ga)))))
+    (concat (capitalize (subseq ins 0 1)) (subseq ins 1) " !")))
+
+
+(defun insulte-moi ()
+  (interactive)
+  (message "%s" (insulte)))
+
+;; (loop repeat 10 do (princ (insulte)) (terpri))
+;; Vieux saltimbanque !
+;; Zapotèque ostrogoth !
+;; Potentat emplumé sauvage !
+;; Espèce de végétarien moricaud !
+;; Vieux hors­la­loi !
+;; Vieux moricaud !
+;; Coléoptère moricaud !
+;; Paltoquet canaque !
+;; Bande de rat paranoïaque !
+;; Cachalot misérable !
+;; nil
+
+(provide 'insulte)
+;;;; THE END ;;;;
diff --git a/pjb-animate.el b/pjb-animate.el
new file mode 100644
index 0000000..084e931
--- /dev/null
+++ b/pjb-animate.el
@@ -0,0 +1,17 @@
+(defun pjb-animate (speed)
+  (interactive "nSpeed: ")
+  (let ((delay (/ 1.0  speed))
+        (done  nil))
+    (widen)
+    (goto-char (point-min))
+    (message "Animating...")
+    (while (not done)
+      (widen)
+      (if (search-forward "\f" nil 'at-limit)
+          nil
+        (goto-char (point-max))
+        (setq done t))
+      (narrow-to-page)
+      (sit-for delay)
+      (force-mode-line-update t))
+    (message "Done.")))
diff --git a/pjb-emacs.el b/pjb-emacs.el
index 3401af4..d5b699b 100644
--- a/pjb-emacs.el
+++ b/pjb-emacs.el
@@ -2539,8 +2539,7 @@ FILE-AND-OPTION: either an atom evaluated to a path,
         (t
          nil)))))

-(defun* recursive-replace-string (from-string to-string
-                                              &key directory recursive delimited exceptions)
+(defun* recursive-replace-string (from-string to-string &key directory recursive delimited exceptions)
   "Replace the all occurences of `from-string' by `to-string' in all the files in the directory.
 If `recursive' is true (or a prefix argument is given), then the files are searched recursively
 otherwise only the files directly in the given `directory' are modified.
@@ -2553,7 +2552,10 @@ recursive search.  Backup files (name ending in ~) are ignored too.
           (arguments (query-replace-read-args
                       (format "Replace string in all files in %s" directory)
                       nil)))
-     (list (first arguments) (second arguments) directory (third arguments) nil)))
+     (list (first arguments) (second arguments)
+           :directory directory
+           :recursive (third arguments)
+           :delimited nil)))
   (with-files (file directory :recursive recursive :exceptions (exception-function exceptions))
     (with-file (file)
       (message "Processing %S" file)
@@ -2574,7 +2576,10 @@ recursive search.  Backup files (name ending in ~) are ignored too.
           (arguments (query-replace-read-args
                       (format "Replace string in all files in %s" directory)
                       nil)))
-     (list (first arguments) (second arguments) directory (third arguments) nil)))
+     (list (first arguments) (second arguments)
+           :directory directory
+           :recursive (third arguments)
+           :delimited nil)))
   (with-files (file directory :recursive recursive :exceptions (exception-function exceptions))
     (with-file (file)
       (message "Processing %S" file)
diff --git a/trustonic.el b/trustonic.el
new file mode 100644
index 0000000..7bcdc2a
--- /dev/null
+++ b/trustonic.el
@@ -0,0 +1,483 @@
+;;; trustonic-c-style -- c-style following Trustonic coding conventions
+;;;; -*- mode:emacs-lisp;coding:utf-8 -*-
+;;;;**************************************************************************
+;;;;FILE:               trustonic.el
+;;;;LANGUAGE:           emacs lisp
+;;;;SYSTEM:             POSIX
+;;;;USER-INTERFACE:     NONE
+;;;;DESCRIPTION
+;;;;
+;;;;    Emacs configuration used at Trustonics Ltd.
+;;;;
+;;;;    Add to your ~/.emacs:
+;;;;
+;;;;         (require 'trustonic)
+;;;;
+;;;;    Then new C, Objective-C or C++ buffers will get the trustonic style.
+;;;;
+;;;;    To change the c-style manually:
+;;;;
+;;;;        M-x c-set-style RET trustonic RET
+;;;;
+;;;;AUTHORS
+;;;;    <PJB> Pascal Bourguignon <pjb@informatimago.com>
+;;;;MODIFICATIONS
+;;;;    2016-06-09 <PJB> Adapted to trustonic.
+;;;;    2012-11-15 <PJB> Created.
+;;;;BUGS
+;;;;LEGAL
+;;;;    GPL3
+;;;;
+;;;;    Copyright Pascal Bourguignon 2012 - 2016
+;;;;
+;;;;    This program is free software: you can redistribute it and/or modify
+;;;;    it under the terms of the GNU General Public License as published by
+;;;;    the Free Software Foundation, either version 3 of the License, or
+;;;;    (at your option) any later version.
+;;;;
+;;;;    This program is distributed in the hope that it will be useful,
+;;;;    but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;;;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;;;    GNU General Public License for more details.
+;;;;
+;;;;    You should have received a copy of the GNU General Public License
+;;;;    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+;;;;**************************************************************************
+;;; Commentary:
+;;; http://wiki.trustonic.internal/confluence/display/mc/Coding+Guidelines+And+Conventions
+;;; Code:
+
+(require 'cl) ; always
+(require 'cc-mode)
+
+(defmacro* with-marker ((var position) &body body)
+  (let ((vposition (gensym))) ; so (eq var position) still works.
+    `(let* ((,vposition ,position)
+            (,var (make-marker)))
+       (set-marker ,var ,vposition)
+       (unwind-protect (progn ,@body)
+         (set-marker ,var nil)))))
+
+(setf auto-mode-alist (append '(("\\.m$"  . objc-mode)
+                                ("\\.mm$" . objc-mode))
+                              auto-mode-alist))
+
+
+(c-add-style
+ "trustonic"
+ '((c-backslash-column             .  78)
+
+   (c-backslash-max-column         . 128)
+
+   (c-basic-offset                 .   4)
+
+   (c-block-comment-prefix         . "* ")
+
+   (c-cleanup-list                 . (list-close-comma
+                                      scope-operator))
+
+   (c-comment-only-line-offset     . (0 . 0))
+
+   ;; (c-comment-prefix-regexp)
+
+   (c-doc-comment-style            . javadoc)
+
+   (c-hanging-braces-alist         . (
+                                      ;; (statement-cont)
+                                      ;; (brace-list-intro)
+                                      (inexpr-class-open    . (before after))
+                                      (inexpr-class-close   . (before after))
+
+                                      (defun-open           . (before after)) ; Brace that opens a function definition.
+                                      (defun-close          . (before after)) ; Brace that closes a function definition.
+                                      (class-open           . (before after)) ; Brace that opens a class definition.
+                                      (class-close          . (before after)) ; Brace that closes a class definition.
+                                      (inline-open          . (before after)) ; Brace that opens an in-class inline method.
+                                      (inline-close         . (before after)) ; Brace that closes an in-class inline method.
+                                      (block-open           . (before after)) ; Statement block open brace.
+                                      (block-close          . (before after)) ; Statement block close brace.
+                                      (brace-list-open      . (before after)) ; Open brace of an enum or static array list.
+                                      (brace-list-close     . (before after)) ; Close brace of an enum or static array list.
+                                      (brace-entry-open     . (before after)) ; Subsequent lines in an enum or static array
+                                      (statement-case-open  . (before after)) ; The first line in a case block starting with brace.
+                                      (substatement-open    . (before after)) ; The brace that opens a substatement block.
+                                      (extern-lang-open     . (before after)) ; Brace that opens an "extern" block.
+
+
+
+
+
+
+
+                                      (extern-lang-close    . (before after)) ; Brace that closes an "extern" block.
+                                      (namespace-open       . (before after))
+                                      (namespace-close      . (before after))
+                                      (module-open          . (before after))
+                                      (module-close         . (before after))
+                                      (composition-open     . (before after))
+                                      (composition-close)   . (before after)))
+
+   (c-hanging-colons-alist         . ((case-label           . (after))
+                                      (label                . (after))
+                                      (access-label         . (after))
+                                      (member-init-intro    . ())
+                                      (inher-intro          . ())))
+
+   (c-hanging-semi&comma-criteria  . ())
+
+   ;; (c-indent-comment-alist)
+
+   (c-indent-comments-syntactically-p . nil)
+
+   (c-label-minimum-indentation       . 2)
+
+   (c-offsets-alist                   . (
+
+                                         (string             . 0)
+                                         ;; Inside multi-line string.
+
+                                         (c                  . 1)
+                                         ;; Inside a multi-line C style block comment.
+
+                                         (defun-open         . 0)
+                                         ;; Brace that opens a function definition.
+
+                                         (defun-close        . 0)
+                                         ;; Brace that closes a function definition.
+
+                                         (defun-block-intro  . +)
+                                         ;; The first line in a top-level defun.
+
+                                         (class-open         . 0)
+                                         ;; Brace that opens a class definition.
+
+                                         (class-close        . 0)
+                                         ;; Brace that closes a class definition.
+
+                                         (inline-open        . 0)
+                                         ;; Brace that opens an in-class inline method.
+
+                                         (inline-close       . 0)
+                                         ;; Brace that closes an in-class inline method.
+
+                                         (func-decl-cont     . +)
+                                         ;; The region between a function definition's
+                                         ;; argument list and the function opening brace
+                                         ;; (excluding K&R argument declarations).  In C, you
+                                         ;; cannot put anything but whitespace and comments
+                                         ;; between them; in C++ and Java, throws declarations
+                                         ;; and other things can appear in this context.
+
+                                         (knr-argdecl-intro     . +)
+                                         ;; First line of a K&R C argument declaration.
+
+                                         (knr-argdecl           . +)
+                                         ;; Subsequent lines in a K&R C argument declaration.
+
+                                         (topmost-intro         . 0)
+                                         ;; The first line in a topmost construct definition.
+
+                                         (topmost-intro-cont    . 0)
+                                         ;; Topmost definition continuation lines.
+
+                                         (member-init-intro     . +)
+                                         ;; First line in a member initialization list.
+
+                                         (member-init-cont      . ++)
+                                         ;; Subsequent member initialization list lines.
+
+                                         (inher-intro           . +)
+                                         ;; First line of a multiple inheritance list.
+
+                                         (inher-cont            . ++)
+                                         ;; Subsequent multiple inheritance lines.
+
+                                         (block-open            . 0)
+                                         ;; Statement block open brace.
+
+                                         (block-close           . 0)
+                                         ;; Statement block close brace.
+
+                                         (brace-list-open       . 0)
+                                         ;; Open brace of an enum or static array list.
+
+                                         (brace-list-close      . 0)
+                                         ;; Close brace of an enum or static array list.
+
+                                         (brace-list-intro      . +)
+                                         ;; First line in an enum or static array list.
+
+                                         (brace-list-entry      . 0)
+                                         ;; Subsequent lines in an enum or static array list.
+
+                                         (brace-entry-open      . +)
+                                         ;; Subsequent lines in an enum or static array
+                                         ;; list that start with an open brace.
+
+                                         (statement             . 0)
+                                         ;; A C (or like) statement.
+
+                                         (statement-cont        . ++)
+                                         ;; A continuation of a C (or like) statement.
+
+                                         (statement-block-intro . +)
+                                         ;; The first line in a new statement block.
+
+                                         (statement-case-intro  . +)
+                                         ;; The first line in a case "block".
+
+                                         (statement-case-open   . +)
+                                         ;; The first line in a case block starting with brace.
+
+                                         (substatement          . 0)
+                                         ;; The first line after an if/while/for/do/else.
+
+                                         (substatement-open     . 0)
+                                         ;; The brace that opens a substatement block.
+
+                                         (substatement-label    . /)
+                                         ;; Labelled line after an if/while/for/do/else.
+
+                                         (case-label            . +)
+                                         ;; A "case" or "default" label.
+
+                                         (access-label          . 0)
+                                         ;; C++ private/protected/public access label.
+
+                                         (label                 . /)
+                                         ;; Any ordinary label.
+
+                                         (do-while-closure      . 0)
+                                         ;; The "while" that ends a do/while construct.
+
+                                         (else-clause           . 0)
+                                         ;; The "else" of an if/else construct.
+
+                                         (catch-clause          . 0)
+                                         ;; The "catch" or "finally" of a try/catch construct.
+
+                                         (comment-intro         . 0)
+                                         ;; A line containing only a comment introduction.
+
+                                         (arglist-intro         . +)
+                                         ;; The first line in an argument list.
+
+                                         (arglist-cont          . +)
+                                         ;; Subsequent argument list lines when no
+                                         ;; arguments follow on the same line as the
+                                         ;; arglist opening paren.
+
+                                         (arglist-cont-nonempty . +)
+                                         ;; Subsequent argument list lines when at
+                                         ;; least one argument follows on the same
+                                         ;; line as the arglist opening paren.
+
+                                         (arglist-close         . 0)
+                                         ;; The solo close paren of an argument list.
+
+                                         (stream-op             . +)
+                                         ;; Lines continuing a stream operator construct.
+
+                                         (inclass               . +)
+                                         ;; The construct is nested inside a class definition.
+                                         ;; Used together with e.g. `topmost-intro'.
+
+                                         (cpp-macro             . [0])
+                                         ;; The start of a C preprocessor macro definition.
+
+                                         (cpp-macro-cont        . [8])
+                                         ;; Inside a multi-line C preprocessor macro definition.
+
+                                         (friend                . 0)
+                                         ;; A C++ friend declaration.
+
+                                         (objc-method-intro     . [0])
+                                         ;; The first line of an Objective-C method definition.
+
+                                         (objc-method-args-cont . 0)
+                                         ;; Lines continuing an Objective-C method definition.
+
+                                         (objc-method-call-cont . (c-lineup-ObjC-method-call-colons ++))
+                                         ;; Lines continuing an Objective-C method call.
+
+                                         (extern-lang-open      . 0)
+                                         ;; Brace that opens an "extern" block.
+
+                                         (extern-lang-close     . 0)
+                                         ;; Brace that closes an "extern" block.
+
+                                         (inextern-lang         . +)
+                                         ;; Analogous to the `inclass' syntactic symbol,
+                                         ;; but used inside "extern" blocks.
+
+                                         (namespace-open        . 0)
+
+                                         (namespace-close       . 0)
+
+                                         (innamespace           . +)
+                                         ;; Similar to the three `extern-lang' symbols, but for
+                                         ;; C++ "namespace" blocks.
+
+                                         (module-open           . 0)
+
+                                         (module-close          . 0)
+
+                                         (inmodule              . +)
+                                         ;; Similar to the three `extern-lang' symbols, but for
+                                         ;; CORBA IDL "module" blocks.
+
+                                         (composition-open      . 0)
+
+                                         (composition-close     . 0)
+
+                                         (incomposition         . +)
+                                         ;; Similar to the three `extern-lang' symbols, but for
+                                         ;; CORBA CIDL "composition" blocks.
+
+                                         (template-args-cont    . +)
+                                         ;; C++ template argument list continuations.
+
+                                         (inlambda              . +)
+                                         ;; In the header or body of a lambda function.
+
+                                         (lambda-intro-cont     . ++)
+                                         ;; Continuation of the header of a lambda function.
+
+                                         (inexpr-statement      . +)
+                                         ;; The statement is inside an expression.
+
+                                         (inexpr-class          . +)
+                                         ;; The class is inside an expression.  Used e.g. for
+                                         ;; Java anonymous classes.
+                                         ))
+   ;; Only called when c-syntactic-indentation is non nil.
+   ;; (c-special-indent-hook . user-fun)
+
+
+   (tab-width                     . 4)  ; the true one!
+
+   (c-indent-level                . 4)  ; Indentation of C statements with
+                                        ; respect to containing block.
+
+   (c-brace-imaginary-offset      . 0)  ; Imagined indentation of a C open brace
+                                        ; that actually follows a statement.
+
+   (c-brace-offset                . 0)  ; Extra indentation for braces, compared
+                                        ; with other text in same context.
+
+   (c-argdecl-indent              . +)  ; Indentation level of declarations of
+                                        ; C function arguments.
+
+   (c-label-offset                . -)  ; Offset of C label lines and case
+                                        ; statements relative to usual
+                                        ; indentation.
+
+   (c-continued-statement-offset  . 8)  ; Extra indent for lines not starting
+                                        ; new statements.
+
+   (c-continued-brace-offset      . 0)  ; Extra indent for substatements that
+					; start with open-braces.
+
+
+   (c-auto-newline                . t)  ; Non-nil means automatically newline
+					; before and after braces, and after
+					; colons and semicolons, inserted in C
+					; code. If you do not want a leading
+					; newline before braces then use:
+					; (define-key c-mode-map \"{\"
+					;          'electric-c-semi)"
+
+   (c-tab-always-indent           . t)  ; Non-nil means TAB in C mode should
+					; always reindent the current line,
+					; regardless of where in the line point
+					; is when the TAB command is used.
+   ))
+
+
+
+(defun trustonic-c-mode-common-meat ()
+  "Meat for `c-mode-hook` for Trustonic code."
+  (interactive)
+  (c-set-style "trustonic")
+  (c-toggle-auto-newline 1))
+
+(add-hook 'c-mode-common-hook 'trustonic-c-mode-common-meat)
+
+
+
+(defun trustonic-company-name ()
+  "Substitute __MyCompanyName__ by Trustonic Ltd· in the whole current buffer."
+  (interactive)
+  (goto-char (point-min))
+  (while (re-search-forward "__MyCompanyName__" nil t)
+    (delete-region (match-beginning 0) (match-end 0))
+    (insert "Trustonic Ltd."))
+  (goto-char (point-min))
+  (message "Did you mind setting the company name in XCode preferences?"))
+
+
+(defun trustonic-remove-unneeded-spaces (start end)
+  "Remove duplicate spaces in the region.  (Inverse function of align-cols).
+START the start point
+END the end point."
+  (interactive "r")
+  (goto-char start)
+  (with-marker (end end)
+    (while (< (point) end)
+      (cond
+
+        ((looking-at "\"\\([^\\\"]\\|\\.\\)*\"")
+         (message "string ")
+         ;; skip over strings
+         (goto-char (match-end 0)))
+
+        ((looking-at "//.*\n")
+         (message "//comment ")
+         ;; skip over // comments
+         (goto-char (match-end 0)))
+
+        ((looking-at "/\\*\\(.\\|\n\\)*?\\*/")
+         (message "/*comment ")
+         ;; skip over C comments..
+         (goto-char (match-end 0)))
+
+        ((looking-at "  +")
+         (message "whitespaces ")
+         (delete-region (1+ (match-beginning 0)) (match-end 0)))
+
+        (t
+         (message ". ")
+         (forward-char 1))))
+    (indent-region start end)))
+
+
+(defun trustonic-remove-interlines ()
+  "Remove duplicate lines after toplevel closing braces."
+  (interactive)
+  (save-excursion
+   (goto-char (point-min))
+   (while (re-search-forward "^\\(}\\|@end\\) *\\(\n *\\)*\n" nil t)
+     (let ((token (match-string 1)))
+       (delete-region (match-beginning 0) (match-end 0))
+       (insert (cond
+                 ((string= token "}")    "}\n\n")
+                 ((string= token "@end") "@end\n\n")
+                 (t                      (format "%s\n\n" token))))))))
+
+
+(defun trustonic-insert-interlines ()
+  "Insert duplicate lines after toplevel closing braces."
+  (interactive)
+  (save-excursion
+   (goto-char (point-min))
+   (while (re-search-forward "^\\(}\\|@end\\) *\\(\n *\\)*\n" nil t)
+     (let ((token (match-string 1)))
+       (delete-region (match-beginning 0) (match-end 0))
+       (insert (cond
+                 ((string= token "}")    "}\n\n\n")
+                 ((string= token "@end") "@end\n\n\n\n")
+                 (t                      (format "%s\n\n" token))))))))
+
+
+(provide 'trustonic-c-style)
+;;; trustonic.el ends here
ViewGit