Source

cc-mode / NEWS

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
CC Mode NEWS -- user visible changes.  -*- outline -*-

* Changes in 5.30

There is a lot of change in this version, so it's considered
experimental.  It is however fairly well tested already since the
developers have an extensive test suite to ensure correct syntactic
analysis and font locking.

** Font lock support.
CC Mode now provides font lock support for all its languages.  This
supersedes the font lock patterns that have been in the core font lock
package for C, C++, Java and Objective-C.  Like indentation, font
locking is done in a uniform way across all languages (except the new
AWK mode - see below).  That means that the new font locking will be
different from the old patterns in various details for most languages.

The main goal of the font locking in CC Mode is accuracy, to provide a
dependable aid in recognizing the various constructs.  Some, like
strings and comments, are easy to recognize while others like
declarations and types can be very tricky.  CC Mode can go to great
lengths to recognize declarations and casts correctly, especially when
the types aren't recognized by standard patterns.  This is a fairly
demanding analysis which can be slow on older hardware, and it can
therefore be disabled by choosing a lower decoration level with the
variable font-lock-maximum-decoration.

Note that the most demanding font lock level has been tuned with lazy
fontification in mind, i.e.  there should be a support mode that waits
with the fontification until the text is actually shown
(e.g. Just-in-time Lock mode, which is the default in Emacs 21, or
Lazy Lock mode).  Fontifying a file with several thousand lines in one
go can take the better part of a minute.

*** The (c|c++|objc|java|idl|pike)-font-lock-extra-types variables
are now used by CC Mode to recognize identifiers that are certain to
be types.  (They are also used in cases that aren't related to font
locking.)  At the maximum decoration level, types are often recognized
properly anyway, so these variables should be fairly restrictive and
not contain patterns for uncertain types.

*** Support for documentation comments.
There is a "plugin" system to fontify documentation comments like
Javadoc and the markup within them.  It's independent of the host
language, so it's possible to e.g. turn on Javadoc font locking in C
buffers.  See the variable c-doc-comment-style for details.

Currently two kinds of doc comment styles are recognized: Suns Javadoc
and Autodoc which is used in Pike.  This is by no means a complete
list of the most common tools; if your doc comment extractor of choice
is missing then please drop a note to bug-cc-mode@gnu.org.

*** Better handling of C++ templates.
As a side effect of the more accurate font locking, C++ templates are
now handled much better.  The angle brackets that delimit them are
given parenthesis syntax so that they can be navigated like other
parens.

This also improves indentation of templates, although there still is
work to be done in that area.  E.g. it's required that multiline
template clauses are written in full and then refontified to be
recognized, and the indentation of nested templates is a bit odd and
not as configurable as it ought to be.

*** Improved handling of Objective-C and CORBA IDL.
Especially the support for Objective-C and IDL has gotten an overhaul.
The special "@" declarations in Objective-C are handled correctly.
All the keywords used in CORBA IDL, PSDL, and CIDL are recognized and
handled correctly, also wrt indentation.

** Support for the AWK language.
Support for the AWK language has been introduced.  The implementation is
based around GNU AWK version 3.1, but it should work pretty well with
any AWK.  As yet, not all features of CC Mode have been adapted for AWK.
Here is a summary:

*** Indentation Engine
The CC Mode indentation engine fully supports AWK mode.

AWK mode handles code formatted in the conventional AWK fashion: `{'s
which start actions, user-defined functions, or compound statements are
placed on the same line as the associated construct; the matching `}'s
are normally placed under the start of the respective pattern, function
definition, or structured statement.

The predefined indentation functions haven't yet been adapted for AWK
mode, though some of them may work serendipitously.  There shouldn't be
any problems writing custom indentation functions for AWK mode.

