diff options
| -rw-r--r-- | doc/misc/ChangeLog | 20 | ||||
| -rw-r--r-- | doc/misc/cl.texi | 5 | ||||
| -rw-r--r-- | doc/misc/ede.texi | 104 | ||||
| -rw-r--r-- | lisp/ChangeLog | 19 | ||||
| -rw-r--r-- | lisp/gnus/ChangeLog | 5 | ||||
| -rw-r--r-- | lisp/gnus/auth-source.el | 2 | ||||
| -rw-r--r-- | lisp/progmodes/cc-engine.el | 317 | ||||
| -rw-r--r-- | nt/INSTALL | 12 |
8 files changed, 263 insertions, 221 deletions
diff --git a/doc/misc/ChangeLog b/doc/misc/ChangeLog index d4dde056461..05f53257fa8 100644 --- a/doc/misc/ChangeLog +++ b/doc/misc/ChangeLog @@ -1,3 +1,23 @@ +2013-02-07 Glenn Morris <rgm@gnu.org> + + * cl.texi (Equality Predicates): Mention memql. + +2013-02-07 Eric Ludlam <zappo@gnu.org> + + * doc/misc/ede.texi (Creating a project): Make ede-new doc less + specific, and only about items it supports, indicating that there + might be more. Remove refs to simple project and direct automake + from ede new. + (Simple projects): Re-write to not talk about ede-simple-project + which is deprecated, and instead use the term to mean projects + that don't do much management, just project wrapping. Add + ede-generic-project link. + (ede-generic-project): New node (bug#11441). + +2013-02-07 Glenn Morris <rgm@gnu.org> + + * cl.texi (Equality Predicates): Fix eq/eql pedantry. + 2013-02-01 Glenn Morris <rgm@gnu.org> * calc.texi (Help Commands): Update calc-view-news description. diff --git a/doc/misc/cl.texi b/doc/misc/cl.texi index c3657415078..8da6032d728 100644 --- a/doc/misc/cl.texi +++ b/doc/misc/cl.texi @@ -817,8 +817,9 @@ not compare strings against vectors of integers. Also note that the Common Lisp functions @code{member} and @code{assoc} use @code{eql} to compare elements, whereas Emacs Lisp follows the MacLisp tradition and uses @code{equal} for these two functions. -In Emacs, use @code{memq} (or @code{cl-member}) and @code{assq} (or -@code{cl-assoc}) to get functions which use @code{eql} for comparisons. +The functions @code{cl-member} and @code{cl-assoc} use @code{eql}, +as in Common Lisp. The standard Emacs Lisp functions @code{memq} and +@code{assq} use @code{eq}, and the standard @code{memql} uses @code{eql}. @node Control Structure @chapter Control Structure diff --git a/doc/misc/ede.texi b/doc/misc/ede.texi index cadd815025c..ddee7e6b5d5 100644 --- a/doc/misc/ede.texi +++ b/doc/misc/ede.texi @@ -450,9 +450,11 @@ ede-new}, or click on the @samp{Create Project} item in the The @command{ede-new} command prompts for the type of project you would like to create. Each project type has its own benefits or -language specific enhancements. @ede{} supports four different -project types: @samp{Make}, @samp{Automake}, @samp{direct Automake}, -and @samp{Simple}. +language specific enhancements. Not all projects that @ede{} supports +also allow creating a new project. Projects such as @code{emacs} +or @code{linux} are designed to recognize existing projects only. +Project types such as @samp{Make} and @samp{Automake} do support +creating new project types with @command{ede-new}. @itemize @item @@ -468,21 +470,6 @@ Unlike a @samp{Make} project, this project autogenerates a @file{Makefile.am} file. @ede{} handles the Automake bootstrapping routines, which import and maintain a @file{configure.am} script and other required files. - -@item -For the @samp{direct Automake} project type, @ede{} reads directly -from the Automake files. - -You cannot create direct Automake projects with the @command{ede-new} -command. Instead, when you visit a project with existing Automake -files, @ede{} automatically detects them. - -@item -The @samp{Simple} project type provides light-weight constructs for -identifying a project root and looking up files. If you already have -a non-@ede{} project infrastructure, you can use a @samp{Simple} -project to provide other Emacs packages, such as Semantic, with some -information about the project. @xref{Simple projects}. @end itemize A subproject is merely a project in a subdirectory of another project. @@ -795,24 +782,19 @@ able to find your SDK and compile your programs. @node Simple projects @section Simple Projects -There is a wide array of Simple projects. The root for simple -projects is the class @code{ede-simple-project}. This handles the -infrastructure of storing a .ede file if needed. - -The class @code{ede-simple-project} is designed to be subclassed. -Then key @ede{} methods can be overridden to provide a quick wrapper -over any project. +There is a wide array of simple projects. In this case a simple +project is one that detects, or is directed to identify a directory as +belonging to a project, but doesn't provide many features of a typical +@ede{} project. Having the project however allows tools such as +@semantic{} to find sources and perform project level completions. -A second project type is @code{ede-cpp-root}. This project type is -designed to be created for a directory hierarchy full of C/C++ code. -It can be configured with minimal lisp knowledge to do header file -lookup for @semantic{}, improving code completion performance. @menu * ede-cpp-root:: This project marks the root of a C/C++ code project. * ede-java-root:: This project marks the root of a Java project. * ede-emacs:: A project for working with Emacs. * ede-linux:: A project for working with Linux kernels. +* ede-generic-project:: A project type for wrapping build systems with EDE. * Custom Locate:: Customizing how to locate files in a simple project @end menu @@ -1045,7 +1027,7 @@ tree, and enables EDE project mode for it. It pre-populates the C Preprocessor symbol map for correct parsing, and has an optimized include file identification function. -@node ede-linux, Custom Locate, ede-emacs, Simple projects +@node ede-linux, ede-generic-project, ede-emacs, Simple projects @subsection ede-linux The @code{ede-linux} project will automatically identify a Linux @@ -1054,7 +1036,60 @@ Kernel source tree, and enable EDE project mode for it. It pre-populates the C Preprocessor symbol map for reasonable parsing, and has an optimized include file identification function. -@node Custom Locate, , ede-linux, Simple projects +@node ede-generic-project, Custom Locate, ede-linux, Simple projects +@subsection ede-generic-project + +The @code{ede-generic-project} is a project system that makes it easy +to wrap up different kinds of build systems as an EDE project. +Projects such as @ref{ede-emacs} require coding skills to create. +Generic projects also require writing Emacs Lisp code, but the +requirements are minimal. You can then use +@command{customize-project} to configure build commands, includes, and +other options for that project. The configuration is saved in +@file{EDEConfig.el}. + +Generic projects are disabled by default because they have the +potential to interfere with other projects. To use the generic +project sytem to start detecting projects, you need to enable it. + +@deffn Command ede-enable-generic-projects +Enable generic project loaders. + +This enables generic loaders for projects that are detected using +either a @file{Makefile}, @file{SConstruct}, or @file{CMakeLists}. + +You do not need to use this command if you create your own generic +project type. +@end deffn + +If you want to create your own generic project loader, you need to +define your own project and target classes, and create an autoloader. +The example for Makefiles looks like this: + +@example +;;; MAKEFILE + +(defclass ede-generic-makefile-project (ede-generic-project) + ((buildfile :initform "Makefile") + ) + "Generic Project for makefiles.") + +(defmethod ede-generic-setup-configuration ((proj ede-generic-makefile-project) config) + "Setup a configuration for Make." + (oset config build-command "make -k") + (oset config debug-command "gdb ") + ) + +(ede-generic-new-autoloader "generic-makefile" "Make" + "Makefile" 'ede-generic-makefile-project) +@end example + +This example project will detect any directory with the file +@file{Makefile} in it as belonging to this project type. +Customization of the project will allow you to make build and debug +commands more precise. + +@node Custom Locate, , ede-generic-project, Simple projects @subsection Custom Locate The various simple project styles all have one major drawback, which @@ -1062,8 +1097,6 @@ is that the files in the project are not completely known to EDE@. When the EDE API is used to try and file files by some reference name in the project, then that could fail. -@@TODO - Add ID Utils and CScope examples - @ede{} can therefore use some external locate commands, such as the unix ``locate'' command, or ``GNU Global''. @@ -1093,6 +1126,11 @@ You can add your own locate tool but subclassing from methods. See the code in @file{ede-locate.el} for GNU Global as a simple example. +@@TODO - Add ID Utils and CScope examples + +More on idutils and cscope is in the CEDET manual, and they each have +their own section. + @node Extending EDE, GNU Free Documentation License, Miscellaneous commands, Top @chapter Extending @ede{} diff --git a/lisp/ChangeLog b/lisp/ChangeLog index f87bdddacda..ef97f6a8816 100644 --- a/lisp/ChangeLog +++ b/lisp/ChangeLog @@ -1,3 +1,22 @@ +2013-02-07 Alan Mackenzie <acm@muc.de> + + Fix bug in state cache mechanism. Remove 'BOD "strategy". Refactor. + * progmodes/cc-engine.el (c-get-fallback-scan-pos): Remove. + (c-parse-state-get-strategy): Don't return 'BOD any more. + (c-append-lower-brace-pair-to-state-cache): + Extra parameter HERE instead of narrowing. + Widen to top of buffer before searching backwards for a brace pair. + (c-state-push-any-brace-pair): Add HERE parameter to function call. + (c-append-to-state-cache): Extra parameter HERE in place of narrowing. + Narrow to parameter HERE, in place of being called narrowed. + (c-remove-stale-state-cache): Extra parameter HERE in place of + narrowing. Check there's an open brace in the cache before + searching for its match. + (c-invalidate-state-cache-1): Add HERE parameter to function call. + (c-parse-state-1): Don't narrow here for 'forward strategy, + instead passing extra parameter HERE to several functions. + Remove 'BOD strategy. + 2013-02-06 Nicolas Richard <theonewiththeevillook@yahoo.fr> (tiny change) * emacs-lisp/package.el (describe-package-1): Tell what archive is diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog index 7cb278f2a6f..56ec2ed50c8 100644 --- a/lisp/gnus/ChangeLog +++ b/lisp/gnus/ChangeLog @@ -1,3 +1,8 @@ +2013-02-07 Gábor Vida <gabor.v.vida@ericsson.com> (tiny change) + + * auth-source.el (auth-source-format-prompt): Don't get confused by + any "\" in replacement text. (Bug#13637) + 2013-01-30 Christopher Schmidt <christopher@ch.ristopher.com> * gnus-int.el (gnus-backend-trace-elapsed): New variable. diff --git a/lisp/gnus/auth-source.el b/lisp/gnus/auth-source.el index ac16200adb2..e94904bf175 100644 --- a/lisp/gnus/auth-source.el +++ b/lisp/gnus/auth-source.el @@ -913,7 +913,7 @@ while \(:host t) would find all host entries." (when (and c v) (setq prompt (replace-regexp-in-string (format "%%%c" c) (format "%s" v) - prompt))))) + prompt nil t))))) prompt) (defun auth-source-ensure-strings (values) diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el index d4e4d6de483..977bc755e32 100644 --- a/lisp/progmodes/cc-engine.el +++ b/lisp/progmodes/cc-engine.el @@ -2477,20 +2477,6 @@ comment at the start of cc-engine.el for more info." ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Defuns which analyze the buffer, yet don't change `c-state-cache'. -(defun c-get-fallback-scan-pos (here) - ;; Return a start position for building `c-state-cache' from - ;; scratch. This will be at the top level, 2 defuns back. - (save-excursion - ;; Go back 2 bods, but ignore any bogus positions returned by - ;; beginning-of-defun (i.e. open paren in column zero). - (goto-char here) - (let ((cnt 2)) - (while (not (or (bobp) (zerop cnt))) - (c-beginning-of-defun-1) ; Pure elisp BOD. - (if (eq (char-after) ?\{) - (setq cnt (1- cnt))))) - (point))) - (defun c-state-balance-parens-backwards (here- here+ top) ;; Return the position of the opening paren/brace/bracket before HERE- which ;; matches the outermost close p/b/b between HERE+ and TOP. Except when @@ -2548,47 +2534,23 @@ comment at the start of cc-engine.el for more info." ;; o - ('forward START-POINT) - scan forward from START-POINT, ;; which is not less than the highest position in `c-state-cache' below here. ;; o - ('backward nil) - scan backwards (from HERE). - ;; o - ('BOD START-POINT) - scan forwards from START-POINT, which is at the - ;; top level. ;; o - ('IN-LIT nil) - point is inside the literal containing point-min. (let ((cache-pos (c-get-cache-scan-pos here)) ; highest position below HERE in cache (or 1) - BOD-pos ; position of 2nd BOD before HERE. - strategy ; 'forward, 'backward, 'BOD, or 'IN-LIT. - start-point - how-far) ; putative scanning distance. + strategy ; 'forward, 'backward, or 'IN-LIT. + start-point) (setq good-pos (or good-pos (c-state-get-min-scan-pos))) (cond ((< here (c-state-get-min-scan-pos)) - (setq strategy 'IN-LIT - start-point nil - cache-pos nil - how-far 0)) + (setq strategy 'IN-LIT)) ((<= good-pos here) (setq strategy 'forward - start-point (max good-pos cache-pos) - how-far (- here start-point))) + start-point (max good-pos cache-pos))) ((< (- good-pos here) (- here cache-pos)) ; FIXME!!! ; apply some sort of weighting. - (setq strategy 'backward - how-far (- good-pos here))) + (setq strategy 'backward)) (t (setq strategy 'forward - how-far (- here cache-pos) - start-point cache-pos))) - - ;; Might we be better off starting from the top level, two defuns back, - ;; instead? This heuristic no longer works well in C++, where - ;; declarations inside namespace brace blocks are frequently placed at - ;; column zero. - (when (and (not (c-major-mode-is 'c++-mode)) - (> how-far c-state-cache-too-far)) - (setq BOD-pos (c-get-fallback-scan-pos here)) ; somewhat EXPENSIVE!!! - (if (< (- here BOD-pos) how-far) - (setq strategy 'BOD - start-point BOD-pos))) - - (list - strategy - (and (memq strategy '(forward BOD)) start-point)))) + start-point cache-pos))) + (list strategy (and (eq strategy 'forward) start-point)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -2630,7 +2592,7 @@ comment at the start of cc-engine.el for more info." (setq c-state-point-min (point-min))) -(defun c-append-lower-brace-pair-to-state-cache (from &optional upper-lim) +(defun c-append-lower-brace-pair-to-state-cache (from here &optional upper-lim) ;; If there is a brace pair preceding FROM in the buffer, at the same level ;; of nesting (not necessarily immediately preceding), push a cons onto ;; `c-state-cache' to represent it. FROM must not be inside a literal. If @@ -2654,8 +2616,7 @@ comment at the start of cc-engine.el for more info." ;; reduce the time wasted in repeated fruitless searches in brace deserts. (save-excursion (save-restriction - (let* ((here (point-max)) - new-cons + (let* (new-cons (cache-pos (c-state-cache-top-lparen)) ; might be nil. (macro-start-or-from (progn (goto-char from) @@ -2690,7 +2651,6 @@ comment at the start of cc-engine.el for more info." ;; search bound, even though the algorithm below would skip ;; over the new paren pair. (cache-lim (and cache-pos (< cache-pos from) cache-pos))) - (widen) (narrow-to-region (cond ((and desert-lim cache-lim) @@ -2698,7 +2658,9 @@ comment at the start of cc-engine.el for more info." (desert-lim) (cache-lim) ((point-min))) - (point-max))) + ;; The top limit is EOB to ensure that `bra' is inside the + ;; accessible part of the buffer at the next scan operation. + (1+ (buffer-size)))) ;; In the next pair of nested loops, the inner one moves back past a ;; pair of (mis-)matching parens or brackets; the outer one moves @@ -2765,25 +2727,24 @@ comment at the start of cc-engine.el for more info." (if (consp (car c-state-cache)) (cdr c-state-cache) c-state-cache))) - ;; N.B. This defsubst codes one method for the simple, normal case, + ;; N.B. This defsubst codes one method for the simple, normal case, ;; and a more sophisticated, slower way for the general case. Don't ;; eliminate this defsubst - it's a speed optimization. - (c-append-lower-brace-pair-to-state-cache (1- bra+1))))) + (c-append-lower-brace-pair-to-state-cache (1- bra+1) (point-max))))) -(defun c-append-to-state-cache (from) - ;; Scan the buffer from FROM to (point-max), adding elements into - ;; `c-state-cache' for braces etc. Return a candidate for - ;; `c-state-cache-good-pos'. +(defun c-append-to-state-cache (from here) + ;; Scan the buffer from FROM to HERE, adding elements into `c-state-cache' + ;; for braces etc. Return a candidate for `c-state-cache-good-pos'. ;; ;; FROM must be after the latest brace/paren/bracket in `c-state-cache', if ;; any. Typically, it is immediately after it. It must not be inside a ;; literal. - (let ((here-bol (c-point 'bol (point-max))) + (let ((here-bol (c-point 'bol here)) (macro-start-or-here - (save-excursion (goto-char (point-max)) + (save-excursion (goto-char here) (if (c-beginning-of-macro) (point) - (point-max)))) + here))) pa+1 ; pos just after an opening PAren (or brace). (ren+1 from) ; usually a pos just after an closing paREN etc. ; Is actually the pos. to scan for a (/{/[ from, @@ -2796,75 +2757,77 @@ comment at the start of cc-engine.el for more info." mstart) ; start of a macro. (save-excursion - ;; Each time round the following loop, we enter a successively deeper - ;; level of brace/paren nesting. (Except sometimes we "continue at - ;; the existing level".) `pa+1' is a pos inside an opening - ;; brace/paren/bracket, usually just after it. - (while - (progn - ;; Each time round the next loop moves forward over an opening then - ;; a closing brace/bracket/paren. This loop is white hot, so it - ;; plays ugly tricks to go fast. DON'T PUT ANYTHING INTO THIS - ;; LOOP WHICH ISN'T ABSOLUTELY NECESSARY!!! It terminates when a - ;; call of `scan-lists' signals an error, which happens when there - ;; are no more b/b/p's to scan. - (c-safe - (while t - (setq pa+1 (scan-lists ren+1 1 -1) ; Into (/{/[; might signal - paren+1s (cons pa+1 paren+1s)) - (setq ren+1 (scan-lists pa+1 1 1)) ; Out of )/}/]; might signal - (if (and (eq (char-before pa+1) ?{)) ; Check for a macro later. - (setq bra+1 pa+1)) - (setcar paren+1s ren+1))) - - (if (and pa+1 (> pa+1 ren+1)) - ;; We've just entered a deeper nesting level. - (progn - ;; Insert the brace pair (if present) and the single open - ;; paren/brace/bracket into `c-state-cache' It cannot be - ;; inside a macro, except one around point, because of what - ;; `c-neutralize-syntax-in-CPP' has done. - (c-state-push-any-brace-pair bra+1 macro-start-or-here) - ;; Insert the opening brace/bracket/paren position. - (setq c-state-cache (cons (1- pa+1) c-state-cache)) - ;; Clear admin stuff for the next more nested part of the scan. - (setq ren+1 pa+1 pa+1 nil bra+1 nil bra+1s nil) - t) ; Carry on the loop - - ;; All open p/b/b's at this nesting level, if any, have probably - ;; been closed by matching/mismatching ones. We're probably - ;; finished - we just need to check for having found an - ;; unmatched )/}/], which we ignore. Such a )/}/] can't be in a - ;; macro, due the action of `c-neutralize-syntax-in-CPP'. - (c-safe (setq ren+1 (scan-lists ren+1 1 1)))))) ; acts as loop control. - - ;; Record the final, innermost, brace-pair if there is one. - (c-state-push-any-brace-pair bra+1 macro-start-or-here) - - ;; Determine a good pos - (while (and (setq paren+1 (car paren+1s)) - (> (if (> paren+1 macro-start-or-here) - paren+1 - (goto-char paren+1) - (setq mstart (and (c-beginning-of-macro) - (point))) - (or mstart paren+1)) - here-bol)) - (setq paren+1s (cdr paren+1s))) - (cond - ((and paren+1 mstart) - (min paren+1 mstart)) - (paren+1) - (t from))))) + (save-restriction + (narrow-to-region (point-min) here) + ;; Each time round the following loop, we enter a successively deeper + ;; level of brace/paren nesting. (Except sometimes we "continue at + ;; the existing level".) `pa+1' is a pos inside an opening + ;; brace/paren/bracket, usually just after it. + (while + (progn + ;; Each time round the next loop moves forward over an opening then + ;; a closing brace/bracket/paren. This loop is white hot, so it + ;; plays ugly tricks to go fast. DON'T PUT ANYTHING INTO THIS + ;; LOOP WHICH ISN'T ABSOLUTELY NECESSARY!!! It terminates when a + ;; call of `scan-lists' signals an error, which happens when there + ;; are no more b/b/p's to scan. + (c-safe + (while t + (setq pa+1 (scan-lists ren+1 1 -1) ; Into (/{/[; might signal + paren+1s (cons pa+1 paren+1s)) + (setq ren+1 (scan-lists pa+1 1 1)) ; Out of )/}/]; might signal + (if (and (eq (char-before pa+1) ?{)) ; Check for a macro later. + (setq bra+1 pa+1)) + (setcar paren+1s ren+1))) + + (if (and pa+1 (> pa+1 ren+1)) + ;; We've just entered a deeper nesting level. + (progn + ;; Insert the brace pair (if present) and the single open + ;; paren/brace/bracket into `c-state-cache' It cannot be + ;; inside a macro, except one around point, because of what + ;; `c-neutralize-syntax-in-CPP' has done. + (c-state-push-any-brace-pair bra+1 macro-start-or-here) + ;; Insert the opening brace/bracket/paren position. + (setq c-state-cache (cons (1- pa+1) c-state-cache)) + ;; Clear admin stuff for the next more nested part of the scan. + (setq ren+1 pa+1 pa+1 nil bra+1 nil bra+1s nil) + t) ; Carry on the loop + + ;; All open p/b/b's at this nesting level, if any, have probably + ;; been closed by matching/mismatching ones. We're probably + ;; finished - we just need to check for having found an + ;; unmatched )/}/], which we ignore. Such a )/}/] can't be in a + ;; macro, due the action of `c-neutralize-syntax-in-CPP'. + (c-safe (setq ren+1 (scan-lists ren+1 1 1)))))) ; acts as loop control. + + ;; Record the final, innermost, brace-pair if there is one. + (c-state-push-any-brace-pair bra+1 macro-start-or-here) + + ;; Determine a good pos + (while (and (setq paren+1 (car paren+1s)) + (> (if (> paren+1 macro-start-or-here) + paren+1 + (goto-char paren+1) + (setq mstart (and (c-beginning-of-macro) + (point))) + (or mstart paren+1)) + here-bol)) + (setq paren+1s (cdr paren+1s))) + (cond + ((and paren+1 mstart) + (min paren+1 mstart)) + (paren+1) + (t from)))))) -(defun c-remove-stale-state-cache (start-point pps-point) +(defun c-remove-stale-state-cache (start-point here pps-point) ;; Remove stale entries from the `c-cache-state', i.e. those which will - ;; not be in it when it is amended for position (point-max). - ;; Additionally, the "outermost" open-brace entry before (point-max) - ;; will be converted to a cons if the matching close-brace is scanned. + ;; not be in it when it is amended for position HERE. Additionally, the + ;; "outermost" open-brace entry before HERE will be converted to a cons if + ;; the matching close-brace is scanned. ;; ;; START-POINT is a "maximal" "safe position" - there must be no open - ;; parens/braces/brackets between START-POINT and (point-max). + ;; parens/braces/brackets between START-POINT and HERE. ;; ;; As a second thing, calculate the result of parse-partial-sexp at ;; PPS-POINT, w.r.t. START-POINT. The motivation here is that @@ -2881,23 +2844,23 @@ comment at the start of cc-engine.el for more info." ;; last element to be removed from `c-state-cache', when that elt is a ;; cons, otherwise nil. ;; o - PPS-STATE is the parse-partial-sexp state at PPS-POINT. - (save-restriction - (narrow-to-region 1 (point-max)) - (save-excursion - (let* ((in-macro-start ; start of macro containing (point-max) or nil. + (save-excursion + (save-restriction + (narrow-to-region 1 (point-max)) + (let* ((in-macro-start ; start of macro containing HERE or nil. (save-excursion - (goto-char (point-max)) + (goto-char here) (and (c-beginning-of-macro) (point)))) (start-point-actual-macro-start ; Start of macro containing ; start-point or nil - (and (< start-point (point-max)) + (and (< start-point here) (save-excursion (goto-char start-point) (and (c-beginning-of-macro) (point))))) (start-point-actual-macro-end ; End of this macro, (maybe - ; (point-max)), or nil. + ; HERE), or nil. (and start-point-actual-macro-start (save-excursion (goto-char start-point-actual-macro-start) @@ -2909,14 +2872,14 @@ comment at the start of cc-engine.el for more info." scan-back-pos pair-beg pps-point-state target-depth) - ;; Remove entries beyond (point-max). Also remove any entries inside - ;; a macro, unless (point-max) is in the same macro. + ;; Remove entries beyond HERE. Also remove any entries inside + ;; a macro, unless HERE is in the same macro. (setq upper-lim (if (or (null c-state-old-cpp-beg) - (and (> (point-max) c-state-old-cpp-beg) - (< (point-max) c-state-old-cpp-end))) - (point-max) - (min (point-max) c-state-old-cpp-beg))) + (and (> here c-state-old-cpp-beg) + (< here c-state-old-cpp-end))) + here + (min here c-state-old-cpp-beg))) (while (and c-state-cache (>= (c-state-cache-top-lparen) upper-lim)) (setq scan-back-pos (car-safe (car c-state-cache))) (setq c-state-cache (cdr c-state-cache))) @@ -2934,7 +2897,7 @@ comment at the start of cc-engine.el for more info." ;; time round; the corresponding elements in `c-state-cache' are ;; removed. `pos' is just after the brace-pair or the open paren at ;; (car c-state-cache). There can be no open parens/braces/brackets - ;; between `start-point'/`start-point-actual-macro-start' and (point-max), + ;; between `start-point'/`start-point-actual-macro-start' and HERE, ;; due to the interface spec to this function. (setq pos (if (and start-point-actual-macro-end (not (eq start-point-actual-macro-start @@ -2944,7 +2907,9 @@ comment at the start of cc-engine.el for more info." start-point)) (goto-char pos) (while (and c-state-cache - (< (point) (point-max))) + (or (numberp (car c-state-cache)) ; Have we a { at all? + (cdr c-state-cache)) + (< (point) here)) (cond ((null pps-state) ; first time through (setq target-depth -1)) @@ -2956,7 +2921,7 @@ comment at the start of cc-engine.el for more info." ;; Scan! (setq pps-state (parse-partial-sexp - (point) (if (< (point) pps-point) pps-point (point-max)) + (point) (if (< (point) pps-point) pps-point here) target-depth nil pps-state)) @@ -3209,7 +3174,7 @@ comment at the start of cc-engine.el for more info." ;; Do we need to add in an earlier brace pair, having lopped one off? (if (and dropped-cons (< too-high-pa (+ here c-state-cache-too-far))) - (c-append-lower-brace-pair-to-state-cache too-high-pa here-bol)) + (c-append-lower-brace-pair-to-state-cache too-high-pa here here-bol)) (setq c-state-cache-good-pos (or (c-state-cache-after-top-paren) (c-state-get-min-scan-pos))))) @@ -3285,47 +3250,39 @@ comment at the start of cc-engine.el for more info." strategy (car res) start-point (cadr res)) - (when (eq strategy 'BOD) - (setq c-state-cache nil - c-state-cache-good-pos start-point)) - ;; SCAN! - (save-restriction - (cond - ((memq strategy '(forward BOD)) - (narrow-to-region (point-min) here) - (setq res (c-remove-stale-state-cache start-point here-bopl)) - (setq cache-pos (car res) - scan-backward-pos (cadr res) - bopl-state (car (cddr res))) ; will be nil if (< here-bopl + (cond + ((eq strategy 'forward) + (setq res (c-remove-stale-state-cache start-point here here-bopl)) + (setq cache-pos (car res) + scan-backward-pos (cadr res) + bopl-state (car (cddr res))) ; will be nil if (< here-bopl ; start-point) - (if scan-backward-pos - (c-append-lower-brace-pair-to-state-cache scan-backward-pos)) - (setq good-pos - (c-append-to-state-cache cache-pos)) - (setq c-state-cache-good-pos - (if (and bopl-state - (< good-pos (- here c-state-cache-too-far))) - (c-state-cache-non-literal-place here-bopl bopl-state) - good-pos))) - - ((eq strategy 'backward) - (setq res (c-remove-stale-state-cache-backwards here) - good-pos (car res) - scan-backward-pos (cadr res) - scan-forward-p (car (cddr res))) - (if scan-backward-pos - (c-append-lower-brace-pair-to-state-cache - scan-backward-pos)) - (setq c-state-cache-good-pos - (if scan-forward-p - (progn (narrow-to-region (point-min) here) - (c-append-to-state-cache good-pos)) - good-pos))) - - (t ; (eq strategy 'IN-LIT) - (setq c-state-cache nil - c-state-cache-good-pos nil))))) + (if scan-backward-pos + (c-append-lower-brace-pair-to-state-cache scan-backward-pos here)) + (setq good-pos + (c-append-to-state-cache cache-pos here)) + (setq c-state-cache-good-pos + (if (and bopl-state + (< good-pos (- here c-state-cache-too-far))) + (c-state-cache-non-literal-place here-bopl bopl-state) + good-pos))) + + ((eq strategy 'backward) + (setq res (c-remove-stale-state-cache-backwards here) + good-pos (car res) + scan-backward-pos (cadr res) + scan-forward-p (car (cddr res))) + (if scan-backward-pos + (c-append-lower-brace-pair-to-state-cache scan-backward-pos here)) + (setq c-state-cache-good-pos + (if scan-forward-p + (c-append-to-state-cache good-pos here) + good-pos))) + + (t ; (eq strategy 'IN-LIT) + (setq c-state-cache nil + c-state-cache-good-pos nil)))) c-state-cache) diff --git a/nt/INSTALL b/nt/INSTALL index 487e5ec0bf8..0c4b50f0c28 100644 --- a/nt/INSTALL +++ b/nt/INSTALL @@ -110,12 +110,14 @@ WinZip is known to create some subtle and hard to debug problems, such as converting files to DOS CR-LF format, not creating empty directories, etc. We suggest to use djtarnt.exe from the GNU FTP - site. + site. For modern formats, such as .tar.xz, we suggest bsdtar.exe + from the libarchive package; its precompiled Windows binaries are + available from this site: + + http://sourceforge.net/projects/ezwinports/files/ - In addition to this file, you should also read INSTALL.BZR in the - parent directory, and make sure that you have a version of - "touch.exe" in your path, and that it will create files that do not - yet exist. + In addition to this file, if you build a development snapshot, you + should also read INSTALL.BZR in the parent directory. * Supported development environments |