;ELC ;;; compiled by rms@mole.gnu.ai.mit.edu on Mon Jun 19 21:59:08 1995 ;;; from file /home/fsf/rms/e19/lisp/cc-mode.el ;;; emacs version 19.28.95.3. ;;; bytecomp version FSF 2.10 ;;; optimization is on. ;;; this file uses opcodes which do not exist in Emacs 18. (if (and (boundp 'emacs-version) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.28.90"))) (error "`cc-mode.el' was compiled for Emacs 19.29 or later")) #@56 *If non-nil, inhibits start up compatibility warnings. (defvar c-inhibit-startup-warnings-p nil (#$ . -475)) #@255 *If non-nil, all syntactic symbols must be found in `c-offsets-alist'. If the syntactic symbol for a particular line does not match a symbol in the offsets alist, an error is generated, otherwise no error is reported and the syntactic symbol is ignored. (defvar c-strict-syntax-p nil (#$ . -591)) #@66 *If non-nil, syntactic info is echoed when the line is indented. (defvar c-echo-syntactic-information-p nil (#$ . -894)) #@71 *Amount of basic offset used by + and - symbols in `c-offsets-alist'. (defvar c-basic-offset 4 (#$ . -1021)) #@5374 *Association list of syntactic element symbols and indentation offsets. As described below, each cons cell in this list has the form: (SYNTACTIC-SYMBOL . OFFSET) When a line is indented, cc-mode first determines the syntactic context of the line by generating a list of symbols called syntactic elements. This list can contain more than one syntactic element and the global variable `c-syntactic-context' contains the context list for the line being indented. Each element in this list is actually a cons cell of the syntactic symbol and a buffer position. This buffer position is called the relative indent point for the line. Some syntactic symbols may not have a relative indent point associated with them. After the syntactic context list for a line is generated, cc-mode calculates the absolute indentation for the line by looking at each syntactic element in the list. First, it compares the syntactic element against the SYNTACTIC-SYMBOL's in `c-offsets-alist'. When it finds a match, it adds the OFFSET to the column of the relative indent point. The sum of this calculation for each element in the syntactic list is the absolute offset for line being indented. If the syntactic element does not match any in the `c-offsets-alist', an error is generated if `c-strict-syntax-p' is non-nil, otherwise the element is ignored. Actually, OFFSET can be an integer, a function, a variable, or one of the following symbols: `+', `-', `++', `--', `*', or `/'. These latter designate positive or negative multiples of `c-basic-offset', respectively: *1, *-1, *2, *-2, *0.5, and *-0.5. If OFFSET is a function, it is called with a single argument containing the cons of the syntactic element symbol and the relative indent point. The function should return an integer offset. Here is the current list of valid syntactic element symbols: string -- inside multi-line string c -- inside a multi-line C style block comment defun-open -- brace that opens a function definition defun-close -- brace that closes a function definition defun-block-intro -- the first line in a top-level defun class-open -- brace that opens a class definition class-close -- brace that closes a class definition inline-open -- brace that opens an in-class inline method inline-close -- brace that closes an in-class inline method ansi-funcdecl-cont -- the nether region between an ANSI function declaration and the defun opening brace knr-argdecl-intro -- first line of a K&R C argument declaration knr-argdecl -- subsequent lines in a K&R C argument declaration topmost-intro -- the first line in a topmost construct definition topmost-intro-cont -- topmost definition continuation lines member-init-intro -- first line in a member initialization list member-init-cont -- subsequent member initialization list lines inher-intro -- first line of a multiple inheritance list inher-cont -- subsequent multiple inheritance lines block-open -- statement block open brace block-close -- statement block close brace brace-list-open -- open brace of an enum or static array list brace-list-close -- close brace of an enum or static array list brace-list-intro -- first line in an enum or static array list brace-list-entry -- subsequent lines in an enum or static array list statement -- a C/C++/ObjC statement statement-cont -- a continuation of a C/C++/ObjC statement statement-block-intro -- the first line in a new statement block statement-case-intro -- the first line in a case `block' statement-case-open -- the first line in a case block starting with brace substatement -- the first line after an if/while/for/do/else substatement-open -- the brace that opens a substatement block case-label -- a case or default label access-label -- C++ private/protected/public access label label -- any non-special C/C++/ObjC label do-while-closure -- the `while' that ends a do/while construct else-clause -- the `else' of an if/else construct comment-intro -- a line containing only a comment introduction arglist-intro -- the first line in an argument list arglist-cont -- subsequent argument list lines when no arguments follow on the same line as the the arglist opening paren arglist-cont-nonempty -- subsequent argument list lines when at least one argument follows on the same line as the arglist opening paren arglist-close -- the solo close paren of an argument list stream-op -- lines continuing a stream operator construct inclass -- the construct is nested inside a class definition cpp-macro -- the start of a cpp macro friend -- a C++ friend declaration objc-method-intro -- the first line of an Objective-C method definition objc-method-args-cont -- lines continuing an Objective-C method definition objc-method-call-cont -- lines continuing an Objective-C method call  (defvar c-offsets-alist (quote ((string . -1000) (c . c-lineup-C-comments) (defun-open . 0) (defun-close . 0) (defun-block-intro . +) (class-open . 0) (class-close . 0) (inline-open . +) (inline-close . 0) (ansi-funcdecl-cont . -) (knr-argdecl-intro . +) (knr-argdecl . 0) (topmost-intro . 0) (topmost-intro-cont . 0) (member-init-intro . +) (member-init-cont . 0) (inher-intro . +) (inher-cont . c-lineup-multi-inher) (block-open . 0) (block-close . 0) (brace-list-open . 0) (brace-list-close . 0) (brace-list-intro . +) (brace-list-entry . 0) (statement . 0) (statement-cont . +) (statement-block-intro . +) (statement-case-intro . +) (statement-case-open . 0) (substatement . +) (substatement-open . +) (case-label . 0) (access-label . -) (label . 2) (do-while-closure . 0) (else-clause . 0) (comment-intro . c-lineup-comment) (arglist-intro . +) (arglist-cont . 0) (arglist-cont-nonempty . c-lineup-arglist) (arglist-close . +) (stream-op . c-lineup-streamop) (inclass . +) (cpp-macro . -1000) (friend . 0) (objc-method-intro . -1000) (objc-method-args-cont . c-lineup-ObjC-method-args) (objc-method-call-cont . c-lineup-ObjC-method-call))) (#$ . -1138)) #@539 *Controls the operation of the TAB key. If t, hitting TAB always just indents the current line. If nil, hitting TAB indents the current line if point is at the left margin or in the line's indentation, otherwise it insert a real tab character. If other than nil or t, then tab is inserted only within literals -- defined as comments and strings -- and inside preprocessor directives, but line is always reindented. Note that indentation of lines containing only comments is also controlled by the `c-comment-only-line-offset' variable. (defvar c-tab-always-indent t (#$ . -7677)) #@418 *Extra offset for line which contains only the start of a comment. Can contain an integer or a cons cell of the form: (NON-ANCHORED-OFFSET . ANCHORED-OFFSET) Where NON-ANCHORED-OFFSET is the amount of offset given to non-column-zero anchored comment-only lines, and ANCHORED-OFFSET is the amount of offset to give column-zero anchored comment-only lines. Just an integer as value is equivalent to ( . -1000). (defvar c-comment-only-line-offset 0 (#$ . -8266)) #@214 *Specifies how comment-only lines should be indented. When this variable is non-nil, comment-only lines are indented according to syntactic analysis via `c-offsets-alist', even when \[indent-for-comment] is used. (defvar c-indent-comments-syntactically-p nil (#$ . -8741)) #@854 *Specifies how to re-indent C style block comments. Examples of the supported styles of C block comment indentation are shown below. When this variable is nil, block comments are indented as shown in styles 1 through 4. If this variable is non-nil, block comments are indented as shown in style 5. Note that cc-mode does not automatically insert any stars or block comment delimiters. You must type these in manually. This variable only controls how the lines within the block comment are indented when you hit ``\[c-indent-command]''. style 1: style 2 (GNU): style 3: style 4: style 5: /* /* Blah /* /* /* blah blah. */ * blah ** blah blah blah * blah ** blah blah */ */ */ */ (defvar c-block-comments-indent-p nil (#$ . -9021)) #@1436 *List of various C/C++/ObjC constructs to "clean up". These clean ups only take place when the auto-newline feature is turned on, as evidenced by the `/a' or `/ah' appearing next to the mode name. Valid symbols are: brace-else-brace -- cleans up `} else {' constructs by placing entire construct on a single line. This clean up only takes place when there is nothing but white space between the braces and the `else'. Clean up occurs when the open-brace after the `else' is typed. empty-defun-braces -- cleans up empty defun braces by placing the braces on the same line. Clean up occurs when the defun closing brace is typed. defun-close-semi -- cleans up the terminating semi-colon on defuns by placing the semi-colon on the same line as the closing brace. Clean up occurs when the semi-colon is typed. list-close-comma -- cleans up commas following braces in array and aggregate initializers. Clean up occurs when the comma is typed. scope-operator -- cleans up double colons which may designate a C++ scope operator split across multiple lines. Note that certain C++ constructs can generate ambiguous situations. This clean up only takes place when there is nothing but whitespace between colons. Clean up occurs when the second colon is typed. (defvar c-cleanup-list (quote (scope-operator)) (#$ . -9934)) #@1332 *Controls the insertion of newlines before and after braces. This variable contains an association list with elements of the following form: (SYNTACTIC-SYMBOL . ACTION). When a brace (either opening or closing) is inserted, the syntactic context it defines is looked up in this list, and if found, the associated ACTION is used to determine where newlines are inserted. If the context is not found, the default is to insert a newline both before and after the brace. SYNTACTIC-SYMBOL can be any of: defun-open, defun-close, class-open, class-close, inline-open, inline-close, block-open, block-close, substatement-open, statement-case-open, brace-list-open, brace-list-close, brace-list-intro, or brace-list-entry. See `c-offsets-alist' for details. ACTION can be either a function symbol or a list containing any combination of the symbols `before' or `after'. If the list is empty, no newlines are inserted either before or after the brace. When ACTION is a function symbol, the function is called with a two arguments: the syntactic symbol for the brace and the buffer position at which the brace was inserted. The function must return a list as described in the preceding paragraph. Note that during the call to the function, the variable `c-syntactic-context' is set to the entire syntactic context for the brace line. (defvar c-hanging-braces-alist (quote ((brace-list-open) (substatement-open after) (block-close . c-snug-do-while))) (#$ . -11439)) #@355 *Controls the insertion of newlines before and after certain colons. This variable contains an association list with elements of the following form: (SYNTACTIC-SYMBOL . ACTION). See the variable `c-hanging-braces-alist' for the semantics of this variable. Note however that making ACTION a function symbol is currently not supported for this variable. (defvar c-hanging-colons-alist nil (#$ . -12909)) #@677 *List of functions that decide whether to insert a newline or not. The functions in this list are called, in order, whenever the auto-newline minor mode is activated (as evidenced by a `/a' or `/ah' string in the mode line), and a semicolon or comma is typed (see `c-electric-semi&comma'). Each function in this list is called with no arguments, and should return one of the following values: nil -- no determination made, continue checking 'stop -- do not insert a newline, and stop checking (anything else) -- insert a newline, and stop checking If every function in the list is called with no determination made, then no newline is inserted. (defvar c-hanging-semi&comma-criteria (quote (c-semi&comma-inside-parenlist)) (#$ . -13320)) #@206 *If nil, `c-fill-paragraph' leaves C block comment enders on their own line. Default value is t, which inhibits leaving block comment ending string `*/' on a line by itself. This is BOCM's sole behavior. (defvar c-hanging-comment-ender-p t (#$ . -14096)) #@57 *Column to insert backslashes when macroizing a region. (defvar c-backslash-column 48 (#$ . -14358)) #@117 *Hook for user defined special indentation adjustments. This hook gets called after a line is indented by the mode. (defvar c-special-indent-hook nil (#$ . -14466)) #@67 *Function called by `c-electric-delete' when deleting characters. (defvar c-delete-function (quote backward-delete-char-untabify) (#$ . -14637)) #@100 *List of behaviors for electric pound insertion. Only currently supported behavior is `alignleft'. (defvar c-electric-pound-behavior nil (#$ . -14789)) #@405 *If non-nil, `c-mode' and `objc-mode' will recognize K&R constructs. This variable is needed because of ambiguities in C syntax that make fast recognition of K&R constructs problematic, and slow. If you are coding with ANSI prototypes, set this variable to nil to speed up recognition of certain constructs. By setting this variable to nil, I have seen an increase of 20 times under some circumstance. (defvar c-recognize-knr-p nil (#$ . -14948)) #@227 *Interval used to update progress status during long re-indentation. If a number, percentage complete gets updated after each interval of that many seconds. Set to nil to inhibit updating. This is only useful for Emacs 19. (defvar c-progress-interval 5 (#$ . -15404)) #@776 Styles of Indentation. Elements of this alist are of the form: (STYLE-STRING (VARIABLE . VALUE) [(VARIABLE . VALUE) ...]) where STYLE-STRING is a short descriptive string used to select a style, VARIABLE is any cc-mode variable, and VALUE is the intended value for that variable when using the selected style. There is one special case when VARIABLE is `c-offsets-alist'. In this case, the VALUE is a list containing elements of the form: (SYNTACTIC-SYMBOL . VALUE) as described in `c-offsets-alist'. These are passed directly to `c-set-offset' so there is no need to set every syntactic symbol in your style, only those that are different from the default. Note that all styles inherit from the "CC-MODE" style, which is computed at the time the mode is loaded. (defvar c-style-alist (quote (("GNU" (c-basic-offset . 2) (c-comment-only-line-offset 0 . 0) (c-offsets-alist (statement-block-intro . +) (knr-argdecl-intro . 5) (substatement-open . +) (label . 0) (statement-case-open . +) (statement-cont . +) (arglist-intro . c-lineup-arglist-intro-after-paren) (arglist-close . c-lineup-arglist))) ("K&R" (c-basic-offset . 5) (c-comment-only-line-offset . 0) (c-offsets-alist (statement-block-intro . +) (knr-argdecl-intro . 0) (substatement-open . 0) (label . 0) (statement-cont . +))) ("BSD" (c-basic-offset . 4) (c-comment-only-line-offset . 0) (c-offsets-alist (statement-block-intro . +) (knr-argdecl-intro . +) (substatement-open . 0) (label . 0) (statement-cont . +))) ("Stroustrup" (c-basic-offset . 4) (c-comment-only-line-offset . 0) (c-offsets-alist (statement-block-intro . +) (substatement-open . 0) (label . 0) (statement-cont . +))) ("Whitesmith" (c-basic-offset . 4) (c-comment-only-line-offset . 0) (c-offsets-alist (statement-block-intro . +) (knr-argdecl-intro . +) (substatement-open . 0) (label . 0) (statement-cont . +))) ("Ellemtel" (c-basic-offset . 3) (c-comment-only-line-offset . 0) (c-hanging-braces-alist (substatement-open before after)) (c-offsets-alist (topmost-intro . 0) (topmost-intro-cont . 0) (substatement . 3) (substatement-open . 0) (statement-case-intro . 0) (case-label . +) (access-label . -3) (inclass . 6) (inline-open . 0))))) (#$ . 15682)) #@381 *Variable interface for setting style via File Local Variables. In a file's Local Variable section, you can set this variable to a string suitable for `c-set-style'. When the file is visited, cc-mode will set the style of the file to this value automatically. Note that file style settings are applied before file offset settings as designated in the variable `c-file-offsets'. (defvar c-file-style nil (#$ . -17888)) #@407 *Variable interface for setting offsets via File Local Variables. In a file's Local Variable section, you can set this variable to an association list similiar to the values allowed in `c-offsets-alist'. When the file is visited, cc-mode will institute these offset settings automatically. Note that file offset settings are applied after file style settings as designated in the variable `c-file-style'. (defvar c-file-offsets nil (#$ . -18315)) #@27 *Hook called by `c-mode'. (defvar c-mode-hook nil (#$ . -18769)) #@29 *Hook called by `c++-mode'. (defvar c++-mode-hook nil (#$ . -18840)) #@30 *Hook called by `objc-mode'. (defvar objc-mode-hook nil (#$ . -18915)) #@75 *Hook called by `c-mode', `c++-mode', and 'objc-mode' during common init. (defvar c-mode-common-hook nil (#$ . -18992)) #@55 XEmacs 19 (formerly Lucid) menu for C/C++/ObjC modes. (defvar c-mode-menu (quote (["Comment Out Region" comment-region (mark)] ["Macro Expand Region" c-macro-expand (mark)] ["Backslashify" c-backslash-region (mark)] ["Indent Expression" c-indent-exp (memq (following-char) (quote (40 91 123)))] ["Indent Line" c-indent-command t] ["Fill Comment Paragraph" c-fill-paragraph t] ["Up Conditional" c-up-conditional t] ["Backward Conditional" c-backward-conditional t] ["Forward Conditional" c-forward-conditional t] ["Backward Statement" c-beginning-of-statement t] ["Forward Statement" c-end-of-statement t])) (#$ . 19118)) #@417 A list of features extant in the Emacs you are using. There are many flavors of Emacs out there, each with different features supporting those needed by cc-mode. Here's the current supported list, along with the values for this variable: Vanilla Emacs 18/Epoch 4: (v18 no-dual-comments) Emacs 18/Epoch 4 (patch2): (v18 8-bit) XEmacs (formerly Lucid) 19: (v19 8-bit) Emacs 19: (v19 1-bit). (defconst c-emacs-features (byte-code "! !\nÉ=\n\"=\n̔̕O!\n͔͕O!GK!UXUeU\n\"\n\"ׂ\"= #H\"\"U)= =W= =W(\n\"!=\f=(\n\"!=,\f=,(,!!\f,D" [boundp emacs-major-version emacs-minor-version nil comments flavor minor major string-match "\\([0-9]+\\).\\([0-9]+\\)" emacs-version string-to-int 1 2 error "Cannot figure out the major and minor version numbers." 18 v18 4 19 v19 "Lucid" "XEmacs" XEmacs FSF "Cannot recognize major version number: %s" copy-syntax-table table modify-syntax-entry 97 ". 12345678" logand lsh -16 255 8-bit 1-bit no-dual-comments 6 21 c-inhibit-startup-warnings-p "*cc-mode warnings*" print format "The version of Emacs that you are running, %s,\nhas known bugs in its syntax.c parsing routines which will affect the\nperformance of cc-mode. You should strongly consider upgrading to the\nlatest available version. cc-mode may continue to work, after a\nfashion, but strange indentation errors could be encountered." "The version of Emacs 18 you are running, %s,\nhas known deficiencies in its ability to handle dual C++ comments,\ni.e. C++ line style comments and C block style comments. This will\nnot be much of a problem for you if you are only editing C code, but\nif you are doing much C++ editing, you should strongly consider\nupgrading to one of the latest Emacs 19's. In Emacs 18, you may also\nexperience performance degradations. Emacs 19 has some new built-in\nroutines which will speed things up for you.\n\nBecause of these inherent problems, cc-mode is no longer being\nactively maintained for Emacs 18, however, until you can upgrade to\nEmacs 19, you may want to look at cc-mode-18.el in the cc-mode\ndistribution. THIS FILE IS COMPLETELY UNSUPPORTED! If you use it,\nyou are on your own, although patch contributions will be folded into\nthe main release." "You are running a syntax patched Emacs 18 variant. While this should\nwork for you, you may want to consider upgrading to Emacs 19.\nThe syntax patches are no longer supported either for syntax.c or cc-mode."] 6) (#$ . 19746)) #@42 Abbrev table in use in c++-mode buffers. (defvar c++-mode-abbrev-table nil (#$ . 22426)) (define-abbrev-table (quote c++-mode-abbrev-table) nil) #@40 Abbrev table in use in c-mode buffers. (defvar c-mode-abbrev-table nil (#$ . 22577)) (define-abbrev-table (quote c-mode-abbrev-table) nil) #@43 Abbrev table in use in objc-mode buffers. (defvar objc-mode-abbrev-table nil (#$ . 22722)) (define-abbrev-table (quote objc-mode-abbrev-table) nil) (defalias 'c-mode-fsf-menu #[(name map) "" [nil (byte-code " # !B# # # # # # # # # # # #܇" [define-key map [menu-bar] make-sparse-keymap [menu-bar c] name [menu-bar c comment-region] ("Comment Out Region" . comment-region) [menu-bar c c-macro-expand] ("Macro Expand Region" . c-macro-expand) [menu-bar c c-backslash-region] ("Backslashify" . c-backslash-region) [menu-bar c indent-exp] ("Indent Expression" . c-indent-exp) [menu-bar c indent-line] ("Indent Line" . c-indent-command) [menu-bar c fill] ("Fill Comment Paragraph" . c-fill-paragraph) [menu-bar c up] ("Up Conditional" . c-up-conditional) [menu-bar c backward] ("Backward Conditional" . c-backward-conditional) [menu-bar c forward] ("Forward Conditional" . c-forward-conditional) [menu-bar c backward-stmt] ("Backward Statement" . c-beginning-of-statement) [menu-bar c forward-stmt] ("Forward Statement" . c-end-of-statement) t] 6) ((error))] 3]) #@32 Keymap used in c-mode buffers. (defvar c-mode-map nil (#$ . 23846)) (byte-code " ############################\"!!#" [c-mode-map make-sparse-keymap define-key "{" c-electric-brace "}" ";" c-electric-semi&comma "#" c-electric-pound ":" c-electric-colon "" c-mark-function "" c-indent-exp "a" c-beginning-of-statement "e" c-end-of-statement "q" c-fill-paragraph "" c-forward-conditional "" c-backward-conditional "" c-up-conditional " " c-indent-command "" c-electric-delete "," "/" c-electric-slash "*" c-electric-star "" c-indent-defun "" c-backslash-region "" c-toggle-auto-state "" c-submit-bug-report "" comment-region "" c-toggle-hungry-state "" c-macro-expand "" c-set-offset "" c-show-syntactic-information "" c-toggle-auto-hungry-state c-mode-fsf-menu "C" boundp current-menubar mode-popup-menu button3 c-popup-menu] 4) #@34 Keymap used in c++-mode buffers. (defvar c++-mode-map nil (#$ . 24881)) (byte-code "5\n>$!B* \"* #\"" [c++-mode-map v19 c-emacs-features fboundp set-keymap-parent keymap c-mode-map make-sparse-keymap define-key ":" c-scope-operator c-mode-fsf-menu "C++"] 4) #@35 Keymap used in objc-mode buffers. (defvar objc-mode-map nil (#$ . 25188)) (byte-code "/\n>$!B* \"* \"" [objc-mode-map v19 c-emacs-features fboundp set-keymap-parent keymap c-mode-map make-sparse-keymap c-mode-fsf-menu "ObjC"] 3) (defalias 'c-populate-syntax-table #[(table) " # # # # # # # # # # #" [modify-syntax-entry 95 "_" table 92 "\\" 43 "." 45 61 37 60 62 38 124 39 "\""] 4]) (defalias 'c-setup-dual-comments #[(table) " > # # # # >; # # # #" [8-bit c-emacs-features modify-syntax-entry 47 ". 1456" table 42 ". 23" 10 "> b" 13 1-bit ". 124b"] 4]) #@38 Syntax table used in c-mode buffers. (defvar c-mode-syntax-table nil (#$ . 25868)) (byte-code " !##" [c-mode-syntax-table make-syntax-table c-populate-syntax-table modify-syntax-entry 47 ". 14" 42 ". 23"] 4) #@40 Syntax table used in c++-mode buffers. (defvar c++-mode-syntax-table nil (#$ . 26103)) (byte-code " !!" [c++-mode-syntax-table make-syntax-table c-populate-syntax-table c-setup-dual-comments] 2) #@41 Syntax table used in objc-mode buffers. (defvar objc-mode-syntax-table nil (#$ . 26318)) (byte-code " !!#" [objc-mode-syntax-table make-syntax-table c-populate-syntax-table c-setup-dual-comments modify-syntax-entry 64 "_"] 4) #@46 Internal state of hungry delete key feature. (defvar c-hungry-delete-key nil (#$ . 26569)) #@41 Internal state of auto newline feature. (defvar c-auto-newline nil (#$ . 26666)) #@71 Internal auto-newline/hungry-delete designation string for mode line. (defvar c-auto-hungry-string nil (#$ . 26753)) #@65 Variable containing syntactic analysis list during indentation. (defvar c-syntactic-context nil (#$ . 26876)) #@62 Buffer local variable describing how comment are introduced. (defvar c-comment-start-regexp nil (#$ . 26992)) #@60 Buffer local language-specific conditional keyword regexp. (defvar c-conditional-key nil (#$ . 27108)) #@51 Buffer local language-specific access key regexp. (defvar c-access-key nil (#$ . 27217)) #@50 Buffer local language-specific class key regexp. (defvar c-class-key nil (#$ . 27312)) #@40 Regexp describing protection keywords. (defconst c-protection-key "\\<\\(public\\|protected\\|private\\)\\>" (#$ . 27405)) #@216 Regexp describing a C/C++/ObjC symbol. We cannot use just `word' syntax class since `_' cannot be in word class. Putting underscore in word class breaks forward word movement behavior that users are familiar with. (defconst c-symbol-key "\\(\\w\\|\\s_\\)+" (#$ . 27535)) #@67 Regexp describing C++ base classes in a derived class definition. (defconst c-baseclass-key (concat ":?[ ]*\\(virtual[ ]+\\)?\\(" c-protection-key "[ ]+\\)" c-symbol-key) (#$ . 27813)) (byte-code "!!!!!!!!!" [make-variable-buffer-local c-auto-newline c-hungry-delete-key c-auto-hungry-string c-comment-start-regexp c-conditional-key c-access-key c-class-key c-baseclass-key c-recognize-knr-p] 2) #@141 Display the result of expanding all C macros occurring in the region. The expansion is entirely correct because it uses the C preprocessor. (autoload (quote c-macro-expand) "cmacexp" '(#$ . 28246) t) #@65 Regexp describing a C++ class declaration, including templates. (defconst c-C++-class-key "\\(class\\|struct\\|union\\)" (#$ . 28452)) #@43 Regexp describing a C struct declaration. (defconst c-C-class-key "\\(struct\\|union\\)" (#$ . 28593)) #@52 Regexp describing a class inheritance declaration. (defconst c-inher-key (concat "\\(\\\\s +\\)?" c-C++-class-key "[ ]+" c-symbol-key "\\([ ]*:[ ]*\\)?\\s *[^;]") (#$ . 28702)) #@52 Regexp describing a switch's case or default label (defconst c-switch-label-key "\\(\\(case[( ]+\\S .*\\)\\|default[ ]*\\):" (#$ . 28898)) #@54 Regexp describing C++ access specification keywords. (defconst c-C++-access-key (concat c-protection-key ":") (#$ . 29045)) #@30 Regexp describing any label. (defconst c-label-key (concat c-symbol-key ":\\([^:]\\|$\\)") (#$ . 29175)) #@42 Regexp describing a conditional control. (defconst c-C-conditional-key "\\b\\(for\\|if\\|do\\|else\\|while\\|switch\\)\\b[^_]" (#$ . 29286)) #@50 Regexp describing a conditional control for C++. (defconst c-C++-conditional-key "\\b\\(for\\|if\\|do\\|else\\|while\\|switch\\|try\\|catch\\)\\b[^_]" (#$ . 29433)) #@55 Regexp describing friend declarations in C++ classes. (defconst c-C++-friend-key "friend[ ]+\\|template[ ]*<.+>[ ]*friend[ ]+" (#$ . 29604)) #@50 Dual comment value for `c-comment-start-regexp'. (defconst c-C++-comment-start-regexp "//\\|/\\*" (#$ . 29755)) #@58 Single comment style value for `c-comment-start-regexp'. (defconst c-C-comment-start-regexp "/\\*" (#$ . 29873)) #@48 Regexp describing an Objective-C method intro. (defconst c-ObjC-method-key (concat "^\\s *[+-]\\s *" "\\(([^)]*)\\)?" "[ \n]*" c-symbol-key) (#$ . 29992)) #@66 Regexp describing access specification keywords for Objective-C. (defconst c-ObjC-access-key (concat "@" c-protection-key) (#$ . 30154)) #@68 Regexp describing a class or protocol declaration for Objective-C. (defconst c-ObjC-class-key (concat "@\\(interface\\|implementation\\)\\s +" c-symbol-key "\\(\\s *:\\s *" c-symbol-key "\\)?" "\\(\\s *<[^>]+>\\)?") (#$ . 30297)) (byte-code "\n\"\f\"\" B LJ" [set-default c-conditional-key c-C-conditional-key c-class-key c-C-class-key c-comment-start-regexp c-C-comment-start-regexp nil c-list-of-mode-names current-load-list] 3) #@850 Major mode for editing C++ code. To submit a problem report, enter `\[c-submit-bug-report]' from a c++-mode buffer. This automatically sets up a mail buffer with version information already added. You just need to add a description of the problem, including a reproducable test case and send the message. To see what version of cc-mode you are running, enter `\[c-version]'. Note that the details of configuring c++-mode have been moved to the accompanying texinfo manual (which is not yet completed -- volunteers are welcome). Until then, please read the README file that came with the cc-mode distribution. The hook variable `c++-mode-hook' is run with no args, if that variable is bound and has a non-nil value. Also the common hook c-mode-common-hook is run first, by this defun, `c-mode', and `objc-mode'. Key bindings: \{c++-mode-map} (defalias 'c++-mode #[nil " \n!\n!  !!" [kill-all-local-variables set-syntax-table c++-mode-syntax-table c++-mode major-mode "C++" mode-name c++-mode-abbrev-table local-abbrev-table use-local-map c++-mode-map c-common-init "// " comment-start "" comment-end c-C++-conditional-key c-conditional-key c-C++-comment-start-regexp c-comment-start-regexp c-C++-class-key c-class-key c-C++-access-key c-access-key run-hooks c-mode-common-hook c++-mode-hook] 2 (#$ . 30752) nil]) (byte-code " B‡" ["C++" c-list-of-mode-names nil] 2) #@852 Major mode for editing K&R and ANSI C code. To submit a problem report, enter `\[c-submit-bug-report]' from a c-mode buffer. This automatically sets up a mail buffer with version information already added. You just need to add a description of the problem, including a reproducable test case and send the message. To see what version of cc-mode you are running, enter `\[c-version]'. Note that the details of configuring c-mode have been moved to the accompanying texinfo manual (which is not yet completed -- volunteers are welcome). Until then, please read the README file that came with the cc-mode distribution. The hook variable `c-mode-hook' is run with no args, if that value is bound and has a non-nil value. Also the common hook c-mode-common-hook is run first, by this defun, `c++-mode', and `objc-mode'. Key bindings: \{c-mode-map} (defalias 'c-mode #[nil " \n!\n!  !!" [kill-all-local-variables set-syntax-table c-mode-syntax-table c-mode major-mode "C" mode-name c-mode-abbrev-table local-abbrev-table use-local-map c-mode-map c-common-init "/* " comment-start " */" comment-end t comment-multi-line c-C-conditional-key c-conditional-key c-C-class-key c-class-key nil c-baseclass-key c-C-comment-start-regexp c-comment-start-regexp run-hooks c-mode-common-hook c-mode-hook] 2 (#$ . 32180) nil]) (byte-code " B‡" ["C" c-list-of-mode-names nil] 2) #@859 Major mode for editing Objective C code. To submit a problem report, enter `\[c-submit-bug-report]' from an objc-mode buffer. This automatically sets up a mail buffer with version information already added. You just need to add a description of the problem, including a reproducable test case and send the message. To see what version of cc-mode you are running, enter `\[c-version]'. Note that the details of configuring objc-mode have been moved to the accompanying texinfo manual (which is not yet completed -- volunteers are welcome). Until then, please read the README file that came with the cc-mode distribution. The hook variable `objc-mode-hook' is run with no args, if that value is bound and has a non-nil value. Also the common hook c-mode-common-hook is run first, by this defun, `c-mode', and `c++-mode'. Key bindings: \{objc-mode-map} (defalias 'objc-mode #[nil " \n!\n!  !!" [kill-all-local-variables set-syntax-table objc-mode-syntax-table objc-mode major-mode "ObjC" mode-name objc-mode-abbrev-table local-abbrev-table use-local-map objc-mode-map c-common-init "// " comment-start "" comment-end c-C-conditional-key c-conditional-key c-C++-comment-start-regexp c-comment-start-regexp c-ObjC-class-key c-class-key nil c-baseclass-key c-ObjC-access-key c-access-key run-hooks c-mode-common-hook objc-mode-hook] 2 (#$ . 33604) nil]) (byte-code " B‡" ["ObjC" c-list-of-mode-names nil] 2) (defalias 'c-common-init #[nil "!!!!!!!!!!!!!P\f \n !c!j!!\"!!\"$\"\"\"\"\"@\"\"A\"\"@C\"\"!!!!(#*!P(B),,B," [make-local-variable paragraph-start paragraph-separate paragraph-ignore-fill-prefix require-final-newline parse-sexp-ignore-comments indent-line-function indent-region-function comment-start comment-end comment-column comment-start-skip outline-regexp outline-level "^$\\|" page-delimiter t c-indent-line c-indent-region "[^#\n ]" c-outline-level 32 "/\\*+ *\\|// *" boundp comment-indent-function c-comment-indent comment-indent-hook current-menubar assoc mode-name copy-sequence c-list-of-mode-names nil changed-p modes delete major-mode relabel-menu-item set-buffer-menubar add-menu c-mode-menu mode-popup-menu " Mode Commands" c-auto-hungry-string minor-mode-alist (c-auto-hungry-string c-auto-hungry-string)] 5]) #@299 Function that post processes relevent file local variables. Currently, this function simply applies any style and offset settings found in the file's Local Variable list. It first applies any style setting found in `c-file-style', then it applies any offset settings it finds in `c-file-offsets'. (defalias 'c-postprocess-file-styles #[nil "!\n\n\"" [c-file-style c-set-style c-file-offsets mapcar #[(langentry) "@A\n \"*" [langentry offset langelem c-set-offset] 3]] 3 (#$ . 36076)]) (byte-code "! \"" [fboundp add-hook hack-local-variables-hook c-postprocess-file-styles] 3) #@297 Enables // as a comment delimiter in `c-mode'. ANSI C currently does *not* allow this, although many C compilers support optional C++ style comments. To use, call this function from your `.emacs' file before you visit any C files. The changes are global and affect all future `c-mode' buffers. (defalias 'c-enable-//-in-c-mode #[nil " !\f\"" [c-setup-dual-comments c-mode-syntax-table set-default c-C-comment-start-regexp c-C++-comment-start-regexp] 3 (#$ . 36690)]) (defalias 'c-point '(macro . #[(position) " = AA \" A@ =#Ȃm =-ʂm =7̂m =A΂m =KЂm =U҂m =_Ԃm =iւm \"#BB" [quote position error "bad buffer position requested: %s" let ((here (point))) append bol ((beginning-of-line)) eol ((end-of-line)) bod ((beginning-of-defun) (and (boundp (quote defun-prompt-regexp)) defun-prompt-regexp (looking-at defun-prompt-regexp) (goto-char (match-end 0)))) boi ((back-to-indentation)) bonl ((forward-line 1)) bopl ((forward-line -1)) iopl ((forward-line -1) (back-to-indentation)) ionl ((forward-line 1) (back-to-indentation)) "unknown buffer position requested: %s" ((prog1 (point) (goto-char here))) nil] 6])) (defalias 'c-auto-newline '(macro . #[nil "" [(and c-auto-newline (not (c-in-literal)) (not (newline)))] 1])) (defalias 'c-safe '(macro . #[(&rest body) " BBBB" [condition-case nil progn body ((error nil))] 4])) (defalias 'c-insert-special-chars #[(arg) "\n!!" [self-insert-command prefix-numeric-value arg] 3]) (defalias 'c-intersect-lists #[(list alist) "\n\n@ \nA )" [nil match list alist] 3]) (defalias 'c-lookup-lists #[(list alist1 alist2) " \n\"@ " [c-intersect-lists list alist1 alist2] 3]) (defalias 'c-comment-indent #[nil "\nQ! ć`y\nQ!'!iT!3!7͂w!Il) ywl)b!:mqB\"\"*yoyw\n!`)biWibxUnĂiT]+" [looking-at "^\\(" c-comment-start-regexp "\\)" 0 nil placeholder opoint "[ ]*}[ ]*\\($\\|" search-forward "}" "^#[ ]*endif[ ]*" "^#[ ]*else[ ]*" 7 c-indent-comments-syntactically-p " " comment-start c-guess-basic-syntax syntax c-add-syntax comment-intro c-comment-only-line-offset apply + mapcar c-get-offset -1 comment-column] 5]) (defalias 'c-outline-level #[nil "wi)" [" " nil] 2]) (defalias 'c-keep-region-active #[nil "! ‰" [boundp zmacs-region-stays t] 2]) (defalias 'c-update-modeline #[nil " \f‚ > !" [c-auto-newline c-hungry-delete-key "/ah" "/a" "/h" c-auto-hungry-string v19 c-emacs-features force-mode-line-update set-buffer-modified-p buffer-modified-p] 2]) (defalias 'c-calculate-state #[(arg prevstate) "!U ?V" [arg prefix-numeric-value 0 prevstate] 2]) #@380 Toggle auto-newline feature. Optional numeric ARG, if supplied turns on auto-newline when positive, turns it off when negative, and just toggles it when zero. When the auto-newline feature is enabled (as evidenced by the `/a' or `/ah' on the modeline after the mode name) newlines are automatically inserted after special characters such as brace, comma, semi-colon, and colon. (defalias 'c-toggle-auto-state #[(arg) " \n\" " [c-calculate-state arg c-auto-newline c-update-modeline c-keep-region-active] 3 (#$ . 39478) "P"]) #@352 Toggle hungry-delete-key feature. Optional numeric ARG, if supplied turns on hungry-delete when positive, turns it off when negative, and just toggles it when zero. When the hungry-delete-key feature is enabled (as evidenced by the `/h' or `/ah' on the modeline after the mode name) the delete key gobbles all preceding whitespace in one fell swoop. (defalias 'c-toggle-hungry-state #[(arg) " \n\" " [c-calculate-state arg c-hungry-delete-key c-update-modeline c-keep-region-active] 3 (#$ . 40018) "P"]) #@273 Toggle auto-newline and hungry-delete-key features. Optional numeric ARG, if supplied turns on auto-newline and hungry-delete when positive, turns them off when negative, and just toggles them when zero. See `c-toggle-auto-state' and `c-toggle-hungry-state' for details. (defalias 'c-toggle-auto-hungry-state #[(arg) " \n\" \" " [c-calculate-state arg c-auto-newline c-hungry-delete-key c-update-modeline c-keep-region-active] 3 (#$ . 40537) "P"]) #@342 Deletes preceding character or whitespace. If `c-hungry-delete-key' is non-nil, as evidenced by the "/h" or "/ah" string on the mode line, then all preceding whitespace is consumed. If however an ARG is supplied, or `c-hungry-delete-key' is nil, or point is inside a literal then the function in the variable `c-delete-function' is called. (defalias 'c-electric-delete #[(arg) "  !!`x` U%` |( !)" [c-hungry-delete-key arg c-in-literal c-delete-function prefix-numeric-value here " \n" nil 1] 3 (#$ . 41003) "P"]) #@211 Electric pound (`#') insertion. Inserts a `#' character specially depending on the variable `c-electric-pound-behavior'. If a numeric ARG is supplied, or if point is inside a literal, nothing special happens. (defalias 'c-electric-pound #[(arg) "   > !!d`Zny  \"?4dZb*" [c-in-literal arg alignleft c-electric-pound-behavior self-insert-command prefix-numeric-value bolp pos 0 delete-horizontal-space insert-char last-command-char 1] 3 (#$ . 41550) "P"]) #@394 Insert a brace. If the auto-newline feature is turned on, as evidenced by the "/a" or "/ah" string on the mode line, newlines are inserted before and after braces based on the value of `c-hanging-braces-alist'. Also, the line is re-indented unless a numeric ARG is supplied, there are non-whitespace characters present on the line after the brace, or the brace is inserted inside a literal. (defalias 'c-electric-brace #[(arg) " ` \" !!\"!g !0 2 `hzUxn)Y !! u #u!A:!A!#!A!@\"!)!>d`Z` %&y%`}鏃h>~쏃` # @ @:` @X A*` 0%`%y`%b)%0[ $*d&Zb`%U +_) ( )`%y`%b)55`S\"@UQ5 \" ^y! *`!0%`%y`%b)%0[ $*`d`ZЉ9:&%<>=U@\"uAxhBU `%S|C<>=BUDE#:9%U :9|Fcd&Zb,G!>? `HZIfBU.1JKIK # +=UeeL !!^ dM!).\n+" [c-parse-state c-state-cache c-safe-position safepos c-in-literal literal arg looking-at "[ ]*$" c-insert-special-chars (class-open class-close defun-open defun-close inline-open inline-close brace-list-open brace-list-close brace-list-intro brace-list-entry block-open block-close substatement-open statement-case-open) syms boundp blink-paren-function blink-paren-hook old-blink-paren nil insertion-point delete-temp-newline 32 preserve-p c-echo-syntactic-information-p " " newline t self-insert-command prefix-numeric-value c-guess-basic-syntax syntax c-auto-newline c-lookup-lists c-hanging-braces-alist (ignore before after) newlines fboundp c-syntactic-context before here pos -1 (byte-code "!‡" [backward-up-list -1 t] 2) ((error)) (41 125) (byte-code "!‡" [forward-sexp -1 t] 2) ((error)) c-hack-state open c-indent-line shift c-adjust-state 0 delete-indentation just-one-space bol parse-partial-sexp c-whack-state makunbound mend mbeg empty-defun-braces c-cleanup-list last-command-char 125 c-intersect-lists (defun-close class-close inline-close) " \n" 123 brace-else-brace re-search-backward "}[ \n]*else[ \n]*{" "} else {" after 2 bufpos close which c-backward-syntactic-ws run-hooks] 6 (#$ . 42045) "P"]) #@247 Insert a slash character. If slash is second of a double-slash C++ style comment introducing construct, and we are on a comment-only-line, indent line as comment. If numeric ARG is supplied or point is inside a literal, indentation is inhibited. (defalias 'c-electric-slash #[(arg) ">\n?hU\fU ?\n!!, *" [major-mode (c++-mode objc-mode) arg 47 last-command-char c-in-literal nil c-echo-syntactic-information-p indentp self-insert-command prefix-numeric-value c-indent-line] 3 (#$ . 44339) "P"]) #@248 Insert a star character. If the star is the second character of a C style comment introducing construct, and we are on a comment-only-line, indent line as comment. If numeric ARG is supplied or point is inside a literal, indentation is inhibited. (defalias 'c-electric-star #[(arg) "\n!!\n?8 >8hU8uxhU)uxn)8 )" [self-insert-command prefix-numeric-value arg c-in-literal (c) 42 -1 "*" nil 47 " " c-echo-syntactic-information-p c-indent-line] 3 (#$ . 44871) "P"]) #@443 Insert a comma or semicolon. When the auto-newline feature is turned on, as evidenced by the "/a" or "/ah" string on the mode line, a newline might be inserted. See the variable `c-hanging-semi&comma-criteria' for how newline insertion is determined. When semicolon is inserted, the line is re-indented unless a numeric arg is supplied, point is inside a literal, or there are non-whitespace characters on the line following the semicolon. (defalias 'c-electric-semi&comma #[(arg) " !\n!`\f!$!!!??d`ZUE>SUj>juxhUj\n!j` |dZb) Ɖ@ A=?~ +," [c-most-enclosing-brace c-parse-state lim c-in-literal literal here nil c-echo-syntactic-information-p arg looking-at "[ ]*$" c-insert-special-chars self-insert-command prefix-numeric-value c-auto-newline pos last-command-char 44 list-close-comma c-cleanup-list 59 defun-close-semi -1 " \n" 125 c-indent-line c-hanging-semi&comma-criteria add-newline-p answer criteria stop newline] 4 (#$ . 45374) "P"]) #@313 Determine if a newline should be added after a semicolon. 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 "U??ďŇƇ" [last-command-char 59 nil (byte-code "!gU)?" [up-list -1 40] 2) ((error t)) t stop] 3 (#$ . 46452)]) #@488 Insert a colon. If the auto-newline feature is turned on, as evidenced by the "/a" or "/ah" string on the mode line, newlines are inserted before and after colons based on the value of `c-hanging-colons-alist'. Also, the line is re-indented unless a numeric ARG is supplied, there are non-whitespace characters present on the line after the colon, or the colon is inserted inside a literal. This function cleans up double colon scope operators based on the value of `c-cleanup-list'. (defalias 'c-electric-colon #[(arg) "` !  !ŕb`b)!\n \f? ?!F ! !!d`Z`>hUuxhU `ZfU`S|dZb* \n\n#c !# \n! >xn)d`Zu dZb) > -" [here beginning-of-defun boundp defun-prompt-regexp looking-at 0 bod c-in-literal literal nil syntax newlines c-echo-syntactic-information-p arg "[ ]*$" c-insert-special-chars self-insert-command prefix-numeric-value pos c-auto-newline scope-operator c-cleanup-list 58 -1 " \n" 2 c-guess-basic-syntax c-lookup-lists (case-label (quote label) (quote access-label)) c-hanging-colons-alist (member-init-intro inher-intro) "\n" delete-char c-indent-line before ": " newline after] 5 (#$ . 46947) "P"]) (byte-code "\"##" [mapcar #[(sym) " # #" [put sym delete-selection t pending-delete] 4] (c-electric-pound c-electric-brace c-electric-slash c-electric-star c-electric-semi&comma c-electric-colon) put c-electric-delete delete-selection supersede pending-delete] 4) (defalias 'c-read-offset #[(langelem) " \n\" Q P\n\f \f\n! И3\n ј>҂ ӘIԂ ՘Tւ ט_؂ ٘jڂ ۘu܂ \" ! !!! \nˉ\f#\f." [langelem c-offsets-alist oldoff format "(default %s): " defstr "Offset must be int, func, var, " "or in [+,-,++,--,*,/] " errmsg "Offset " prompt nil offset input interned read-string "" "+" + "-" - "++" ++ "--" -- "*" * "/" / string-match "^-?[0-9]+$" string-to-int fboundp intern boundp ding] 4]) #@266 Change the value of a syntactic element symbol in `c-offsets-alist'. SYMBOL is the syntactic element symbol to change and OFFSET is the new offset for that syntactic element. Optional ADD says to add SYMBOL to `c-offsets-alist' if it doesn't already appear there. (defalias 'c-set-offset #[(symbol offset &optional add-p) "=:=:=:=:=:=::!:!:\" \f M d^ B\fB\fd \") " [offset + - ++ -- * / fboundp boundp error "Offset must be int, func, var, or in [+,-,++,--,*,/]: %s" symbol c-offsets-alist entry add-p "%s is not a valid syntactic symbol." c-keep-region-active] 4 (#$ . 49038) (byte-code " Ă\fQ \" ? \fG  S\f8@\">8B:+%!! E*" [intern completing-read "Syntactic symbol to change" current-prefix-arg " or add" "" ": " mapcar #[(langelem) "\n@\"B" [format "%s" langelem nil] 3] c-offsets-alist nil c-guess-basic-syntax syntax len format "%s" ic v19 c-emacs-features 0 langelem c-read-offset offset] 11)]) (defalias 'c-set-style-1 #[(stylevars) "\n\"" [mapcar #[(conscell) "@A=\n L \"*" [conscell val attr c-offsets-alist mapcar #[(langentry) "@A\n \"*" [langentry offset langelem c-set-offset] 3]] 4] stylevars] 3]) #@248 Set cc-mode variables to use one of several different indentation styles. STYLENAME is a string representing the desired style from the list of styles described in the variable `c-style-alist'. See that variable for details of setting up styles. (defalias 'c-set-style #[(stylename) " \n\"A\n\"A \"\f!\f! Ø+ !* " [assoc stylename c-style-alist "CC-MODE" default vars error "Invalid indentation style `%s'" "No \"CC-MODE\" style found!" c-set-style-1 c-keep-region-active] 5 (#$ . 50303) (list (let ((completion-ignore-case t) (prompt (format "Which %s indentation style? " mode-name))) (completing-read prompt c-style-alist nil t)))]) #@433 Adds a style to `c-style-alist', or updates an existing one. STYLE is a string identifying the style to add or update. DESCRIP is an association list describing the style and must be of the form: ((VARIABLE . VALUE) [(VARIABLE . VALUE) ...]) See the variable `c-style-alist' for the semantics of VARIABLE and VALUE. This function also sets the current style to STYLE using `c-set-style' if the optional SET-P flag is non-nil. (defalias 'c-add-style #[(style descrip &optional set-p) " \n\" ! B\nB)! !" [assoc style c-style-alist s copy-alist descrip set-p c-set-style] 4 (#$ . 50973) (byte-code "\n\"! !E*" [completing-read "Style to add: " c-style-alist eval-minibuffer "Style description: " description stylename y-or-n-p "Set the style too? "] 5)]) #@246 Like \[fill-paragraph] but handles C and C++ style comments. If any of the current line is a comment or within a comment, fill the comment or the paragraph of it that point is in, preserving the comment indentation or line-starting decorations. (defalias 'c-fill-paragraph #[(&optional arg) "yw !`)>y!)\nP\fP\f\n yoK!Ky;!Ty!”•{ `y`b)y !}yp`)}!- =y `)#`)y! !i\"yiy`y``b)w`{!``|))\nP\fP\f\n  b!i\"`\"\"\"* / \\b#y`)}!ebVS``\\|dby#y({!{*\\*y`d\").!*" [nil comment-start-place 0 " \n" looking-at comment-start-skip first-line major-mode (c++-mode objc-mode) ".*//" paragraph-start "\\|[ ]*/\\*[ ]*$\\|[ ]*\\*/[ ]*$\\|[ /*]*$" paragraph-separate fill-prefix "[ ]*//" -1 1 re-search-forward "[ ]*//[ ]*" here fill-paragraph arg c-in-literal c t "[ ]*/\\*.*\\*/" make-string 32 line-width " *" move-to-column chars-to-delete search-backward "/*" column insert-char 2 search-forward "*/" move c-hanging-comment-ender-p "[ ]*\\*/" fill-column 9999 fill-region-as-paragraph] 5 (#$ . 51770) "P"]) #@83 Move forward to end of a nomenclature section or word. With arg, to it arg times. (defalias 'c-forward-into-nomenclature #[(&optional arg) "\nVd\n$*\nW*e#*u\nT) " [nil case-fold-search arg 0 re-search-forward "\\W*\\([A-Z]*[a-z0-9]*\\)" t re-search-backward "\\(\\(\\W\\|[a-z0-9]\\)[A-Z]+\\|\\W\\w+\\)" 1 c-keep-region-active] 6 (#$ . 53027) "p"]) #@139 Move backward to beginning of a nomenclature section or word. With optional ARG, move that many times. If ARG is negative, move forward. (defalias 'c-backward-into-nomenclature #[(&optional arg) " [! " [c-forward-into-nomenclature arg c-keep-region-active] 2 (#$ . 53411) "p"]) #@106 Insert a double colon scope operator at point. No indentation or other "electric" behavior is performed. (defalias 'c-scope-operator #[nil "c" ["::"] 1 (#$ . 53701) nil]) #@454 Go to the beginning of the innermost C statement. With prefix arg, go back N - 1 statements. If already at the beginning of a statement then go to the beginning of the preceding one. If within a string or comment, or next to a comment (only whitespace between), move by sentences instead of statements. When called from a program, this function takes 2 optional args: the prefix arg, and a buffer position limit which is the farthest back to search. (defalias 'c-beginning-of-statement #[(&optional count lim) "`\n*` !%%!%ȕb` b)\n\nb` ɉ$\n)tq\n8i\n8iP!ix`Zb!)q[!V\n!SrW T`\n]b, " [count 1 lim here beginning-of-defun boundp defun-prompt-regexp looking-at 0 nil state parse-partial-sexp 3 4 "[ ]*" comment-start-skip " " 2 "\\*/" forward-sentence c-beginning-of-statement-1 c-end-of-statement-1 c-keep-region-active] 6 (#$ . 53881) "p"]) #@375 Go to the end of the innermost C statement. With prefix arg, go forward N - 1 statements. Move forward to end of the next statement if already at end. If within a string or comment, move by sentences instead of statements. When called from a program, this function takes 2 optional args: the prefix arg, and a buffer position limit which is the farthest back to search. (defalias 'c-end-of-statement #[(&optional count lim) " [ \" " [c-beginning-of-statement count 1 lim c-keep-region-active] 3 (#$ . 54826) "p"]) (defalias 'c-beginning-of-statement-1 #[(&optional lim) "` |oɏL/!2\nb !xhUD`)\nb`  !=ay !!gU! gU)` !v  `X !?!b*?܏! !?)! !! !! !`\"!\"`\n\"?``\n\"/ c$?$!`y %!SXb)\"!&=w w`\nb` `b)x." [t nil last-begin maybe-labelp c-in-literal-cache donep substmt-p firstp (byte-code "!‡" [backward-sexp 1 t] 2) ((error)) backward-up-list 1 c-backward-syntactic-ws lim "-+!*&:.~ \n" 40 c-in-literal pound 0 looking-at c-conditional-key forward-sexp c-forward-syntactic-ws 59 -1 foundp here (byte-code "!‡" [forward-sexp -1 t] 2) ((error)) "\\[ \n]+\\" c-backward-to-start-of-if "\\[^_]" "\\[^_]" c-backward-to-start-of-do c-label-key c-crosses-statement-barrier-p c-access-key c-switch-label-key major-mode objc-mode c-in-objc-method-def-p "-+!*&:.~" back-to-indentation] 7]) (defalias 'c-end-of-statement-1 #[nil "" [nil (byte-code "m`!`b #+!u" [beg forward-sexp 1 end re-search-forward "[;{}]" t re-search-backward "[;}]"] 4) ((error (byte-code "`!`b #*" [beg backward-up-list -1 end search-forward ";" move] 4)))] 3]) (defalias 'c-crosses-statement-barrier-p #[(from to) "`Ə\fb\n+" [from nil crossedp lim here (byte-code "b 9`\nW9\nw !3g>\".gU+ u`uć" [from crossedp to "^;{}:" c-in-literal lim (59 123 125) t 58 maybe-labelp 1] 2) ((error (byte-code "" [nil crossedp] 1)))] 3]) #@328 Move back to the containing preprocessor conditional, leaving mark behind. A prefix argument acts as a repeat count. With a negative argument, move forward to the end of the containing preprocessor conditional. When going backwards, `#elif' is treated like `#else' followed by `#if'. When going forwards, `#elif' is ignored. (defalias 'c-up-conditional #[(count) " [\" " [c-forward-conditional count t c-keep-region-active] 3 (#$ . 57038) "p"]) #@184 Move back across a preprocessor conditional, leaving mark behind. A prefix argument acts as a repeat count. With a negative argument, move forward across a preprocessor conditional. (defalias 'c-backward-conditional #[(count &optional up-flag) " [\n\" " [c-forward-conditional count up-flag c-keep-region-active] 3 (#$ . 57497) "p"]) #@188 Move forward across a preprocessor conditional, leaving mark behind. A prefix argument acts as a repeat count. With a negative argument, move backward across a preprocessor conditional. (defalias 'c-forward-conditional #[(count &optional up-flag) "V\f \nƂ\nU ,-\f \f#y! y!` \\ }!w\n} U}`\f} Z W W\nւ!\ny W`\f)3\n3y3)\f!\f\nb* \\) \nb, " [count 0 forward -1 1 increment re-search-forward re-search-backward search-function nil new up-flag found depth "#[ ]*\\(if\\|elif\\|endif\\)" t looking-at "^[ ]*#[ ]*\\(if\\|elif\\|endif\\)" prev "[ ]*#[ ]*endif" "[ ]*#[ ]*elif" error "No following conditional at this level" "No previous conditional at this level" "No containing preprocessor conditional" push-mark c-keep-region-active] 5 (#$ . 57843) "p"]) #@663 Indent current line as C++ code, or in some cases insert a tab character. If `c-tab-always-indent' is t, always just indent the current line. If nil, indent the current line only if point is at the left margin or in the line's indentation; otherwise insert a tab. If other than nil or t, then tab is inserted only within literals (comments and strings) and inside preprocessor directives, but line is always reindented. A numeric argument, regardless of its value, means indent rigidly all the lines of the expression starting after point so that this line becomes properly indented. The relative indentation among the lines of the expression are preserved. (defalias 'c-indent-command #[(&optional whole-exp) "` !  !ŕb`b)e ɉ\n \f =:y` !`\n by` )\n Va \n\f[$+ ~xn)y  = ! )" [here beginning-of-defun boundp defun-prompt-regexp looking-at 0 bod whole-exp c-indent-line nil end beg shift-amt c-tab-always-indent t forward-sexp 1 indent-code-rigidly "#" " " insert-tab c-in-literal] 5 (#$ . 58758) "P"]) #@134 Indent each line in balanced expression following point. Optional SHUTUP-P if non-nil, inhibits message printing and error checking. (defalias 'c-indent-exp #[(&optional shutup-p) "`Ďwg>`<``` b)\"A@;A@b;g>;`)\n ͏I \nXX!\nee!\n\n#\nby`\nW! yu." [nil progress-p end here ((byte-code " \n! b" [end nil progress-p c-progress-fini c-indent-exp here] 3)) " \n" (40 91 123) parse-partial-sexp state (40 91 123) start c-echo-syntactic-information-p (byte-code "!‡" [forward-sexp 1 t] 2) ((error)) point-marker shutup-p error "Cannot find start of balanced expression to indent." "Cannot find end of balanced expression to\n indent." c-progress-init c-indent-exp t 0 looking-at "[ ]*$" c-indent-line c-progress-update 1] 6 (#$ . 59867) "P"]) #@77 Re-indents the current top-level function def, struct or class declaration. (defalias 'c-indent-defun #[nil " !\f\fb !. . !.˕b̎ ," [point-marker nil c-least-enclosing-brace c-parse-state brace c-echo-syntactic-information-p here beginning-of-defun boundp defun-prompt-regexp looking-at 0 ((byte-code "b" [here nil] 3)) c-indent-exp] 4 (#$ . 60725) nil]) (defalias 'c-indent-region #[(start end) "bwyŎ\n#\n!nm?`\fW ‰wy y!)Wy`y`b)y`W{׏ ib ۏ`)yw!`y`b))ߏ!‰y+!-" [start " \n" nil 0 endmark ((byte-code "!" [endmark nil c-progress-fini c-indent-region] 3)) t c-echo-syntactic-information-p c-tab-always-indent c-progress-init end c-indent-region copy-marker c-progress-update sexpbeg sexpend nextline c-indent-line looking-at "[ ]*#" 1 here (byte-code "!`" [forward-sexp 1 sexpend] 2) ((error (byte-code "\nb" [nil sexpend nextline] 1))) c-forward-syntactic-ws point-marker (backward-sexp 1) ((error)) " " c-comment-start-regexp (byte-code " V\nX b! bć" [sexpend nextline endmark sexpbeg c-indent-exp shutup c-progress-update] 2) ((error (byte-code "b " [sexpbeg c-indent-line] 1))) markerp] 4]) #@72 Put mark at end of a C, C++, or Objective-C defun, point at beginning. (defalias 'c-mark-function #[nil "` `) \f,\f@:\" Ab% b\fAgUEyoL!Ly5yw! #," [end-of-defun c-parse-state nil brace state eod here 123 -1 looking-at "[ ]*$" 1 " \n" push-mark t] 5 (#$ . 62057) nil]) (byte-code "! B‡" [boundp c-progress-info nil current-load-list] 2) (defalias 'c-progress-init #[(start end context) "!\n!\f?%b ) A@ $!" [fboundp current-time message "indenting region... (this may take a while)" c-progress-info vector start end point-marker context "indenting region..."] 5]) (defalias 'c-progress-update #[nil " ??? A@HHH  ZW>`Z_Z\" I," [c-progress-info c-progress-interval current-time 0 1 2 lastsecs end start now message "indenting region... (%d%% complete)" 100] 5]) (defalias 'c-progress-fini #[(context) " H== Hʼn!" [context c-progress-info 3 t 1 nil message "indenting region... done."] 3]) (defalias 'c-forward-syntactic-ws #[(&optional lim) "dd`} `U?7`\n!gU` ` b)`U," [lim here hugenum forward-comment 35 back-to-indentation nil] 3]) (defalias 'c-backward-syntactic-ws #[(&optional lim) "#` !\f\f!ƕb` b)d[`WP`} `U?P`!!=4y4," [lim here beginning-of-defun boundp defun-prompt-regexp looking-at 0 hugenum forward-comment c-in-literal pound] 3]) (defalias 'c-in-literal #[(&optional lim) "! ` HU H\f;` !66!6•b` b)`\f`\"\n\n8Ôv\n8e\n8aςvЂv by!u҂v,!`\")" [boundp c-in-literal-cache 0 1 lim here beginning-of-defun defun-prompt-regexp looking-at parse-partial-sexp state 3 string 4 7 c++ c "[ ]*#" pound nil rtn vector] 3]) (defalias 'c-parse-state #[nil "!  - U- gU# So ɉ)`)\n`) \n\f\n ҍH." [boundp c-state-cache nil at-bob 2 cnt 0 beginning-of-defun 123 t pos here last-bod last-pos placeholder state sexp-end backup-bod (byte-code "\n\n W\nƏX\n XXȏ P XP\nSfUI\nS B @:F AG B \nS B\n ͏ XSfUяS\"{eU fU{\"{" [nil state pos here last-pos (scan-lists pos 1 -1) ((error)) (byte-code " S\"" [scan-sexps pos 1] 3) ((error)) sexp-end 123 at-bob (byte-code " ‰#" [scan-lists last-pos 1] 4) ((error)) placeholder 125 (scan-lists last-bod -1 1) ((error)) last-bod error "unbalanced close brace at position %d" throw backup-bod t] 4)] 3]) (defalias 'c-whack-state #[(bufpos state) " K @ A :8\f @X\f AX+\n @C\"\n C #\f X\n C #\n*" [nil car newstate state bufpos append] 5]) (defalias 'c-hack-state #[(bufpos which state) "=!\n@ :\f U\f\nB\n)=,\"\n@\nA:A@A :J\n] \fB@:ZA\\B*" [which open state car bufpos close error "c-hack-state, bad argument: %s" cdr] 4]) (defalias 'c-adjust-state #[(from to shift state) "\n\"" [mapcar #[(e) ":3@A \nX\n\fW \n\\ X/ \fW/ \\*C XC\fWC \\" [e cdr car from to shift] 3] state] 3]) (defalias 'c-beginning-of-inheritance-list #[(&optional lim) "\"` !\f\f!ƕb` b) `!`VQh>Qy`w !Q!-b`` b)w*" [lim here beginning-of-defun boundp defun-prompt-regexp looking-at 0 back-to-indentation placeholder c-backward-syntactic-ws (44 58) " " nil c-class-key "^:"] 3]) (defalias 'c-beginning-of-macro #[(&optional lim) " " [back-to-indentation] 1]) (defalias 'c-in-objc-method-def-p #[nil "y\n! `)" [0 looking-at c-ObjC-method-key] 2]) (defalias 'c-just-after-func-arglist-p #[(&optional containing) " `bhU$v$!$ <\nbhU9u !<\nbhUi\n=?i!u hUhhUh!!?*" [c-backward-syntactic-ws containing checkpoint 116 -1 looking-at "\\" 58 "[ \n]*:\\([^:]+\\|$\\)" 41 major-mode objc-mode forward-sexp 45 43 -2 c-class-key] 3]) (defalias 'c-backward-to-start-of-do #[(&optional lim) "\n&` !!!!!ȕb` b)` \n  U?͏0 G b -" [1 nil lim here beginning-of-defun boundp defun-prompt-regexp looking-at 0 foundp case-fold-search do-level (byte-code "! !>=!T=!1SU= =` W= b" [backward-sexp 1 c-in-literal lim (c c++) looking-at "while\\b[^_]" do-level "do\\b[^_]" 0 t foundp] 2) ((error (byte-code "b" [lim 0 do-level] 1)))] 5]) (defalias 'c-backward-to-start-of-if #[(&optional lim) "`y` b)\f0` !++!+•b` b)!\n \f΍-" [1 here 0 nil lim beginning-of-defun boundp defun-prompt-regexp looking-at "if\\b[^_]" at-if case-fold-search if-level orphan-if (byte-code "oMUM ŏ!T!=` ˏ!9S b)` W b·" [if-level 0 c-backward-syntactic-ws nil (backward-sexp 1) ((error (byte-code "\f\"\"T\"Ç" [at-if throw orphan-if nil error "No matching `if' found for `else' on line %d." count-lines 1 here] 5))) looking-at "else\\b[^_]" "if\\b[^_]" here (forward-sexp -1) ((error)) "\\[ ]+\\" lim t] 3)] 6]) (defalias 'c-skip-conditional #[nil "! Â!ł!" [forward-sexp looking-at "\\[ ]+\\" 3 "\\<\\(do\\|else\\)\\>" 1 2] 3]) (defalias 'c-skip-case-statement-forward #[(state &optional lim) "d``\n@`Wff`\n#̔\f! U :Z @VZ AWZ Ab bob." [lim nil state balanced safepos bufpos foundp donep here re-search-forward c-switch-label-key move 0 c-in-literal t] 7]) (defalias 'c-search-uplist-for-classkey #[(brace-state) "??@:8A@$A@@\n:.\n\"\n?>\neW>\nfU?? KeS :S A b \n\n \n`V \n#ϔ !^ bw` `b)\n\"\n=\n#^\n` xhUP)\nw`\nU\n)^\n,+" [brace-state nil search-end search-start carcache 2 error "consp search-end: %s" 123 class foundp c-forward-syntactic-ws re-search-forward c-class-key t 0 c-in-literal " \n" vector here back-to-indentation major-mode objc-mode c-ObjC-method-key "^;=)" skipchars "^<>" 60 ">"] 5]) (defalias 'c-inside-bracelist-p #[(containing-sexp brace-state) "T\fR R :%@A\f bȏ 9gUE@A\f!!`\f+" [nil (byte-code "b!!!!`)" [containing-sexp forward-sexp -1 looking-at "enum[ \n ]+"] 2) ((error)) failedp bufpos containing-sexp brace-state (byte-code "!!\f!" [forward-sexp -1 1 c-forward-syntactic-ws containing-sexp] 2) ((error (byte-code "" [t failedp] 1))) 61 c-beginning-of-statement-1 c-most-enclosing-brace] 4]) (defalias 'c-add-syntax '(macro . #[(symbol &optional relpos) "‰ \fEBBE" [setq syntax cons symbol relpos (syntax)] 6])) (defalias 'c-most-enclosing-brace #[(state) "\n( (\n@\nA :e V\" )" [nil enclosingp state] 3]) (defalias 'c-least-enclosing-brace #[(state) " !" [c-most-enclosing-brace state] 2]) (defalias 'c-safe-position #[(bufpos state) "\n(\n@:\n@A\n@ W!\nA )" [nil safepos state bufpos] 3]) (defalias 'c-narrow-out-enclosing-class #[(state lim) "\n?\n!? HTbw` HX, HTb!`b``b)} )" [nil inclass-p state c-search-uplist-for-classkey 1 " \n" lim c-forward-syntactic-ws here] 3]) (defalias 'c-guess-basic-syntax #[nil "y` =\n! \f  \" bwx  @ A : A`Uy @ J J eXJ J) @: @Ae bwg!h bw!\f>`y`b)BB% \f>yU!\f`y`b)BB% \f=)!` `b)BB%  D` `b)BB%  U bw !)i)H*yBB% !o !`!U wgU)?)BB% HBB% b`y`b)BB% UU.Uu!hUu!hU!` `b)BB% :Y` `b)BB% HBB% ` `b)BB% HBB% >>!UU !Uu! ?!) U!@` `b)BB% U\f@` `b)BB% HBB% A!B`BB% CU7 b!`WghCUgu`y`b)!hU\\!y!1hUvD!) b!EFG` `b)BB% !gUHwG`BB% I!B` `b)BB% JxhKU!?)L`BB% !D!y !M` `b)BB% kDkD!kN`y`b)BBHBB% OU~uPQ`HU*~HbR` `b)BB)% :<!hS>y`!hU=?T!u hUUhVUTW!?!?)< ɁX!)<bY` `b)BB% !mDmomZ[D!)m!!Aoyh\\>~]`y`b)BB)% HBB% =!y\n!^`BB% ! _` `b)BB%  fUs !CUI`>I=- Sb!a!-M BB%  bb` `b)BB% c>n bd` `b)BB%  befɁg!) Tb ! !Uh`BB% M`BB% = fiU Sb`j kl!ll!b`b)!a!?\fm BB)%  Tbwl)O!nx` X)O bo` `b)BB%  !u !L` `b)BB% > bw>!) bwU!@` `b)BB% U@` `b)BB% A!B`BB% p \"}OU'qr'` U's` `b)BB% b !` TU)U bt` `b)BB%  Tb !Up`BB% u`BB% v>\n` !`)V\n U\n bwbw!xy gz>u `){ { Y bU|` `b)BB\n}` `b)BB\nU~ bw !)5 )H*E BB\nbɁ~!)Z Uf BB\nMBBBB\nɁ! b{ {b # ! ` U ` `b)BB\n!M` `b)BB\n{!{ {`] `bM`BB)% Ɂ!,\n !` `b)BB% bwɁ!]\n !`Ɂ!)]\nBB% !\n b`` `b)U\nT!` `b)BB% !\n b` `b)BB% OUT  \" b`` `b)U\n!` `b* b! BBP !% BBP e } !)D R)HBBO BB**%  bu ! \"t !| | _ ! b !|  b ! `! bwgU BB% BB% CU M` `b)BB% >\f b! !)+\f>C\f bwɁ!)C\fM` `b)BB% ` W\f ! b!h` `b)BBU~\fBB)% ~ b \"!*\f b`` `b)U\f ` `b)BB%  b`` `b)U\f`U\f`\"\f!` `b)BBU% BB bw!= BB=W !W BB." [0 indent-point nil case-fold-search c-parse-state fullstate state major-mode objc-mode looking-at c-ObjC-method-key in-method-intro-p literal containing-sexp char-before-ip char-after-ip lim syntax placeholder c-in-literal-cache inswitch-p c-narrow-out-enclosing-class inclass-p " }" " " c-backward-syntactic-ws c-in-literal (string) string here -1 (c c++) "^[ ]*$" pound c-beginning-of-macro cpp-macro back-to-indentation objc-method-intro 123 " {" c-search-uplist-for-classkey decl class-open c-beginning-of-statement-1 c-forward-syntactic-ws "enum[ \n]+" 61 "^;" 59 brace-list-open inline-open defun-open c-just-after-func-arglist-p 58 41 backward-sexp 1 member-init-intro c-recognize-knr-p knr-argdecl-intro inclass ansi-funcdecl-cont c-baseclass-key c-class-key inher-intro c-beginning-of-inheritance-list inher-cont 44 c-access-key (backward-sexp 1) ((error)) member-init-cont " :" c-inher-key "^<" 60 arglist-cont statement-cont access-label 125 (byte-code "!‡" [backward-sexp 1 t] 2) ((error)) class-close (59 44) forward-sexp 45 43 -2 "typedef[ \n]+" knr-argdecl (backward-sexp 1) ((error)) (59 125) topmost-intro objc-method-args-cont topmost-intro-cont (41 93) c-symbol-key arglist-close (40 91) arglist-intro (byte-code "!‡" [forward-sexp -1 t] 2) ((error)) "\\" statement 91 beginning-of-defun boundp defun-prompt-regexp objc-method-call-cont " ([" arglist-cont-nonempty c-inside-bracelist-p (byte-code "u!‡" [1 backward-sexp t] 2) ((error)) brace-list-close brace-list-intro brace-list-entry (59 125 58) c-conditional-key (c-skip-conditional) ((error)) (59) after-cond-placeholder substatement-open substatement "\\" block-open "<<\\|>>" re-search-forward move stream-op "\\[^_]" c-backward-to-start-of-if else-clause "while\\b[^_]" c-backward-to-start-of-do "do\\b[^_]" do-while-closure c-switch-label-key case-label c-label-key label c-safe-position relpos inline-close c-most-enclosing-brace block-close defun-close c-skip-case-statement-forward t statement-case-open statement-case-intro (58 63) (58 63) "::" safepos (byte-code "hU ‚\f!" [forward-sexp 41 -1 -2] 3) ((error)) defun-block-intro statement-block-intro c-comment-start-regexp comment-intro c++-mode c-C++-friend-key friend] 5]) (defalias 'c-get-offset #[(langelem) "@A \f% \" =1  => [ =L \\ =[ [_ =i ϥ =x [ϥ ! ! !\n\n`y`b)W\nbi) \\," [langelem symbol relpos c-offsets-alist match offset c-strict-syntax-p error "don't know how to indent a %s" 0 + c-basic-offset - ++ -- 2 * / fboundp eval here] 4]) (defalias 'c-indent-line #[(&optional syntax) " d`Z\n\"\" Z\n '\n#\nUO`y`b)` `b)|yj`` `b)Wf sd Z`Vsd Zb!\n," [syntax c-guess-basic-syntax c-syntactic-context pos apply + mapcar c-get-offset indent current-indentation shift-amt c-echo-syntactic-information-p message "syntax: %s, indent= %d" 0 here back-to-indentation run-hooks c-special-indent-hook] 5]) #@46 Show syntactic information for current line. (defalias 'c-show-syntactic-information #[nil " \" " [message "syntactic analysis: %s" c-guess-basic-syntax c-keep-region-active] 3 (#$ . 76086) nil]) (defalias 'c-lineup-arglist #[(langelem) "@>\"y!``b)w&Ab`)Abi) y!)S•b!u i Zblg>``b)uw` `Wb*i Z+" [langelem (arglist-intro arglist-cont-nonempty) 0 backward-up-list 1 " " here nil containing-sexp cs-curcol looking-at "[ ]*)" forward-sexp -1 c-forward-syntactic-ws (123 40) eol] 3]) (defalias 'c-lineup-arglist-intro-after-paren #[(langelem) "Abi)y!`` b)wi)ZZ+" [langelem 0 backward-up-list 1 " " here nil ce-curcol cs-curcol -1] 4]) (defalias 'c-lineup-streamop #[(langelem) "Abi`` b)#Ȕbi\nZ+" [langelem relpos curcol re-search-forward "<<\\|>>" here nil move 0] 5]) (defalias 'c-lineup-multi-inher #[(langelem) "`` b)`\fAbi\nw\nwl)!- !i Z," [nil here eol cs-curcol langelem "^:" " :" looking-at c-comment-start-regexp c-forward-syntactic-ws] 3]) (defalias 'c-lineup-C-comments #[(langelem) "yw!Z Abi ` ` b)#_ A\\UL΂\\UW\\Z\\biZ+" [0 " " nil looking-at "\\*\\*?" langelem cs-curcol stars back-to-indentation re-search-forward "/\\*[ ]*" here t c-block-comments-indent-p 1 2] 4]) (defalias 'c-lineup-comment #[(langelem) " n    )" [back-to-indentation c-comment-only-line-offset -1000] 1]) (defalias 'c-lineup-runin-statements #[(langelem) "AfUAbiuwi\nZ*Ƈ" [langelem 123 curcol 1 " " nil 0] 2]) (defalias 'c-lineup-math #[(langelem) "A` `\nb)b``\nb)wgU0`` `\nb)Z) bi  q```\nb)Wq``\nb)wA!ju<̉ AgU| uwiZZ-" [langelem relpos here back-to-indentation "^=" nil 61 equalp curcol donep c-in-literal 1 t c-basic-offset " " 0] 4]) (defalias 'c-lineup-ObjC-method-call #[(langelem) "Abiu wl \n\\\\!i\nZ," [langelem open-bracket-pos open-bracket-col nil forward-sexp " " c-basic-offset target-col] 4]) (defalias 'c-lineup-ObjC-method-args #[(langelem) "` `b)bi``b) Ab\fwgU.i 9\nQb\fwgUO\n iZ\\Q\n." [here back-to-indentation curcol nil eol langelem relpos "^:" 58 first-col-column c-basic-offset] 4]) (defalias 'c-lineup-ObjC-method-args-2 #[(langelem) "` `b)bi``b) AxhU.iZ\n9 Qb\fwgUO\n\niZ\\Q ." [here back-to-indentation curcol nil eol langelem relpos "^:" 58 1 prev-col-column c-basic-offset] 4]) #@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) "\n=)\f) AbgU!!)ʂ**" [nil langelem syntax block-close c-syntactic-context 123 forward-sexp -1 looking-at "\\[^_]" (before) (before after)] 2 (#$ . 78761)]) (defalias 'c-backslashify-current-line #[(doit) " Au!)?ai Yci X+c!i W>c/cn?au!ax``\f`\fb)|" [nil doit -1 looking-at "\\\\" c-backslash-column " \\" " " delete-char " " "\\" " " here] 3]) #@156 Insert backslashes at end of every line in region. Useful for defining cpp macros. If called with a prefix argument, it trailing backslashes are removed. (defalias 'c-backslash-region #[(beg end arg) "bn?\n}ebym)# ?!y) /b ?!*" [end do-lastline-p beg 1 c-backslashify-current-line arg] 2 (#$ . 79555) "r\nP"]) (byte-code "\nQ\fBÇ" ["4.222" " as included in " emacs-version c-version current-load-list] 3) #@46 Address accepting submission of bug reports. (defconst c-mode-help-address "cc-mode-help@merlin.cnri.reston.va.us" (#$ . 79998)) #@56 Echo the current version of cc-mode in the minibuffer. (defalias 'c-version #[nil "\n\" " [message "Using cc-mode version %s" c-version c-keep-region-active] 3 (#$ . 80133) nil]) #@42 Submit via mail a bug report on cc-mode. (defalias 'c-submit-bug-report #[nil "!!Ȃi!i\f=*҂==5Ԃ===װ'!a'\"c')&*" [t (c-offsets-alist) reporter-dont-compact-list reporter-prompt-for-summary-p y-or-n-p "Do you want to submit a report on cc-mode? " message "" nil require reporter reporter-submit-bug-report c-mode-help-address "cc-mode " c-version " (" major-mode c++-mode "C++" c-mode "C" objc-mode "ObjC" ")" c-basic-offset c-offsets-alist c-block-comments-indent-p c-cleanup-list c-comment-only-line-offset c-backslash-column c-delete-function c-electric-pound-behavior c-hanging-braces-alist c-hanging-colons-alist c-hanging-comment-ender-p c-tab-always-indent c-recognize-knr-p defun-prompt-regexp tab-width vars boundp delq #[nil "\"ư \"" [c-special-indent-hook "\n@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n" "c-special-indent-hook is set to '" format "%s" ".\nPerhaps this is your problem?\n" "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n" "\n" "c-emacs-features: %s\n" c-emacs-features] 5] "Dear Barry,"] 18 (#$ . 80323) nil]) #@30 Pops up the C/C++/ObjC menu. (defalias 'c-popup-menu #[(e) " P B! " [popup-menu mode-name " Mode Commands" c-mode-menu c-keep-region-active] 3 (#$ . 81447) "@e"]) (byte-code "\n\"\"\"!!!!!!!!!!!!MMMMMMMM%>'BB'BB'BBB'BBBBBBBBB'B'BB@BABBCDBEFBG'BH'BIJBKLBMBN'BOBPBQBRBSBTBUB$VāWV\"*XY!" [assoc "CC-MODE" c-style-alist c-add-style mapcar #[(var) "J :  !)B" [var val copy-alist] 3] (c-backslash-column c-basic-offset c-block-comments-indent-p c-cleanup-list c-comment-only-line-offset c-echo-syntactic-information-p c-electric-pound-behavior c-hanging-braces-alist c-hanging-colons-alist c-hanging-comment-ender-p c-offsets-alist c-recognize-knr-p c-strict-syntax-p c-tab-always-indent c-inhibit-startup-warnings-p) c-set-style "GNU" make-variable-buffer-local c-offsets-alist c-basic-offset c-file-style c-file-offsets c-comment-only-line-offset c-block-comments-indent-p c-cleanup-list c-hanging-braces-alist c-hanging-colons-alist c-hanging-comment-ender-p c-backslash-column electric-c-brace c-electric-brace electric-c-semi c-electric-semi&comma electric-c-sharp-sign c-electric-pound mark-c-function c-mark-function indent-c-exp c-indent-exp set-c-style c++-beginning-of-defun beginning-of-defun c++-end-of-defun end-of-defun v19 c-emacs-features "Nothing appropriate." na c++-c-mode-syntax-table c-mode-syntaxt-table c++-tab-always-indent c-tab-always-indent c++-always-arglist-indent-p c++-block-close-brace-offset c++-paren-as-block-close-p c++-continued-member-init-offset c++-member-init-indent c++-friend-offset c++-access-specifier-offset c++-empty-arglist-indent c++-comment-only-line-offset c++-C-block-comments-indent-p c++-cleanup-list c++-hanging-braces c++-hanging-member-init-colon c++-auto-hungry-initial-state "Use `c-auto-newline' and `c-hungry-delete-key' instead." c++-auto-hungry-toggle c++-relative-offset-p c++-special-indent-hook c-special-indent-hook c++-delete-function c-delete-function c++-electric-pound-behavior c-electric-pound-behavior c++-hungry-delete-key c-hungry-delete-key c++-auto-newline c-auto-newline c++-match-header-strongly c++-defun-header-strong-struct-equivs c++-version c-version c++-mode-help-address c-mode-help-address c-indent-level c-brace-imaginary-offset c-brace-offset c-argdecl-indent c-label-offset c-continued-statement-offset c-continued-brace-offset c-default-macroize-column c++-default-macroize-column vars #[(elt) " @ A\"" [make-obsolete-variable elt] 3] provide cc-mode] 37)