Re: C++ access label indentation.

["Pascal J. Bourguignon" <pjb@informatimago.com>]

Alessio Giovanni Baroni <alessiogiovanni.baroni@gmail.com> writes:

> Hi to all,
>
> I'm writing you because I don't know how to indenting the C++ code in
> the following mode:
>
> class foo
> {
>     private:
>          int n;
>     public:
>         void bar ();
> };
>
> I did many searches, and the two principal messages (http://
> lists.gnu.org/archive/html/help-gnu-emacs/2009-09/msg00593.html and 
> http://lists.gnu.org/archive/html/help-gnu-emacs/2012-10/
> msg00332.html) doesn't resolve my problem.
>
> Any help?

M-x set-variable RET c-echo-syntactic-information-p RET t RET
C-x C-f /tmp/test.c++ RET
and paste the code there, then:
C-x h C-M-\

now you get the "default" indentation.

Go at the beginning of the line that's not indented as you want, and
type TAB.  You should see in the minibuffer the syntactic information
echoed.
For example, for "private:", I get:

    syntax: ((inclass 11) (access-label 11)), indent: 0

It means that you can set the indentation by configuring the inclass
and/or the access-label offset in c-offsets-alist

       (inclass               . +)
       (access-label          . 0)

Then do the same for the member lines:

    syntax: ((inclass 11) (topmost-intro 11)), indent: 8

so combining inclass and topmost-intro:

       (topmost-intro         . +)

you should get the indentation you want.

You can configure it in two ways: 

- with a c-style, in which case the custom variables must be set to
  'set-from-style to defer to the c-style, and you will configure
  c-offsets-alist in your c-style, 

    (custom-set-variables
      …
     '(c-basic-offset (quote set-from-style))
      …)


    (c-add-style "Your style"
     '(
       …
       (c-offsets-alist
        . (
           …
           (inclass               . +)
           (access-label          . 0)
           (topmost-intro         . +)
           …
           ))
       …
       )))

- or directly setting the custom variable c-offsets-alist.

    (customize-variables
      …
       '(c-offsets-alist
         '(
           (inclass               . +)
           (access-label          . 0)
           (topmost-intro         . +)
           …))
     …)


Of course, in either case, you will want to configure a lot more to get
indenting of the rest to your taste.  Following the fold are my own
settings.

\f

(custom-set-variables
 '(c-argdecl-indent 4 t)
 '(c-auto-newline nil t)
 '(c-backslash-column (quote set-from-style))
 '(c-backslash-max-column (quote set-from-style))
 '(c-basic-offset (quote set-from-style))
 '(c-block-comment-prefix (quote set-from-style))
 '(c-brace-imaginary-offset 0 t)
 '(c-brace-offset 0 t)
 '(c-cleanup-list (quote set-from-style))
 '(c-comment-continuation-stars "" t)
 '(c-comment-only-line-offset (quote set-from-style))
 '(c-comment-prefix-regexp (quote set-from-style))
 '(c-continued-brace-offset 0 t)
 '(c-continued-statement-offset 4 t)
 '(c-default-style "pjb")
 '(c-doc-comment-style (quote set-from-style))
 '(c-echo-syntactic-information-p t)
 '(c-hanging-braces-alist (quote set-from-style))
 '(c-hanging-colons-alist (quote set-from-style))
 '(c-hanging-comment-ender-p nil t)
 '(c-hanging-comment-starter-p nil t)
 '(c-hanging-semi&comma-criteria (quote set-from-style))
 '(c-indent-comment-alist (quote set-from-style))
 '(c-indent-comments-syntactically-p (quote set-from-style))
 '(c-indent-level 4 t)
 '(c-label-minimum-indentation 2)
 '(c-label-offset -4 t)
 '(c-macro-shrink-window-flag t)
 '(c-offsets-alist nil)
 '(c-special-indent-hook nil)
 '(c-tab-always-indent t))


(c-add-style "pjb"
 '((c-backslash-column             .  72)

   (c-backslash-max-column         . 128)

   (c-basic-offset                 . 4)  ; Amount of basic offset used by `+' and
                                        ; `-' symbols in `c-offsets-alist'.

   (c-block-comment-prefix         .  "")

   (c-cleanup-list                 . (brace-else-brace
                                      brace-elseif-brace
                                      brace-catch-brace
                                      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    . (after))
       (inexpr-class-close   . (before))

       (defun-open           . (after))         ; Brace that opens a function definition.
       (defun-close          . (before))        ; Brace that closes a function definition.
       (class-open           . (before after))  ; Brace that opens a class definition.
       (class-close          . ())              ; Brace that closes a class definition.
       (inline-open          . (before after))  ; Brace that opens an in-class inline method.
       (inline-close         . (before))        ; Brace that closes an in-class inline method.
       (block-open           . ())              ; Statement block open brace.
       (block-close          . c-snug-do-while) ; Statement block close brace.
       (brace-list-open      . (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  . (after))         ; The first line in a case block starting with brace.
       (substatement-open    . (after))         ; The brace that opens a substatement block.
       (extern-lang-open     . (after))         ; Brace that opens an "extern" block.
       (extern-lang-close    . (before after))  ; Brace that closes an "extern" block.
       (namespace-open       . (after))
       (namespace-close      . ())
       (module-open          . (after))
       (module-close         . ())
       (composition-open     . (after))
       (composition-close)   . ()))

   (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                     . 0)
       ;; 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         . +)
       ;; The first line in a topmost construct definition.
       
       (topmost-intro-cont    . (c-lineup-string-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             . (c-lineup-runin-statements
                                 0))
       ;; A C (or like) statement.
       
       (statement-cont        . (c-lineup-string-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          . +)
       ;; 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          . -)
       ;; 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         . (c-lineup-arglist-intro-after-paren
                                 +))
       ;; The first line in an argument list.
       
       (arglist-cont          . (c-lineup-string-cont
                                 c-lineup-arglist-intro-after-paren
                                 c-lineup-argcont
                                 +))
       ;; Subsequent argument list lines when no
       ;; arguments follow on the same line as the
       ;; arglist opening paren.
       
       (arglist-cont-nonempty . (c-lineup-string-cont
                                 c-lineup-arglist-intro-after-paren
                                 c-lineup-argcont
                                 +))
       ;; Subsequent argument list lines when at
       ;; least one argument follows on the same
       ;; line as the arglist opening paren.
       
       (arglist-close         . (c-lineup-argcont
                                 c-lineup-arglist-intro-after-paren
                                 -))
       ;; The solo close paren of an argument list.
       
       (stream-op             . (c-lineup-streamop +))
       ;; 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 . (c-lineup-ObjC-method-args-2
                                 +))
       ;; Lines continuing an Objective-C method definition.
       
       (objc-method-call-cont . (c-lineup-ObjC-method-call-colons
                                 c-lineup-ObjC-method-call
                                 +))
       ;; 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-lineup-template-args +))
       ;; 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)
   (c-label-minimum-indentation    . 2)

   ;; other emacs variables:
   ;; (c-comment-continuation-stars "" t)
   ;; (c-echo-syntactic-information-p t)
   ;; (c-hanging-comment-ender-p nil t)
   ;; (c-hanging-comment-starter-p nil t)
   ;; (c-macro-shrink-window-flag          . t)


   (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               . 4)  ; 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   . 4)  ; 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                . nil) ; 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           . nil) ; 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.
   )))

-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
A bad day in () is better than a good day in {}.