;ELC ;;; Compiled by pot@pot.cnuce.cnr.it on Tue Mar 18 15:50:06 2003 ;;; from file /home/pot/gnu/emacs-pretest.new/lisp/progmodes/cc-align.el ;;; in Emacs version 21.3 ;;; with bytecomp version 2.85.4.1 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. (if (and (boundp 'emacs-version) (< (aref emacs-version (1- (length emacs-version))) ?A) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.29"))) (error "`cc-align.el' was compiled for Emacs 19.29 or later")) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\207" [require cc-defs cc-vars cc-langs cc-engine] 2) #@97 Line up the current argument line under the first argument. Works with: arglist-cont-nonempty. (defalias 'c-lineup-arglist #[(langelem) "\212\212@\306>\203\307 \210\310\311!\210\312\212\313\210`)w\210\202 Ab\210`)\314\211A\203>`Ab\210i\n\203: b\210)\202?\315*\212\307 \210\316\317!)\203f\315\225b\210\320`\321\"\206Xeb\210\311u\210\322 \210i\fZ\202\224 b\210l\204\221\313f\323>\203\221\212\313\210`)\311u\210\312\313w\210`\322 \210` W\203\220 b\210*i\fZ+\207" [langelem containing-sexp preserve-point here langelem-col eol (arglist-intro arglist-cont-nonempty) beginning-of-line backward-up-list 1 " " nil t 0 looking-at "[ ]*)" scan-sexps -1 c-forward-syntactic-ws (123 40 91)] 4 (#$ . 742)]) #@193 Line up a line just after the open paren of the surrounding paren or brace block. Works with: defun-block-intro, brace-list-intro, statement-block-intro, statement-case-intro, arglist-intro. (defalias 'c-lineup-arglist-intro-after-paren #[(langelem) "\212\305\211A\203`Ab\210i \203\nb\210)\202\306*\212\307 \210\310\311!\210\312\212\313\210`)w\210i) \fZ\314Z+\207" [langelem preserve-point here ce-curcol langelem-col t 0 beginning-of-line backward-up-list 1 " " nil -1] 4 (#$ . 1471)]) #@282 Line up a closing paren line under the corresponding open paren. Works with: defun-close, class-close, inline-close, block-close, brace-list-close, arglist-close, extern-lang-close, namespace-close (for most of these, a zero offset will normally produce the same result, though). (defalias 'c-lineup-arglist-close-under-paren #[(langelem) "\212\305\211A\203`Ab\210i \203\nb\210)\202\306*\212\307 \210\310\311!\210i) \fZ+\207" [langelem preserve-point here ce-curcol langelem-col t 0 beginning-of-line backward-up-list 1] 4 (#$ . 1981)]) #@440 Line up the closing paren under its corresponding open paren if the open paren is followed by code. If the open paren ends its line, no indentation is added. E.g: main (int, main ( char ** int, char ** ) <-> ) <- c-lineup-close-paren Works with: defun-close, class-close, inline-close, block-close, brace-list-close, arglist-close, extern-lang-close, namespace-close. (defalias 'c-lineup-close-paren #[(langelem) "\212\300\301\302\217)\207" [nil (byte-code "\305\211\306 \210\307\310!\210\311 \211\203@@b\210i\310u\210\203&\312 \210\310u\210\312\212\305\210`)!\210l\2037\313\202V \n\314\211A\203S`\nAb\210i \203O\fb\210)\202T\313*Z*\207" [spec opencol langelem preserve-point here nil beginning-of-line backward-up-list 1 c-looking-at-special-brace-list c-forward-syntactic-ws 0 t] 4) ((error))] 3 (#$ . 2539)]) #@72 Line up C++ stream operators under each other. Works with: stream-op. (defalias 'c-lineup-streamop #[(langelem) "\212\304\211A\203`Ab\210i \203\nb\210)\202\305*\306\307\212\304\210`)\310#\210\305\224b\210i Z*\207" [langelem preserve-point here langelem-col nil 0 re-search-forward "<<\\|>>" move] 5 (#$ . 3446)]) #@656 Line up the classes in C++ multiple inheritance clauses and member initializers under each other. E.g: class Foo: Foo::Foo (int a, int b): public Cyphr, Cyphr (a), public Bar <-> Bar (b) <- c-lineup-multi-inher class Foo Foo::Foo (int a, int b) : public Cyphr, : Cyphr (a), public Bar <-> Bar (b) <- c-lineup-multi-inher class Foo Foo::Foo (int a, int b) : public Cyphr : Cyphr (a) , public Bar <-> , Bar (b) <- c-lineup-multi-inher Works with: inher-cont, member-init-cont. (defalias 'c-lineup-multi-inher #[(langelem) "\212\212\306\210`)`\307\306w\210\306f \306\211A\203,` Ab\210i\f\203( b\210)\202-\310*\311 \210`Sf\312=\203@\313u\210\311 \210\314w\210\n\315=\203Q\307w\210\202U\316w\210l\204`\317!\203d\320 !\210i Z-\207" [eol here char-after-ip langelem preserve-point langelem-col nil " " 0 c-backward-syntactic-ws 58 -1 "^:" 44 " :" looking-at c-forward-syntactic-ws c-comment-start-regexp] 3 (#$ . 3780)]) #@442 Line up Java implements and extends declarations. If class names follows on the same line as the implements/extends keyword, they are lined up under each other. Otherwise, they are indented by adding `c-basic-offset' to the column of the keyword. E.g: class Foo class Foo extends extends Cyphr, Bar <-> Bar <- c-lineup-java-inher <--> c-basic-offset Works with: inher-cont. (defalias 'c-lineup-java-inher #[(langelem) "\212\305\211A\203`Ab\210i \203\nb\210)\202\306*\307v\210\310\311!\203,\f\2022\312 \210i Z*\207" [langelem preserve-point here langelem-col c-basic-offset nil 0 1 looking-at "[ ]*$" c-forward-syntactic-ws] 3 (#$ . 4904)]) #@594 Line up Java throws declarations. If exception names follows on the same line as the throws keyword, they are lined up under each other. Otherwise, they are indented by adding `c-basic-offset' to the column of the throws keyword. The throws keyword itself is also indented by `c-basic-offset' from the function declaration start if it doesn't hang. E.g: int foo() int foo() throws Cyphr, throws <-> Bar, <- c-lineup-java-throws Bar <-> Vlod <- c-lineup-java-throws <--><--> c-basic-offset Works with: func-decl-cont. (defalias 'c-lineup-java-throws #[(langelem) "\212\212\306 \210`)S\307\310\215\211\203i\311\312\313\314\212\314\210`)#!\203Bi\n\314\211A\203<`\nAb\210i \2038\fb\210)\202=\315*Z\202j\316 \210i\n\314\211A\203a`\nAb\210i \203]\fb\210)\202b\315*Z \\\202j +\207" [lim throws langelem preserve-point here c-basic-offset beginning-of-line done (byte-code "Ab\210\302\303\304\305 #!\205\306\307!\203\310\311\305\"\210\202\207" [langelem lim zerop c-forward-token-1 1 t looking-at "throws\\>[^_]" throw done] 5) zerop c-forward-token-1 1 nil 0 back-to-indentation] 6 (#$ . 5633)]) #@476 Indent a one line block `c-basic-offset' extra. E.g: if (n > 0) if (n > 0) {m+=n; n=0;} <-> { <- c-indent-one-line-block <--> c-basic-offset m+=n; n=0; } The block may use any kind of parenthesis character. nil is returned if the line doesn't start with a one line block, which makes the function usable in list expressions. Work with: Almost all syntactic symbols, but most useful on *-open. (defalias 'c-indent-one-line-block #[(langelem) "\212\212\302\210`)\303 \210\302fz\304=\205!\302\305\306\217\205!`X\205! *\207" [eol c-basic-offset nil back-to-indentation 40 (byte-code "\300`\301\"\206db\210\302\207" [scan-sexps 1 t] 3) ((error))] 3 (#$ . 6831)]) #@566 Indent a multi line block `c-basic-offset' extra. E.g: int *foo[] = { int *foo[] = { NULL, NULL, {17}, <-> { <- c-indent-multi-line-block 17 } <--> c-basic-offset The block may use any kind of parenthesis character. nil is returned if the line doesn't start with a multi line block, which makes the function usable in list expressions. Work with: Almost all syntactic symbols, but most useful on *-open. (defalias 'c-indent-multi-line-block #[(langelem) "\212\212\302\210`)\303 \210\302fz\304=\205!\302\305\306\217\203 `V\205! *\207" [eol c-basic-offset nil back-to-indentation 40 (byte-code "\300`\301\"\206db\210\302\207" [scan-sexps 1 t] 3) ((error))] 3 (#$ . 7586)]) #@1062 Line up C block comment continuation lines. Various heuristics are used to handle many of the common comment styles. Some examples: /* /** /* /* text /* /** * text * text text text ** text ** text */ */ */ */ */ */ /********************************************************************* * text ********************************************************************/ /********************************************************************* 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. The delimiter line is whatever matches the `comment-start-skip' regexp. *********************************************************************/ The variable `c-comment-prefix-regexp' is used to recognize the comment line prefix, e.g. the `*' that usually starts every line inside a comment. Works with: The `c' syntactic symbol. (defalias 'c-lineup-C-comments #[(langelem) "\212`\306 \210\307 !\203\310\225`Z\202\310\212 Ab\210\307\f!\210\212\310\225b\210\311\312x\210`)\313\225\206/`Z\313Z)\212 \312\211A\203R` Ab\210i\203Nb\210)\202S\310+ \314V\203i\315\n!\203iiZ\202\370\316y\210\306 \210 A`Y\203\265\315\n!\203\221\310\225b\210\307\317!\203\212\313\225b\210iZ\202\370 \nV\203\244 Ab\210iZ\316Z\202\370\310\225b\210\311\312x\210i\nZZ\202\370\307 !\203\303\310\224\310\225=\203\364b\210\306 \210\307\320 \321Q!\203\331 Ab\210\202\364\315\316y!\203\346\307\322!\204\331\306 \210` AW\203\364 Ab\210iZ-\207" [here c-current-comment-prefix prefixlen langelem comment-start-skip starterlen back-to-indentation looking-at 0 " " nil 1 10 zerop -1 "\\([ ]+\\).+$" "\\(" "\\)\\*/" "^[ ]*$" preserve-point langelem-col] 5 (#$ . 8434)]) #@197 Line up a comment start according to `c-comment-only-line-offset'. If the comment is lined up with a comment starter on the previous line, that alignment is preserved. Works with: comment-intro. (defalias 'c-lineup-comment #[(langelem) "\212\304 \210i\212\305` \306Y\203-\307 !\205Pl\203)\310\311\n`\"8\203)\312\313\312\217\210\314\202P\315\312x\210o\2039\312\202P\316\317\n\314#\210\307 !\205Pl\203O\307\305!\202P\314*\205WiU)\203a\320!\202yn\204n \242\206y \202y \243\206y \242\206y\321*\207" [col count here c-comment-only-line-offset back-to-indentation -1 0 forward-comment 7 parse-partial-sexp nil (forward-char 1) t " \n \f" re-search-forward "[\n ]" vector -1000] 4 (#$ . 10352)]) #@377 Line up statements when the first statement is on the same line as the block opening brace. E.g: int main() { puts ("Hello world!"); return 0; <- c-lineup-runin-statements } If there is no statement after the opening brace to align with, nil is returned. This makes the function usable in list expressions. Works with: The `statement' syntactic symbol. (defalias 'c-lineup-runin-statements #[(langelem) "Af\304=\2057\212\305\211A\203$`Ab\210i \203 \nb\210)\202%\306*\307u\210\310\305w\210l?\2056i Z*\207" [langelem preserve-point here langelem-col 123 nil 0 1 " "] 3 (#$ . 11073)]) #@248 Line up the current line after the equal sign on the first line in the statement. If there isn't any, indent with `c-basic-offset'. If the current line contains an equal sign too, try to align it with the first one. Works with: statement-cont. (defalias 'c-lineup-math #[(langelem) "\212\212\212\306 \210`)b\210\212\307\210`)\310\311\312#\210\307f\313=\204(\310\314\312#\311U\204)\307f\313=\2058`\212\306 \210`)Z) \307\211A\203T` Ab\210i\n\203P b\210)\202U\311*\307\f\204\206`\212\307\210`)W\203\206\315\212\307\210`)w\210\316 A!\203\200\314u\210\202[\312\211\203_\307f\313=\203\237\212\314u\210\317\212\307\210`)!\210l)\203\244\202\271\204\263\314u\210\320\307w\210\311iZ Z,\207" [eol langelem preserve-point here donep langelem-col back-to-indentation nil c-forward-token-1 0 t 61 1 "^=" c-in-literal c-forward-syntactic-ws " " equalp c-basic-offset] 5 (#$ . 11698)]) #@215 Line up template argument lines under the first argument. To allow this function to be used in a list expression, nil is returned if there's no template argument on the first line. Works with: template-args-cont. (defalias 'c-lineup-template-args #[(langelem) "\212\305 \306\216\307 !\210\310 \210\311\312!\210\313f\314=\205F\315\316\312\313\212\313\210`)#!\205Fi\n\313\211A\203C`\nAb\210i \203?\fb\210)\202D\317*Z+\207" [c-with-syntax-table-orig-table c++-template-syntax-table langelem preserve-point here syntax-table ((set-syntax-table c-with-syntax-table-orig-table)) set-syntax-table beginning-of-line backward-up-list 1 nil 60 zerop c-forward-token-1 0] 6 (#$ . 12618)]) #@383 Line up selector args as elisp-mode does with function args: Go to the position right after the message receiver, and if you are at the end of the line, indent the current line c-basic-offset columns from the opening bracket; otherwise you are looking at the first character of the first method call argument, so lineup the current line with it. Works with: objc-method-call-cont. (defalias 'c-lineup-ObjC-method-call #[(langelem) "\212\212\306 \210\307A!\210`Sf\310=\203 [\202\311)A\211b\210i\312u\210\313`\314\"\206-db\210\315\312w\210l\203=\f \\\202>i\211\fZ\nZ-\207" [langelem c-basic-offset extra open-bracket-pos open-bracket-col target-col back-to-indentation c-backward-syntactic-ws 58 0 nil scan-sexps 1 " "] 4 (#$ . 13314)]) #@149 Line up the colons that separate args. The colon on the current line is aligned with the one on the first line. Works with: objc-method-args-cont. (defalias 'c-lineup-ObjC-method-args #[(langelem) "\212\212\306 \210`)\211b\210i\212\307\210`) A\211b\210\310\nw\210\307f\311=\205&i\211\2040\n\202Hb\210\310\nw\210\307f\311=\203F iZ\\\202H\n.\207" [here curcol eol langelem relpos first-col-column back-to-indentation nil "^:" 58 c-basic-offset] 4 (#$ . 14071)]) #@152 Line up the colons that separate args. The colon on the current line is aligned with the one on the previous line. Works with: objc-method-args-cont. (defalias 'c-lineup-ObjC-method-args-2 #[(langelem) "\212\212\306 \210`)\211b\210i\212\307\210`) A\310\fx\210`Sf\311=\205%iS\211\204/\n\202Gb\210\310\nw\210\307f\311=\203E iZ\\\202G\n.\207" [here curcol eol langelem relpos prev-col-column back-to-indentation nil "^:" 58 c-basic-offset] 4 (#$ . 14555)]) #@339 Line up the block for constructs that use a block inside an expression, e.g. anonymous classes in Java and lambda functions in Pike. The body is aligned with the start of the header, e.g. with the "new" or "lambda" keyword. Returns nil if the block isn't part of such a construct. Works with: inlambda, inexpr-statement, inexpr-class. (defalias 'c-lineup-inexpr-block #[(langelem) "\212\301 \210\302 \206\303\304\305\217\205\302 \211\205!Ab\210i\301 \210iZ*\207" [res back-to-indentation c-looking-at-inexpr-block nil (byte-code "\300\301!\210\302f\303=\207" [backward-up-list 1 nil 123] 2) ((error))] 4 (#$ . 15033)]) #@569 Line up lines inside a block in whitesmith style. It's done in a way that works both when the opening brace hangs and when it doesn't. E.g: something { something { foo; <-> foo; <- c-lineup-whitesmith-in-block } } <--> c-basic-offset In the first case the indentation is kept unchanged, in the second `c-basic-offset' is added. Works with: defun-close, defun-block-intro, block-close, brace-list-close, brace-list-intro, statement-block-intro, inclass, inextern-lang, innamespace. (defalias 'c-lineup-whitesmith-in-block #[(langelem) "\212Ab\210\302 \210\303fz\304=\203\305\202 )\207" [langelem c-basic-offset back-to-indentation nil 40 0] 2 (#$ . 15669)]) #@87 Do not change the indentation of the current line. Works with: Any syntactic symbol. (defalias 'c-lineup-dont-change #[(langelem) "\212\300 \210\301i!)\207" [back-to-indentation vector] 2 (#$ . 16424)]) #@309 Dynamically calculate brace hanginess for do-while statements. Using this function, `while' clauses that end a `do-while' block will remain on the same line as the brace that closes that block. See `c-hanging-braces-alist' for how to utilize this function as an ACTION associated with `block-close' syntax. (defalias 'c-snug-do-while #[(syntax pos) "\212\303 \304=\203+\304\n\236\211\203+Ab\210\303f\305=\203!\303\306\307\217\210\310\311!\203+\312\202,\313*\207" [langelem syntax c-syntactic-context nil block-close 123 (byte-code "\300`\301\"\206eb\207" [scan-sexps -1] 3) ((error)) looking-at "\\[^_]" (before) (before after)] 3 (#$ . 16635)]) #@156 Imposes a minimum indentation for lines inside a top-level construct. The variable `c-label-minimum-indentation' specifies the minimum indentation amount. (defalias 'c-gnu-impose-minimum #[nil "\305\306\n\2059\n@@\nA \307>\203\306\211\202 >\203\212\306\310 \210\311i!\2035\312\f\313\"c\210)\202+\207" [c-syntactic-context langelem syntax non-top-levels c-label-minimum-indentation (defun-block-intro statement statement-cont statement-block-intro statement-case-intro statement-case-open substatement substatement-open case-label label do-while-closure else-clause) nil (cpp-macro comment-intro) back-to-indentation zerop make-string 32] 4 (#$ . 17305)]) #@321 Controls newline insertion after semicolons in parenthesis lists. If a comma was inserted, no determination is made. If a semicolon was inserted inside a parenthesis list, no newline is added otherwise a newline is added. In either case, checking is stopped. This supports exactly the old newline insertion behavior. (defalias 'c-semi&comma-inside-parenlist #[nil "\301=\205\302\303\304\217\203\305\207\306\207" [last-command-char 59 nil (byte-code "\212\300\301!\210\302f)\303=?\207" [up-list -1 nil 40] 2) ((error t)) t stop] 3 (#$ . 17986)]) #@225 Controls newline insertion after semicolons. If a comma was inserted, no determination is made. If a semicolon was inserted, and the following line is not blank, no newline is inserted. Otherwise, no determination is made. (defalias 'c-semi&comma-no-newlines-before-nonblanks #[nil "\212\301U\205\302\303y!\205\304\305!?\205\306)\207" [last-command-char 59 zerop 1 looking-at "^[ ]*$" stop] 2 (#$ . 18546)]) #@263 Controls newline insertion after semicolons for some one-line methods. If a comma was inserted, no determination is made. Newlines are suppressed in one-liners, if the line is an in-class inline function. For other semicolon contexts, no determination is made. (defalias 'c-semi&comma-no-newlines-for-oneline-inliners #[nil "\303 \212\304\305\306\217\203\212\307 \210`)\202\310)\n\311=\205: @@\312=\205: A@@\313=\205:\212\307 \210`)U\205:\314*\207" [bol syntax last-command-char c-guess-basic-syntax nil (byte-code "\300\301!\210\302\207" [up-list -1 t] 2) ((error)) beginning-of-line -1 59 inclass topmost-intro stop] 4 (#$ . 18970)]) (provide 'cc-align)