Linux server.edchosting.com 4.18.0-553.79.1.lve.el7h.x86_64 #1 SMP Wed Oct 15 16:34:46 UTC 2025 x86_64
LiteSpeed
Server IP : 75.98.162.185 & Your IP : 216.73.216.163
Domains :
Cant Read [ /etc/named.conf ]
User : goons4good
Terminal
Auto Root
Create File
Create Folder
Localroot Suggester
Backdoor Destroyer
Readme
/
usr /
share /
emacs /
24.3 /
lisp /
progmodes /
Delete
Unzip
Name
Size
Permission
Date
Action
ada-mode.elc
107.31
KB
-rw-r--r--
2023-06-07 04:14
ada-prj.elc
17.96
KB
-rw-r--r--
2023-06-07 04:14
ada-stmt.elc
35.97
KB
-rw-r--r--
2023-06-07 04:14
ada-xref.elc
55.09
KB
-rw-r--r--
2023-06-07 04:14
antlr-mode.elc
79.34
KB
-rw-r--r--
2023-06-07 04:14
asm-mode.elc
7.69
KB
-rw-r--r--
2023-06-07 04:14
autoconf.elc
5.1
KB
-rw-r--r--
2023-06-07 04:14
bug-reference.elc
6.43
KB
-rw-r--r--
2023-06-07 04:14
cap-words.elc
3.59
KB
-rw-r--r--
2023-06-07 04:14
cc-align.elc
35.39
KB
-rw-r--r--
2023-06-07 04:14
cc-awk.elc
17.81
KB
-rw-r--r--
2023-06-07 04:14
cc-bytecomp.elc
9.35
KB
-rw-r--r--
2023-06-07 04:14
cc-cmds.elc
96.69
KB
-rw-r--r--
2023-06-07 04:14
cc-compat.elc
2.92
KB
-rw-r--r--
2023-06-07 04:14
cc-defs.elc
49.04
KB
-rw-r--r--
2023-06-07 04:14
cc-engine.elc
173.3
KB
-rw-r--r--
2023-06-07 04:14
cc-fonts.elc
153.89
KB
-rw-r--r--
2023-06-07 04:14
cc-guess.elc
13.77
KB
-rw-r--r--
2023-06-07 04:14
cc-langs.elc
75.55
KB
-rw-r--r--
2023-06-07 04:14
cc-menus.elc
7.28
KB
-rw-r--r--
2023-06-07 04:14
cc-mode.elc
191.85
KB
-rw-r--r--
2023-06-07 04:14
cc-styles.elc
16.38
KB
-rw-r--r--
2023-06-07 04:14
cc-vars.elc
69.17
KB
-rw-r--r--
2023-06-07 04:14
cfengine.elc
15.58
KB
-rw-r--r--
2023-06-07 04:14
cmacexp.elc
6.3
KB
-rw-r--r--
2023-06-07 04:14
compile.elc
83.66
KB
-rw-r--r--
2023-06-07 04:14
cperl-mode.elc
215.31
KB
-rw-r--r--
2023-06-07 04:14
cpp.elc
22.18
KB
-rw-r--r--
2023-06-07 04:14
cwarn.elc
11.09
KB
-rw-r--r--
2023-06-07 04:14
dcl-mode.elc
50.23
KB
-rw-r--r--
2023-06-07 04:14
delphi.elc
50.8
KB
-rw-r--r--
2023-06-07 04:14
ebnf-abn.elc
6.88
KB
-rw-r--r--
2023-06-07 04:14
ebnf-bnf.elc
7.67
KB
-rw-r--r--
2023-06-07 04:14
ebnf-dtd.elc
13.03
KB
-rw-r--r--
2023-06-07 04:15
ebnf-ebx.elc
7.99
KB
-rw-r--r--
2023-06-07 04:15
ebnf-iso.elc
7.83
KB
-rw-r--r--
2023-06-07 04:15
ebnf-otz.elc
8.46
KB
-rw-r--r--
2023-06-07 04:15
ebnf-yac.elc
7.22
KB
-rw-r--r--
2023-06-07 04:15
ebnf2ps.elc
117.22
KB
-rw-r--r--
2023-06-07 04:15
ebrowse.elc
206.22
KB
-rw-r--r--
2023-06-07 04:15
etags.elc
55.93
KB
-rw-r--r--
2023-06-07 04:15
executable.elc
7.49
KB
-rw-r--r--
2023-06-07 04:15
f90.elc
92.25
KB
-rw-r--r--
2023-06-07 04:15
flymake.elc
61.63
KB
-rw-r--r--
2023-06-07 04:15
fortran.elc
60.04
KB
-rw-r--r--
2023-06-07 04:15
gdb-mi.elc
169.74
KB
-rw-r--r--
2023-06-07 04:15
glasses.elc
10.17
KB
-rw-r--r--
2023-06-07 04:15
grep.elc
32.61
KB
-rw-r--r--
2023-06-07 04:15
gud.elc
93.14
KB
-rw-r--r--
2023-06-07 04:15
hideif.elc
26.37
KB
-rw-r--r--
2023-06-07 04:15
hideshow.elc
25.32
KB
-rw-r--r--
2023-06-07 04:15
icon.elc
16.85
KB
-rw-r--r--
2023-06-07 04:15
idlw-complete-structtag.elc
4.5
KB
-rw-r--r--
2023-06-07 04:15
idlw-help.elc
36.32
KB
-rw-r--r--
2023-06-07 04:15
idlw-shell.elc
130.41
KB
-rw-r--r--
2023-06-07 04:15
idlw-toolbar.elc
27.61
KB
-rw-r--r--
2023-06-07 04:15
idlwave.elc
251.77
KB
-rw-r--r--
2023-06-07 04:15
inf-lisp.elc
20.29
KB
-rw-r--r--
2023-06-07 04:15
js.elc
95.5
KB
-rw-r--r--
2023-06-07 04:15
ld-script.elc
5.68
KB
-rw-r--r--
2023-06-07 04:15
m4-mode.elc
6.12
KB
-rw-r--r--
2023-06-07 04:15
make-mode.elc
63.81
KB
-rw-r--r--
2023-06-07 04:15
mantemp.elc
3.71
KB
-rw-r--r--
2023-06-07 04:15
meta-mode.elc
32.62
KB
-rw-r--r--
2023-06-07 04:15
mixal-mode.elc
36.42
KB
-rw-r--r--
2023-06-07 04:15
modula2.elc
29.79
KB
-rw-r--r--
2023-06-07 04:15
octave-inf.elc
13.56
KB
-rw-r--r--
2023-06-07 04:15
octave-mod.elc
33.98
KB
-rw-r--r--
2023-06-07 04:15
pascal.elc
39.33
KB
-rw-r--r--
2023-06-07 04:15
perl-mode.elc
24.86
KB
-rw-r--r--
2023-06-07 04:15
prolog.elc
95.73
KB
-rw-r--r--
2023-06-07 04:15
ps-mode.elc
34.13
KB
-rw-r--r--
2023-06-07 04:15
python.elc
99.85
KB
-rw-r--r--
2023-06-07 04:15
ruby-mode.elc
36.94
KB
-rw-r--r--
2023-06-07 04:15
scheme.elc
18.28
KB
-rw-r--r--
2023-06-07 04:15
sh-script.elc
103.89
KB
-rw-r--r--
2023-06-07 04:15
simula.elc
45.68
KB
-rw-r--r--
2023-06-07 04:15
sql.elc
158.59
KB
-rw-r--r--
2023-06-07 04:15
subword.elc
10.31
KB
-rw-r--r--
2023-06-07 04:15
tcl.elc
39.55
KB
-rw-r--r--
2023-06-07 04:15
vera-mode.elc
45.89
KB
-rw-r--r--
2023-06-07 04:15
verilog-mode.elc
419.97
KB
-rw-r--r--
2023-06-07 04:15
vhdl-mode.elc
528.67
KB
-rw-r--r--
2023-06-07 04:15
which-func.elc
9.72
KB
-rw-r--r--
2023-06-07 04:11
xscheme.elc
37.06
KB
-rw-r--r--
2023-06-07 04:15
Save
Rename
;ELC ;;; Compiled by mockbuild@buildfarm06.corp.cloudlinux.com on Wed Jun 7 08:14:50 2023 ;;; from file /builddir/build/BUILD/emacs-24.3/lisp/progmodes/cc-align.el ;;; in Emacs version 24.3.1 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. ;;; This file does not contain utf-8 non-ASCII characters, ;;; and so can be loaded in Emacs versions earlier than 23. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (byte-code "\300\301!\210\300\302!\210\300\303!\207" [require cc-defs cc-vars cc-engine] 2) #@854 Line up declaration continuation lines zero or one indentation step. For lines in the "header" of a definition, zero is used. For other lines, `c-basic-offset' is added to the indentation. E.g.: int neg (int i) <- c-lineup-topmost-intro-cont { return -i; } struct larch <- c-lineup-topmost-intro-cont { double height; } the_larch, <- c-lineup-topmost-intro-cont another_larch; <- c-lineup-topmost-intro-cont <--> c-basic-offset struct larch the_larch, <- c-lineup-topmost-intro-cont another_larch; <- c-lineup-topmost-intro-cont (This function is mainly provided to mimic the behavior of CC Mode 5.28 and earlier where this case wasn't handled consistently so that these lines could be analyzed as either topmost-intro-cont or statement-cont.) Works with: topmost-intro-cont. (defalias 'c-lineup-topmost-intro-cont #[(langelem) "\212\303 \210\214\211A:\203 A\242\202 A)\206 ed}\210\304 \210)`Sf\305>\2054 \205/ \306 ?\2054 \n)\207" [langelem c-overloadable-operators-regexp c-basic-offset beginning-of-line c-backward-sws (125 44) c-after-special-operator-id] 3 (#$ . 650)]) #@673 Line up the continuation lines of a DEFUN macro in the Emacs C source. These lines are indented as though they were `knr-argdecl-intro' lines. Return nil when we're not in such a construct. This function is for historical compatibility with how previous CC Modes (5.28 and earlier) indented such lines. Here is an example: DEFUN ("forward-char", Fforward_char, Sforward_char, 0, 1, "p", doc: /* Move point right N characters (left if N is negative). On reaching end of buffer, stop and signal error. */) (n) <- c-lineup-gnu-DEFUN-into-cont Lisp_Object n; <- c-lineup-gnu-DEFUN-into-cont Works with: topmost-intro-cont. (defalias 'c-lineup-gnu-DEFUN-intro-cont #[(langelem) "\212\302 \211A:\203 A\242\202 A)b\210\303\304!\205 \305\306!*\207" [case-fold-search langelem nil looking-at "\\<DEFUN\\>" c-calc-offset (knr-argdecl-intro)] 3 (#$ . 1817)]) (defalias 'c-block-in-arglist-dwim #[(arglist-start) "\306\236\206o \307\236\206o \310\236\206o \214 \212 b\210\311\210`)}\210 b\210\312\313\311\314#\203G \315u\210\n\203: \214~\210\316 )\204A \311\317\320\217\203G \311u\210\202\" \321\313!)\206o \311 b\210\322\f!\210\323\224b\210\324 \210\325\326 !\327\330 \206j ` \" \")\207" [c-syntactic-context arglist-start c-special-brace-lists containing-sexp c-syntactic-eol c-state-cache inexpr-class inexpr-statement inlambda nil c-syntactic-re-search-forward "{" t -1 c-looking-at-special-brace-list (byte-code "\300`\301\"b\210\302\207" [scan-sexps 1 t] 3) ((error)) looking-at re-search-forward 0 c-forward-sws c-most-enclosing-brace c-parse-state c-looking-at-inexpr-block c-safe-position] 4]) #@664 Line up the current argument line under the first argument. As a special case, if the indented line is inside a brace block construct, the indentation is `c-basic-offset' only. This is intended as a "DWIM" measure in cases like macros that contains statement blocks, e.g.: A_VERY_LONG_MACRO_NAME ({ some (code, with + long, lines * in[it]); }); <--> c-basic-offset This is motivated partly because it's more in line with how code blocks are handled, and partly since it approximates the behavior of earlier CC Mode versions, which due to inaccurate analysis tended to indent such cases this way. Works with: arglist-cont-nonempty, arglist-close. (defalias 'c-lineup-arglist #[(langelem) "\212`\306 \211\243\243\242)!\203 \202G \211\243\243\242)b\210\f\203. \307 \203. \310 \210\311u\210\2021 \311u\210` \312 \210`W\203C b\210\313\311w\210\314i!)*\207" [indent-pos c-syntactic-element langelem c-basic-offset c-special-brace-lists arglist-content-start c-block-in-arglist-dwim c-looking-at-special-brace-list c-forward-token-2 nil c-forward-sws " " vector] 3 (#$ . 3481)]) #@431 Line up a continued argument. foo (xyz, aaa + bbb + ccc + ddd + eee + fff); <- c-lineup-argcont Only continuation lines like this are touched, nil is returned on lines which are the start of an argument. Within a gcc asm block, ":" is recognized as an argument separator, but of course only between operand specifications, not in the expressions for the operands. Works with: arglist-cont, arglist-cont-nonempty. (defalias 'c-lineup-argcont #[(elem) "\212\306 \210@\307=\203/ \211\243\243\242)\310 @\f=\204. @:\204' @b\210 A\211\202 *`\311 n\203? \312 \210`Sf \313=?\205t \212b\210\314 )\211 \205c \315=\206c \212b\210\316\317!)?\205s \320\205n \315!\210\321i!)+\207" [elem c-syntactic-element langelem paren-state open-paren c beginning-of-line arglist-cont-nonempty c-parse-state nil c-backward-sws 44 c-in-gcc-asm-p 58 looking-at "[ ]*:" c-lineup-argcont-scan vector start gcc-asm] 3 (#$ . 4586)]) (defalias 'c-lineup-argcont-scan #[(&optional other-match) "\302\303\304\305\"!\205$ \306f\211\307=\204 =\203 \306u\210\310 \202# \311 !)\207" [c other-match zerop c-backward-token-2 1 t nil 44 c-forward-sws c-lineup-argcont-scan] 5]) #@196 Line up a line to 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\300 \210\301\302!\210\303\304 w\210\305iT!)\207" [beginning-of-line backward-up-list 1 " " line-end-position vector] 2 (#$ . 5773)]) #@639 Line up a line under the enclosing open paren. Normally used to line up a closing paren in the same column as its corresponding open paren, but can also be used with arglist-cont and arglist-cont-nonempty to line up all lines inside a parenthesis under the open paren. As a special case, if a brace block construct starts at the same line as the open parenthesis of the argument list, the indentation is `c-basic-offset' only. See `c-lineup-arglist' for further discussion of this "DWIM" measure. Works with: Almost all symbols, but are typically most useful on arglist-close, brace-list-close, arglist-cont and arglist-cont-nonempty. (defalias 'c-lineup-arglist-close-under-paren #[(langelem) "\212\211@)\305>\203 \211\243\243\242)b\210\202 \306 \210\307\310\311\217\210\212\312`!)\203+ \n\202A \307\f\203= \313 \211\203= @@b\210\314i!))\207" [langelem c-syntactic-element c-basic-offset special-list c-special-brace-lists (arglist-cont-nonempty arglist-close) beginning-of-line nil (byte-code "\300`\301\302#b\207" [scan-lists -1 1] 4) ((error)) c-block-in-arglist-dwim c-looking-at-special-brace-list vector] 4 (#$ . 6174)]) #@870 Line up lines starting with an infix operator under the open paren. Return nil on lines that don't start with an operator, to leave those cases to other line-up functions. Example: if ( x < 10 || at_limit (x, <- c-lineup-arglist-operators list) <- c-lineup-arglist-operators returns nil ) Since this function doesn't do anything for lines without an infix operator you typically want to use it together with some other line-up settings, e.g. as follows (the arglist-close setting is just a suggestion to get a consistent style): (c-set-offset 'arglist-cont '(c-lineup-arglist-operators 0)) (c-set-offset 'arglist-cont-nonempty '(c-lineup-arglist-operators c-lineup-arglist)) (c-set-offset 'arglist-close '(c-lineup-arglist-close-under-paren)) Works with: arglist-cont, arglist-cont-nonempty. (defalias 'c-lineup-arglist-operators #[(langelem) "\212\301 \210\302\303!\205 \304!)\207" [langelem back-to-indentation looking-at "[-+|&*%<>=]\\|\\(/[^/*]\\)" c-lineup-arglist-close-under-paren] 2 (#$ . 7321)]) #@598 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 As a special case, if a brace block construct starts at the same line as the open parenthesis of the argument list, the indentation is `c-basic-offset' instead of the open paren column. See `c-lineup-arglist' for further discussion of this "DWIM" measure. Works with: All *-close symbols. (defalias 'c-lineup-close-paren #[(langelem) "\212\211@)\306>\203 \211\243\243\242)b\210\202 \307 \210\310\311\312\217\210\310\211\f\203> \313 \211\203> @@\211b\210\314 \210\310u\210\202C `\310u\210\315 !\203M \316\202^ \317`!\203X \202^ \nb\210\320i!+\207" [langelem c-syntactic-element arglist-start special-list c-special-brace-lists c-syntactic-eol (arglist-cont-nonempty arglist-close) beginning-of-line nil (byte-code "\300`\301\302#b\207" [scan-lists -1 1] 4) ((error)) c-looking-at-special-brace-list c-forward-token-2 looking-at 0 c-block-in-arglist-dwim vector c-basic-offset] 4 (#$ . 8412)]) #@72 Line up C++ stream operators under each other. Works with: stream-op. (defalias 'c-lineup-streamop #[(langelem) "\212\211A:\203 A\242\202 A)b\210\301\302\303 \304#\210\305\224b\210\306i!)\207" [langelem re-search-forward "<<\\|>>" line-end-position move 0 vector] 5 (#$ . 9632)]) #@657 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\305 \210\306 `\307f \211A:\203 A\242\202 A)\2033 \211A:\203. A\242\2020 A)b\210\310 \210`Sf\311=\203D \312u\210\310 \210\313\314\315#\210\316\f!\203` \214e \206W d}\210\317 \210)\202p \n\320=\203l \312u\210\202p \321w\210` W\205y \322i!,\207" [eol here char-after-ip langelem c-syntactic-eol back-to-indentation line-end-position nil c-backward-sws 58 -1 c-syntactic-re-search-forward ":" move looking-at c-forward-sws 44 " " vector] 5 (#$ . 9926)]) #@442 Line up Java implements and extends declarations. If class names follow 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\211A:\203 A\242\202 A)b\210\302v\210\303\304!\203! \202' \305 \210\306i!)\207" [langelem c-basic-offset 1 looking-at "[ ]*$" c-forward-sws vector] 3 (#$ . 11105)]) #@594 Line up Java throws declarations. If exception names follow 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\303 S\304\305\215\211\203) \306\307\310\311\312 #!\203 \313i!\202* \314 \210\313i\n\\!\202* \n+\207" [lim throws c-basic-offset line-beginning-position done (byte-code "\211A:\203 A\242\202 A)b\210\302\303\304\305 #!\205+ \306\307!\203 \310\311\305\"\210\202 \207" [langelem lim zerop c-forward-token-2 1 t looking-at "throws\\>[^_]" throw done] 6) zerop c-forward-token-2 1 nil line-end-position vector back-to-indentation] 6 (#$ . 11775)]) #@477 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\302 \303 \210\304fz\305=\205 \304\306\307\217\205 `X\205 *\207" [eol c-basic-offset line-end-position back-to-indentation nil 40 (byte-code "\300`\301\"b\210\302\207" [scan-sexps 1 t] 3) ((error))] 3 (#$ . 12879)]) #@567 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\302 \303 \210\304fz\305=\205 \304\306\307\217\203 `V\205 *\207" [eol c-basic-offset line-end-position back-to-indentation nil 40 (byte-code "\300`\301\"b\210\302\207" [scan-sexps 1 t] 3) ((error))] 3 (#$ . 13637)]) #@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 \211A:\203$ A\242\202& A)Tb\210\311\310!\203B \307\312\311\310!!!\203B \310\225\310\224Z\202C \310)\212 \211A:\203S A\242\202U A)b\210\307\f!\210\313\314\225\206m \212\310\225b\210\315\316x\210`)`\314#)]\211 \317V\203\205 \320\n!\203\205 \321i!\202\322y\210\306 \210` \211A:\203\232 A\242\202\234 A)V\203\247 \307\323!\204\205 \211A:\203\265 A\242\202\267 A)`Y\203\320\n!\203\321 \307\f!\210\310\225b\210\321i!\202 \nV\203\361 \211A:\203\345 A\242\202\347 A)b\210\321iT!\202\324 \211A:\203 A\242\202 A) \314#b\210\321i\nZ!\202\307 !\203 \310\224\310\225=\203|b\210\306 \210\307\325 \326Q!\203C \211A:\203; A\242\202= A)b\210\202|\320\322y!\203P\307\327!\204C\306 \210` \211A:\203b A\242\202d A)W\203| \211A:\203w A\242\202y A)b\210\321i!,\207" [here c-current-comment-prefix prefixlen langelem comment-start-skip starterlen back-to-indentation looking-at 0 match-string regexp-quote - 1 " " nil 10 zerop vector -1 "[ ]*$" + "\\(" "\\)\\*/" "^[ ]*$"] 6 (#$ . 14488)]) #@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\302 \210i\212\303 \205 iU)\203 \304!\2021 n\204& \242\2061 \2021 \243\2061 \242\2061 \305*\207" [col c-comment-only-line-offset back-to-indentation c-backward-single-comment vector -1000] 2 (#$ . 16673)]) #@357 Line up a comment in the "K&R region" with the declaration. That is the region between the function or class header and the beginning of the block. E.g.: int main() /* This is the main function. */ <- c-lineup-knr-region-comment { return 0; } Return nil if called in any other situation, to be useful in list expressions. Works with: comment-intro. (defalias 'c-lineup-knr-region-comment #[(langelem) "\301\236\204 \302\236\204 \303\236\204 \304\236\205# \212\305 \210\306 \210\307i!)\207" [c-syntactic-context topmost-intro-cont func-decl-cont knr-argdecl-intro lambda-intro-cont beginning-of-line c-beginning-of-statement-1 vector] 2 (#$ . 17137)]) #@378 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) "\211A:\203 A\242\202 A)f\301=\205O \212\211A:\203& A\242\202( A)\203? \211A:\203: A\242\202< A)b\210\302u\210\303\304w\210l?\205N \305i!)\207" [langelem 123 1 " " nil vector] 3 (#$ . 17809)]) #@352 Line up the current line after the assignment operator on the first line in the statement. If there isn't any, return nil to allow stacking with other line-up functions. If the current line contains an assignment operator too, try to align it with the first one. Works with: topmost-intro-cont, statement-cont, arglist-cont, arglist-cont-nonempty. (defalias 'c-lineup-assignments #[(langelem) "\306\211\211 \211@)\307=\203S \212\214\f\211\243\243\242) \211A:\203( A\242\202* A) }\210\306\310\311\217\211\203= \nT\202O \211A:\203K A\242\202M A)*\202\206 \211A:\203a A\242\202c A)`\212\312 \210\313 \314 \315\211\211%\203\205 \316\224\206} \317\225\212\320 \210`)Z)\212\nb\210\313 \314 ^\315\211\211%\203\243 \316\224\206\236 \317\225b\210\202\247 \315\202\270 \212\214e\314 \206\260 d}\210\321 \210)l)?\205\313 \204\306 \322\306w\210\317\323iZ!,\207" [equalp endpos startpos langelem c-syntactic-element c-assignment-op-regexp nil arglist-cont-nonempty (scan-lists endpos -1 1) ((error)) beginning-of-line c-syntactic-re-search-forward line-end-position t 1 0 back-to-indentation c-forward-sws " " vector] 7 (#$ . 18451)]) #@340 Like `c-lineup-assignments' but indent with `c-basic-offset' if no assignment operator was found on the first line. I.e. this function is the same as specifying a list (c-lineup-assignments +). It's provided for compatibility with old configurations. Works with: topmost-intro-cont, statement-cont, arglist-cont, arglist-cont-nonempty. (defalias 'c-lineup-math #[(langelem) "\302!\206 \207" [langelem c-basic-offset c-lineup-assignments] 2 (#$ . 19611)]) #@562 Line up "cascaded calls" under each other. If the line begins with "->" or "." and the preceding line ends with one or more function calls preceded by the same token, then the arrow is lined up with the first of those tokens. E.g.: result = proc->add(17)->add(18) ->add(19) + <- c-lineup-cascaded-calls offset; <- c-lineup-cascaded-calls (inactive) In any other situation nil is returned to allow use in list expressions. Works with: topmost-intro-cont, statement-cont, arglist-cont, arglist-cont-nonempty. (defalias 'c-lineup-cascaded-calls #[(langelem) "\211@)\305=\205 \211\243\243\242)\306\307 !=??\205\226 \212\310 \210\311\312!\205* \313\314\315!!\211A:\2038 A\242\202: A)\316\211 \205\225 \311\f!\205\225 \317\320\321\322 #!\205\225 \316f\323=\205\225 \317\320\324\322 #!\205\225 \311\f!\205\225 i\317\320\321\322 #!\203\222 \316f\323=\203\222 \317\320\324\322 #!\203\222 \311\f!\203\222 i\202l \325\n!,\207" [langelem c-syntactic-element col stmt-start operator arglist-cont-nonempty c-most-enclosing-brace c-parse-state back-to-indentation looking-at "->\\|\\." regexp-quote match-string 0 nil zerop c-backward-token-2 1 t 40 2 vector] 6 (#$ . 20079)]) #@417 Line up a continued string under the one it continues. A continued string in this sense is where a string literal follows directly after another one. E.g.: result = prefix + "A message " "string."; <- c-lineup-string-cont In other situations, returns nil, to allow stacking with other line-up functions. Works with: topmost-intro-cont, statement-cont, arglist-cont, arglist-cont-nonempty. (defalias 'c-lineup-string-cont #[(langelem) "\212\302 \210\303\304!\2059 \305f\305\306 \210`Sf =\203. \305\307\310\217\203. `\211\212\302 \210`)U\203 \2058 b\210\311i!*)\207" [pos quote back-to-indentation looking-at "\\s\"" nil c-backward-sws (byte-code "\300`\301\"b\210\302\207" [scan-sexps -1 t] 3) ((error)) vector] 3 (#$ . 21315)]) #@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\302 \303\216\304 !\210\305 \210\306\307!\210\310f\311=\205& \312\313\307\310\314 #!\205& \315i!+\207" [c-with-syntax-table-orig-table c++-template-syntax-table 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-2 line-end-position vector] 5 (#$ . 22083)]) #@389 Line up selector args as Emacs Lisp 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 line up the current line with it. Works with: objc-method-call-cont. (defalias 'c-lineup-ObjC-method-call #[(langelem) "\212\212\306 \210\214\211A:\203 A\242\202 A)\206 ed}\210\307 \210)`Sf\310=\203/ [\2020 \311)\211A:\203@ A\242\202B A)\211b\210i \312u\210\313`\314\"b\210\315\312w\210l\203` \f \\\202a i \316 \f\n#-\207" [langelem c-basic-offset extra open-bracket-pos open-bracket-col target-col back-to-indentation c-backward-sws 58 0 nil scan-sexps 1 " " -] 5 (#$ . 22711)]) #@307 Line up selector args as Project Builder / XCode: colons of first selector portions on successive lines are aligned. If no decision can be made return NIL, so that other lineup methods can be tried. This is typically chained with `c-lineup-ObjC-method-call'. Works with: objc-method-call-cont. (defalias 'c-lineup-ObjC-method-call-colons #[(langelem) "\212\300\301\215)\207" [no-idea (byte-code "\306 \210\307\310\311 \312#\203 `\212\306 \210`)Z\202 \313\314\315\"\212\306 \210\214 \211A:\203/ A\242\2021 A)\2066 ed}\210\316 \210)`Sf\317=\203I \n\202J \320)\321 ! \315u\210\322`\323\"b\210\307\310\311 \312#\203k \324i\f $\202l \211 Y\203| \\\202\200 \313\314\315\",\207" [method-arg-len langelem c-objc-method-parameter-offset extra open-bracket-col c-objc-method-arg-unfinished-offset back-to-indentation search-forward ":" line-end-position move throw no-idea nil c-backward-sws 58 0 c-langelem-col scan-sexps 2 - arg-ralign-colon-ofs c-objc-method-arg-min-delta-to-bracket] 6)] 2 (#$ . 23532)]) #@173 Line up the colons that separate args in a method declaration. 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\307 \211A:\203 A\242\202 A)\211 b\210\310\nw\210\311f\312=\2051 i\211 \204; \202S b\210\310\nw\210\311f\312=\203Q iZ\\\202S .\207" [here curcol eol langelem relpos first-col-column back-to-indentation line-end-position "^:" nil 58 c-basic-offset] 4 (#$ . 24565)]) #@176 Line up the colons that separate args in a method declaration. 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\307 \211A:\203 A\242\202 A) \310\fx\210`Sf\311=\2050 iS\211 \204: \202R b\210\310\nw\210\312f\311=\203P iZ\\\202R .\207" [here curcol eol langelem relpos prev-col-column back-to-indentation line-end-position "^:" 58 nil c-basic-offset] 4 (#$ . 25106)]) #@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\303 \210\304 \305!\306\307 \" \"\206/ \205/ b\210\310f\311=\205/ \305`\"\306\307 \" \"\211\205; \nAb\210\312i!,\207" [paren-state containing-sexp res back-to-indentation c-parse-state c-most-enclosing-brace c-looking-at-inexpr-block c-safe-position nil 123 vector] 5 (#$ . 25641)]) #@653 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, inline-close, block-close, brace-list-close, brace-list-intro, statement-block-intro, arglist-intro, arglist-cont-nonempty, arglist-close, and all in* symbols, e.g. inclass and inextern-lang. (defalias 'c-lineup-whitesmith-in-block #[(langelem) "\212\301\302\303\217\205 `\212\304 \210`)U?\205 )\207" [c-basic-offset nil (byte-code "\300`\301\302#b\210\303\207" [scan-lists -1 1 t] 4) ((error)) back-to-indentation] 3 (#$ . 26330)]) #@1144 Compensate for Whitesmith style indentation of blocks. Due to the way CC Mode calculates anchor positions for normal lines inside blocks, this function is necessary for those lines to get correct Whitesmith style indentation. Consider the following examples: int foo() { int foo() { { a; a; } x; <-> x; <- c-lineup-after-whitesmith-blocks The fact that the line with "x" is preceded by a Whitesmith style indented block in one case and not the other should not affect its indentation. But since CC Mode in cases like this uses the indentation of the preceding statement as anchor position, the "x" would in the rightmost case be indented too much if the offset for `statement' was set simply to zero. This lineup function corrects for this situation by detecting if the anchor position is at an open paren character. In that case, it instead indents relative to the surrounding block just like `c-lineup-whitesmith-in-block'. Works with: brace-list-entry, brace-entry-open, statement, arglist-cont. (defalias 'c-lineup-after-whitesmith-blocks #[(langelem) "\212\211A:\203 A\242\202 A)b\210\303\304!\205> \305\306\307\217\203; `\310 \210 `U\2032 \311i!\2027 \311i\n\\!)\202> \311\312!)\207" [langelem pos c-basic-offset looking-at "\\s(" nil (byte-code "\300`\301\302#b\210\303\207" [scan-lists -1 1 t] 4) ((error)) back-to-indentation vector 0] 4 (#$ . 27234)]) #@1976 Line up macro continuation lines according to the indentation of the construct preceding the macro. E.g.: v beg of preceding constr v beg of preceding constr int dribble() { const char msg[] = if (!running) "Some text."; error("Not running!"); #define X(A, B) #define X(A, B) do { <-> do { <- c-lineup-cpp-define printf (A, B); printf (A, B); } while (0) } while (0) If `c-syntactic-indentation-in-macros' is non-nil, the function returns the relative indentation to the macro start line to allow accumulation with other offsets. E.g. in the following cases, cpp-define-intro is combined with the statement-block-intro that comes from the "do {" that hangs on the "#define" line: int dribble() { const char msg[] = if (!running) "Some text."; error("Not running!"); #define X(A, B) do { #define X(A, B) do { printf (A, B); <-> printf (A, B); <- c-lineup-cpp-define this->refs++; this->refs++; } while (0) <-> } while (0) <- c-lineup-cpp-define The relative indentation returned by `c-lineup-cpp-define' is zero and two, respectively, in these two examples. They are then added to the two column indentation that statement-block-intro gives in both cases here. If the relative indentation is zero, then nil is returned instead. That is useful in a list expression to specify the default indentation on the top level. If `c-syntactic-indentation-in-macros' is nil then this function keeps the current indentation, except for empty lines (ignoring the ending backslash) where it takes the indentation from the closest preceding nonempty line in the macro. If there's no such line in the macro then the indentation is taken from the construct preceding it, as described above. Works with: cpp-define-intro. (defalias 'c-lineup-cpp-define #[(langelem) "\306 \203% \212\307 \210\310\311\312\313 \"!\212\314 \210i)Z\315!?\205! )\202\224 \212\212\n9\203S \212\316 \317\211 \317 \306\211 \306\211 \306 \320\216\307 \205N `. \202T \nb\210\321 \210`) \321 \210` V\203t \322\323!\203t \324y\325U\204` ` X\203\206 \310\311\326\313 \"!\202\211 \327 \315!?\205\223 \330!*)\207" [offset c-syntactic-indentation-in-macros c-macro-start modified buffer-undo-list inhibit-read-only nil c-beginning-of-macro c-get-syntactic-indentation delete (cpp-macro) c-guess-basic-syntax back-to-indentation zerop buffer-modified-p t ((byte-code "\204 \301 \203 \302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) beginning-of-line looking-at "[ ]*\\\\?$" -1 0 (cpp-macro) current-indentation vector inhibit-point-motion-hooks before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename macro-start-line] 5 (#$ . 28755)]) #@605 Line up a gcc asm register under one on a previous line. asm ("foo %1, %0\n" "bar %0, %1" : "=r" (w), "=r" (x) : "0" (y), "1" (z)); The "x" line is aligned to the text after the ":" on the "w" line, and similarly "z" under "y". This is done only in an "asm" or "__asm__" block, and only to those lines mentioned. Anywhere else nil is returned. The usual arrangement is to have this routine as an extra feature at the start of arglist line-ups, e.g. (c-lineup-gcc-asm-reg c-lineup-arglist) Works with: arglist-cont, arglist-cont-nonempty. (defalias 'c-lineup-gcc-asm-reg #[(elem) "`\306\212\n\205J @\307=\203 \f\211 \243\243\242)\310\311 !=\205J \312\313 A\314#\205J \315\224\211\205J b\210\316 \210\317\320!?\205J b\210\321 \205J \322b\210i!+\207" [alignto orig-pos c-opt-asm-stmt-key elem c-syntactic-element langelem nil arglist-cont-nonempty c-most-enclosing-brace c-parse-state re-search-backward "^[ ]*:[ ]*\\(.\\)?" t 1 beginning-of-line looking-at "^[ ]*:" c-in-gcc-asm-p vector] 5 (#$ . 31720)]) #@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 (#$ . 32807)]) #@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: \211A:\203 A\242\202! A)b\210\303f\305=\2030 \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\"b\207" [scan-sexps -1] 3) ((error)) looking-at "\\<do\\>[^_]" (before) (before after)] 4 (#$ . 33018)]) #@169 Determine the brace hanginess for an AWK defun-close. If the action/function being closed is a one-liner, keep it so. Otherwise put the closing brace on its own line. (defalias 'c-snug-1line-defun-close #[(syntax pos) "\212b\210\301 \302\303!\210`V\203 \304\202 \305)\207" [pos line-beginning-position up-list -1 (before after) (after)] 3 (#$ . 33708)]) #@146 Imposes a minimum indentation for lines inside code blocks. The variable `c-label-minimum-indentation' specifies the minimum indentation amount. (defalias 'c-gnu-impose-minimum #[nil "\306\236\206 \307\236?\205= \310 \203' @\n\236\211\204' A\211\204 \f+\205= \212\311 \210i W)\205= \312 \313 Z!\207" [c-syntactic-context c-inside-block-syms alist list match c-label-minimum-indentation cpp-macro comment-intro nil back-to-indentation c-shift-line-indentation current-indentation] 4 (#$ . 34073)]) #@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-event 59 nil (byte-code "\212\300\301!\210\302f)\303=?\207" [up-list -1 nil 40] 2) ((error t)) t stop] 3 (#$ . 34590)]) #@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 n\205 \304\305!?\205 \306)\207" [last-command-event 59 zerop 1 looking-at "^[ ]*$" stop] 2 (#$ . 35151)]) #@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 \307 \202 \310)\n\311=\2052 @@\312=\2052 A@@\313=\2052 \307 U\2052 \314*\207" [bol syntax last-command-event c-guess-basic-syntax nil (byte-code "\300\301!\210\302\207" [up-list -1 t] 2) ((error)) line-beginning-position -1 59 inclass topmost-intro stop] 4 (#$ . 35583)]) (provide 'cc-align)