The command C-c C-q (c-indent-defun) hasn't yet been adapted for AWK,
though in practice it works properly nearly all the time.  Should it
fail, explicitly set the region around the function (using C-u C-SPC:
C-M-h probably won't work either) then do C-M-\ (indent-region).

*** Font Locking
There is a single level of font locking in AWK mode, rather than the
three distinct levels the other modes have.  There are several
idiosyncrasies in AWK mode's font-locking due to the peculiarities of
the AWK language itself.

*** Comment Commands
M-; (indent-for-comment) works fine.  None of the other CC Mode
comment formatting commands have yet been adapted for AWK mode.

*** Movement Commands
Most of the movement commands work in AWK mode.  The most important
exceptions are M-a (c-beginning-of-statement) and M-e
(c-end-of-statement) which haven't yet been adapted.

The notion of "defun" has been augmented to include AWK pattern-action
pairs.  C-M-a (c-awk-beginning-of-defun) and C-M-e (c-awk-end-of-defun)
recognise these pattern-action pairs, as well as user defined
functions.

*** Auto-newline Insertion and Clean-ups
Auto-newline insertion hasn't yet been adapted for AWK.  Some of
the clean-ups can actually convert good AWK code into syntactically
invalid code.  These features are best disabled in AWK buffers.

** New syntactic symbols in IDL mode.
The top level constructs "module" and "composition" (from CIDL) are
now handled like "namespace" in C++: They are given syntactic symbols
module-open, module-close, inmodule, composition-open,
composition-close, and incomposition.

** New lineup function c-lineup-string-cont.
This lineup function lines up a continued string under the one it
continues.  E.g:

result = prefix + "A message "
                  "string.";      <- c-lineup-string-cont

** New functions to do hungry delete without enabling hungry delete mode.
The functions c-hungry-backspace and c-hungry-delete-forward can be
bound to keys to get this feature without toggling a mode.
Contributed by Kevin Ryde.

** Better control over require-final-newline.
The variable that controls how to handle a final newline when the
buffer is saved, require-final-newline, is now customizable on a
per-mode basis through c-require-final-newline.  The default is to set
it to t only in languages that mandate a final newline in source files
(C, C++ and Objective-C).

** Format change for syntactic context elements.
The elements in the syntactic context returned by c-guess-basic-syntax
and stored in c-syntactic-context has been changed somewhat to allow
attaching more information.  They are now lists instead of single cons
cells.  E.g. a line that previously had the syntactic analysis

((inclass . 11) (topmost-intro . 13))

is now analysed as

((inclass 11) (topmost-intro 13))

In some cases there are more than one position given for a syntactic
symbol.

This change might affect code that call c-guess-basic-syntax directly,
and custom lineup functions if they use c-syntactic-context.  However,
the argument given to lineup functions is still a single cons cell
with nil or an integer in the cdr.

** API changes for derived modes.
There have been extensive changes "under the hood" which can affect
derived mode writers.  Some of these changes are likely to cause
incompatibilities with existing derived modes, but on the other hand
care has now been taken to make it possible to extend and modify CC
Mode with less risk of such problems in the future.

*** New language variable system.
See the comment blurb near the top of cc-langs.el.

*** New initialization functions.
The initialization procedure has been split up into more functions to
give better control: c-basic-common-init, c-font-lock-init, and
c-init-language-vars.

** Compiled byte code is now (X)Emacs version specific.
Previously byte compiled versions of CC Mode could be shared between
major (X)Emacs versions to some extent.  That is no longer the case
since macros are now used extensively to adapt to (X)Emacs specific
features without sacrificing performance.

* Changes in 5.29

Note: This was an unfinished interim release that was never publicly
announced.

** Changes in analysis of nested syntactic constructs.
The syntactic analysis engine has better handling of cases where
several syntactic constructs appear nested on the same line.  They are
now handled as if each construct started on a line of its own.

This means that CC Mode now indents some cases differently, and
although it's more consistent there might be cases where the old way
gave results that's more to one's liking.  So if you find a situation
where you think that the indentation has become worse, please report
it to bug-cc-mode@gnu.org.

*** New syntactic symbol substatement-label.
This symbol is used when a label is inserted between a statement and
its substatement.  E.g:

    if (x)
      x_is_true:
        do_stuff();

** Better handling of multiline macros.

*** Syntactic indentation inside macros.
The contents of multiline #define's are now analyzed and indented
syntactically just like other code.  This can be disabled by the new
variable c-syntactic-indentation-in-macros.  A new syntactic symbol
cpp-define-intro has been added to control the initial indentation
inside #define's.

*** New lineup function c-lineup-cpp-define.
Now used by default to line up macro continuation lines.  The behavior
of this function closely mimics the indentation one gets if the macro
is indented while the line continuation backslashes are temporarily
removed.  If syntactic indentation in macros is turned off, it works
much line c-lineup-dont-change, which was used earlier, but handles
empty lines within the macro better.

*** Automatically inserted newlines continues the macro if used within one.
This applies to the newlines inserted by the auto-newline mode, and to
c-context-line-break and c-context-open-line.

*** Better alignment of line continuation backslashes.
c-backslash-region tries to adapt to surrounding backslashes.  New
variable c-backslash-max-column which put a limit on how far out
backslashes can be moved.

*** Automatic alignment of line continuation backslashes.
This is controlled by the new variable c-auto-align-backslashes.  It
affects c-context-line-break, c-context-open-line and newlines
inserted in auto-newline mode.

*** Line indentation works better inside macros.
Regardless whether syntactic indentation and syntactic indentation
inside macros are enabled or not, line indentation now ignores the
line continuation backslashes.  This is most noticeable when syntactic
indentation is turned off and there are empty lines (save for the
backslash) in the macro.

** indent-for-comment is more customizable.
The behavior of M-; (indent-for-comment) is now configurable through
the variable c-indent-comment-alist.  The indentation behavior is
based on the preceding code on the line, e.g. to get two spaces after
#else and #endif but indentation to comment-column in most other cases
(something which was hardcoded earlier).

** New function c-context-open-line.
It's the open-line equivalent of c-context-line-break.

** New lineup functions

*** c-lineup-cascaded-calls
Lines up series of calls separated by "->" or ".".

*** c-lineup-knr-region-comment
Gives (what most people think is) better indentation of comments in
the "K&R region" between the function header and its body.

*** c-lineup-gcc-asm-reg
Provides better indentation inside asm blocks.  Contributed by Kevin
Ryde.

*** c-lineup-argcont
Lines up continued function arguments after the preceding comma.
Contributed by Kevin Ryde.

** Better caching of the syntactic context.
CC Mode caches the positions of the opening parentheses (of any kind)
of the lists surrounding the point.  Those positions are used in many
places as anchor points for various searches.  The cache is now
improved so that it can be reused to a large extent when the point is
moved.  The less it moves, the less needs to be recalculated.

The effect is that CC Mode should be fast most of the time even when
opening parens are hung (i.e. aren't in column zero).  It's typically
only the first time after the point is moved far down in a complex
file that it'll take noticeable time to find out the syntactic
context.

** Statements are recognized in a more robust way.
Statements are recognized most of the time even when they occur in an
"invalid" context, e.g. in a function argument.  In practice that can
happen when macros are involved.

** Improved the way c-indent-exp chooses the block to indent.
It now indents the block for the closest sexp following the point
whose closing paren ends on a different line.  This means that the
point doesn't have to be immediately before the block to indent.
Also, only the block and the closing line is indented; the current
line is left untouched.

** Added toggle for syntactic indentation.
The function c-toggle-syntactic-indentation can be used to toggle
syntactic indentation.

* Changes in 5.28

** The hardcoded switch to "java" style in Java mode is gone.
CC Mode used to automatically set the style to "java" when Java mode
is entered.  This has now been removed since it caused too much
confusion.

However, to keep backward compatibility to a certain extent, the
default value for c-default-style now specifies the "java" style for
java-mode, but "gnu" for all other modes (as before).  So you won't
notice the change if you haven't touched that variable.

** New cleanups, space-before-funcall and compact-empty-funcall.
Two new cleanups have been added to c-cleanup-list:

space-before-funcall causes a space to be inserted before the opening
parenthesis of a function call, which gives the style "foo (bar)".

compact-empty-funcall causes any space before a function call opening
parenthesis to be removed if there are no arguments to the function.
It's typically useful together with space-before-funcall to get the
style "foo (bar)" and "foo()".

** Some keywords now automatically trigger reindentation.
Keywords like "else", "while", "catch" and "finally" have been made
"electric" to make them reindent automatically when they continue an
earlier statement.  An example:

for (i = 0; i < 17; i++)
  if (a[i])
    res += a[i]->offset;
else

Here, the "else" should be indented like the preceding "if", since it
continues that statement. CC Mode will automatically reindent it after
the "else" has been typed in full, since it's not until then it's
possible to decide whether it's a new statement or a continuation of
the preceding "if".

CC Mode uses Abbrev mode to achieve this, which is therefore turned on
by default.

** M-a and M-e now moves by sentence in multiline strings.
Previously these two keys only moved by sentence in comments, which
meant that sentence movement didn't work in strings containing
documentation or other natural language text.

The reason it's only activated in multiline strings (i.e. strings that
contain a newline, even when escaped by a '\') is to avoid stopping in
the short strings that often reside inside statements.  Multiline
strings almost always contain text in a natural language, as opposed
to other strings that typically contain format specifications,
commands, etc.  Also, it's not that bothersome that M-a and M-e misses
sentences in single line strings, since they're short anyway.

** Support for autodoc comments in Pike mode.
Autodoc comments for Pike are used to extract documentation from the
source, like Javadoc in Java.  Pike mode now recognize this markup in
comment prefixes and paragraph starts.

** The comment prefix regexps on c-comment-prefix may be mode specific.
When c-comment-prefix is an association list, it specifies the comment
line prefix on a per-mode basis, like c-default-style does.  This
change came about to support the special autodoc comment prefix in
Pike mode only.

** Better handling of syntactic errors.
The recovery after unbalanced parens earlier in the buffer has been
improved; CC Mode now reports them by dinging and giving a message
stating the offending line, but still recovers and indent the
following lines in a sane way (most of the time).  An "else" with no
matching "if" is handled similarly.  If an error is discovered while
indenting a region, the whole region is still indented and the error
is reported afterwards.

** Lineup functions may now return absolute columns.
A lineup function can give an absolute column to indent the line to by
returning a vector with the desired column as the first element.

** More robust and warning-free byte compilation.
Although this is strictly not a user visible change (well, depending
on the view of a user), it's still worth mentioning that CC Mode now
can be compiled in the standard ways without causing trouble.  Some
code have also been moved between the subpackages to enhance the
modularity somewhat.  Thanks to Martin Buchholz for doing the
groundwork.

* Changes in 5.27

Note: This is mostly a bugfix release.  The features labeled
experimental in 5.26 remain and are now considered permanent.

** c-style-variables-are-local-p now defaults to t.
This is an incompatible change that has been made to make the behavior
of the style system wrt global variable settings less confusing for
non-advanced users.  If you know what this variable does you might
want to set it to nil in your .emacs, otherwise you probably don't
have to bother.

Defaulting c-style-variables-are-local-p to t avoids the confusing
situation that occurs when a user sets some style variables globally
and edit both a Java and a non-Java file in the same Emacs session.
If the style variables aren't buffer local in this case, loading of
the second file will cause the default style (either "gnu" or "java"
by default) to override the global settings made by the user.

* Changes in 5.26

Note: This release contains changes that might not be compatible with
current user setups (although it's believed that these
incompatibilities will only show up in very uncommon circumstances).
However, since the impact is uncertain, these changes may be rolled
back depending on user feedback.  Therefore there's no forward
compatibility guarantee wrt the new features introduced in this
release.

** New initialization procedure for the style system.
When the initial style for a buffer is determined by CC Mode (from the
variable c-default-style), the global values of style variables now
take precedence over the values specified by the chosen style.  This
is different from the old behavior: previously, the style-specific
settings would override the global settings.  This change makes it
possible to do simple configuration in the intuitive way with
Customize or with setq lines in one's .emacs file.

By default, the global value of every style variable is the new
special symbol set-from-style, which causes the value to be taken from
the style system.  This means that in effect, only an explicit setting
of a style variable will cause the "overriding" behavior described
above.

Also note that global settings override style-specific settings *only*
when the initial style of a buffer is chosen by a CC Mode major mode
function.  When a style is chosen in other ways --- for example, by a
call like (c-set-style "gnu") in a hook, or via M-x c-set-style ---
then the style-specific values take precedence over any global style
values.  In Lisp terms, global values override style-specific values
only when the new second argument to c-set-style is non-nil; see the
function documentation for more info.

The purpose of these changes is to make it easier for users,
especially novice users, to do simple customizations with Customize or
with setq in their .emacs files.  On the other hand, the new system is
intended to be compatible with advanced users' customizations as well,
such as those that choose styles in hooks or whatnot.  This new system
is believed to be almost entirely compatible with current
configurations, in spite of the changed precedence between style and
global variable settings when a buffer's default style is set.

(Thanks to Eric Eide for clarifying this explanation a bit.)

*** c-offsets-alist is now a customizable variable.
This became possible as a result of the new initialization behavior.

This variable is treated slightly differently from the other style
variables; instead of using the symbol set-from-style, it will be
completed with the syntactic symbols it doesn't already contain when
the style is first initialized.  This means it now defaults to the
empty list to make all syntactic elements get their values from the
style system.

*** Compatibility variable to restore the old behavior.
In case your configuration doesn't work with this change, you can set
c-old-style-variable-behavior to non-nil to get the old behavior back
as far as possible.

** Improvements to line breaking and text filling.
CC Mode now handles this more intelligently and seamlessly wrt the
surrounding code, especially inside comments.  For details see the new
chapter about this in the manual.

*** New variable to recognize comment line prefix decorations.
The variable c-comment-prefix-regexp has been added to properly
recognize the line prefix in both block and line comments.  It's
primarily used to initialize the various paragraph recognition and
adaptive filling variables that the text handling functions uses.

*** New variable c-block-comment-prefix.
This is a generalization of the now obsolete variable
c-comment-continuation-stars to handle arbitrary strings.

*** CC Mode now uses adaptive fill mode.
This to make it adapt better to the paragraph style inside comments.

It's also possible to use other adaptive filling packages inside CC
Mode, notably Kyle E. Jones' Filladapt mode (http://wonderworks.com/).
A new convenience function c-setup-filladapt sets up Filladapt for use
inside CC Mode.

Note though that the 2.12 version of Filladapt lacks a feature that
causes it to work suboptimally when c-comment-prefix-regexp can match
the empty string (which it commonly does).  A patch for that is
available from the CC Mode web site (http://www.python.org/emacs/
cc-mode/).

*** It's now possible to selectively turn off auto filling.
The variable c-ignore-auto-fill is used to ignore auto fill mode in
specific contexts, e.g. in preprocessor directives and in string
literals.

*** New context sensitive line break function c-context-line-break.
It works like newline-and-indent in normal code, and adapts the line
prefix according to the comment style when used inside comments.  If
you're normally using newline-and-indent, you might want to switch to
this function.

*** c-hanging-comment-starter-p and c-hanging-comment-ender-p are obsolete.
The new comment handling code no longer consults these two variables.
It instead detects how the "hangingness" of the comment delimiters
look like currently and simply keeps them that way.

** Fixes to IDL mode.
It now does a better job in recognizing only the constructs relevant
to IDL.  E.g. it no longer matches "class" as the beginning of a
struct block, but it does match the CORBA 2.3 "valuetype" keyword.
Thanks to Eric Eide.

** Improvements to the Whitesmith style.
It now keeps the style consistently on all levels and both when
opening braces hangs and when they don't.

*** New lineup function c-lineup-whitesmith-in-block.

** New lineup functions c-lineup-template-args and c-indent-multi-line-block.
See their docstrings for details.  c-lineup-template-args does a
better job of tracking the brackets used as parens in C++ templates,
and is used by default to line up continued template arguments.

** c-lineup-comment now preserves alignment with a comment on the
previous line.  It used to instead preserve comments that started in
the column specified by comment-column.

** c-lineup-C-comments handles "free form" text comments.
In comments with a long delimiter line at the start, the indentation
is kept unchanged for lines that start with an empty comment line
prefix.  This is intended for the type of large block comments that
contain documentation with its own formatting.  In these you normally
don't want CC Mode to change the indentation.

** The `c' syntactic symbol is now relative to the comment start
instead of the previous line, to make integers usable as lineup
arguments.

** All lineup functions have gotten docstrings.

** More preprocessor directive movement functions.
c-down-conditional does the reverse of c-up-conditional.
c-up-conditional-with-else and c-down-conditional-with-else are
variants of these that also stops at "#else" lines (suggested by Don
Provan).

** Minor improvements to many movement functions in tricky situations.

* Changes in 5.25

This is a bug fix release only.

* Changes in 5.24

Note: See also changes in 5.23 to get the complete list of additions
since the last public release.

** c-default-style can now take an association list that maps major
modes to style names.  When this variable is an alist, Java mode no
longer hardcodes a setting to "java" style.  See the variable's
docstring for details.

** It's now possible to put a list as the offset on a syntactic
symbol.  The list is evaluated recursively until a non-nil offset is
found.  This is useful to combine several lineup functions to act in a
prioritized order on a single line.  However, none of the supplied
lineup functions use this feature currently.

** New syntactic symbol catch-clause, which is used on the "catch" and
"finally" lines in try-catch constructs in C++ and Java.

** New cleanup brace-catch-brace on c-cleanup-list, which does for
"catch" lines what brace-elseif-brace does for "else if" lines.

** The braces of Java anonymous inner classes are treated separately
from the braces of other classes in auto-newline mode.  Two new
symbols inexpr-class-open and inexpr-class-close may be used on
c-hanging-braces-alist to control the automatic newlines used for
anonymous classes.

** bug-cc-mode@gnu.org is now the primary bug reporting address.
This is an alias for cc-mode-help@python.org.

* Changes in 5.23

Note: Due to the extensive changes, this version was a beta test
release that was never publicly announced.

** Support for the Pike language added, along with new Pike specific
syntactic symbols: inlambda, lambda-intro-cont

** Support for Java anonymous classes via new syntactic symbol
inexpr-class.  New syntactic symbol inexpr-statement for Pike
support and gcc-style statements inside expressions.  New lineup
function c-lineup-inexpr-stat.

** New syntactic symbol brace-entry-open which is used in brace lists
(i.e. static initializers) when a list entry starts with an open
brace.  These used to be recognized as brace-list-entry's.
c-electric-brace also recognizes brace-entry-open braces
(brace-list-entry's can no longer be electrified).

** New command c-indent-line-or-region, not bound by default.

** Improvements to M-C-h (c-mark-function).

** `#' is only electric when typed in the indentation of a line.

** Parentheses are now electric (via the new command c-electric-paren)
for auto-reindenting lines when parens are typed.

** In "gnu" style, inline-open offset is now set to zero.

** Uniform handling of the inclass syntactic symbol.  The indentation
associated with it is now always relative to the class opening brace.
This means that the indentation behavior has changed in some
circumstances, but only if you've put anything besides 0 on the
class-open syntactic symbol (none of the default styles do that).

** c-enable-xemacs-performance-kludge-p is set to nil by default,
since for Emacs-friendly styles (i.e. where the top-level opening
brace starts in column zero) setting this variable to t can degrade
performance significantly.

* Changes in 5.22

Note: There was no net release of 5.22!  This version went only to the
XEmacs developers and was primarily a bug fix release.

* Changes in 5.21

This is a bug fix release only.

* Changes in 5.20

** Multiline macros are now handled, both as they affect indentation,
and as recognized syntax.  New syntactic symbol cpp-macro-cont is
assigned to second and subsequent lines of a multiline macro
definition.

** A new style "user" which captures all non-hook-ified
(i.e. top-level) .emacs file variable settings and customizations.
Style "cc-mode" is an alias for "user" and is deprecated.  "gnu" style
is still the default however.

** "java" style now conforms to Sun's JDK coding style.

** New commands c-beginning-of-defun, c-end-of-defun which are not
bound by default to C-M-a and C-M-e.

** New and improved implementations of M-a (c-beginning-of-statement)
and M-e (c-end-of-statement).

** C++ namespace blocks are supported, with new syntactic symbols
namespace-open, namespace-close, and innamespace.

** File local variable settings of c-file-style and c-file-offsets
makes the style variables local to that buffer only.

** New indentation functions c-lineup-close-paren,
c-indent-one-line-block, c-lineup-dont-change.

** Various Imenu patches (thanks to Masatake Yamato, Jan Dubois, and
Peter Pilgrim).

** Performance improvements.  Some improvements affect only Emacs or
only XEmacs (see the variable c-enable-xemacs-performance-kludge-p).

** Improvements (hopefully!) to the way CC Mode is loaded.  You should
now be able to do a (require 'cc-mode) to get the entire package
loaded properly for customization in your .emacs file.  A new variable
c-initialize-on-load controls this and is set to t by default.

* Changes in 5.19

** extern-lang-close relative buffer positions have changed.  The used
to point to the extern's open brace, but they now point to the first
non-whitespace character on the line with the open brace.

** c-progress-interval's semantics have changed slightly.  When set to
nil, indentation proceeds silently.  Previously, even when nil, the
start and end messages were printed.

* Changes in 5.18

** M-a and M-e should now properly move into comments when point is
before or after a comment, and move by sentences when inside a
comment.

** c-electric-slash should be bound in all modes now.  Also,
c-expand-macro is not bound in Java or IDL modes.

** Imenu enhancements: Objective-C support donated by Masatake (jet)
YAMATO; a fix to Java support given by Ake Stenhoff; and improvements
to C++ support given by Jan Dubois.

* Changes in 5.17

** Recognition of enum declarations in K&R argdecls.

** Changes to "python" style to more closely match Python C API coding
standards.

** / is bound to c-electric-slash in all modes, and C-c C-e is bound
to c-expand-macro in all languages except Java and IDL.

* Changes in 5.16

This is primarily a bug fix release.  Users of XEmacs 19.15 and Emacs
19.34 are highly encouraged to pick up this release.

* Changes in 5.15

** A new syntactic symbol: template-args-cont, used in C++ template
declarations where the argument list spans multiple lines.

** In "java" style, c-hanging-comment-starter-p defaults to nil to
preserve Javadoc starter lines.

** Line oriented comments (i.e. C++ style comments) are now recognized
by default in all modes, including C mode (as per the ANSI 9X C draft
standard).  Thus the function c-enable-//-in-c-mode has been removed.

** Auto-filling of comments has been improved.  CC Mode will now
properly auto-fill both line and block oriented comments, and allows
you to choose the leader string on block oriented continued comments,
via the variable c-comment-continuation-stars.  See the CC Mode manual
for details.

** c-electric-slash is electric in all modes.

** The need for c-mode-19.el is automatically detected now.  You do
not need to load or require it in your .emacs file.

* Changes in 5.14

** Support for CORBA's IDL language.  There is now a new mode called
idl-mode, with all the expected hooks, abbreviation tables, etc.

** In "java" style, c-hanging-comment-starter-p is set to nil by
default to preserve Javadoc comments.

** A new hook variable: c-initialization-hook. This is called only
once an X/Emacs session, when the CC Mode package is initialized.

* Changes in version 5

CC Mode version 5 was a major upgrade, as evidenced by the change in
major revision number.  Here is a list of the important user visible
changes in CC Mode 5.

** CC Mode 5 will not work with Emacs 18, and will only work with the
latest Emacs and XEmacs releases.

** c-mode-map is no longer the base keymap for all modes.  This was
incompatible with the way Emacs 19 supports menus, so now
c-mode-base-map is the base map for all modes (including c-mode-map).
If you are installing custom keybindings into c-mode-map and expecting
them to be present in all other modes, this will break.  Put your
keybindings in c-mode-base-map instead.

** The function c-electric-delete and variable c-delete-function are
handled differently now, in order to accommodate the separation of the
BackSpace and Delete keysyms.  CC Mode now binds only the Delete
keysym to c-electric-delete (which runs c-delete-function), and the
BackSpace keysym to c-electric-backspace (which runs
c-backspace-function).  See the CC Mode manual for details.

** The single cc-mode.el file was simply too unwieldy so I have split
the file up.  See the MANIFEST file for details.

** Also, all user variables have been converted to Per Abrahamsen's
Custom library, and all support for older Emacsen have been ripped
out.  See the release notes for details of running CC Mode 5 in your
version of Emacs.

** All style variables are now global by default.  Specifically, the
default value for c-style-variables-are-local-p is nil.  The same
rules apply as before, only reversed: if you want the style variables
to be buffer local, you should set c-style-variables-are-local-p to t
before you load CC Mode.

* Changes from 4.322 to 4.353

** Better control over the buffer localness of the indentation variables.

In previous version of cc-mode the variables that control indentation
were always buffer local.  This was applauded by those who edited
files in many different styles, but reviled by those who usually edit
files of only one style.

You can now control whether these variables are buffer local or not,
by setting the variable c-style-variables-are-local-p.  This variable
only has effect at the time cc-mode.el is loaded.  If this variable is
non-nil, then all indentation style related variables will be made
buffer local.  Otherwise, they will remain global, so that users can
actually use setq in their top-level .emacs file without having to use
a mode hook.

Note that once the variables are made buffer local, they cannot be
made global again; they will remain buffer local for the rest of the
current Emacs session.  The list of variables that are buffer
localizable are:

  c-offsets-alist
  c-basic-offset
  c-file-style
  c-file-offsets
  c-comment-only-line-offset
  c-cleanup-list
  c-hanging-braces-alist
  c-hanging-colons-alist
  c-hanging-comment-ender-p
  c-backslash-column
  c-label-minimum-indentation
  c-special-indent-hook
  c-indentation-style

For backwards compatibility, the default value of
c-style-variables-are-local-p is non-nil, meaning the variables are
buffer local by default.  This may change in the future.

** New variable c-indentation-style which holds the current style name
of the buffer.

** Menus are not installed when running in Infodock.

** Improvements to the alignment of C block comments.
The variable c-block-comments-indent-p has been removed.

I have improved the c-lineup-C-comments function, which is responsible
for lining up subsequent lines in C block comments.  It should now do
the Right Thing for most comment styles that use some combination of
stars at the beginning of comment lines (including zero stars! :-).
For example, the following styles are aligned correctly by default:

int main()
{
    /*
     *
     */

    /*
    **
    **
    */

    /**
     **
     **
     **/

    /***
     ***
     ***
     ***
     ***/

    /**
    ***
    ***
    **/
}

For this reason, the variable c-block-comments-indent-p has been
removed.

** New indentation style python.
The blessed standard for writing Python extension modules in C.

** New c-cleanup-list option: brace-elseif-brace

* Changes from 4.282 to 4.322

** A new style linux has been added.

**The following variables have been removed from the default cc-mode
style:
   c-echo-syntactic-information-p
   c-strict-syntax-p
   c-tab-always-indent
   c-inhibit-startup-warnings-p

** External language declaration blocks are now handled properly.
Three new syntactic symbols have been added:

*** extern-lang-open
The brace that opens an extern block.  Hangable via
c-hanging-braces-alist.

*** extern-lang-close
The brace that closes an extern block.  Hangable via
c-hanging-braces-alist.

*** inextern-lang
A modifier (with no relative buffer position) which is added to
topmost-intro syntax lines that occur within an extern block.  See the
texinfo manual for details.

** New variable: c-label-minimum-indentation which defines the minimum
indentation a label can have in gnu style.  This variable has no
effect in other styles.

** c-special-indent-hook is handled slightly differently when it
appears in a style definition; the functions in the style definition
are appended to the global value of c-special-indent-hook.

** c-style-alist is defconst'd now.
This should eliminate problems people had with Java mode.

** Lambda expressions (anonymous functions) can now be used as custom
indentation functions.

** Whitespace is allowed between the protection keyword (public,
private, protected) and the trailing colon in C++.

** Java mode now recognizes the finally and synchronized keywords.

** New lineup function: c-lineup-arglist-close-under-paren.
Try setting arglist-close to this function.

** The variable c-recognize-knr-p is deprecated.
Now by default, c-mode will always recognize K&R argument declarations
with no performance penalty.  cc-mode has adopted BOCM's approach
which assumes that argdecls will always be indented at least one
space, while the function headers they are associated with will not be
indented at all.  If your programming style differs from this, you may
have trouble.  You should remove any setting of this variable from
your cc-mode configurations!

** New variable c-insert-tab-function, normally just inserts a tab
character when indicated by c-tab-always-indent and indent-tabs-mode.
You could set this to run tab-to-tab-stop instead.

** C-s C-s (c-show-syntactic-information) now takes an optional
universal argument, which inserts the analysis into the buffer on the
current line, as a comment.

** c-mark-function has been moved to C-c C-m.

** In addition, I have made a change to the way braces which are given
inline-open syntax are handled.

In the following sample:

  1: class Outer
  2: {
  3:     void a_function( int a )
  4:     {
  5:         do_something( a );
  6:     }
  7:     class Inner
  8:     {
  9:         void b_function( int b )
 10:         {
 11:             do_something( b );
 12:         }
 13:     }
 14: }

cc-mode 4.282 would have analyzed line 4 as ((inline-open . 1)), and
line 10 as ((inline-open . 87)).  So the fact that this brace opened
an inclass-inline method which should be given extra indentation, was
implicit in the syntactic symbol.

Some people have argued that the inclass modifier should be added to
the analysis of such lines.  This release implements this change so
that line 4 is now analyzed as ((inclass . 1) (inline-open)) and line
10 as ((inclass . 87) (inline-open)).  The inline-open symbol has no
relative buffer position so that braces in nested classes would not be
indented too much.
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.