1;;; cc-defs.el --- compile time definitions for CC Mode 2 3;; Copyright (C) 1985, 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 4;; 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 5;; Free Software Foundation, Inc. 6 7;; Authors: 2003- Alan Mackenzie 8;; 1998- Martin Stjernholm 9;; 1992-1999 Barry A. Warsaw 10;; 1987 Dave Detlefs and Stewart Clamen 11;; 1985 Richard M. Stallman 12;; Maintainer: bug-cc-mode@gnu.org 13;; Created: 22-Apr-1997 (split from cc-mode.el) 14;; Version: See cc-mode.el 15;; Keywords: c languages oop 16 17;; This file is part of GNU Emacs. 18 19;; GNU Emacs is free software; you can redistribute it and/or modify 20;; it under the terms of the GNU General Public License as published by 21;; the Free Software Foundation; either version 2, or (at your option) 22;; any later version. 23 24;; GNU Emacs is distributed in the hope that it will be useful, 25;; but WITHOUT ANY WARRANTY; without even the implied warranty of 26;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 27;; GNU General Public License for more details. 28 29;; You should have received a copy of the GNU General Public License 30;; along with this program; see the file COPYING. If not, write to 31;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 32;; Boston, MA 02110-1301, USA. 33 34;;; Commentary: 35 36;; This file contains macros, defsubsts, and various other things that 37;; must be loaded early both during compilation and at runtime. 38 39;;; Code: 40 41(eval-when-compile 42 (let ((load-path 43 (if (and (boundp 'byte-compile-dest-file) 44 (stringp byte-compile-dest-file)) 45 (cons (file-name-directory byte-compile-dest-file) load-path) 46 load-path))) 47 (load "cc-bytecomp" nil t))) 48 49(eval-when-compile (require 'cl)) ; was (cc-external-require 'cl). ACM 2005/11/29. 50(cc-external-require 'regexp-opt) 51 52;; Silence the compiler. 53(cc-bytecomp-defvar c-enable-xemacs-performance-kludge-p) ; In cc-vars.el 54(cc-bytecomp-defun buffer-syntactic-context-depth) ; XEmacs 55(cc-bytecomp-defun region-active-p) ; XEmacs 56(cc-bytecomp-defvar zmacs-region-stays) ; XEmacs 57(cc-bytecomp-defvar zmacs-regions) ; XEmacs 58(cc-bytecomp-defvar mark-active) ; Emacs 59(cc-bytecomp-defvar deactivate-mark) ; Emacs 60(cc-bytecomp-defvar inhibit-point-motion-hooks) ; Emacs 61(cc-bytecomp-defvar parse-sexp-lookup-properties) ; Emacs 62(cc-bytecomp-defvar text-property-default-nonsticky) ; Emacs 21 63(cc-bytecomp-defvar lookup-syntax-properties) ; XEmacs 64(cc-bytecomp-defun string-to-syntax) ; Emacs 21 65 66 67;; cc-fix.el contains compatibility macros that should be used if 68;; needed. 69(eval-and-compile 70 (if (or (/= (regexp-opt-depth "\\(\\(\\)\\)") 2) 71 (not (fboundp 'push))) 72 (cc-load "cc-fix"))) 73 74; (eval-after-load "font-lock" ; 2006-07-09. font-lock is now preloaded 75; ' 76(if (and (not (featurep 'cc-fix)) ; only load the file once. 77 (featurep 'xemacs) ; There is now (2005/12) code in GNU Emacs CVS 78 ; to make the call to f-l-c-k throw an error. 79 (let (font-lock-keywords) 80 (font-lock-compile-keywords '("\\<\\>")) 81 font-lock-keywords)) ; did the previous call foul this up? 82 (load "cc-fix")) ;) 83 84;; The above takes care of the delayed loading, but this is necessary 85;; to ensure correct byte compilation. 86(eval-when-compile 87 (if (and (not (featurep 'cc-fix)) 88 (featurep 'xemacs) 89 (progn 90 (require 'font-lock) 91 (let (font-lock-keywords) 92 (font-lock-compile-keywords '("\\<\\>")) 93 font-lock-keywords))) 94 (cc-load "cc-fix"))) 95 96 97;;; Variables also used at compile time. 98 99(defconst c-version "5.31.4" 100 "CC Mode version number.") 101 102(defconst c-version-sym (intern c-version)) 103;; A little more compact and faster in comparisons. 104 105(defvar c-buffer-is-cc-mode nil 106 "Non-nil for all buffers with a major mode derived from CC Mode. 107Otherwise, this variable is nil. I.e. this variable is non-nil for 108`c-mode', `c++-mode', `objc-mode', `java-mode', `idl-mode', 109`pike-mode', `awk-mode', and any other non-CC Mode mode that calls 110`c-initialize-cc-mode'. The value is the mode symbol itself 111\(i.e. `c-mode' etc) of the original CC Mode mode, or just t if it's 112not known.") 113(make-variable-buffer-local 'c-buffer-is-cc-mode) 114 115;; Have to make `c-buffer-is-cc-mode' permanently local so that it 116;; survives the initialization of the derived mode. 117(put 'c-buffer-is-cc-mode 'permanent-local t) 118 119 120;; The following is used below during compilation. 121(eval-and-compile 122 (defvar c-inside-eval-when-compile nil) 123 124 (defmacro cc-eval-when-compile (&rest body) 125 "Like `progn', but evaluates the body at compile time. 126The result of the body appears to the compiler as a quoted constant. 127 128This variant works around bugs in `eval-when-compile' in various 129\(X)Emacs versions. See cc-defs.el for details." 130 131 (if c-inside-eval-when-compile 132 ;; XEmacs 21.4.6 has a bug in `eval-when-compile' in that it 133 ;; evaluates its body at macro expansion time if it's nested 134 ;; inside another `eval-when-compile'. So we use a dynamically 135 ;; bound variable to avoid nesting them. 136 `(progn ,@body) 137 138 `(eval-when-compile 139 ;; In all (X)Emacsen so far, `eval-when-compile' byte compiles 140 ;; its contents before evaluating it. That can cause forms to 141 ;; be compiled in situations they aren't intended to be 142 ;; compiled. 143 ;; 144 ;; Example: It's not possible to defsubst a primitive, e.g. the 145 ;; following will produce an error (in any emacs flavor), since 146 ;; `nthcdr' is a primitive function that's handled specially by 147 ;; the byte compiler and thus can't be redefined: 148 ;; 149 ;; (defsubst nthcdr (val) val) 150 ;; 151 ;; `defsubst', like `defmacro', needs to be evaluated at 152 ;; compile time, so this will produce an error during byte 153 ;; compilation. 154 ;; 155 ;; CC Mode occasionally needs to do things like this for 156 ;; cross-emacs compatibility. It therefore uses the following 157 ;; to conditionally do a `defsubst': 158 ;; 159 ;; (eval-when-compile 160 ;; (if (not (fboundp 'foo)) 161 ;; (defsubst foo ...))) 162 ;; 163 ;; But `eval-when-compile' byte compiles its contents and 164 ;; _then_ evaluates it (in all current emacs versions, up to 165 ;; and including Emacs 20.6 and XEmacs 21.1 as of this 166 ;; writing). So this will still produce an error, since the 167 ;; byte compiler will get to the defsubst anyway. That's 168 ;; arguably a bug because the point with `eval-when-compile' is 169 ;; that it should evaluate rather than compile its contents. 170 ;; 171 ;; We get around it by expanding the body to a quoted 172 ;; constant that we eval. That otoh introduce a problem in 173 ;; that a returned lambda expression doesn't get byte 174 ;; compiled (even if `function' is used). 175 (eval '(let ((c-inside-eval-when-compile t)) ,@body))))) 176 177 (put 'cc-eval-when-compile 'lisp-indent-hook 0)) 178 179 180;;; Macros. 181 182(defmacro c-point (position &optional point) 183 "Return the value of certain commonly referenced POSITIONs relative to POINT. 184The current point is used if POINT isn't specified. POSITION can be 185one of the following symbols: 186 187`bol' -- beginning of line 188`eol' -- end of line 189`bod' -- beginning of defun 190`eod' -- end of defun 191`boi' -- beginning of indentation 192`ionl' -- indentation of next line 193`iopl' -- indentation of previous line 194`bonl' -- beginning of next line 195`eonl' -- end of next line 196`bopl' -- beginning of previous line 197`eopl' -- end of previous line 198`bosws' -- beginning of syntactic whitespace 199`eosws' -- end of syntactic whitespace 200 201If the referenced position doesn't exist, the closest accessible point 202to it is returned. This function does not modify the point or the mark." 203 204 (if (eq (car-safe position) 'quote) 205 (let ((position (eval position))) 206 (cond 207 208 ((eq position 'bol) 209 (if (and (cc-bytecomp-fboundp 'line-beginning-position) (not point)) 210 `(line-beginning-position) 211 `(save-excursion 212 ,@(if point `((goto-char ,point))) 213 (beginning-of-line) 214 (point)))) 215 216 ((eq position 'eol) 217 (if (and (cc-bytecomp-fboundp 'line-end-position) (not point)) 218 `(line-end-position) 219 `(save-excursion 220 ,@(if point `((goto-char ,point))) 221 (end-of-line) 222 (point)))) 223 224 ((eq position 'boi) 225 `(save-excursion 226 ,@(if point `((goto-char ,point))) 227 (back-to-indentation) 228 (point))) 229 230 ((eq position 'bod) 231 `(save-excursion 232 ,@(if point `((goto-char ,point))) 233 (c-beginning-of-defun-1) 234 (point))) 235 236 ((eq position 'eod) 237 `(save-excursion 238 ,@(if point `((goto-char ,point))) 239 (c-end-of-defun-1) 240 (point))) 241 242 ((eq position 'bopl) 243 (if (and (cc-bytecomp-fboundp 'line-beginning-position) (not point)) 244 `(line-beginning-position 0) 245 `(save-excursion 246 ,@(if point `((goto-char ,point))) 247 (forward-line -1) 248 (point)))) 249 250 ((eq position 'bonl) 251 (if (and (cc-bytecomp-fboundp 'line-beginning-position) (not point)) 252 `(line-beginning-position 2) 253 `(save-excursion 254 ,@(if point `((goto-char ,point))) 255 (forward-line 1) 256 (point)))) 257 258 ((eq position 'eopl) 259 (if (and (cc-bytecomp-fboundp 'line-end-position) (not point)) 260 `(line-end-position 0) 261 `(save-excursion 262 ,@(if point `((goto-char ,point))) 263 (beginning-of-line) 264 (or (bobp) (backward-char)) 265 (point)))) 266 267 ((eq position 'eonl) 268 (if (and (cc-bytecomp-fboundp 'line-end-position) (not point)) 269 `(line-end-position 2) 270 `(save-excursion 271 ,@(if point `((goto-char ,point))) 272 (forward-line 1) 273 (end-of-line) 274 (point)))) 275 276 ((eq position 'iopl) 277 `(save-excursion 278 ,@(if point `((goto-char ,point))) 279 (forward-line -1) 280 (back-to-indentation) 281 (point))) 282 283 ((eq position 'ionl) 284 `(save-excursion 285 ,@(if point `((goto-char ,point))) 286 (forward-line 1) 287 (back-to-indentation) 288 (point))) 289 290 ((eq position 'bosws) 291 `(save-excursion 292 ,@(if point `((goto-char ,point))) 293 (c-backward-syntactic-ws) 294 (point))) 295 296 ((eq position 'eosws) 297 `(save-excursion 298 ,@(if point `((goto-char ,point))) 299 (c-forward-syntactic-ws) 300 (point))) 301 302 (t (error "Unknown buffer position requested: %s" position)))) 303 304 ;; The bulk of this should perhaps be in a function to avoid large 305 ;; expansions, but this case is not used anywhere in CC Mode (and 306 ;; probably not anywhere else either) so we only have it to be on 307 ;; the safe side. 308 (message "Warning: c-point long expansion") 309 `(save-excursion 310 ,@(if point `((goto-char ,point))) 311 (let ((position ,position)) 312 (cond 313 ((eq position 'bol) (beginning-of-line)) 314 ((eq position 'eol) (end-of-line)) 315 ((eq position 'boi) (back-to-indentation)) 316 ((eq position 'bod) (c-beginning-of-defun-1)) 317 ((eq position 'eod) (c-end-of-defun-1)) 318 ((eq position 'bopl) (forward-line -1)) 319 ((eq position 'bonl) (forward-line 1)) 320 ((eq position 'eopl) (progn 321 (beginning-of-line) 322 (or (bobp) (backward-char)))) 323 ((eq position 'eonl) (progn 324 (forward-line 1) 325 (end-of-line))) 326 ((eq position 'iopl) (progn 327 (forward-line -1) 328 (back-to-indentation))) 329 ((eq position 'ionl) (progn 330 (forward-line 1) 331 (back-to-indentation))) 332 ((eq position 'bosws) (c-backward-syntactic-ws)) 333 ((eq position 'eosws) (c-forward-syntactic-ws)) 334 (t (error "Unknown buffer position requested: %s" position)))) 335 (point)))) 336 337(defmacro c-region-is-active-p () 338 ;; Return t when the region is active. The determination of region 339 ;; activeness is different in both Emacs and XEmacs. 340 (if (cc-bytecomp-fboundp 'region-active-p) 341 ;; XEmacs. 342 '(region-active-p) 343 ;; Emacs. 344 'mark-active)) 345 346(defmacro c-set-region-active (activate) 347 ;; Activate the region if ACTIVE is non-nil, deactivate it 348 ;; otherwise. Covers the differences between Emacs and XEmacs. 349 (if (cc-bytecomp-fboundp 'zmacs-activate-region) 350 ;; XEmacs. 351 `(if ,activate 352 (zmacs-activate-region) 353 (zmacs-deactivate-region)) 354 ;; Emacs. 355 `(setq mark-active ,activate))) 356 357(defmacro c-delete-and-extract-region (start end) 358 "Delete the text between START and END and return it." 359 (if (cc-bytecomp-fboundp 'delete-and-extract-region) 360 ;; Emacs 21.1 and later 361 `(delete-and-extract-region ,start ,end) 362 ;; XEmacs and Emacs 20.x 363 `(prog1 364 (buffer-substring ,start ,end) 365 (delete-region ,start ,end)))) 366 367(defmacro c-safe (&rest body) 368 ;; safely execute BODY, return nil if an error occurred 369 `(condition-case nil 370 (progn ,@body) 371 (error nil))) 372(put 'c-safe 'lisp-indent-function 0) 373 374(defmacro c-int-to-char (integer) 375 ;; In GNU Emacs, a character is an integer. In XEmacs, a character is a 376 ;; type distinct from an integer. Sometimes we need to convert integers to 377 ;; characters. `c-int-to-char' makes this conversion, if necessary. 378 (if (fboundp 'int-to-char) 379 `(int-to-char ,integer) 380 integer)) 381 382(defmacro c-sentence-end () 383 ;; Get the regular expression `sentence-end'. 384 (if (cc-bytecomp-fboundp 'sentence-end) 385 ;; Emacs 22: 386 `(sentence-end) 387 ;; Emacs <22 + XEmacs 388 `sentence-end)) 389 390(defmacro c-default-value-sentence-end () 391 ;; Get the default value of the variable sentence end. 392 (if (cc-bytecomp-fboundp 'sentence-end) 393 ;; Emacs 22: 394 `(let (sentence-end) (sentence-end)) 395 ;; Emacs <22 + XEmacs 396 `(default-value 'sentence-end))) 397 398;; The following is essentially `save-buffer-state' from lazy-lock.el. 399;; It ought to be a standard macro. 400(defmacro c-save-buffer-state (varlist &rest body) 401 "Bind variables according to VARLIST (in `let*' style) and eval BODY, 402then restore the buffer state under the assumption that no significant 403modification has been made in BODY. A change is considered 404significant if it affects the buffer text in any way that isn't 405completely restored again. Changes in text properties like `face' or 406`syntax-table' are considered insignificant. This macro allows text 407properties to be changed, even in a read-only buffer. 408 409This macro should be placed around all calculations which set 410\"insignificant\" text properties in a buffer, even when the buffer is 411known to be writeable. That way, these text properties remain set 412even if the user undoes the command which set them. 413 414This macro should ALWAYS be placed around \"temporary\" internal buffer 415changes \(like adding a newline to calculate a text-property then 416deleting it again\), so that the user never sees them on his 417`buffer-undo-list'. See also `c-tentative-buffer-changes'. 418 419However, any user-visible changes to the buffer \(like auto-newlines\) 420must not be within a `c-save-buffer-state', since the user then 421wouldn't be able to undo them. 422 423The return value is the value of the last form in BODY." 424 `(let* ((modified (buffer-modified-p)) (buffer-undo-list t) 425 (inhibit-read-only t) (inhibit-point-motion-hooks t) 426 before-change-functions after-change-functions 427 deactivate-mark 428 ,@varlist) 429 (unwind-protect 430 (progn ,@body) 431 (and (not modified) 432 (buffer-modified-p) 433 (set-buffer-modified-p nil))))) 434(put 'c-save-buffer-state 'lisp-indent-function 1) 435 436(defmacro c-tentative-buffer-changes (&rest body) 437 "Eval BODY and optionally restore the buffer contents to the state it 438was in before BODY. Any changes are kept if the last form in BODY 439returns non-nil. Otherwise it's undone using the undo facility, and 440various other buffer state that might be affected by the changes is 441restored. That includes the current buffer, point, mark, mark 442activation \(similar to `save-excursion'), and the modified state. 443The state is also restored if BODY exits nonlocally. 444 445If BODY makes a change that unconditionally is undone then wrap this 446macro inside `c-save-buffer-state'. That way the change can be done 447even when the buffer is read-only, and without interference from 448various buffer change hooks." 449 `(let (-tnt-chng-keep 450 -tnt-chng-state) 451 (unwind-protect 452 ;; Insert an undo boundary for use with `undo-more'. We 453 ;; don't use `undo-boundary' since it doesn't insert one 454 ;; unconditionally. 455 (setq buffer-undo-list (cons nil buffer-undo-list) 456 -tnt-chng-state (c-tnt-chng-record-state) 457 -tnt-chng-keep (progn ,@body)) 458 (c-tnt-chng-cleanup -tnt-chng-keep -tnt-chng-state)))) 459(put 'c-tentative-buffer-changes 'lisp-indent-function 0) 460 461(defun c-tnt-chng-record-state () 462 ;; Used internally in `c-tentative-buffer-changes'. 463 (vector buffer-undo-list ; 0 464 (current-buffer) ; 1 465 ;; No need to use markers for the point and mark; if the 466 ;; undo got out of synch we're hosed anyway. 467 (point) ; 2 468 (mark t) ; 3 469 (c-region-is-active-p) ; 4 470 (buffer-modified-p))) ; 5 471 472(defun c-tnt-chng-cleanup (keep saved-state) 473 ;; Used internally in `c-tentative-buffer-changes'. 474 475 (let ((saved-undo-list (elt saved-state 0))) 476 (if (eq buffer-undo-list saved-undo-list) 477 ;; No change was done afterall. 478 (setq buffer-undo-list (cdr saved-undo-list)) 479 480 (if keep 481 ;; Find and remove the undo boundary. 482 (let ((p buffer-undo-list)) 483 (while (not (eq (cdr p) saved-undo-list)) 484 (setq p (cdr p))) 485 (setcdr p (cdr saved-undo-list))) 486 487 ;; `primitive-undo' will remove the boundary. 488 (setq saved-undo-list (cdr saved-undo-list)) 489 (let ((undo-in-progress t)) 490 (while (not (eq (setq buffer-undo-list 491 (primitive-undo 1 buffer-undo-list)) 492 saved-undo-list)))) 493 494 (when (buffer-live-p (elt saved-state 1)) 495 (set-buffer (elt saved-state 1)) 496 (goto-char (elt saved-state 2)) 497 (set-mark (elt saved-state 3)) 498 (c-set-region-active (elt saved-state 4)) 499 (and (not (elt saved-state 5)) 500 (buffer-modified-p) 501 (set-buffer-modified-p nil))))))) 502 503(defmacro c-forward-syntactic-ws (&optional limit) 504 "Forward skip over syntactic whitespace. 505Syntactic whitespace is defined as whitespace characters, comments, 506and preprocessor directives. However if point starts inside a comment 507or preprocessor directive, the content of it is not treated as 508whitespace. 509 510LIMIT sets an upper limit of the forward movement, if specified. If 511LIMIT or the end of the buffer is reached inside a comment or 512preprocessor directive, the point will be left there. 513 514Note that this function might do hidden buffer changes. See the 515comment at the start of cc-engine.el for more info." 516 (if limit 517 `(save-restriction 518 (narrow-to-region (point-min) (or ,limit (point-max))) 519 (c-forward-sws)) 520 '(c-forward-sws))) 521 522(defmacro c-backward-syntactic-ws (&optional limit) 523 "Backward skip over syntactic whitespace. 524Syntactic whitespace is defined as whitespace characters, comments, 525and preprocessor directives. However if point starts inside a comment 526or preprocessor directive, the content of it is not treated as 527whitespace. 528 529LIMIT sets a lower limit of the backward movement, if specified. If 530LIMIT is reached inside a line comment or preprocessor directive then 531the point is moved into it past the whitespace at the end. 532 533Note that this function might do hidden buffer changes. See the 534comment at the start of cc-engine.el for more info." 535 (if limit 536 `(save-restriction 537 (narrow-to-region (or ,limit (point-min)) (point-max)) 538 (c-backward-sws)) 539 '(c-backward-sws))) 540 541(defmacro c-forward-sexp (&optional count) 542 "Move forward across COUNT balanced expressions. 543A negative COUNT means move backward. Signal an error if the move 544fails for any reason. 545 546This is like `forward-sexp' except that it isn't interactive and does 547not do any user friendly adjustments of the point and that it isn't 548susceptible to user configurations such as disabling of signals in 549certain situations." 550 (or count (setq count 1)) 551 `(goto-char (scan-sexps (point) ,count))) 552 553(defmacro c-backward-sexp (&optional count) 554 "See `c-forward-sexp' and reverse directions." 555 (or count (setq count 1)) 556 `(c-forward-sexp ,(if (numberp count) (- count) `(- ,count)))) 557 558(defmacro c-safe-scan-lists (from count depth &optional limit) 559 "Like `scan-lists' but returns nil instead of signalling errors 560for unbalanced parens. 561 562A limit for the search may be given. FROM is assumed to be on the 563right side of it." 564 (let ((res (if (featurep 'xemacs) 565 `(scan-lists ,from ,count ,depth nil t) 566 `(c-safe (scan-lists ,from ,count ,depth))))) 567 (if limit 568 `(save-restriction 569 ,(if (numberp count) 570 (if (< count 0) 571 `(narrow-to-region ,limit (point-max)) 572 `(narrow-to-region (point-min) ,limit)) 573 `(if (< ,count 0) 574 (narrow-to-region ,limit (point-max)) 575 (narrow-to-region (point-min) ,limit))) 576 ,res) 577 res))) 578 579 580;; Wrappers for common scan-lists cases, mainly because it's almost 581;; impossible to get a feel for how that function works. 582 583(defmacro c-go-list-forward () 584 "Move backward across one balanced group of parentheses. 585 586Return POINT when we succeed, NIL when we fail. In the latter case, leave 587point unmoved." 588 `(c-safe (let ((endpos (scan-lists (point) 1 0))) 589 (goto-char endpos) 590 endpos))) 591 592(defmacro c-go-list-backward () 593 "Move backward across one balanced group of parentheses. 594 595Return POINT when we succeed, NIL when we fail. In the latter case, leave 596point unmoved." 597 `(c-safe (let ((endpos (scan-lists (point) -1 0))) 598 (goto-char endpos) 599 endpos))) 600 601(defmacro c-up-list-forward (&optional pos limit) 602 "Return the first position after the list sexp containing POS, 603or nil if no such position exists. The point is used if POS is left out. 604 605A limit for the search may be given. The start position is assumed to 606be before it." 607 `(c-safe-scan-lists ,(or pos `(point)) 1 1 ,limit)) 608 609(defmacro c-up-list-backward (&optional pos limit) 610 "Return the position of the start of the list sexp containing POS, 611or nil if no such position exists. The point is used if POS is left out. 612 613A limit for the search may be given. The start position is assumed to 614be after it." 615 `(c-safe-scan-lists ,(or pos `(point)) -1 1 ,limit)) 616 617(defmacro c-down-list-forward (&optional pos limit) 618 "Return the first position inside the first list sexp after POS, 619or nil if no such position exists. The point is used if POS is left out. 620 621A limit for the search may be given. The start position is assumed to 622be before it." 623 `(c-safe-scan-lists ,(or pos `(point)) 1 -1 ,limit)) 624 625(defmacro c-down-list-backward (&optional pos limit) 626 "Return the last position inside the last list sexp before POS, 627or nil if no such position exists. The point is used if POS is left out. 628 629A limit for the search may be given. The start position is assumed to 630be after it." 631 `(c-safe-scan-lists ,(or pos `(point)) -1 -1 ,limit)) 632 633(defmacro c-go-up-list-forward (&optional pos limit) 634 "Move the point to the first position after the list sexp containing POS, 635or containing the point if POS is left out. Return t if such a 636position exists, otherwise nil is returned and the point isn't moved. 637 638A limit for the search may be given. The start position is assumed to 639be before it." 640 (let ((res `(c-safe (goto-char (scan-lists ,(or pos `(point)) 1 1)) t))) 641 (if limit 642 `(save-restriction 643 (narrow-to-region (point-min) ,limit) 644 ,res) 645 res))) 646 647(defmacro c-go-up-list-backward (&optional pos limit) 648 "Move the point to the position of the start of the list sexp containing POS, 649or containing the point if POS is left out. Return t if such a 650position exists, otherwise nil is returned and the point isn't moved. 651 652A limit for the search may be given. The start position is assumed to 653be after it." 654 (let ((res `(c-safe (goto-char (scan-lists ,(or pos `(point)) -1 1)) t))) 655 (if limit 656 `(save-restriction 657 (narrow-to-region ,limit (point-max)) 658 ,res) 659 res))) 660 661(defmacro c-go-down-list-forward (&optional pos limit) 662 "Move the point to the first position inside the first list sexp after POS, 663or before the point if POS is left out. Return t if such a position 664exists, otherwise nil is returned and the point isn't moved. 665 666A limit for the search may be given. The start position is assumed to 667be before it." 668 (let ((res `(c-safe (goto-char (scan-lists ,(or pos `(point)) 1 -1)) t))) 669 (if limit 670 `(save-restriction 671 (narrow-to-region (point-min) ,limit) 672 ,res) 673 res))) 674 675(defmacro c-go-down-list-backward (&optional pos limit) 676 "Move the point to the last position inside the last list sexp before POS, 677or before the point if POS is left out. Return t if such a position 678exists, otherwise nil is returned and the point isn't moved. 679 680A limit for the search may be given. The start position is assumed to 681be after it." 682 (let ((res `(c-safe (goto-char (scan-lists ,(or pos `(point)) -1 -1)) t))) 683 (if limit 684 `(save-restriction 685 (narrow-to-region ,limit (point-max)) 686 ,res) 687 res))) 688 689 690(defmacro c-beginning-of-defun-1 () 691 ;; Wrapper around beginning-of-defun. 692 ;; 693 ;; NOTE: This function should contain the only explicit use of 694 ;; beginning-of-defun in CC Mode. Eventually something better than 695 ;; b-o-d will be available and this should be the only place the 696 ;; code needs to change. Everything else should use 697 ;; (c-beginning-of-defun-1) 698 ;; 699 ;; This is really a bit too large to be a macro but that isn't a 700 ;; problem as long as it only is used in one place in 701 ;; `c-parse-state'. 702 703 `(progn 704 (if (and ,(cc-bytecomp-fboundp 'buffer-syntactic-context-depth) 705 c-enable-xemacs-performance-kludge-p) 706 ,(when (cc-bytecomp-fboundp 'buffer-syntactic-context-depth) 707 ;; XEmacs only. This can improve the performance of 708 ;; c-parse-state to between 3 and 60 times faster when 709 ;; braces are hung. It can also degrade performance by 710 ;; about as much when braces are not hung. 711 '(let (beginning-of-defun-function end-of-defun-function 712 pos) 713 (while (not pos) 714 (save-restriction 715 (widen) 716 (setq pos (c-safe-scan-lists 717 (point) -1 (buffer-syntactic-context-depth)))) 718 (cond 719 ((bobp) (setq pos (point-min))) 720 ((not pos) 721 (let ((distance (skip-chars-backward "^{"))) 722 ;; unbalanced parenthesis, while illegal C code, 723 ;; shouldn't cause an infloop! See unbal.c 724 (when (zerop distance) 725 ;; Punt! 726 (beginning-of-defun) 727 (setq pos (point))))) 728 ((= pos 0)) 729 ((not (eq (char-after pos) ?{)) 730 (goto-char pos) 731 (setq pos nil)) 732 )) 733 (goto-char pos))) 734 ;; Emacs, which doesn't have buffer-syntactic-context-depth 735 (let (beginning-of-defun-function end-of-defun-function) 736 (beginning-of-defun))) 737 ;; if defun-prompt-regexp is non-nil, b-o-d won't leave us at the 738 ;; open brace. 739 (and defun-prompt-regexp 740 (looking-at defun-prompt-regexp) 741 (goto-char (match-end 0))))) 742 743 744;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 745;; V i r t u a l S e m i c o l o n s 746;; 747;; In most CC Mode languages, statements are terminated explicitly by 748;; semicolons or closing braces. In some of the CC modes (currently only AWK 749;; Mode (April 2004)), statements are (or can be) terminated by EOLs. Such a 750;; statement is said to be terminated by a "virtual semicolon" (VS). A 751;; statement terminated by an actual semicolon or brace is never considered to 752;; have a VS. 753;; 754;; The indentation engine (or whatever) tests for a VS at a specific position 755;; by invoking the macro `c-at-vsemi-p', which in its turn calls the mode 756;; specific function (if any) which is the value of the language variable 757;; `c-at-vsemi-p-fn'. The actual details of what constitutes a VS in a 758;; language are thus encapsulated in code specific to that language 759;; (e.g. cc-awk.el). `c-at-vsemi-p' returns non-nil if point (or the optional 760;; parameter POS) is at a VS, nil otherwise. 761;; 762;; The language specific function might well do extensive analysis of the 763;; source text, and may use a cacheing scheme to speed up repeated calls. 764;; 765;; The "virtual semicolon" lies just after the last non-ws token on the line. 766;; Like POINT, it is considered to lie between two characters. For example, 767;; at the place shown in the following AWK source line: 768;; 769;; kbyte = 1024 # 1000 if you're not picky 770;; ^ 771;; | 772;; Virtual Semicolon 773;; 774;; In addition to `c-at-vsemi-p-fn', a mode may need to supply a function for 775;; `c-vsemi-status-unknown-p-fn'. The macro `c-vsemi-status-unknown-p' is a 776;; rather recondite kludge. It exists because the function 777;; `c-beginning-of-statement-1' sometimes tests for VSs as an optimisation, 778;; but `c-at-vsemi-p' might well need to call `c-beginning-of-statement-1' in 779;; its calculations, thus potentially leading to infinite recursion. 780;; 781;; The macro `c-vsemi-status-unknown-p' resolves this problem; it may return 782;; non-nil at any time; returning nil is a guarantee that an immediate 783;; invocation of `c-at-vsemi-p' at point will NOT call 784;; `c-beginning-of-statement-1'. `c-vsemi-status-unknown-p' may not itself 785;; call `c-beginning-of-statement-1'. 786;; 787;; The macro `c-vsemi-status-unknown-p' will typically check the cacheing 788;; scheme used by the `c-at-vsemi-p-fn', hence the name - the status is 789;; "unknown" if there is no cache entry current for the line. 790;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 791 792(defmacro c-at-vsemi-p (&optional pos) 793 ;; Is there a virtual semicolon (not a real one or a }) at POS (defaults to 794 ;; point)? Always returns nil for languages which don't have Virtual 795 ;; semicolons. 796 ;; This macro might do hidden buffer changes. 797 `(if c-at-vsemi-p-fn 798 (funcall c-at-vsemi-p-fn ,@(if pos `(,pos))))) 799 800(defmacro c-vsemi-status-unknown-p () 801 ;; Return NIL only if it can be guaranteed that an immediate 802 ;; (c-at-vsemi-p) will NOT call c-beginning-of-statement-1. Otherwise, 803 ;; return non-nil. (See comments above). The function invoked by this 804 ;; macro MUST NOT UNDER ANY CIRCUMSTANCES itself call 805 ;; c-beginning-of-statement-1. 806 ;; Languages which don't have EOL terminated statements always return NIL 807 ;; (they _know_ there's no vsemi ;-). 808 `(if c-vsemi-status-unknown-p-fn (funcall c-vsemi-status-unknown-p-fn))) 809 810 811(defmacro c-benign-error (format &rest args) 812 ;; Formats an error message for the echo area and dings, i.e. like 813 ;; `error' but doesn't abort. 814 `(progn 815 (message ,format ,@args) 816 (ding))) 817 818(defmacro c-with-syntax-table (table &rest code) 819 ;; Temporarily switches to the specified syntax table in a failsafe 820 ;; way to execute code. 821 `(let ((c-with-syntax-table-orig-table (syntax-table))) 822 (unwind-protect 823 (progn 824 (set-syntax-table ,table) 825 ,@code) 826 (set-syntax-table c-with-syntax-table-orig-table)))) 827(put 'c-with-syntax-table 'lisp-indent-function 1) 828 829(defmacro c-skip-ws-forward (&optional limit) 830 "Skip over any whitespace following point. 831This function skips over horizontal and vertical whitespace and line 832continuations." 833 (if limit 834 `(let ((limit (or ,limit (point-max)))) 835 (while (progn 836 ;; skip-syntax-* doesn't count \n as whitespace.. 837 (skip-chars-forward " \t\n\r\f\v" limit) 838 (when (and (eq (char-after) ?\\) 839 (< (point) limit)) 840 (forward-char) 841 (or (eolp) 842 (progn (backward-char) nil)))))) 843 '(while (progn 844 (skip-chars-forward " \t\n\r\f\v") 845 (when (eq (char-after) ?\\) 846 (forward-char) 847 (or (eolp) 848 (progn (backward-char) nil))))))) 849 850(defmacro c-skip-ws-backward (&optional limit) 851 "Skip over any whitespace preceding point. 852This function skips over horizontal and vertical whitespace and line 853continuations." 854 (if limit 855 `(let ((limit (or ,limit (point-min)))) 856 (while (progn 857 ;; skip-syntax-* doesn't count \n as whitespace.. 858 (skip-chars-backward " \t\n\r\f\v" limit) 859 (and (eolp) 860 (eq (char-before) ?\\) 861 (> (point) limit))) 862 (backward-char))) 863 '(while (progn 864 (skip-chars-backward " \t\n\r\f\v") 865 (and (eolp) 866 (eq (char-before) ?\\))) 867 (backward-char)))) 868 869(eval-and-compile 870 (defvar c-langs-are-parametric nil)) 871 872(defmacro c-major-mode-is (mode) 873 "Return non-nil if the current CC Mode major mode is MODE. 874MODE is either a mode symbol or a list of mode symbols." 875 876 (if c-langs-are-parametric 877 ;; Inside a `c-lang-defconst'. 878 `(c-lang-major-mode-is ,mode) 879 880 (if (eq (car-safe mode) 'quote) 881 (let ((mode (eval mode))) 882 (if (listp mode) 883 `(memq c-buffer-is-cc-mode ',mode) 884 `(eq c-buffer-is-cc-mode ',mode))) 885 886 `(let ((mode ,mode)) 887 (if (listp mode) 888 (memq c-buffer-is-cc-mode mode) 889 (eq c-buffer-is-cc-mode mode)))))) 890 891 892;; Macros/functions to handle so-called "char properties", which are 893;; properties set on a single character and that never spread to any 894;; other characters. 895 896(eval-and-compile 897 ;; Constant used at compile time to decide whether or not to use 898 ;; XEmacs extents. Check all the extent functions we'll use since 899 ;; some packages might add compatibility aliases for some of them in 900 ;; Emacs. 901 (defconst c-use-extents (and (cc-bytecomp-fboundp 'extent-at) 902 (cc-bytecomp-fboundp 'set-extent-property) 903 (cc-bytecomp-fboundp 'set-extent-properties) 904 (cc-bytecomp-fboundp 'make-extent) 905 (cc-bytecomp-fboundp 'extent-property) 906 (cc-bytecomp-fboundp 'delete-extent) 907 (cc-bytecomp-fboundp 'map-extents)))) 908 909;; `c-put-char-property' is complex enough in XEmacs and Emacs < 21 to 910;; make it a function. 911(defalias 'c-put-char-property-fun 912 (cc-eval-when-compile 913 (cond (c-use-extents 914 ;; XEmacs. 915 (byte-compile 916 (lambda (pos property value) 917 (let ((ext (extent-at pos nil property))) 918 (if ext 919 (set-extent-property ext property value) 920 (set-extent-properties (make-extent pos (1+ pos)) 921 (cons property 922 (cons value 923 '(start-open t 924 end-open t))))))))) 925 926 ((not (cc-bytecomp-boundp 'text-property-default-nonsticky)) 927 ;; In Emacs < 21 we have to mess with the `rear-nonsticky' property. 928 (byte-compile 929 (lambda (pos property value) 930 (put-text-property pos (1+ pos) property value) 931 (let ((prop (get-text-property pos 'rear-nonsticky))) 932 (or (memq property prop) 933 (put-text-property pos (1+ pos) 934 'rear-nonsticky 935 (cons property prop)))))))))) 936(cc-bytecomp-defun c-put-char-property-fun) ; Make it known below. 937 938(defmacro c-put-char-property (pos property value) 939 ;; Put the given property with the given value on the character at 940 ;; POS and make it front and rear nonsticky, or start and end open 941 ;; in XEmacs vocabulary. If the character already has the given 942 ;; property then the value is replaced, and the behavior is 943 ;; undefined if that property has been put by some other function. 944 ;; PROPERTY is assumed to be constant. 945 ;; 946 ;; If there's a `text-property-default-nonsticky' variable (Emacs 947 ;; 21) then it's assumed that the property is present on it. 948 ;; 949 ;; This macro does a hidden buffer change. 950 (setq property (eval property)) 951 (if (or c-use-extents 952 (not (cc-bytecomp-boundp 'text-property-default-nonsticky))) 953 ;; XEmacs and Emacs < 21. 954 `(c-put-char-property-fun ,pos ',property ,value) 955 ;; In Emacs 21 we got the `rear-nonsticky' property covered 956 ;; by `text-property-default-nonsticky'. 957 `(let ((-pos- ,pos)) 958 (put-text-property -pos- (1+ -pos-) ',property ,value)))) 959 960(defmacro c-get-char-property (pos property) 961 ;; Get the value of the given property on the character at POS if 962 ;; it's been put there by `c-put-char-property'. PROPERTY is 963 ;; assumed to be constant. 964 (setq property (eval property)) 965 (if c-use-extents 966 ;; XEmacs. 967 `(let ((ext (extent-at ,pos nil ',property))) 968 (if ext (extent-property ext ',property))) 969 ;; Emacs. 970 `(get-text-property ,pos ',property))) 971 972;; `c-clear-char-property' is complex enough in Emacs < 21 to make it 973;; a function, since we have to mess with the `rear-nonsticky' property. 974(defalias 'c-clear-char-property-fun 975 (cc-eval-when-compile 976 (unless (or c-use-extents 977 (cc-bytecomp-boundp 'text-property-default-nonsticky)) 978 (byte-compile 979 (lambda (pos property) 980 (when (get-text-property pos property) 981 (remove-text-properties pos (1+ pos) (list property nil)) 982 (put-text-property pos (1+ pos) 983 'rear-nonsticky 984 (delq property (get-text-property 985 pos 'rear-nonsticky))))))))) 986(cc-bytecomp-defun c-clear-char-property-fun) ; Make it known below. 987 988(defmacro c-clear-char-property (pos property) 989 ;; Remove the given property on the character at POS if it's been put 990 ;; there by `c-put-char-property'. PROPERTY is assumed to be 991 ;; constant. 992 ;; 993 ;; This macro does a hidden buffer change. 994 (setq property (eval property)) 995 (cond (c-use-extents 996 ;; XEmacs. 997 `(let ((ext (extent-at ,pos nil ',property))) 998 (if ext (delete-extent ext)))) 999 ((cc-bytecomp-boundp 'text-property-default-nonsticky) 1000 ;; In Emacs 21 we got the `rear-nonsticky' property covered 1001 ;; by `text-property-default-nonsticky'. 1002 `(let ((pos ,pos)) 1003 (remove-text-properties pos (1+ pos) 1004 '(,property nil)))) 1005 (t 1006 ;; Emacs < 21. 1007 `(c-clear-char-property-fun ,pos ',property)))) 1008 1009(defmacro c-clear-char-properties (from to property) 1010 ;; Remove all the occurences of the given property in the given 1011 ;; region that has been put with `c-put-char-property'. PROPERTY is 1012 ;; assumed to be constant. 1013 ;; 1014 ;; Note that this function does not clean up the property from the 1015 ;; lists of the `rear-nonsticky' properties in the region, if such 1016 ;; are used. Thus it should not be used for common properties like 1017 ;; `syntax-table'. 1018 ;; 1019 ;; This macro does hidden buffer changes. 1020 (setq property (eval property)) 1021 (if c-use-extents 1022 ;; XEmacs. 1023 `(map-extents (lambda (ext ignored) 1024 (delete-extent ext)) 1025 nil ,from ,to nil nil ',property) 1026 ;; Emacs. 1027 `(remove-text-properties ,from ,to '(,property nil)))) 1028 1029 1030;; Macros to put overlays (Emacs) or extents (XEmacs) on buffer text. 1031;; For our purposes, these are characterized by being possible to 1032;; remove again without affecting the other text properties in the 1033;; buffer that got overridden when they were put. 1034 1035(defmacro c-put-overlay (from to property value) 1036 ;; Put an overlay/extent covering the given range in the current 1037 ;; buffer. It's currently undefined whether it's front/end sticky 1038 ;; or not. The overlay/extent object is returned. 1039 (if (cc-bytecomp-fboundp 'make-overlay) 1040 ;; Emacs. 1041 `(let ((ol (make-overlay ,from ,to))) 1042 (overlay-put ol ,property ,value) 1043 ol) 1044 ;; XEmacs. 1045 `(let ((ext (make-extent ,from ,to))) 1046 (set-extent-property ext ,property ,value) 1047 ext))) 1048 1049(defmacro c-delete-overlay (overlay) 1050 ;; Deletes an overlay/extent object previously retrieved using 1051 ;; `c-put-overlay'. 1052 (if (cc-bytecomp-fboundp 'make-overlay) 1053 ;; Emacs. 1054 `(delete-overlay ,overlay) 1055 ;; XEmacs. 1056 `(delete-extent ,overlay))) 1057 1058 1059;; Make edebug understand the macros. 1060;(eval-after-load "edebug" ; 2006-07-09: def-edebug-spec is now in subr.el. 1061; '(progn 1062(def-edebug-spec cc-eval-when-compile t) 1063(def-edebug-spec c-point t) 1064(def-edebug-spec c-set-region-active t) 1065(def-edebug-spec c-safe t) 1066(def-edebug-spec c-save-buffer-state let*) 1067(def-edebug-spec c-tentative-buffer-changes t) 1068(def-edebug-spec c-forward-syntactic-ws t) 1069(def-edebug-spec c-backward-syntactic-ws t) 1070(def-edebug-spec c-forward-sexp t) 1071(def-edebug-spec c-backward-sexp t) 1072(def-edebug-spec c-up-list-forward t) 1073(def-edebug-spec c-up-list-backward t) 1074(def-edebug-spec c-down-list-forward t) 1075(def-edebug-spec c-down-list-backward t) 1076(def-edebug-spec c-add-syntax t) 1077(def-edebug-spec c-add-class-syntax t) 1078(def-edebug-spec c-benign-error t) 1079(def-edebug-spec c-with-syntax-table t) 1080(def-edebug-spec c-skip-ws-forward t) 1081(def-edebug-spec c-skip-ws-backward t) 1082(def-edebug-spec c-major-mode-is t) 1083(def-edebug-spec c-put-char-property t) 1084(def-edebug-spec c-get-char-property t) 1085(def-edebug-spec c-clear-char-property t) 1086(def-edebug-spec c-clear-char-properties t) 1087(def-edebug-spec c-put-overlay t) 1088(def-edebug-spec c-delete-overlay t) ;)) 1089 1090 1091;;; Functions. 1092 1093;; Note: All these after the macros, to be on safe side in avoiding 1094;; bugs where macros are defined too late. These bugs often only show 1095;; when the files are compiled in a certain order within the same 1096;; session. 1097 1098(defsubst c-end-of-defun-1 () 1099 ;; Replacement for end-of-defun that use c-beginning-of-defun-1. 1100 (let ((start (point))) 1101 ;; Skip forward into the next defun block. Don't bother to avoid 1102 ;; comments, literals etc, since beginning-of-defun doesn't do that 1103 ;; anyway. 1104 (skip-chars-forward "^}") 1105 (c-beginning-of-defun-1) 1106 (if (eq (char-after) ?{) 1107 (c-forward-sexp)) 1108 (if (< (point) start) 1109 (goto-char (point-max))))) 1110 1111(defconst c-<-as-paren-syntax '(4 . ?>)) 1112 1113(defsubst c-mark-<-as-paren (pos) 1114 ;; Mark the "<" character at POS as an sexp list opener using the 1115 ;; syntax-table property. 1116 ;; 1117 ;; This function does a hidden buffer change. 1118 (c-put-char-property pos 'syntax-table c-<-as-paren-syntax)) 1119 1120(defconst c->-as-paren-syntax '(5 . ?<)) 1121 1122(defsubst c-mark->-as-paren (pos) 1123 ;; Mark the ">" character at POS as an sexp list closer using the 1124 ;; syntax-table property. 1125 ;; 1126 ;; This function does a hidden buffer change. 1127 (c-put-char-property pos 'syntax-table c->-as-paren-syntax)) 1128 1129(defsubst c-intersect-lists (list alist) 1130 ;; return the element of ALIST that matches the first element found 1131 ;; in LIST. Uses assq. 1132 (let (match) 1133 (while (and list 1134 (not (setq match (assq (car list) alist)))) 1135 (setq list (cdr list))) 1136 match)) 1137 1138(defsubst c-lookup-lists (list alist1 alist2) 1139 ;; first, find the first entry from LIST that is present in ALIST1, 1140 ;; then find the entry in ALIST2 for that entry. 1141 (assq (car (c-intersect-lists list alist1)) alist2)) 1142 1143(defsubst c-langelem-sym (langelem) 1144 "Return the syntactic symbol in LANGELEM. 1145 1146LANGELEM is either a cons cell on the \"old\" form given as the first 1147argument to lineup functions or a syntactic element on the \"new\" 1148form as used in `c-syntactic-element'." 1149 (car langelem)) 1150 1151(defsubst c-langelem-pos (langelem) 1152 "Return the anchor position in LANGELEM, or nil if there is none. 1153 1154LANGELEM is either a cons cell on the \"old\" form given as the first 1155argument to lineup functions or a syntactic element on the \"new\" 1156form as used in `c-syntactic-element'." 1157 (if (consp (cdr langelem)) 1158 (car-safe (cdr langelem)) 1159 (cdr langelem))) 1160 1161(defun c-langelem-col (langelem &optional preserve-point) 1162 "Return the column of the anchor position in LANGELEM. 1163Also move the point to that position unless PRESERVE-POINT is non-nil. 1164 1165LANGELEM is either a cons cell on the \"old\" form given as the first 1166argument to lineup functions or a syntactic element on the \"new\" 1167form as used in `c-syntactic-element'." 1168 (let ((pos (c-langelem-pos langelem)) 1169 (here (point))) 1170 (if pos 1171 (progn 1172 (goto-char pos) 1173 (prog1 (current-column) 1174 (if preserve-point 1175 (goto-char here)))) 1176 0))) 1177 1178(defsubst c-langelem-2nd-pos (langelem) 1179 "Return the secondary position in LANGELEM, or nil if there is none. 1180 1181LANGELEM is typically a syntactic element on the \"new\" form as used 1182in `c-syntactic-element'. It may also be a cons cell as passed in the 1183first argument to lineup functions, but then the returned value always 1184will be nil." 1185 (car-safe (cdr-safe (cdr-safe langelem)))) 1186 1187(defsubst c-keep-region-active () 1188 ;; Do whatever is necessary to keep the region active in XEmacs. 1189 ;; This is not needed for Emacs. 1190 (and (boundp 'zmacs-region-stays) 1191 (setq zmacs-region-stays t))) 1192 1193(put 'c-mode 'c-mode-prefix "c-") 1194(put 'c++-mode 'c-mode-prefix "c++-") 1195(put 'objc-mode 'c-mode-prefix "objc-") 1196(put 'java-mode 'c-mode-prefix "java-") 1197(put 'idl-mode 'c-mode-prefix "idl-") 1198(put 'pike-mode 'c-mode-prefix "pike-") 1199(put 'awk-mode 'c-mode-prefix "awk-") 1200 1201(defsubst c-mode-symbol (suffix) 1202 "Prefix the current mode prefix (e.g. \"c-\") to SUFFIX and return 1203the corresponding symbol." 1204 (or c-buffer-is-cc-mode 1205 (error "Not inside a CC Mode based mode")) 1206 (let ((mode-prefix (get c-buffer-is-cc-mode 'c-mode-prefix))) 1207 (or mode-prefix 1208 (error "%S has no mode prefix known to `c-mode-symbol'" 1209 c-buffer-is-cc-mode)) 1210 (intern (concat mode-prefix suffix)))) 1211 1212(defsubst c-mode-var (suffix) 1213 "Prefix the current mode prefix (e.g. \"c-\") to SUFFIX and return 1214the value of the variable with that name." 1215 (symbol-value (c-mode-symbol suffix))) 1216 1217(defsubst c-got-face-at (pos faces) 1218 "Return non-nil if position POS in the current buffer has any of the 1219faces in the list FACES." 1220 (let ((pos-faces (get-text-property pos 'face))) 1221 (if (consp pos-faces) 1222 (progn 1223 (while (and pos-faces 1224 (not (memq (car pos-faces) faces))) 1225 (setq pos-faces (cdr pos-faces))) 1226 pos-faces) 1227 (memq pos-faces faces)))) 1228 1229(defsubst c-face-name-p (facename) 1230 ;; Return t if FACENAME is the name of a face. This method is 1231 ;; necessary since facep in XEmacs only returns t for the actual 1232 ;; face objects (while it's only their names that are used just 1233 ;; about anywhere else) without providing a predicate that tests 1234 ;; face names. 1235 (memq facename (face-list))) 1236 1237(defun c-concat-separated (list separator) 1238 "Like `concat' on LIST, but separate each element with SEPARATOR. 1239Notably, null elements in LIST are ignored." 1240 (mapconcat 'identity (delete nil (append list nil)) separator)) 1241 1242(defun c-make-keywords-re (adorn list &optional mode) 1243 "Make a regexp that matches all the strings the list. 1244Duplicates and nil elements in the list are removed. The resulting 1245regexp may contain zero or more submatch expressions. 1246 1247If ADORN is t there will be at least one submatch and the first 1248surrounds the matched alternative, and the regexp will also not match 1249a prefix of any identifier. Adorned regexps cannot be appended. The 1250language variable `c-nonsymbol-key' is used to make the adornment. 1251 1252A value 'appendable for ADORN is like above, but all alternatives in 1253the list that end with a word constituent char will have \\> appended 1254instead, so that the regexp remains appendable. Note that this 1255variant doesn't always guarantee that an identifier prefix isn't 1256matched since the symbol constituent '_' is normally considered a 1257nonword token by \\>. 1258 1259The optional MODE specifies the language to get `c-nonsymbol-key' from 1260when it's needed. The default is the current language taken from 1261`c-buffer-is-cc-mode'." 1262 1263 (let (unique) 1264 (dolist (elt list) 1265 (unless (member elt unique) 1266 (push elt unique))) 1267 (setq list (delete nil unique))) 1268 (if list 1269 (let (re) 1270 1271 (if (eq adorn 'appendable) 1272 ;; This is kludgy but it works: Search for a string that 1273 ;; doesn't occur in any word in LIST. Append it to all 1274 ;; the alternatives where we want to add \>. Run through 1275 ;; `regexp-opt' and then replace it with \>. 1276 (let ((unique "") pos) 1277 (while (let (found) 1278 (setq unique (concat unique "@") 1279 pos list) 1280 (while (and pos 1281 (if (string-match unique (car pos)) 1282 (progn (setq found t) 1283 nil) 1284 t)) 1285 (setq pos (cdr pos))) 1286 found)) 1287 (setq pos list) 1288 (while pos 1289 (if (string-match "\\w\\'" (car pos)) 1290 (setcar pos (concat (car pos) unique))) 1291 (setq pos (cdr pos))) 1292 (setq re (regexp-opt list)) 1293 (setq pos 0) 1294 (while (string-match unique re pos) 1295 (setq pos (+ (match-beginning 0) 2) 1296 re (replace-match "\\>" t t re)))) 1297 1298 (setq re (regexp-opt list))) 1299 1300 ;; Emacs 20 and XEmacs (all versions so far) has a buggy 1301 ;; regexp-opt that doesn't always cope with strings containing 1302 ;; newlines. This kludge doesn't handle shy parens correctly 1303 ;; so we can't advice regexp-opt directly with it. 1304 (let (fail-list) 1305 (while list 1306 (and (string-match "\n" (car list)) ; To speed it up a little. 1307 (not (string-match (concat "\\`\\(" re "\\)\\'") 1308 (car list))) 1309 (setq fail-list (cons (car list) fail-list))) 1310 (setq list (cdr list))) 1311 (when fail-list 1312 (setq re (concat re 1313 "\\|" 1314 (mapconcat 1315 (if (eq adorn 'appendable) 1316 (lambda (str) 1317 (if (string-match "\\w\\'" str) 1318 (concat (regexp-quote str) 1319 "\\>") 1320 (regexp-quote str))) 1321 'regexp-quote) 1322 (sort fail-list 1323 (lambda (a b) 1324 (> (length a) (length b)))) 1325 "\\|"))))) 1326 1327 ;; Add our own grouping parenthesis around re instead of 1328 ;; passing adorn to `regexp-opt', since in XEmacs it makes the 1329 ;; top level grouping "shy". 1330 (cond ((eq adorn 'appendable) 1331 (concat "\\(" re "\\)")) 1332 (adorn 1333 (concat "\\(" re "\\)" 1334 "\\(" 1335 (c-get-lang-constant 'c-nonsymbol-key nil mode) 1336 "\\|$\\)")) 1337 (t 1338 re))) 1339 1340 ;; Produce a regexp that matches nothing. 1341 (if adorn 1342 "\\(\\<\\>\\)" 1343 "\\<\\>"))) 1344 1345(put 'c-make-keywords-re 'lisp-indent-function 1) 1346 1347(defun c-make-bare-char-alt (chars &optional inverted) 1348 "Make a character alternative string from the list of characters CHARS. 1349The returned string is of the type that can be used with 1350`skip-chars-forward' and `skip-chars-backward'. If INVERTED is 1351non-nil, a caret is prepended to invert the set." 1352 ;; This function ought to be in the elisp core somewhere. 1353 (let ((str (if inverted "^" "")) char char2) 1354 (setq chars (sort (append chars nil) `<)) 1355 (while chars 1356 (setq char (pop chars)) 1357 (if (memq char '(?\\ ?^ ?-)) 1358 ;; Quoting necessary (this method only works in the skip 1359 ;; functions). 1360 (setq str (format "%s\\%c" str char)) 1361 (setq str (format "%s%c" str char))) 1362 ;; Check for range. 1363 (setq char2 char) 1364 (while (and chars (>= (1+ char2) (car chars))) 1365 (setq char2 (pop chars))) 1366 (unless (= char char2) 1367 (if (< (1+ char) char2) 1368 (setq str (format "%s-%c" str char2)) 1369 (push char2 chars)))) 1370 str)) 1371 1372;; Leftovers from (X)Emacs 19 compatibility. 1373(defalias 'c-regexp-opt 'regexp-opt) 1374(defalias 'c-regexp-opt-depth 'regexp-opt-depth) 1375 1376 1377;; Figure out what features this Emacs has 1378 1379(cc-bytecomp-defvar open-paren-in-column-0-is-defun-start) 1380 1381(defconst c-emacs-features 1382 (let (list) 1383 1384 (if (boundp 'infodock-version) 1385 ;; I've no idea what this actually is, but it's legacy. /mast 1386 (setq list (cons 'infodock list))) 1387 1388 ;; XEmacs uses 8-bit modify-syntax-entry flags. 1389 ;; Emacs uses a 1-bit flag. We will have to set up our 1390 ;; syntax tables differently to handle this. 1391 (let ((table (copy-syntax-table)) 1392 entry) 1393 (modify-syntax-entry ?a ". 12345678" table) 1394 (cond 1395 ;; Emacs 1396 ((arrayp table) 1397 (setq entry (aref table ?a)) 1398 ;; In Emacs, table entries are cons cells 1399 (if (consp entry) (setq entry (car entry)))) 1400 ;; XEmacs 1401 ((fboundp 'get-char-table) 1402 (setq entry (get-char-table ?a table))) 1403 ;; incompatible 1404 (t (error "CC Mode is incompatible with this version of Emacs"))) 1405 (setq list (cons (if (= (logand (lsh entry -16) 255) 255) 1406 '8-bit 1407 '1-bit) 1408 list))) 1409 1410 (let ((buf (generate-new-buffer " test")) 1411 parse-sexp-lookup-properties 1412 parse-sexp-ignore-comments 1413 lookup-syntax-properties) 1414 (save-excursion 1415 (set-buffer buf) 1416 (set-syntax-table (make-syntax-table)) 1417 1418 ;; For some reason we have to set some of these after the 1419 ;; buffer has been made current. (Specifically, 1420 ;; `parse-sexp-ignore-comments' in Emacs 21.) 1421 (setq parse-sexp-lookup-properties t 1422 parse-sexp-ignore-comments t 1423 lookup-syntax-properties t) 1424 1425 ;; Find out if the `syntax-table' text property works. 1426 (modify-syntax-entry ?< ".") 1427 (modify-syntax-entry ?> ".") 1428 (insert "<()>") 1429 (c-mark-<-as-paren (point-min)) 1430 (c-mark->-as-paren (+ 3 (point-min))) 1431 (goto-char (point-min)) 1432 (c-forward-sexp) 1433 (if (= (point) (+ 4 (point-min))) 1434 (setq list (cons 'syntax-properties list)) 1435 (error (concat 1436 "CC Mode is incompatible with this version of Emacs - " 1437 "support for the `syntax-table' text property " 1438 "is required."))) 1439 1440 ;; Find out if generic comment delimiters work. 1441 (c-safe 1442 (modify-syntax-entry ?x "!") 1443 (if (string-match "\\s!" "x") 1444 (setq list (cons 'gen-comment-delim list)))) 1445 1446 ;; Find out if generic string delimiters work. 1447 (c-safe 1448 (modify-syntax-entry ?x "|") 1449 (if (string-match "\\s|" "x") 1450 (setq list (cons 'gen-string-delim list)))) 1451 1452 ;; See if POSIX char classes work. 1453 (when (and (string-match "[[:alpha:]]" "a") 1454 ;; All versions of Emacs 21 so far haven't fixed 1455 ;; char classes in `skip-chars-forward' and 1456 ;; `skip-chars-backward'. 1457 (progn 1458 (delete-region (point-min) (point-max)) 1459 (insert "foo123") 1460 (skip-chars-backward "[:alnum:]") 1461 (bobp)) 1462 (= (skip-chars-forward "[:alpha:]") 3)) 1463 (setq list (cons 'posix-char-classes list))) 1464 1465 ;; See if `open-paren-in-column-0-is-defun-start' exists and 1466 ;; isn't buggy (Emacs >= 21.4). 1467 (when (boundp 'open-paren-in-column-0-is-defun-start) 1468 (let ((open-paren-in-column-0-is-defun-start nil) 1469 (parse-sexp-ignore-comments t)) 1470 (delete-region (point-min) (point-max)) 1471 (set-syntax-table (make-syntax-table)) 1472 (modify-syntax-entry ?\' "\"") 1473 (cond 1474 ;; XEmacs. Afaik this is currently an Emacs-only 1475 ;; feature, but it's good to be prepared. 1476 ((memq '8-bit list) 1477 (modify-syntax-entry ?/ ". 1456") 1478 (modify-syntax-entry ?* ". 23")) 1479 ;; Emacs 1480 ((memq '1-bit list) 1481 (modify-syntax-entry ?/ ". 124b") 1482 (modify-syntax-entry ?* ". 23"))) 1483 (modify-syntax-entry ?\n "> b") 1484 (insert "/* '\n () */") 1485 (backward-sexp) 1486 (if (bobp) 1487 (setq list (cons 'col-0-paren list))))) 1488 1489 (set-buffer-modified-p nil)) 1490 (kill-buffer buf)) 1491 1492 ;; See if `parse-partial-sexp' returns the eighth element. 1493 (if (c-safe (>= (length (save-excursion (parse-partial-sexp (point) (point)))) 1494 10)) 1495 (setq list (cons 'pps-extended-state list)) 1496 (error (concat 1497 "CC Mode is incompatible with this version of Emacs - " 1498 "`parse-partial-sexp' has to return at least 10 elements."))) 1499 1500 ;;(message "c-emacs-features: %S" list) 1501 list) 1502 "A list of certain features in the (X)Emacs you are using. 1503There are many flavors of Emacs out there, each with different 1504features supporting those needed by CC Mode. The following values 1505might be present: 1506 1507'8-bit 8 bit syntax entry flags (XEmacs style). 1508'1-bit 1 bit syntax entry flags (Emacs style). 1509'syntax-properties It works to override the syntax for specific characters 1510 in the buffer with the 'syntax-table property. It's 1511 always set - CC Mode no longer works in emacsen without 1512 this feature. 1513'gen-comment-delim Generic comment delimiters work 1514 (i.e. the syntax class `!'). 1515'gen-string-delim Generic string delimiters work 1516 (i.e. the syntax class `|'). 1517'pps-extended-state `parse-partial-sexp' returns a list with at least 10 1518 elements, i.e. it contains the position of the start of 1519 the last comment or string. It's always set - CC Mode 1520 no longer works in emacsen without this feature. 1521'posix-char-classes The regexp engine understands POSIX character classes. 1522'col-0-paren It's possible to turn off the ad-hoc rule that a paren 1523 in column zero is the start of a defun. 1524'infodock This is Infodock (based on XEmacs). 1525 1526'8-bit and '1-bit are mutually exclusive.") 1527 1528 1529;;; Some helper constants. 1530 1531;; If the regexp engine supports POSIX char classes then we can use 1532;; them to handle extended charsets correctly. 1533(if (memq 'posix-char-classes c-emacs-features) 1534 (progn 1535 (defconst c-alpha "[:alpha:]") 1536 (defconst c-alnum "[:alnum:]") 1537 (defconst c-digit "[:digit:]") 1538 (defconst c-upper "[:upper:]") 1539 (defconst c-lower "[:lower:]")) 1540 (defconst c-alpha "a-zA-Z") 1541 (defconst c-alnum "a-zA-Z0-9") 1542 (defconst c-digit "0-9") 1543 (defconst c-upper "A-Z") 1544 (defconst c-lower "a-z")) 1545 1546 1547;;; System for handling language dependent constants. 1548 1549;; This is used to set various language dependent data in a flexible 1550;; way: Language constants can be built from the values of other 1551;; language constants, also those for other languages. They can also 1552;; process the values of other language constants uniformly across all 1553;; the languages. E.g. one language constant can list all the type 1554;; keywords in each language, and another can build a regexp for each 1555;; language from those lists without code duplication. 1556;; 1557;; Language constants are defined with `c-lang-defconst', and their 1558;; value forms (referred to as source definitions) are evaluated only 1559;; on demand when requested for a particular language with 1560;; `c-lang-const'. It's therefore possible to refer to the values of 1561;; constants defined later in the file, or in another file, just as 1562;; long as all the relevant `c-lang-defconst' have been loaded when 1563;; `c-lang-const' is actually evaluated from somewhere else. 1564;; 1565;; `c-lang-const' forms are also evaluated at compile time and 1566;; replaced with the values they produce. Thus there's no overhead 1567;; for this system when compiled code is used - only the values 1568;; actually used in the code are present, and the file(s) containing 1569;; the `c-lang-defconst' forms don't need to be loaded at all then. 1570;; There are however safeguards to make sure that they can be loaded 1571;; to get the source definitions for the values if there's a mismatch 1572;; in compiled versions, or if `c-lang-const' is used uncompiled. 1573;; 1574;; Note that the source definitions in a `c-lang-defconst' form are 1575;; compiled into the .elc file where it stands; there's no need to 1576;; load the source file to get it. 1577;; 1578;; See cc-langs.el for more details about how this system is deployed 1579;; in CC Mode, and how the associated language variable system 1580;; (`c-lang-defvar') works. That file also contains a lot of 1581;; examples. 1582 1583(defun c-add-language (mode base-mode) 1584 "Declare a new language in the language dependent variable system. 1585This is intended to be used by modes that inherit CC Mode to add new 1586languages. It should be used at the top level before any calls to 1587`c-lang-defconst'. MODE is the mode name symbol for the new language, 1588and BASE-MODE is the mode name symbol for the language in CC Mode that 1589is to be the template for the new mode. 1590 1591The exact effect of BASE-MODE is to make all language constants that 1592haven't got a setting in the new language fall back to their values in 1593BASE-MODE. It does not have any effect outside the language constant 1594system." 1595 (unless (string-match "\\`\\(.*-\\)mode\\'" (symbol-name mode)) 1596 (error "The mode name symbol `%s' must end with \"-mode\"" mode)) 1597 (put mode 'c-mode-prefix (match-string 1 (symbol-name mode))) 1598 (unless (get base-mode 'c-mode-prefix) 1599 (error "Unknown base mode `%s'" base-mode)) 1600 (put mode 'c-fallback-mode base-mode)) 1601 1602(defvar c-lang-constants (make-vector 151 0)) 1603;; This obarray is a cache to keep track of the language constants 1604;; defined by `c-lang-defconst' and the evaluated values returned by 1605;; `c-lang-const'. It's mostly used at compile time but it's not 1606;; stored in compiled files. 1607;; 1608;; The obarray contains all the language constants as symbols. The 1609;; value cells hold the evaluated values as alists where each car is 1610;; the mode name symbol and the corresponding cdr is the evaluated 1611;; value in that mode. The property lists hold the source definitions 1612;; and other miscellaneous data. The obarray might also contain 1613;; various other symbols, but those don't have any variable bindings. 1614 1615(defvar c-lang-const-expansion nil) 1616 1617(defsubst c-get-current-file () 1618 ;; Return the base name of the current file. 1619 (let ((file (cond 1620 (load-in-progress 1621 ;; Being loaded. 1622 load-file-name) 1623 ((and (boundp 'byte-compile-dest-file) 1624 (stringp byte-compile-dest-file)) 1625 ;; Being compiled. 1626 byte-compile-dest-file) 1627 (t 1628 ;; Being evaluated interactively. 1629 (buffer-file-name))))) 1630 (and file 1631 (file-name-sans-extension 1632 (file-name-nondirectory file))))) 1633 1634(defmacro c-lang-defconst-eval-immediately (form) 1635 "Can be used inside a VAL in `c-lang-defconst' to evaluate FORM 1636immediately, i.e. at the same time as the `c-lang-defconst' form 1637itself is evaluated." 1638 ;; Evaluate at macro expansion time, i.e. in the 1639 ;; `cl-macroexpand-all' inside `c-lang-defconst'. 1640 (eval form)) 1641 1642(defmacro c-lang-defconst (name &rest args) 1643 "Set the language specific values of the language constant NAME. 1644The second argument can optionally be a docstring. The rest of the 1645arguments are one or more repetitions of LANG VAL where LANG specifies 1646the language(s) that VAL applies to. LANG is the name of the 1647language, i.e. the mode name without the \"-mode\" suffix, or a list 1648of such language names, or `t' for all languages. VAL is a form to 1649evaluate to get the value. 1650 1651If LANG isn't `t' or one of the core languages in CC Mode, it must 1652have been declared with `c-add-language'. 1653 1654Neither NAME, LANG nor VAL are evaluated directly - they should not be 1655quoted. `c-lang-defconst-eval-immediately' can however be used inside 1656VAL to evaluate parts of it directly. 1657 1658When VAL is evaluated for some language, that language is temporarily 1659made current so that `c-lang-const' without an explicit language can 1660be used inside VAL to refer to the value of a language constant in the 1661same language. That is particularly useful if LANG is `t'. 1662 1663VAL is not evaluated right away but rather when the value is requested 1664with `c-lang-const'. Thus it's possible to use `c-lang-const' inside 1665VAL to refer to language constants that haven't been defined yet. 1666However, if the definition of a language constant is in another file 1667then that file must be loaded \(at compile time) before it's safe to 1668reference the constant. 1669 1670The assignments in ARGS are processed in sequence like `setq', so 1671\(c-lang-const NAME) may be used inside a VAL to refer to the last 1672assigned value to this language constant, or a value that it has 1673gotten in another earlier loaded file. 1674 1675To work well with repeated loads and interactive reevaluation, only 1676one `c-lang-defconst' for each NAME is permitted per file. If there 1677already is one it will be completely replaced; the value in the 1678earlier definition will not affect `c-lang-const' on the same 1679constant. A file is identified by its base name." 1680 1681 (let* ((sym (intern (symbol-name name) c-lang-constants)) 1682 ;; Make `c-lang-const' expand to a straightforward call to 1683 ;; `c-get-lang-constant' in `cl-macroexpand-all' below. 1684 ;; 1685 ;; (The default behavior, i.e. to expand to a call inside 1686 ;; `eval-when-compile' should be equivalent, since that macro 1687 ;; should only expand to its content if it's used inside a 1688 ;; form that's already evaluated at compile time. It's 1689 ;; however necessary to use our cover macro 1690 ;; `cc-eval-when-compile' due to bugs in `eval-when-compile', 1691 ;; and it expands to a bulkier form that in this case only is 1692 ;; unnecessary garbage that we don't want to store in the 1693 ;; language constant source definitions.) 1694 (c-lang-const-expansion 'call) 1695 (c-langs-are-parametric t) 1696 bindings 1697 pre-files) 1698 1699 (or (symbolp name) 1700 (error "Not a symbol: %s" name)) 1701 1702 (when (stringp (car-safe args)) 1703 ;; The docstring is hardly used anywhere since there's no normal 1704 ;; symbol to attach it to. It's primarily for getting the right 1705 ;; format in the source. 1706 (put sym 'variable-documentation (car args)) 1707 (setq args (cdr args))) 1708 1709 (or args 1710 (error "No assignments in `c-lang-defconst' for %s" name)) 1711 1712 ;; Rework ARGS to an association list to make it easier to handle. 1713 ;; It's reversed at the same time to make it easier to implement 1714 ;; the demand-driven (i.e. reversed) evaluation in `c-lang-const'. 1715 (while args 1716 (let ((assigned-mode 1717 (cond ((eq (car args) t) t) 1718 ((symbolp (car args)) 1719 (list (intern (concat (symbol-name (car args)) 1720 "-mode")))) 1721 ((listp (car args)) 1722 (mapcar (lambda (lang) 1723 (or (symbolp lang) 1724 (error "Not a list of symbols: %s" 1725 (car args))) 1726 (intern (concat (symbol-name lang) 1727 "-mode"))) 1728 (car args))) 1729 (t (error "Not a symbol or a list of symbols: %s" 1730 (car args))))) 1731 val) 1732 1733 (or (cdr args) 1734 (error "No value for %s" (car args))) 1735 (setq args (cdr args) 1736 val (car args)) 1737 1738 ;; Emacs has a weird bug where it seems to fail to read 1739 ;; backquote lists from byte compiled files correctly (,@ 1740 ;; forms, to be specific), so make sure the bindings in the 1741 ;; expansion below don't contain any backquote stuff. 1742 ;; (XEmacs handles it correctly and doesn't need this for that 1743 ;; reason, but we also use this expansion handle 1744 ;; `c-lang-defconst-eval-immediately' and to register 1745 ;; dependencies on the `c-lang-const's in VAL.) 1746 (setq val (cl-macroexpand-all val)) 1747 1748 (setq bindings (cons (cons assigned-mode val) bindings) 1749 args (cdr args)))) 1750 1751 ;; Compile in the other files that have provided source 1752 ;; definitions for this symbol, to make sure the order in the 1753 ;; `source' property is correct even when files are loaded out of 1754 ;; order. 1755 (setq pre-files (nreverse 1756 ;; Reverse to get the right load order. 1757 (mapcar 'car (get sym 'source)))) 1758 1759 `(eval-and-compile 1760 (c-define-lang-constant ',name ',bindings 1761 ,@(and pre-files `(',pre-files)))))) 1762 1763(put 'c-lang-defconst 'lisp-indent-function 1) 1764;(eval-after-load "edebug" ; 2006-07-09: def-edebug-spec is now in subr.el. 1765; ' 1766(def-edebug-spec c-lang-defconst 1767 (&define name [&optional stringp] [&rest sexp def-form])) 1768 1769(defun c-define-lang-constant (name bindings &optional pre-files) 1770 ;; Used by `c-lang-defconst'. 1771 1772 (let* ((sym (intern (symbol-name name) c-lang-constants)) 1773 (source (get sym 'source)) 1774 (file (intern 1775 (or (c-get-current-file) 1776 (error "`c-lang-defconst' must be used in a file")))) 1777 (elem (assq file source))) 1778 1779 ;;(when (cdr-safe elem) 1780 ;; (message "Language constant %s redefined in %S" name file)) 1781 1782 ;; Note that the order in the source alist is relevant. Like how 1783 ;; `c-lang-defconst' reverses the bindings, this reverses the 1784 ;; order between files so that the last to evaluate comes first. 1785 (unless elem 1786 (while pre-files 1787 (unless (assq (car pre-files) source) 1788 (setq source (cons (list (car pre-files)) source))) 1789 (setq pre-files (cdr pre-files))) 1790 (put sym 'source (cons (setq elem (list file)) source))) 1791 1792 (setcdr elem bindings) 1793 1794 ;; Bind the symbol as a variable, or clear any earlier evaluated 1795 ;; value it has. 1796 (set sym nil) 1797 1798 ;; Clear the evaluated values that depend on this source. 1799 (let ((agenda (get sym 'dependents)) 1800 (visited (make-vector 101 0)) 1801 ptr) 1802 (while agenda 1803 (setq sym (car agenda) 1804 agenda (cdr agenda)) 1805 (intern (symbol-name sym) visited) 1806 (set sym nil) 1807 (setq ptr (get sym 'dependents)) 1808 (while ptr 1809 (setq sym (car ptr) 1810 ptr (cdr ptr)) 1811 (unless (intern-soft (symbol-name sym) visited) 1812 (setq agenda (cons sym agenda)))))) 1813 1814 name)) 1815 1816(defmacro c-lang-const (name &optional lang) 1817 "Get the mode specific value of the language constant NAME in language LANG. 1818LANG is the name of the language, i.e. the mode name without the 1819\"-mode\" suffix. If used inside `c-lang-defconst' or 1820`c-lang-defvar', LANG may be left out to refer to the current 1821language. NAME and LANG are not evaluated so they should not be 1822quoted." 1823 1824 (or (symbolp name) 1825 (error "Not a symbol: %s" name)) 1826 (or (symbolp lang) 1827 (error "Not a symbol: %s" lang)) 1828 1829 (let ((sym (intern (symbol-name name) c-lang-constants)) 1830 mode source-files args) 1831 1832 (when lang 1833 (setq mode (intern (concat (symbol-name lang) "-mode"))) 1834 (unless (get mode 'c-mode-prefix) 1835 (error 1836 "Unknown language %S since it got no `c-mode-prefix' property" 1837 (symbol-name lang)))) 1838 1839 (if (eq c-lang-const-expansion 'immediate) 1840 ;; No need to find out the source file(s) when we evaluate 1841 ;; immediately since all the info is already there in the 1842 ;; `source' property. 1843 `',(c-get-lang-constant name nil mode) 1844 1845 (let ((file (c-get-current-file))) 1846 (if file (setq file (intern file))) 1847 ;; Get the source file(s) that must be loaded to get the value 1848 ;; of the constant. If the symbol isn't defined yet we assume 1849 ;; that its definition will come later in this file, and thus 1850 ;; are no file dependencies needed. 1851 (setq source-files (nreverse 1852 ;; Reverse to get the right load order. 1853 (apply 'nconc 1854 (mapcar (lambda (elem) 1855 (if (eq file (car elem)) 1856 nil ; Exclude our own file. 1857 (list (car elem)))) 1858 (get sym 'source)))))) 1859 1860 ;; Make some effort to do a compact call to 1861 ;; `c-get-lang-constant' since it will be compiled in. 1862 (setq args (and mode `(',mode))) 1863 (if (or source-files args) 1864 (setq args (cons (and source-files `',source-files) 1865 args))) 1866 1867 (if (or (eq c-lang-const-expansion 'call) 1868 (and (not c-lang-const-expansion) 1869 (not mode)) 1870 load-in-progress 1871 (not (boundp 'byte-compile-dest-file)) 1872 (not (stringp byte-compile-dest-file))) 1873 ;; Either a straight call is requested in the context, or 1874 ;; we're in an "uncontrolled" context and got no language, 1875 ;; or we're not being byte compiled so the compile time 1876 ;; stuff below is unnecessary. 1877 `(c-get-lang-constant ',name ,@args) 1878 1879 ;; Being compiled. If the loading and compiling version is 1880 ;; the same we use a value that is evaluated at compile time, 1881 ;; otherwise it's evaluated at runtime. 1882 `(if (eq c-version-sym ',c-version-sym) 1883 (cc-eval-when-compile 1884 (c-get-lang-constant ',name ,@args)) 1885 (c-get-lang-constant ',name ,@args)))))) 1886 1887(defvar c-lang-constants-under-evaluation nil) 1888 1889(defun c-get-lang-constant (name &optional source-files mode) 1890 ;; Used by `c-lang-const'. 1891 1892 (or mode 1893 (setq mode c-buffer-is-cc-mode) 1894 (error "No current language")) 1895 1896 (let* ((sym (intern (symbol-name name) c-lang-constants)) 1897 (source (get sym 'source)) 1898 elem 1899 (eval-in-sym (and c-lang-constants-under-evaluation 1900 (caar c-lang-constants-under-evaluation)))) 1901 1902 ;; Record the dependencies between this symbol and the one we're 1903 ;; being evaluated in. 1904 (when eval-in-sym 1905 (or (memq eval-in-sym (get sym 'dependents)) 1906 (put sym 'dependents (cons eval-in-sym (get sym 'dependents))))) 1907 1908 ;; Make sure the source files have entries on the `source' 1909 ;; property so that loading will take place when necessary. 1910 (while source-files 1911 (unless (assq (car source-files) source) 1912 (put sym 'source 1913 (setq source (cons (list (car source-files)) source))) 1914 ;; Might pull in more definitions which affect the value. The 1915 ;; clearing of dependent values etc is done when the 1916 ;; definition is encountered during the load; this is just to 1917 ;; jump past the check for a cached value below. 1918 (set sym nil)) 1919 (setq source-files (cdr source-files))) 1920 1921 (if (and (boundp sym) 1922 (setq elem (assq mode (symbol-value sym)))) 1923 (cdr elem) 1924 1925 ;; Check if an evaluation of this symbol is already underway. 1926 ;; In that case we just continue with the "assignment" before 1927 ;; the one currently being evaluated, thereby creating the 1928 ;; illusion if a `setq'-like sequence of assignments. 1929 (let* ((c-buffer-is-cc-mode mode) 1930 (source-pos 1931 (or (assq sym c-lang-constants-under-evaluation) 1932 (cons sym (vector source nil)))) 1933 ;; Append `c-lang-constants-under-evaluation' even if an 1934 ;; earlier entry is found. It's only necessary to get 1935 ;; the recording of dependencies above correct. 1936 (c-lang-constants-under-evaluation 1937 (cons source-pos c-lang-constants-under-evaluation)) 1938 (fallback (get mode 'c-fallback-mode)) 1939 value 1940 ;; Make sure the recursion limits aren't very low 1941 ;; since the `c-lang-const' dependencies can go deep. 1942 (max-specpdl-size (max max-specpdl-size 3000)) 1943 (max-lisp-eval-depth (max max-lisp-eval-depth 1000))) 1944 1945 (if (if fallback 1946 (let ((backup-source-pos (copy-sequence (cdr source-pos)))) 1947 (and 1948 ;; First try the original mode but don't accept an 1949 ;; entry matching all languages since the fallback 1950 ;; mode might have an explicit entry before that. 1951 (eq (setq value (c-find-assignment-for-mode 1952 (cdr source-pos) mode nil name)) 1953 c-lang-constants) 1954 ;; Try again with the fallback mode from the 1955 ;; original position. Note that 1956 ;; `c-buffer-is-cc-mode' still is the real mode if 1957 ;; language parameterization takes place. 1958 (eq (setq value (c-find-assignment-for-mode 1959 (setcdr source-pos backup-source-pos) 1960 fallback t name)) 1961 c-lang-constants))) 1962 ;; A simple lookup with no fallback mode. 1963 (eq (setq value (c-find-assignment-for-mode 1964 (cdr source-pos) mode t name)) 1965 c-lang-constants)) 1966 (error 1967 "`%s' got no (prior) value in %s (might be a cyclic reference)" 1968 name mode)) 1969 1970 (condition-case err 1971 (setq value (eval value)) 1972 (error 1973 ;; Print a message to aid in locating the error. We don't 1974 ;; print the error itself since that will be done later by 1975 ;; some caller higher up. 1976 (message "Eval error in the `c-lang-defconst' for `%s' in %s:" 1977 sym mode) 1978 (makunbound sym) 1979 (signal (car err) (cdr err)))) 1980 1981 (set sym (cons (cons mode value) (symbol-value sym))) 1982 value)))) 1983 1984(defun c-find-assignment-for-mode (source-pos mode match-any-lang name) 1985 ;; Find the first assignment entry that applies to MODE at or after 1986 ;; SOURCE-POS. If MATCH-ANY-LANG is non-nil, entries with `t' as 1987 ;; the language list are considered to match, otherwise they don't. 1988 ;; On return SOURCE-POS is updated to point to the next assignment 1989 ;; after the returned one. If no assignment is found, 1990 ;; `c-lang-constants' is returned as a magic value. 1991 ;; 1992 ;; SOURCE-POS is a vector that points out a specific assignment in 1993 ;; the double alist that's used in the `source' property. The first 1994 ;; element is the position in the top alist which is indexed with 1995 ;; the source files, and the second element is the position in the 1996 ;; nested bindings alist. 1997 ;; 1998 ;; NAME is only used for error messages. 1999 2000 (catch 'found 2001 (let ((file-entry (elt source-pos 0)) 2002 (assignment-entry (elt source-pos 1)) 2003 assignment) 2004 2005 (while (if assignment-entry 2006 t 2007 ;; Handled the last assignment from one file, begin on the 2008 ;; next. Due to the check in `c-lang-defconst', we know 2009 ;; there's at least one. 2010 (when file-entry 2011 2012 (unless (aset source-pos 1 2013 (setq assignment-entry (cdar file-entry))) 2014 ;; The file containing the source definitions has not 2015 ;; been loaded. 2016 (let ((file (symbol-name (caar file-entry))) 2017 (c-lang-constants-under-evaluation nil)) 2018 ;;(message (concat "Loading %s to get the source " 2019 ;; "value for language constant %s") 2020 ;; file name) 2021 (load file)) 2022 2023 (unless (setq assignment-entry (cdar file-entry)) 2024 ;; The load didn't fill in the source for the 2025 ;; constant as expected. The situation is 2026 ;; probably that a derived mode was written for 2027 ;; and compiled with another version of CC Mode, 2028 ;; and the requested constant isn't in the 2029 ;; currently loaded one. Put in a dummy 2030 ;; assignment that matches no language. 2031 (setcdr (car file-entry) 2032 (setq assignment-entry (list (list nil)))))) 2033 2034 (aset source-pos 0 (setq file-entry (cdr file-entry))) 2035 t)) 2036 2037 (setq assignment (car assignment-entry)) 2038 (aset source-pos 1 2039 (setq assignment-entry (cdr assignment-entry))) 2040 2041 (when (if (listp (car assignment)) 2042 (memq mode (car assignment)) 2043 match-any-lang) 2044 (throw 'found (cdr assignment)))) 2045 2046 c-lang-constants))) 2047 2048(defun c-lang-major-mode-is (mode) 2049 ;; `c-major-mode-is' expands to a call to this function inside 2050 ;; `c-lang-defconst'. Here we also match the mode(s) against any 2051 ;; fallback modes for the one in `c-buffer-is-cc-mode', so that 2052 ;; e.g. (c-major-mode-is 'c++-mode) is true in a derived language 2053 ;; that has c++-mode as base mode. 2054 (unless (listp mode) 2055 (setq mode (list mode))) 2056 (let (match (buf-mode c-buffer-is-cc-mode)) 2057 (while (if (memq buf-mode mode) 2058 (progn 2059 (setq match t) 2060 nil) 2061 (setq buf-mode (get buf-mode 'c-fallback-mode)))) 2062 match)) 2063 2064 2065(cc-provide 'cc-defs) 2066 2067;;; arch-tag: 3bb2629d-dd84-4ff0-ad39-584be0fe3cda 2068;;; cc-defs.el ends here 2069