etags.el: extend auto-completion-max
18 years, 6 months
David A. Panariti
David A. Panariti
A small patch to etags.el to allow the auto-completion-max to be set by the
user. It was 20K, a bit too small for my current machine.
2005-10-16 David A. Panariti <davep.xemacs(a)meduseld.net>
* etags.el: Changed the max file size for automatically creating a
completion table for a newly loaded TAGS file. Created a variable
to make it customizable.
--
/ BOFH Excuse #14:
davep (|)
/ sounds like a Windows problem, try calling Microsoft support
$$$$
--- etags.el.ORIG 2005-07-08 18:07:05.000000000 -0400
+++ etags.el 2005-07-08 18:07:05.000000000 -0400
＠＠ -80,6 +80,12 ＠＠
(const :tag "Ask" ask))
:group 'etags)
+(defcustom etags-auto-build-completion-table-max 20000
+ "*Don't ask to build the completion table when
+`tags-build-completion-table' is 'Ask and table is less than this size."
+:type 'integer
+:group 'etags)
+
(defcustom tags-always-exact nil
"*If this variable is non-nil, then tags always looks for exact matches.
If it is nil (the default), tags will first go through exact matches,
＠＠ -353,7 +359,7 ＠＠
((t) t)
((ask)
;; don't bother asking for small ones
- (or (< (buffer-size) 20000)
+ (or (< (buffer-size) etags-auto-completion-build-max)
(y-or-n-p
(format "Build tag completion table for %s? "
tag-table)))))
- 1 participants
- 0 comments
[AC (pkgs)] Fix sh-script upstream version
18 years, 6 months
Ville Skyttä
Ville Skyttä
APPROVE COMMIT packages
Thanks, Jérôme!
- 1 participants
- 0 comments
bug in saveconf.el
18 years, 6 months
David A. Panariti
David A. Panariti
In the restore part:
2005-05-02 David A. Panariti <davep.xemacs(a)meduseld.net>
* saveconf.el (recover-context):
Fixed bug when attempting to restore a file that no longer
exists. In this case, the restore loop deletes the buffer but
does not read the following file offset. This puts the restore
loop out of alignment with the data in the restore file, which
causes the loop to terminate possibly leaving some context
unprocessed.
I submitted this a while ago, but didn't see any activity on it.
--
/ I WILL NOT CUT CORNERS
davep (|) " " " " " "
/ " " " " " "
$$ " " " " " "
Bart Simpson on chalkboard in episode 7F11
--- saveconf.el.ORIG 2005-05-02 09:45:05.311505589 -0400
+++ saveconf.el 2005-05-02 09:46:29.710913144 -0400
＠＠ -268,11 +268,12 ＠＠
;;
;; Recover buffer contexts, if any.
;;
- (while (setq sexpr (read context-buffer))
+ (while (setq sexpr (read context-buffer)
+ point (read context-buffer))
(set-buffer (find-file-noselect sexpr t))
(if (zerop (buffer-size))
(kill-buffer (current-buffer))
- (goto-char (read context-buffer))))
+ (goto-char point)))
(bury-buffer "*scratch*")
(kill-buffer context-buffer)
t )
- 2 participants
- 1 comments
[PATCH] Sync of executable.el with Emacs CVS.
18 years, 6 months
Malcolm Purvis
Malcolm Purvis
As a companion to Jérôme's sync of sh-script.el, here is a sync of
executable.el with the current GNU Emacs CVS.
ChangeLog addition:
2005-10-10 Malcolm Purvis <malcolmp(a)xemacs.org>
* executable.el: Sync with GNU Emacs 22.0.50.1 (CVS). Update
FSF's address in GPL notices.
xemacs-sh-script.el source patch:
Diff command: cvs -q diff -u
Files affected: executable.el
Index: executable.el
===================================================================
RCS file: /pack/xemacscvs/XEmacs/packages/xemacs-packages/sh-script/executable.el,v
retrieving revision 1.3
diff -u -r1.3 executable.el
--- executable.el 2002/04/07 16:52:02 1.3
+++ executable.el 2005/10/09 20:42:50
＠＠ -1,6 +1,6 ＠＠
;;; executable.el --- base functionality for executable interpreter scripts -*- byte-compile-dynamic: t -*-
-;; Copyright (C) 1994, 1995, 1996, 2000 by Free Software Foundation, Inc.
+;; Copyright (C) 1994, 1995, 1996, 2000, 2003, 2004 by Free Software Foundation, Inc.
;; Author: Daniel Pfeiffer <occitan(a)esperanto.org>
;; Keywords: languages, unix
＠＠ -19,10 +19,10 ＠＠
;; You should have received a copy of the GNU General Public License
;; along with XEmacs; see the file COPYING. If not, write to the Free
-;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-;; 02111-1307, USA.
+;; Software Foundation, Inc., 51 Franklin Street, Fifth Floor
+;; Boston, MA 02110-1301, USA.
-;;; Synched up with: GNU Emacs 21.2.
+;;; Synched up with: FSF 22.0.50.1 (CVS)
;;; Commentary:
＠＠ -152,8 +152,29 ＠＠
'("")))
;;;###autoload
+(defun executable-command-find-posix-p (&optional program)
+ "Check if PROGRAM handles arguments Posix-style.
+If PROGRAM is non-nil, use that instead of \"find\"."
+ ;; Pick file to search from location we know
+ (let* ((dir (file-truename data-directory))
+ (file (car (directory-files dir nil "^[^.]"))))
+ (with-temp-buffer
+ (call-process (or program "find")
+ nil
+ (current-buffer)
+ nil
+ dir
+ "-name"
+ file
+ "-maxdepth"
+ "1")
+ (goto-char (point-min))
+ (if (search-forward file nil t)
+ t))))
+
+;;;###autoload
(defun executable-find (command)
- "Search for COMMAND in exec-path and return the absolute file name.
+ "Search for COMMAND in `exec-path' and return the absolute file name.
Return nil if COMMAND is not found anywhere in `exec-path'."
(let ((list exec-path)
file)
＠＠ -189,20 +210,20 ＠＠
(file-modes buffer-file-name)))))))
+;;;###autoload
(defun executable-interpret (command)
"Run script with user-specified args, and collect output in a buffer.
-While script runs asynchronously, you can use the \\[next-error] command
-to find the next error."
+While script runs asynchronously, you can use the \\[next-error]
+command to find the next error. The buffer is also in `comint-mode' and
+`compilation-shell-minor-mode', so that you can answer any prompts."
(interactive (list (read-string "Run script: "
(or executable-command
buffer-file-name))))
(require 'compile)
(save-some-buffers (not compilation-ask-about-save))
- (make-local-variable 'executable-command)
- (compile-internal (setq executable-command command)
- "No more errors." "Interpretation"
- ;; Give it a simpler regexp to match.
- nil executable-error-regexp-alist))
+ (set (make-local-variable 'executable-command) command)
+ (let ((compilation-error-regexp-alist executable-error-regexp-alist))
+ (compile-internal command t (lambda (x) "*interpretation*"))))
＠＠ -238,35 +259,28 ＠＠
(not (or insert-flag executable-insert))
(> (point-min) 1)
(save-excursion
- (let ((point (point-marker))
- (buffer-modified-p (buffer-modified-p)))
- (goto-char (point-min))
- (make-local-hook 'after-save-hook)
- (add-hook 'after-save-hook 'executable-chmod nil t)
- (if (looking-at "#![ \t]*\\(.*\\)$")
- (and (goto-char (match-beginning 1))
- ;; If the line ends in a space,
- ;; don't offer to change it.
- (not (= (char-after (1- (match-end 1))) ?\ ))
- (not (string= argument
- (buffer-substring (point) (match-end 1))))
- (if (or (not executable-query) no-query-flag
- (save-window-excursion
- ;; Make buffer visible before question.
- (switch-to-buffer (current-buffer))
- (y-or-n-p (concat "Replace magic number by `"
- executable-prefix argument "'? "))))
- (progn
- (replace-match argument t t nil 1)
- (message "Magic number changed to `%s'"
- (concat executable-prefix argument)))))
- (insert executable-prefix argument ?\n)
- (message "Magic number changed to `%s'"
- (concat executable-prefix argument)))
-;;; (or insert-flag
-;;; (eq executable-insert t)
-;;; (set-buffer-modified-p buffer-modified-p))
- )))
+ (goto-char (point-min))
+ (add-hook 'after-save-hook 'executable-chmod nil t)
+ (if (looking-at "#![ \t]*\\(.*\\)$")
+ (and (goto-char (match-beginning 1))
+ ;; If the line ends in a space,
+ ;; don't offer to change it.
+ (not (= (char-after (1- (match-end 1))) ?\ ))
+ (not (string= argument
+ (buffer-substring (point) (match-end 1))))
+ (if (or (not executable-query) no-query-flag
+ (save-window-excursion
+ ;; Make buffer visible before question.
+ (switch-to-buffer (current-buffer))
+ (y-or-n-p (concat "Replace magic number by `"
+ executable-prefix argument "'? "))))
+ (progn
+ (replace-match argument t t nil 1)
+ (message "Magic number changed to `%s'"
+ (concat executable-prefix argument)))))
+ (insert executable-prefix argument ?\n)
+ (message "Magic number changed to `%s'"
+ (concat executable-prefix argument)))))
interpreter)
＠＠ -288,7 +302,7 ＠＠
(and (>= (buffer-size) 2)
(save-restriction
(widen)
- (string= "#!" (buffer-substring 1 3)))
+ (string= "#!" (buffer-substring (point-min) (+ 2 (point-min)))))
(let* ((current-mode (file-modes (buffer-file-name)))
(add-mode (logand ?\111 (default-file-modes))))
(or (/= (logand ?\111 current-mode) 0)
--
Malcolm Purvis <malcolmp(a)xemacs.org>
- 1 participants
- 1 comments
[C] packages: Re: flyspell-mode became incredibly slow
18 years, 6 months
Adrian Aichner
Adrian Aichner
COMMIT
Hi guys, we should really sync ispell.el from GNU Emacs.
It seems to be the best maintained version now.
http://www.kdstevens.com/~stevens/ispell-page.html
seems to be way behind.
RMS has made a change related to this bug in GNU Emacs recently
(emacs\lisp\textmodes\ispell.el).
Best regards,
Adrian
packages ChangeLog patch:
Diff command: cvs -q diff -U 0
Files affected: xemacs-packages/ispell/ChangeLog
Index: xemacs-packages/ispell/ChangeLog
===================================================================
RCS file: /pack/xemacscvs/XEmacs/packages/xemacs-packages/ispell/ChangeLog,v
retrieving revision 1.38
diff -u -U0 -r1.38 ChangeLog
--- xemacs-packages/ispell/ChangeLog 13 Feb 2005 21:34:13 -0000 1.38
+++ xemacs-packages/ispell/ChangeLog 15 Oct 2005 19:11:05 -0000
＠＠ -0,0 +1,8 ＠＠
+2005-10-15 Adrian Aichner <adrian(a)xemacs.org>
+
+ * ispell.el (ispell-buffer-local-dict): Patch submitted by Mike
+ FABIAN to fix following bug: "when you change the dictionary once,
+ ispell is killed and rerun everytime you invoke it"; originally
+ suggested verbatim by Fabrice Popineau. See also:
+ http://bugzilla.novell.com/show_bug.cgi?id=106703.
+
packages source patch:
Diff command: cvs -f -z3 -q diff -u -w -N
Files affected: xemacs-packages/ispell/ispell.el
Index: xemacs-packages/ispell/ispell.el
===================================================================
RCS file: /pack/xemacscvs/XEmacs/packages/xemacs-packages/ispell/ispell.el,v
retrieving revision 1.22
diff -u -w -r1.22 ispell.el
--- xemacs-packages/ispell/ispell.el 13 Feb 2005 13:40:21 -0000 1.22
+++ xemacs-packages/ispell/ispell.el 15 Oct 2005 19:09:31 -0000
＠＠ -3463,7 +3463,8 ＠＠
(ispell-kill-ispell t)
(setq ispell-personal-dictionary ispell-local-pdict)))
;; Reload if new dictionary defined.
- (if (not (equal ispell-local-dictionary ispell-dictionary))
+ (if (and ispell-local-dictionary
+ (not (equal ispell-local-dictionary ispell-dictionary)))
(ispell-change-dictionary ispell-local-dictionary)))
--
Adrian Aichner
mailto:adrian＠xemacs.org
http://www.xemacs.org/
- 1 participants
- 0 comments
[C] xemacsweb: Linkmending in Download
18 years, 6 months
Adrian Aichner
Adrian Aichner
COMMIT
xemacsweb ChangeLog patch:
Diff command: cvs -q diff -U 0
Files affected: Download/ChangeLog
Index: Download/ChangeLog
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacsweb/Download/ChangeLog,v
retrieving revision 1.163
diff -u -U0 -r1.163 ChangeLog
--- Download/ChangeLog 25 Sep 2005 15:04:49 -0000 1.163
+++ Download/ChangeLog 15 Oct 2005 16:14:11 -0000
＠＠ -0,0 +1,6 ＠＠
+2005-10-15 Adrian Aichner <adrian(a)xemacs.org>
+
+ * elispPackages.content: Comment link to "Tomohiko Morioka Loves
+ Emacsen", which has been giving not found (404) for a month now.
+ * optLibs.content: Update link to bzip2 tarball.
+
xemacsweb source patch:
Diff command: cvs -f -z3 -q diff -u -w -N
Files affected: Download/optLibs.content Download/elispPackages.content
Index: Download/elispPackages.content
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacsweb/Download/elispPackages.content,v
retrieving revision 1.68
diff -u -w -r1.68 elispPackages.content
--- Download/elispPackages.content 13 Jun 2005 18:21:19 -0000 1.68
+++ Download/elispPackages.content 15 Oct 2005 16:10:48 -0000
＠＠ -121,7 +121,8 ＠＠
<li><a href="http://www.splode.com/users/friedman/software/emacs-lisp/index.html... Friedman's Emacs Lisp site</a></li>
<li><a href="http://my.gnus.org/">Robin Socha's my.gnus.org</a></li>
<li><a href="http://turnbull.sk.tsukuba.ac.jp/Tools/XEmacs/">Stephen Turnbull's XEmacs site</a></li>
- <li><a href="http://cvs.m17n.org/tomo/comp/emacsen/">Tomohiko Morioka Loves Emacsen</a></li>
+ <!-- not found (404) -- Adrian, 2005-10-15 -->
+ <!-- <li><a href="http://cvs.m17n.org/tomo/comp/emacsen/">Tomohiko Morioka Loves Emacsen</a></li> -->
</ul>
<h4><a id="OEP" name="OEP">Other</a> Elisp Packages</h4>
Index: Download/optLibs.content
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacsweb/Download/optLibs.content,v
retrieving revision 1.35
diff -u -w -r1.35 optLibs.content
--- Download/optLibs.content 25 Sep 2005 14:48:16 -0000 1.35
+++ Download/optLibs.content 15 Oct 2005 16:10:48 -0000
＠＠ -308,7 +308,7 ＠＠
<p>
<strong>bzip2</strong> is a compressor that compresses much better than gzip.<br />
- <a href="http://ftp.xemacs.org/pub/xemacs/aux/bzip2-1.0.2.tar.gz">bzip2-1.0.... />
+ <a href="http://ftp.xemacs.org/pub/xemacs/aux/bzip2-1.0.3.tar.gz">bzip2-1.0.... />
<a href="http://sources.redhat.com/bzip2/">http://sources.redhat.com/bzip2/<... /></p>
<p>
--
Adrian Aichner
mailto:adrian＠xemacs.org
http://www.xemacs.org/
- 1 participants
- 0 comments
[PATCH] Sync sh-script.el with GNU Emacs 21.4 (3)
18 years, 6 months
Jérôme Marant
Jérôme Marant
Hi,
Here is the final (I hope :-) version of the patch. I added changelog
comments for Malcolm additions. Feel free to improve them :-)
Cheers,
ChangeLog addition:
2005-10-12 Jérôme Marant <jmarant(a)free.fr>
* sh-script.el: Sync with GNU Emacs 21.4
Update FSF's address in GPL notices.
(sh-mode-map): Move menu-related code to sh-mode-menu.
(sh-mode-menu): New menu definition.
(sh-mode): Install menu.
XEmacs packages sh-script source patch:
Diff command: cvs -q diff -u
Files affected: sh-script.el
Index: sh-script.el
===================================================================
RCS file: /pack/xemacscvs/XEmacs/packages/xemacs-packages/sh-script/sh-script.el,v
retrieving revision 1.8
diff -u -r1.8 sh-script.el
--- sh-script.el 2003/01/06 18:31:31 1.8
+++ sh-script.el 2005/10/12 21:30:16
＠＠ -1,9 +1,10 ＠＠
;;; sh-script.el --- shell-script editing commands for Emacs
-;; Copyright (C) 1993, 94, 95, 96, 1997 by Free Software Foundation, Inc.
+;; Copyright (C) 1993, 94, 95, 96, 97, 1999, 2001
+;; Free Software Foundation, Inc.
;; Author: Daniel Pfeiffer <occitan(a)esperanto.org>
-;; Version: 2.0e
+;; Version: 2.0f
;; Maintainer: FSF
;; Keywords: languages, unix
＠＠ -21,10 +22,10 ＠＠
;; You should have received a copy of the GNU General Public License
;; along with XEmacs; see the file COPYING. If not, write to the Free
-;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-;; 02111-1307, USA.
+;; Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+;; 02110-1301, USA.
-;;; Synched up with: FSF 20.7.
+;;; Synched up with: FSF 21.4.
;;; Commentary:
＠＠ -40,25 +41,166 ＠＠
;; - Variables in `"' strings aren't fontified because there's no way of
;; syntactically distinguishing those from `'' strings.
+;; Indentation
+;; ===========
+;; Indentation for rc and es modes is very limited, but for Bourne shells
+;; and its derivatives it is quite customizable.
+;;
+;; The following description applies to sh and derived shells (bash,
+;; zsh, ...).
+;;
+;; There are various customization variables which allow tailoring to
+;; a wide variety of styles. Most of these variables are named
+;; sh-indent-for-XXX and sh-indent-after-XXX. For example.
+;; sh-indent-after-if controls the indenting of a line following
+;; an if statement, and sh-indent-for-fi controls the indentation
+;; of the line containing the fi.
+;;
+;; You can set each to a numeric value, but it is often more convenient
+;; to a symbol such as `+' which uses the value of variable `sh-basic-offset'.
+;; By changing this one variable you can increase or decrease how much
+;; indentation there is. Valid symbols:
+;;
+;; + Indent right by sh-basic-offset
+;; - Indent left by sh-basic-offset
+;; ++ Indent right twice sh-basic-offset
+;; -- Indent left twice sh-basic-offset
+;; * Indent right half sh-basic-offset
+;; / Indent left half sh-basic-offset.
+;;
+;; There are 4 commands to help set the indentation variables:
+;;
+;; `sh-show-indent'
+;; This shows what variable controls the indentation of the current
+;; line and its value.
+;;
+;; `sh-set-indent'
+;; This allows you to set the value of the variable controlling the
+;; current line's indentation. You can enter a number or one of a
+;; number of special symbols to denote the value of sh-basic-offset,
+;; or its negative, or half it, or twice it, etc. If you've used
+;; cc-mode this should be familiar. If you forget which symbols are
+;; valid simply press C-h at the prompt.
+;;
+;; `sh-learn-line-indent'
+;; Simply make the line look the way you want it, then invoke this
+;; command. It will set the variable to the value that makes the line
+;; indent like that. If called with a prefix argument then it will set
+;; the value to one of the symbols if applicable.
+;;
+;; `sh-learn-buffer-indent'
+;; This is the deluxe function! It "learns" the whole buffer (use
+;; narrowing if you want it to process only part). It outputs to a
+;; buffer *indent* any conflicts it finds, and all the variables it has
+;; learned. This buffer is a sort of Occur mode buffer, allowing you to
+;; easily find where something was set. It is popped to automatically
+;; if there are any conflicts found or if `sh-popup-occur-buffer' is
+;; non-nil.
+;; `sh-indent-comment' will be set if all comments follow the same
+;; pattern; if they don't it will be set to nil.
+;; Whether `sh-basic-offset' is set is determined by variable
+;; `sh-learn-basic-offset'.
+;;
+;; Unfortunately, `sh-learn-buffer-indent' can take a long time to run
+;; (e.g. if there are large case statements). Perhaps it does not make
+;; sense to run it on large buffers: if lots of lines have different
+;; indentation styles it will produce a lot of diagnostics in the
+;; *indent* buffer; if there is a consistent style then running
+;; `sh-learn-buffer-indent' on a small region of the buffer should
+;; suffice.
+;;
+;; Saving indentation values
+;; -------------------------
+;; After you've learned the values in a buffer, how to you remember
+;; them? Originally I had hoped that `sh-learn-buffer-indent'
+;; would make this unnecessary; simply learn the values when you visit
+;; the buffer.
+;; You can do this automatically like this:
+;; (add-hook 'sh-set-shell-hook 'sh-learn-buffer-indent)
+;;
+;; However... `sh-learn-buffer-indent' is extremely slow,
+;; especially on large-ish buffer. Also, if there are conflicts the
+;; "last one wins" which may not produce the desired setting.
+;;
+;; So...There is a minimal way of being able to save indentation values and
+;; to reload them in another buffer or at another point in time.
+;;
+;; Use `sh-name-style' to give a name to the indentation settings of
+;; the current buffer.
+;; Use `sh-load-style' to load indentation settings for the current
+;; buffer from a specific style.
+;; Use `sh-save-styles-to-buffer' to write all the styles to a buffer
+;; in lisp code. You can then store it in a file and later use
+;; `load-file' to load it.
+;;
+;; Indentation variables - buffer local or global?
+;; ----------------------------------------------
+;; I think that often having them buffer-local makes sense,
+;; especially if one is using `sh-learn-buffer-indent'. However, if
+;; a user sets values using customization, these changes won't appear
+;; to work if the variables are already local!
+;;
+;; To get round this, there is a variable `sh-make-vars-local' and 2
+;; functions: `sh-make-vars-local' and `sh-reset-indent-vars-to-global-values'.
+;;
+;; If `sh-make-vars-local' is non-nil, then these variables become
+;; buffer local when the mode is established.
+;; If this is nil, then the variables are global. At any time you
+;; can make them local with the command `sh-make-vars-local'.
+;; Conversely, to update with the global values you can use the
+;; command `sh-reset-indent-vars-to-global-values'.
+;;
+;; This may be awkward, but the intent is to cover all cases.
+;;
+;; Awkward things, pitfalls
+;; ------------------------
+;; Indentation for a sh script is complicated for a number of reasons:
+;;
+;; 1. You can't format by simply looking at symbols, you need to look
+;; at keywords. [This is not the case for rc and es shells.]
+;; 2. The character ")" is used both as a matched pair "(" ... ")" and
+;; as a stand-alone symbol (in a case alternative). This makes
+;; things quite tricky!
+;; 3. Here-documents in a script should be treated "as is", and when
+;; they terminate we want to revert to the indentation of the line
+;; containing the "<<" symbol.
+;; 4. A line may be continued using the "\".
+;; 5. The character "#" (outside a string) normally starts a comment,
+;; but it doesn't in the sequence "$#"!
+;;
+;; To try and address points 2 3 and 5 I used a feature that cperl mode
+;; uses, that of a text's syntax property. This, however, has 2
+;; disadvantages:
+;; 1. We need to scan the buffer to find which ")" symbols belong to a
+;; case alternative, to find any here documents, and handle "$#".
+;; 2. Setting the text property makes the buffer modified. If the
+;; buffer is read-only buffer we have to cheat and bypass the read-only
+;; status. This is for cases where the buffer started read-only buffer
+;; but the user issued `toggle-read-only'.
+;;
+;; Bugs
+;; ----
+;; - Indenting many lines is slow. It currently does each line
+;; independently, rather than saving state information.
+;;
+;; - `sh-learn-buffer-indent' is extremely slow.
+;;
+;; Richard Sharman <rsharman(a)pobox.com> June 1999.
+
;;; Code:
;; page 1: variables and settings
-;; page 2: mode-command and utility functions
-;; page 3: statement syntax-commands for various shells
-;; page 4: various other commands
-
+;; page 2: indentation stuff
+;; page 3: mode-command and utility functions
+;; page 4: statement syntax-commands for various shells
+;; page 5: various other commands
+
+(eval-when-compile
+ (require 'skeleton)
+ (require 'comint))
(require 'executable)
-(require 'skeleton)
-(defcustom sh-mode-hook nil
- "*Hook run by `sh-mode'."
-:type 'hook
-:group 'sh)
-(defcustom sh-set-shell-hook nil
- "*Hook run by `sh-set-shell'."
-:type 'hook
-:group 'sh)
(defgroup sh nil
"Shell programming utilities"
＠＠ -123,7 +265,6 ＠＠
(itcsh . tcsh)
(jcsh . csh)
(jsh . sh)
- (cmd . sh)
(ksh . ksh88)
(ksh88 . jsh)
(oash . sh)
＠＠ -148,7 +289,6 ＠＠
ash ? Shell
jsh Bourne Shell with Job Control
bash GNU Bourne Again Shell
- bash2 GNU Bourne Again Shell v2.*
ksh88 Korn Shell '88
ksh Korn Shell '93
dtksh CDE Desktop Korn Shell
＠＠ -163,7 +303,7 ＠＠
(defcustom sh-alias-alist
- ;; XEmacs: Linux is spelled `linux'
+ ;; XEmacs change: Linux is spelled `linux'
(nconc (if (eq system-type 'linux)
'((csh . tcsh)
(ksh . pdksh)))
＠＠ -226,18 +366,18 ＠＠
:group 'sh-script)
(defcustom sh-imenu-generic-expression
- (list
- (cons 'sh
- (concat
- "\\(^\\s-*function\\s-+[A-Za-z_][A-Za-z_0-9]*\\)"
- "\\|"
- "\\(^\\s-*[A-Za-z_][A-Za-z_0-9]*\\s-*()\\)")))
- "*Regular expression for recognizing shell function definitions.
-See `sh-feature'."
-:type '(repeat (cons (symbol :tag "Shell")
- regexp))
+ `((sh
+ . ((nil "^\\s-*\\(function\\s-+\\)?\\([A-Za-z_][A-Za-z_0-9]+\\)\\s-*()" 2))))
+ "*Alist of regular expressions for recognizing shell function definitions.
+See `sh-feature' and `imenu-generic-expression'."
+:type '(alist :key-type (symbol :tag "Shell")
+ :value-type (alist :key-type (choice :tag "Title"
+ string
+ (const :tag "None" nil))
+ :value-type
+ (repeat :tag "Regexp, index..." sexp)))
:group 'sh-script
-:version "20.3")
+:version "20.4")
(defvar sh-shell-variables nil
"Alist of shell variable names that should be included in completion.
＠＠ -257,9 +397,7 ＠＠
(or (cdr (assq shell sh-alias-alist))
shell))
-(defvar sh-shell (sh-canonicalize-shell
- (file-name-sans-extension
- (file-name-nondirectory sh-shell-file)))
+(defvar sh-shell (sh-canonicalize-shell (file-name-nondirectory sh-shell-file))
"The shell being programmed. This is set by \\[sh-set-shell].")
;;; I turned off this feature because it doesn't permit typing commands
＠＠ -300,26 +438,24 ＠＠
-(defvar sh-mode-syntax-table
- '((sh eval sh-mode-syntax-table ()
- ?\# "<"
- ?\^l ">#"
- ?\n ">#"
- ?\" "\"\""
- ?\' "\"'"
- ?\` "\"`"
- ?! "_"
- ?% "_"
- ?: "_"
- ?. "_"
- ?^ "_"
- ?~ "_")
- (csh eval identity sh)
- (rc eval identity sh))
- "Syntax-table used in Shell-Script mode. See `sh-feature'.")
+(easy-mmode-defsyntax sh-mode-syntax-table
+ '((?\# . "<")
+ (?\^l . ">#")
+ (?\n . ">#")
+ (?\" . "\"\"")
+ (?\' . "\"'")
+ (?\` . "\"`")
+ (?! . "_")
+ (?% . "_")
+ (?: . "_")
+ (?. . "_")
+ (?^ . "_")
+ (?~ . "_")
+ (?< . ".")
+ (?> . "."))
+ "Syntax-table used in Shell-Script mode.")
-
(defvar sh-mode-map
(let ((map (make-sparse-keymap))
(menu-map (make-sparse-keymap "Insert")))
＠＠ -334,6 +470,10 ＠＠
(define-key map "\C-c\C-i" 'sh-if)
(define-key map "\C-c\C-f" 'sh-for)
(define-key map "\C-c\C-c" 'sh-case)
+ (define-key map "\C-c?" 'sh-show-indent)
+ (define-key map "\C-c=" 'sh-set-indent)
+ (define-key map "\C-c<" 'sh-learn-line-indent)
+ (define-key map "\C-c>" 'sh-learn-buffer-indent)
(define-key map "=" 'sh-assignment)
(define-key map "\C-c+" 'sh-add)
＠＠ -347,15 +487,14 ＠＠
(define-key map "`" 'skeleton-pair-insert-maybe)
(define-key map "\"" 'skeleton-pair-insert-maybe)
- (define-key map "\t" 'sh-indent-line)
(substitute-key-definition 'complete-tag 'comint-dynamic-complete
map (current-global-map))
(substitute-key-definition 'newline-and-indent 'sh-newline-and-indent
map (current-global-map))
-;; GDF - Don't mess around with the DEL bindings
-; (substitute-key-definition 'delete-backward-char
-; 'backward-delete-char-untabify
-; map (current-global-map))
+;; XEmacs change: Don't mess around with the DEL bindings
+; (substitute-key-definition 'delete-backward-char
+; 'backward-delete-char-untabify
+; map (current-global-map))
(define-key map "\C-c:" 'sh-set-shell)
(substitute-key-definition 'beginning-of-defun
'sh-beginning-of-compound-command
＠＠ -364,23 +503,23 ＠＠
map (current-global-map))
(substitute-key-definition 'forward-sentence 'sh-end-of-command
map (current-global-map))
- (define-key map [menu-bar insert] (cons "Insert" menu-map))
- (define-key menu-map [sh-while] '("While Loop" . sh-while))
- (define-key menu-map [sh-until] '("Until Loop" . sh-until))
- (define-key menu-map [sh-tmp-file] '("Temporary File" . sh-tmp-file))
- (define-key menu-map [sh-select] '("Select Statement" . sh-select))
- (define-key menu-map [sh-repeat] '("Repeat Loop" . sh-repeat))
- (define-key menu-map [sh-while-getopts]
- '("Options Loop" . sh-while-getopts))
- (define-key menu-map [sh-indexed-loop]
- '("Indexed Loop" . sh-indexed-loop))
- (define-key menu-map [sh-if] '("If Statement" . sh-if))
- (define-key menu-map [sh-for] '("For Loop" . sh-for))
- (define-key menu-map [sh-case] '("Case Statement" . sh-case))
map)
"Keymap used in Shell-Script mode.")
-
+;; XEmacs change
+(easy-menu-define
+ sh-mode-menu sh-mode-map "Menu for sh-script mode"
+ '("Insert"
+ ["While Loop" sh-while t]
+ ["Until Loop" sh-until t]
+ ["Temporary File" sh-tmp-file t]
+ ["Select Statement" sh-select t]
+ ["Repeat Loop" sh-repeat t]
+ ["Options Loop" sh-while-getopts t]
+ ["Indexed Loop" sh-indexed-loop t]
+ ["If Statement" sh-if t]
+ ["For Loop" sh-for t]
+ ["Case Statement" sh-case t]))
(defcustom sh-dynamic-complete-functions
'(shell-dynamic-complete-environment-variable
＠＠ -436,7 +575,7 ＠＠
(defvar sh-header-marker nil
- "When non-`nil' is the end of header for prepending by \\[sh-execute-region].
+ "When non-nil is the end of header for prepending by \\[sh-execute-region].
That command is also used for setting this variable.")
＠＠ -461,8 +600,8 ＠＠
"Word to delimit here documents.")
(defvar sh-test
- '((sh "[ ]" . 2)
- (ksh88 "[[ ]]" . 3))
+ '((sh "[ ]" . 3)
+ (ksh88 "[[ ]]" . 4))
"Initial input in Bourne if, while and until skeletons. See `sh-feature'.")
＠＠ -492,7 +631,7 ＠＠
"bg" "fg" "jobs" "kill" "stop" "suspend")
(jcsh eval sh-append csh
- "bg" "fg" "jobs" "kill" "notify" "stop" "suspend")
+ "bg" "fg" "jobs" "kill" "notify" "stop" "suspend")
(ksh88 eval sh-append bourne
"alias" "bg" "false" "fc" "fg" "jobs" "kill" "let" "print" "time"
＠＠ -622,7 +761,7 ＠＠
"pid" "prompt" "signals")
(jcsh eval sh-append csh
- "notify")
+ "notify")
(ksh88 eval sh-append sh
"ENV" "ERRNO" "FCEDIT" "FPATH" "HISTFILE" "HISTSIZE" "LINENO"
＠＠ -667,6 +806,21 ＠＠
"List of all shell variables available for completing read.
See `sh-feature'.")
+
+;;; Font-Lock support
+
+(defface sh-heredoc-face
+ '((((class color)
+ (background dark))
+ (:foreground "yellow" :bold t))
+ (((class color)
+ (background light))
+ (:foreground "tan" ))
+ (t
+ (:bold t)))
+ "Face to show a here-document"
+:group 'sh-indentation)
+(defvar sh-heredoc-face 'sh-heredoc-face)
(defvar sh-font-lock-keywords
＠＠ -707,16 +861,371 ＠＠
(defvar sh-font-lock-keywords-2 ()
"Gaudy level highlighting for Shell Script modes.")
+;; These are used for the syntax table stuff (derived from cperl-mode).
+;; Note: parse-sexp-lookup-properties must be set to t for it to work.
+
+;; XEmacs change: syntax-string-to-code replaces string-to-syntax
+(defconst sh-st-punc (syntax-string-to-code "."))
+(defconst sh-st-symbol (syntax-string-to-code "_"))
+(defconst sh-here-doc-syntax (syntax-string-to-code "|")) ;; generic string
+
+(defun sh-font-lock-heredoc (start string quoted)
+ "Determine the syntax of the \\n after a <<HEREDOC."
+ (unless (sh-in-comment-or-string start)
+ ;; We're looking at <<STRING, so we add "^STRING$" to the syntactic
+ ;; font-lock keywords to detect the end of this here document.
+ (let ((ere (concat
+ "^" (if quoted "[ \t]*")
+ (regexp-quote (replace-regexp-in-string "['\"]" "" string))
+ "\\(\n\\)")))
+ (unless (assoc ere font-lock-syntactic-keywords)
+ (let* ( ;; A rough regexp that should find us back.
+ (sre (concat "<<\\(-\\)?\\s-*\\\\?['\"]?"
+ (regexp-quote string) "['\"]?[ \t\n]"))
+ (code `(cond
+ ((save-excursion (re-search-backward ,sre nil t))
+ ;; This ^STRING$ is indeed following a <<STRING
+ sh-here-doc-syntax)
+ ((not (save-excursion (re-search-forward ,sre nil t)))
+ ;; There's no <<STRING either before or after us,
+ ;; so we should remove this now obsolete entry.
+ (setq font-lock-syntactic-keywords
+ (delq (assoc ,ere font-lock-syntactic-keywords)
+ font-lock-syntactic-keywords))
+ nil))))
+ ;; Use destructive update so the new keyword gets used right away.
+ (setq font-lock-syntactic-keywords
+ (nconc font-lock-syntactic-keywords
+ (list (font-lock-compile-keyword `(,ere 1 ,code))))))))
+ sh-here-doc-syntax))
+
+(defun sh-font-lock-paren (start)
+ (save-excursion
+ (goto-char start)
+ ;; Skip through all patterns
+ (while
+ (progn
+ (forward-comment (- (point-max)))
+ ;; Skip through one pattern
+ (while
+ (or (/= 0 (skip-syntax-backward "w_"))
+ (/= 0 (skip-chars-backward "?*/"))
+ (when (memq (char-before) '(?\" ?\'))
+ (condition-case nil (progn (backward-sexp 1) t)
+ (error nil)))))
+ (forward-comment (- (point-max)))
+ (when (eq (char-before) ?|)
+ (backward-char 1) t)))
+ (when (save-excursion (backward-char 2) (looking-at ";;\\|in"))
+ sh-st-punc)))
+
(defconst sh-font-lock-syntactic-keywords
- ;; Mark a `#' character as having punctuation syntax in a variable reference.
- ;; Really we should do this properly. From Chet Ramey and Brian Fox:
- ;; "A `#' begins a comment when it is unquoted and at the beginning of a
- ;; word. In the shell, words are separated by metacharacters."
- ;; To do this in a regexp would be slow as it would be anchored to the right.
- ;; But I can't be bothered to write a function to do it properly and
- ;; efficiently. So we only do it properly for `#' in variable references and
- ;; do it efficiently by anchoring the regexp to the left.
- '(("\\${?[^}#\n\t ]*\\(##?\\)" 1 (1 . nil))))
+ ;; A `#' begins a comment when it is unquoted and at the beginning of a
+ ;; word. In the shell, words are separated by metacharacters.
+ ;; The list of special chars is taken from the single-unix spec
+ ;; of the shell command language (under `quoting') but with `$' removed.
+ `(("[^|&;<>()`\\\"' \t\n]\\(#+\\)" 1 ,sh-st-symbol)
+ ;; Find HEREDOC starters and add a corresponding rule for the ender.
+ ("[^<>]<<\\(-\\)?\\s-*\\\\?\\(\\(['\"][^'\"]+['\"]\\|\\sw\\|\\s_\\)+\\).*\\(\n\\)"
+ 4 (sh-font-lock-heredoc
+ (match-beginning 0) (match-string 2) (match-end 1)))
+ ;; Distinguish the special close-paren in `case'.
+ (")" 0 (sh-font-lock-paren (match-beginning 0)))))
+
+(defun sh-font-lock-syntactic-face-function (state)
+ (if (nth 3 state)
+ (if (char-valid-p (nth 3 state))
+ font-lock-string-face
+ sh-heredoc-face)
+ font-lock-comment-face))
+
+(defgroup sh-indentation nil
+ "Variables controlling indentation in shell scripts.
+
+Note: customizing these variables will not affect existing buffers if
+`sh-make-vars-local' is no-nil. See the documentation for
+variable `sh-make-vars-local', command `sh-make-vars-local'
+and command `sh-reset-indent-vars-to-global-values'."
+:group 'sh-script)
+
+
+(defcustom sh-set-shell-hook nil
+ "*Hook run by `sh-set-shell'."
+:type 'hook
+:group 'sh-script)
+
+(defcustom sh-mode-hook nil
+ "*Hook run by `sh-mode'."
+:type 'hook
+:group 'sh-script)
+
+(defcustom sh-learn-basic-offset nil
+ "*When `sh-guess-basic-offset' should learn `sh-basic-offset'.
+
+nil mean: never.
+t means: only if there seems to be an obvious value.
+Anything else means: whenever we have a \"good guess\" as to the value."
+:type '(choice
+ (const :tag "Never" nil)
+ (const :tag "Only if sure" t)
+ (const :tag "If have a good guess" usually))
+:group 'sh-indentation)
+
+(defcustom sh-popup-occur-buffer nil
+ "*Controls when `sh-learn-buffer-indent' pops the *indent* buffer.
+If t it is always shown. If nil, it is shown only when there
+are conflicts."
+:type '(choice
+ (const :tag "Only when there are conflicts." nil)
+ (const :tag "Always" t))
+:group 'sh-indentation)
+
+(defcustom sh-blink t
+ "*If non-nil, `sh-show-indent' shows the line indentation is relative to.
+The position on the line is not necessarily meaningful.
+In some cases the line will be the matching keyword, but this is not
+always the case."
+:type 'boolean
+:group 'sh-indentation)
+
+(defcustom sh-first-lines-indent 0
+ "*The indentation of the first non-blank non-comment line.
+Usually 0 meaning first column.
+Can be set to a number, or to nil which means leave it as is."
+:type '(choice
+ (const :tag "Leave as is" nil)
+ (integer :tag "Column number"
+ :menu-tag "Indent to this col (0 means first col)" ))
+:group 'sh-indentation)
+
+
+(defcustom sh-basic-offset 4
+ "*The default indentation increment.
+This value is used for the + and - symbols in an indentation variable."
+:type 'integer
+:group 'sh-indentation)
+
+(defcustom sh-indent-comment nil
+ "*How a comment line is to be indented.
+nil means leave it as it is;
+t means indent it as a normal line, aligning it to previous non-blank
+ non-comment line;
+a number means align to that column, e.g. 0 means fist column."
+:type '(choice
+ (const :tag "Leave as is." nil)
+ (const :tag "Indent as a normal line." t)
+ (integer :menu-tag "Indent to this col (0 means first col)."
+ :tag "Indent to column number.") )
+:group 'sh-indentation)
+
+
+(defvar sh-debug nil
+ "Enable lots of debug messages - if function `sh-debug' is enabled.")
+
+
+;; Uncomment this defun and comment the defmacro for debugging.
+;; (defun sh-debug (&rest args)
+;; "For debugging: display message ARGS if variable SH-DEBUG is non-nil."
+;; (if sh-debug
+;; (apply 'message args)))
+(defmacro sh-debug (&rest args))
+
+(defconst sh-symbol-list
+ '((const :tag "+ " :value +
+ :menu-tag "+ Indent right by sh-basic-offset")
+ (const :tag "- " :value -
+ :menu-tag "- Indent left by sh-basic-offset")
+ (const :tag "++" :value ++
+ :menu-tag "++ Indent right twice sh-basic-offset")
+ (const :tag "--" :value --
+ :menu-tag "-- Indent left twice sh-basic-offset")
+ (const :tag "* " :value *
+ :menu-tag "* Indent right half sh-basic-offset")
+ (const :tag "/ " :value /
+ :menu-tag "/ Indent left half sh-basic-offset")))
+
+(defcustom sh-indent-for-else 0
+ "*How much to indent an else relative to an if. Usually 0."
+:type `(choice
+ (integer :menu-tag "A number (positive=>indent right)"
+ :tag "A number")
+ (const :tag "--") ;; separator!
+ ,＠ sh-symbol-list
+ )
+:group 'sh-indentation)
+
+(defconst sh-number-or-symbol-list
+ (append '((integer :menu-tag "A number (positive=>indent right)"
+ :tag "A number")
+ (const :tag "--")) ; separator
+ sh-symbol-list))
+
+(defcustom sh-indent-for-fi 0
+ "*How much to indent a fi relative to an if. Usually 0."
+:type `(choice ,＠ sh-number-or-symbol-list )
+:group 'sh-indentation)
+
+(defcustom sh-indent-for-done '0
+ "*How much to indent a done relative to its matching stmt. Usually 0."
+:type `(choice ,＠ sh-number-or-symbol-list )
+:group 'sh-indentation)
+
+(defcustom sh-indent-after-else '+
+ "*How much to indent a statement after an else statement."
+:type `(choice ,＠ sh-number-or-symbol-list )
+:group 'sh-indentation)
+
+(defcustom sh-indent-after-if '+
+ "*How much to indent a statement after an if statement.
+This includes lines after else and elif statements, too, but
+does not affect then else elif or fi statements themselves."
+:type `(choice ,＠ sh-number-or-symbol-list )
+:group 'sh-indentation)
+
+(defcustom sh-indent-for-then '+
+ "*How much to indent a then relative to an if."
+:type `(choice ,＠ sh-number-or-symbol-list )
+:group 'sh-indentation)
+
+(defcustom sh-indent-for-do '*
+ "*How much to indent a do statement.
+This is relative to the statement before the do, i.e. the
+while until or for statement."
+:type `(choice ,＠ sh-number-or-symbol-list)
+:group 'sh-indentation)
+
+(defcustom sh-indent-after-do '*
+ "*How much to indent a line after a do statement.
+This is used when the do is the first word of the line.
+This is relative to the statement before the do, e.g. a
+while for repeat or select statement."
+:type `(choice ,＠ sh-number-or-symbol-list)
+:group 'sh-indentation)
+
+(defcustom sh-indent-after-loop-construct '+
+ "*How much to indent a statement after a loop construct.
+
+This variable is used when the keyword \"do\" is on the same line as the
+loop statement (e.g. \"until\", \"while\" or \"for\").
+If the do is on a line by itself, then `sh-indent-after-do' is used instead."
+:type `(choice ,＠ sh-number-or-symbol-list)
+:group 'sh-indentation)
+
+
+(defcustom sh-indent-after-done 0
+ "*How much to indent a statement after a \"done\" keyword.
+Normally this is 0, which aligns the \"done\" to the matching
+looping construct line.
+Setting it non-zero allows you to have the \"do\" statement on a line
+by itself and align the done under to do."
+:type `(choice ,＠ sh-number-or-symbol-list)
+:group 'sh-indentation)
+
+(defcustom sh-indent-for-case-label '+
+ "*How much to indent a case label statement.
+This is relative to the line containing the case statement."
+:type `(choice ,＠ sh-number-or-symbol-list)
+:group 'sh-indentation)
+
+(defcustom sh-indent-for-case-alt '++
+ "*How much to indent statements after the case label.
+This is relative to the line containing the case statement."
+:type `(choice ,＠ sh-number-or-symbol-list)
+:group 'sh-indentation)
+
+
+(defcustom sh-indent-for-continuation '+
+ "*How much to indent for a continuation statement."
+:type `(choice ,＠ sh-number-or-symbol-list)
+:group 'sh-indentation)
+
+(defcustom sh-indent-after-open '+
+ "*How much to indent after a line with an opening parenthesis or brace.
+For an open paren after a function `sh-indent-after-function' is used."
+:type `(choice ,＠ sh-number-or-symbol-list)
+:group 'sh-indentation)
+
+(defcustom sh-indent-after-function '+
+ "*How much to indent after a function line."
+:type `(choice ,＠ sh-number-or-symbol-list)
+:group 'sh-indentation)
+
+;; These 2 are for the rc shell:
+
+(defcustom sh-indent-after-switch '+
+ "*How much to indent a case statement relative to the switch statement.
+This is for the rc shell."
+:type `(choice ,＠ sh-number-or-symbol-list)
+:group 'sh-indentation)
+
+(defcustom sh-indent-after-case '+
+ "*How much to indent a statement relative to the case statement.
+This is for the rc shell."
+:type `(choice ,＠ sh-number-or-symbol-list)
+:group 'sh-indentation)
+
+;; Internal use - not designed to be changed by the user:
+
+(defun sh-mkword-regexpr (word)
+ "Make a regexp which matches WORD as a word.
+This specifically excludes an occurrence of WORD followed by
+punctuation characters like '-'."
+ (concat word "\\([^-a-z0-9_]\\|$\\)"))
+
+(defconst sh-re-done (sh-mkword-regexpr "done"))
+
+
+(defconst sh-kws-for-done
+ '((sh . ( "while" "until" "for" ) )
+ (bash . ( "while" "until" "for" "select" ) )
+ (ksh88 . ( "while" "until" "for" "select" ) )
+ (zsh . ( "while" "until" "for" "repeat" "select" ) ) )
+ "Which keywords can match the word `done' in this shell.")
+
+
+(defconst sh-indent-supported
+ '((sh . t)
+ (csh . nil)
+ (rc . t))
+ "Shell types that shell indenting can do something with.")
+
+(defvar sh-indent-supported-here nil
+ "Non-nil if we support indentation for the current buffer's shell type.")
+
+(defconst sh-electric-rparen-needed
+ '((sh . t))
+ "Non-nil if the shell type needs an electric handling of case alternatives.")
+
+(defconst sh-var-list
+ '(
+ sh-basic-offset sh-first-lines-indent sh-indent-after-case
+ sh-indent-after-do sh-indent-after-done
+ sh-indent-after-else
+ sh-indent-after-if
+ sh-indent-after-loop-construct
+ sh-indent-after-open
+ sh-indent-comment
+ sh-indent-for-case-alt
+ sh-indent-for-case-label
+ sh-indent-for-continuation
+ sh-indent-for-do
+ sh-indent-for-done
+ sh-indent-for-else
+ sh-indent-for-fi
+ sh-indent-for-then
+ )
+ "A list of variables used by script mode to control indentation.
+This list is used when switching between buffer-local and global
+values of variables, and for the commands using indentation styles.")
+
+(defvar sh-make-vars-local t
+ "*Controls whether indentation variables are local to the buffer.
+If non-nil, indentation variables are made local initially.
+If nil, you can later make the variables local by invoking
+command `sh-make-vars-local'.
+The default is t because I assume that in one Emacs session one is
+frequently editing existing scripts with different styles.")
+
;; mode-command and utility functions
＠＠ -724,7 +1233,7 ＠＠
(put 'sh-mode 'mode-class 'special)
;;;###autoload
-(defun sh-mode ()
+(define-derived-mode sh-mode nil "Shell-script"
"Major mode for editing shell scripts.
This mode works for many shells, since they all have roughly the same syntax,
as far as commands, arguments, variables, pipes, comments etc. are concerned.
＠＠ -751,6 +1260,15 ＠＠
\\[sh-until] until loop
\\[sh-while] while loop
+For sh and rc shells indentation commands are:
+\\[sh-show-indent] Show the variable controlling this line's indentation.
+\\[sh-set-indent] Set then variable controlling this line's indentation.
+\\[sh-learn-line-indent] Change the indentation variable so this line
+would indent to the way it currently is.
+\\[sh-learn-buffer-indent] Set the indentation variables so the
+buffer indents as it currently is indented.
+
+
\\[backward-delete-char-untabify] Delete backward one position, even if it was a tab.
\\[sh-newline-and-indent] Delete unquoted space and indent new line same as this one.
\\[sh-end-of-command] Go to end of successive commands.
＠＠ -768,11 +1286,6 ＠＠
If your shell gives error messages with line numbers, you can use \\[executable-interpret]
with your script for an edit-interpret-debug cycle."
- (interactive)
- (kill-all-local-variables)
- (use-local-map sh-mode-map)
- (make-local-variable 'indent-line-function)
- (make-local-variable 'indent-region-function)
(make-local-variable 'skeleton-end-hook)
(make-local-variable 'paragraph-start)
(make-local-variable 'paragraph-separate)
＠＠ -792,19 +1305,8 ＠＠
(make-local-variable 'sh-shell-variables)
(make-local-variable 'sh-shell-variables-initialized)
(make-local-variable 'imenu-generic-expression)
- (setq major-mode 'sh-mode
- mode-name "Shell-script"
- indent-line-function 'sh-indent-line
- ;; not very clever, but enables wrapping skeletons around regions
- indent-region-function (lambda (b e)
- (save-excursion
- (goto-char b)
- (skip-syntax-backward "-")
- (setq b (point))
- (goto-char e)
- (skip-syntax-backward "-")
- (indent-rigidly b (point) sh-indentation)))
- skeleton-end-hook (lambda ()
+ (make-local-variable 'sh-indent-supported-here)
+ (setq skeleton-end-hook (lambda ()
(or (eolp) (newline) (indent-relative)))
paragraph-start (concat page-delimiter "\\|$")
paragraph-separate paragraph-start
＠＠ -813,19 +1315,23 ＠＠
;; we can't look if previous line ended with `\'
comint-prompt-regexp "^[ \t]*"
font-lock-defaults
- '((sh-font-lock-keywords
+ `((sh-font-lock-keywords
sh-font-lock-keywords-1 sh-font-lock-keywords-2)
nil nil
((?/ . "w") (?~ . "w") (?. . "w") (?- . "w") (?_ . "w")) nil
- (font-lock-syntactic-keywords . sh-font-lock-syntactic-keywords))
+ (font-lock-syntactic-keywords
+ ;; Copy so we can use destructive update in `sh-font-lock-heredoc'.
+ . ,(copy-sequence sh-font-lock-syntactic-keywords))
+ (font-lock-syntactic-face-function
+ . sh-font-lock-syntactic-face-function))
skeleton-pair-alist '((?` _ ?`))
skeleton-pair-filter 'sh-quoted-p
skeleton-further-elements '((< '(- (min sh-indentation
(current-column)))))
skeleton-filter 'sh-feature
- skeleton-newline-indent-rigidly t)
- (make-local-variable 'parse-sexp-ignore-comments)
- (setq parse-sexp-ignore-comments t)
+ skeleton-newline-indent-rigidly t
+ sh-indent-supported-here nil)
+ (set (make-local-variable 'parse-sexp-ignore-comments) t)
;; Parse or insert magic number for exec, and set all variables depending
;; on the shell thus determined.
(let ((interpreter
＠＠ -836,20 +1342,15 ＠＠
((and buffer-file-name
(string-match "\\.m?spec$" buffer-file-name))
"rpm")))))
- (if interpreter
- (sh-set-shell interpreter nil nil)
- (progn
- ;; If we don't know the shell for this file, set the syntax
- ;; table anyway, for the user's normal choice of shell.
- (set-syntax-table (or (sh-feature sh-mode-syntax-table)
- (standard-syntax-table)))
- ;; And avoid indent-new-comment-line (at least) losing.
- (setq comment-start-skip "#+[\t ]*"))))
- (run-hooks 'sh-mode-hook))
+ (sh-set-shell (or interpreter sh-shell-file) nil nil))
+ ;; XEmacs change
+ (if sh-mode-menu
+ (easy-menu-add sh-mode-menu)))
+
;;;###autoload
(defalias 'shell-script-mode 'sh-mode)
-;;; XEmacs
+;;; XEmacs change
(put 'sh-mode 'font-lock-defaults
`((sh-font-lock-keywords
sh-font-lock-keywords-1
＠＠ -888,7 +1389,7 ＠＠
(mapconcat 'identity (sh-feature sh-builtins) "\\|")
"\\)\\>")
(2 font-lock-keyword-face nil t)
- (6 font-lock-function-name-face))
+ (6 font-lock-builtin-face))
,＠(sh-feature sh-font-lock-keywords-2)))
(,(concat keywords "\\)\\>")
2 font-lock-keyword-face)
＠＠ -899,6 +1400,61 ＠＠
(sh-font-lock-keywords-1 t))
+(defvar sh-regexp-for-done nil
+ "A buffer-local regexp to match opening keyword for done.")
+
+(defvar sh-kw-alist nil
+ "A buffer-local, since it is shell-type dependent, list of keywords.")
+
+;; ( key-word first-on-this on-prev-line )
+;; This is used to set `sh-kw-alist' which is a list of sublists each
+;; having 3 elements:
+;; a keyword
+;; a rule to check when the keyword appears on "this" line
+;; a rule to check when the keyword appears on "the previous" line
+;; The keyword is usually a string and is the first word on a line.
+;; If this keyword appears on the line whose indentation is to be
+;; calculated, the rule in element 2 is called. If this returns
+;; non-zero, the resulting point (which may be changed by the rule)
+;; is used as the default indentation.
+;; If it returned false or the keyword was not found in the table,
+;; then the keyword from the previous line is looked up and the rule
+;; in element 3 is called. In this case, however,
+;; `sh-get-indent-info' does not stop but may keep going and test
+;; other keywords against rules in element 3. This is because the
+;; preceding line could have, for example, an opening "if" and an
+;; opening "while" keyword and we need to add the indentation offsets
+;; for both.
+;;
+(defconst sh-kw
+ '((sh
+ ("if" nil sh-handle-prev-if)
+ ("elif" sh-handle-this-else sh-handle-prev-else)
+ ("else" sh-handle-this-else sh-handle-prev-else)
+ ("fi" sh-handle-this-fi sh-handle-prev-fi)
+ ("then" sh-handle-this-then sh-handle-prev-then)
+ ("(" nil sh-handle-prev-open)
+ ("{" nil sh-handle-prev-open)
+ ("[" nil sh-handle-prev-open)
+ ("}" sh-handle-this-close nil)
+ (")" sh-handle-this-close nil)
+ ("]" sh-handle-this-close nil)
+ ("case" nil sh-handle-prev-case)
+ ("esac" sh-handle-this-esac sh-handle-prev-esac)
+ (case-label nil sh-handle-after-case-label) ;; ???
+ (";;" nil sh-handle-prev-case-alt-end) ;; ???
+ ("done" sh-handle-this-done sh-handle-prev-done)
+ ("do" sh-handle-this-do sh-handle-prev-do))
+
+ ;; Note: we don't need specific stuff for bash and zsh shells;
+ ;; the regexp `sh-regexp-for-done' handles the extra keywords
+ ;; these shells use.
+ (rc
+ ("{" nil sh-handle-prev-open)
+ ("}" sh-handle-this-close nil)
+ ("case" sh-handle-this-rc-case sh-handle-prev-rc-case))))
+
+
(defun sh-set-shell (shell &optional no-query-flag insert-flag)
"Set this buffer's shell to SHELL (a string).
Makes this script executable via `executable-set-magic', and sets up the
＠＠ -921,26 +1477,33 ＠＠
no-query-flag insert-flag)))
(setq require-final-newline (sh-feature sh-require-final-newline)
;;; local-abbrev-table (sh-feature sh-abbrevs)
- font-lock-defaults-computed nil
-;; Packages should not need to set these variables directly. sm.
-; font-lock-keywords nil ; force resetting
-; font-lock-syntax-table nil
comment-start-skip "#+[\t ]*"
mode-line-process (format "[%s]" sh-shell)
sh-shell-variables nil
sh-shell-variables-initialized nil
imenu-generic-expression (sh-feature sh-imenu-generic-expression)
imenu-case-fold-search nil)
- (set-syntax-table (or (sh-feature sh-mode-syntax-table)
- (standard-syntax-table)))
- (let ((vars (sh-feature sh-variables)))
- (while vars
- (sh-remember-variable (car vars))
- (setq vars (cdr vars))))
-;; Packages should not need to toggle Font Lock mode. sm.
-; (and (boundp 'font-lock-mode)
-; font-lock-mode
-; (font-lock-mode (font-lock-mode 0)))
+ (dolist (var (sh-feature sh-variables))
+ (sh-remember-variable var))
+ (make-local-variable 'indent-line-function)
+ (if (setq sh-indent-supported-here (sh-feature sh-indent-supported))
+ (progn
+ (message "Setting up indent for shell type %s" sh-shell)
+ (set (make-local-variable 'parse-sexp-lookup-properties) t)
+ (set (make-local-variable 'sh-kw-alist) (sh-feature sh-kw))
+ (let ((regexp (sh-feature sh-kws-for-done)))
+ (if regexp
+ (set (make-local-variable 'sh-regexp-for-done)
+ (sh-mkword-regexpr (regexp-opt regexp t)))))
+ (message "setting up indent stuff")
+ ;; sh-mode has already made indent-line-function local
+ ;; but do it in case this is called before that.
+ (setq indent-line-function 'sh-indent-line)
+ (if sh-make-vars-local
+ (sh-make-vars-local))
+ (message "Indentation setup for shell type %s" sh-shell))
+ (message "No indentation for this shell type.")
+ (setq indent-line-function 'sh-basic-indent-line))
(run-hooks 'sh-set-shell-hook))
＠＠ -1034,15 +1597,6 ＠＠
;;; (symbol-value sh-shell)))
-(defun sh-mode-syntax-table (table &rest list)
- "Copy TABLE and set syntax for successive CHARs according to strings S."
- (setq table (copy-syntax-table table))
- (while list
- (modify-syntax-entry (car list) (car (cdr list)) table)
- (setq list (cdr (cdr list))))
- table)
-
-
(defun sh-append (ancestor &rest list)
"Return list composed of first argument (a list) physically appended to rest."
(nconc list ancestor))
＠＠ -1059,7 +1613,7 ＠＠
skeleton)
-(defun sh-indent-line ()
+(defun sh-basic-indent-line ()
"Indent a line for Sh mode (shell script mode).
Indent as far as preceding non-empty line, then by steps of `sh-indentation'.
Lines containing only comments are considered empty."
＠＠ -1067,7 +1621,6 ＠＠
(let ((previous (save-excursion
(while (and (progn (beginning-of-line)
(not (bobp)))
- (not (eq (point-min) (point-at-bol)))
(progn
(forward-line -1)
(back-to-indentation)
＠＠ -1122,7 +1675,7 ＠＠
(or (< (length var) sh-remember-variable-min)
(getenv var)
(assoc var sh-shell-variables)
- (setq sh-shell-variables (cons (cons var var) sh-shell-variables)))
+ (push (cons var var) sh-shell-variables))
var)
＠＠ -1131,6 +1684,1421 ＠＠
"Is point preceded by an odd number of backslashes?"
(eq -1 (% (save-excursion (skip-chars-backward "\\\\")) 2)))
+;; Indentation stuff.
+(defun sh-must-be-shell-mode ()
+ "Signal an error if not in Shell-script mode."
+ (unless (eq major-mode 'sh-mode)
+ (error "This buffer is not in Shell-script mode")))
+
+(defun sh-must-support-indent ()
+ "*Signal an error if the shell type for this buffer is not supported.
+Also, the buffer must be in Shell-script mode."
+ (sh-must-be-shell-mode)
+ (unless sh-indent-supported-here
+ (error "This buffer's shell type is not supported for this command")))
+
+(defun sh-make-vars-local ()
+ "Make the indentation variables local to this buffer.
+Normally they already are local. This command is provided in case
+variable `sh-make-vars-local' has been set to nil.
+
+To revert all these variables to the global values, use
+command `sh-reset-indent-vars-to-global-values'."
+ (interactive)
+ (sh-must-be-shell-mode)
+ (mapcar 'make-local-variable sh-var-list)
+ (message "Indentation variable are now local."))
+
+(defun sh-reset-indent-vars-to-global-values ()
+ "Reset local indentation variables to the global values.
+Then, if variable `sh-make-vars-local' is non-nil, make them local."
+ (interactive)
+ (sh-must-be-shell-mode)
+ (mapcar 'kill-local-variable sh-var-list)
+ (if sh-make-vars-local
+ (mapcar 'make-local-variable sh-var-list)))
+
+
+;; Theoretically these are only needed in shell and derived modes.
+;; However, the routines which use them are only called in those modes.
+(defconst sh-special-keywords "then\\|do")
+
+(defun sh-help-string-for-variable (var)
+ "Construct a string for `sh-read-variable' when changing variable VAR ."
+ (let ((msg (documentation-property var 'variable-documentation))
+ (msg2 ""))
+ (unless (memq var '(sh-first-lines-indent sh-indent-comment))
+ (setq msg2
+ (format "\n
+You can enter a number (positive to increase indentation,
+negative to decrease indentation, zero for no change to indentation).
+
+Or, you can enter one of the following symbols which are relative to
+the value of variable `sh-basic-offset'
+which in this buffer is currently %s.
+
+\t%s."
+ sh-basic-offset
+ (mapconcat (lambda (x)
+ (nth (1- (length x)) x))
+ sh-symbol-list "\n\t"))))
+ (concat
+ ;; The following shows the global not the local value!
+ ;; (format "Current value of %s is %s\n\n" var (symbol-value var))
+ msg msg2)))
+
+(defun sh-read-variable (var)
+ "Read a new value for indentation variable VAR."
+ (interactive "*variable? ") ;; to test
+ (let ((minibuffer-help-form `(sh-help-string-for-variable
+ (quote ,var)))
+ val)
+ (setq val (read-from-minibuffer
+ (format "New value for %s (press %s for help): "
+ var (single-key-description help-char))
+ (format "%s" (symbol-value var))
+ nil t))
+ val))
+
+
+
+(defun sh-in-comment-or-string (start)
+ "Return non-nil if START is in a comment or string."
+ (save-excursion
+ (let (state)
+ (beginning-of-line)
+ (setq state (parse-partial-sexp (point) start nil nil nil t))
+ (or (nth 3 state)(nth 4 state)))))
+
+(defun sh-goto-matching-if ()
+ "Go to the matching if for a fi.
+This handles nested if..fi pairs."
+ (let ((found (sh-find-prev-matching "\\bif\\b" "\\bfi\\b" 1)))
+ (if found
+ (goto-char found))))
+
+
+;; Functions named sh-handle-this-XXX are called when the keyword on the
+;; line whose indentation is being handled contain XXX;
+;; those named sh-handle-prev-XXX are when XXX appears on the previous line.
+
+(defun sh-handle-prev-if ()
+ (list '(+ sh-indent-after-if)))
+
+(defun sh-handle-this-else ()
+ (if (sh-goto-matching-if)
+ ;; (list "aligned to if")
+ (list "aligned to if" '(+ sh-indent-for-else))
+ nil
+ ))
+
+(defun sh-handle-prev-else ()
+ (if (sh-goto-matching-if)
+ (list '(+ sh-indent-after-if))
+ ))
+
+(defun sh-handle-this-fi ()
+ (if (sh-goto-matching-if)
+ (list "aligned to if" '(+ sh-indent-for-fi))
+ nil
+ ))
+
+(defun sh-handle-prev-fi ()
+ ;; Why do we have this rule? Because we must go back to the if
+ ;; to get its indent. We may continue back from there.
+ ;; We return nil because we don't have anything to add to result,
+ ;; the side affect of setting align-point is all that matters.
+ ;; we could return a comment (a string) but I can't think of a good one...
+ (sh-goto-matching-if)
+ nil)
+
+(defun sh-handle-this-then ()
+ (let ((p (sh-goto-matching-if)))
+ (if p
+ (list '(+ sh-indent-for-then))
+ )))
+
+(defun sh-handle-prev-then ()
+ (let ((p (sh-goto-matching-if)))
+ (if p
+ (list '(+ sh-indent-after-if))
+ )))
+
+(defun sh-handle-prev-open ()
+ (save-excursion
+ (let ((x (sh-prev-stmt)))
+ (if (and x
+ (progn
+ (goto-char x)
+ (or
+ (looking-at "function\\b")
+ (looking-at "\\s-*\\S-+\\s-*()")
+ )))
+ (list '(+ sh-indent-after-function))
+ (list '(+ sh-indent-after-open)))
+ )))
+
+(defun sh-handle-this-close ()
+ (forward-char 1) ;; move over ")"
+ (if (sh-safe-forward-sexp -1)
+ (list "aligned to opening paren")))
+
+(defun sh-goto-matching-case ()
+ (let ((found (sh-find-prev-matching "\\bcase\\b" "\\besac\\b" 1)))
+ (if found (goto-char found))))
+
+(defun sh-handle-prev-case ()
+ ;; This is typically called when point is on same line as a case
+ ;; we shouldn't -- and can't find prev-case
+ (if (looking-at ".*\\<case\\>")
+ (list '(+ sh-indent-for-case-label))
+ (error "We don't seem to be on a line with a case"))) ;; debug
+
+(defun sh-handle-this-esac ()
+ (if (sh-goto-matching-case)
+ (list "aligned to matching case")))
+
+(defun sh-handle-prev-esac ()
+ (if (sh-goto-matching-case)
+ (list "matching case")))
+
+(defun sh-handle-after-case-label ()
+ (if (sh-goto-matching-case)
+ (list '(+ sh-indent-for-case-alt))))
+
+(defun sh-handle-prev-case-alt-end ()
+ (if (sh-goto-matching-case)
+ (list '(+ sh-indent-for-case-label))))
+
+(defun sh-safe-forward-sexp (&optional arg)
+ "Try and do a `forward-sexp', but do not error.
+Return new point if successful, nil if an error occurred."
+ (condition-case nil
+ (progn
+ (forward-sexp (or arg 1))
+ (point)) ;; return point if successful
+ (error
+ (sh-debug "oops!(1) %d" (point))
+ nil))) ;; return nil if fail
+
+(defun sh-goto-match-for-done ()
+ (let ((found (sh-find-prev-matching sh-regexp-for-done sh-re-done 1)))
+ (if found
+ (goto-char found))))
+
+(defun sh-handle-this-done ()
+ (if (sh-goto-match-for-done)
+ (list "aligned to do stmt" '(+ sh-indent-for-done))))
+
+(defun sh-handle-prev-done ()
+ (if (sh-goto-match-for-done)
+ (list "previous done")))
+
+(defun sh-handle-this-do ()
+ (if (sh-goto-match-for-done)
+ (list '(+ sh-indent-for-do))))
+
+(defun sh-handle-prev-do ()
+ (cond
+ ((save-restriction
+ (narrow-to-region
+ (point)
+ (save-excursion
+ (beginning-of-line)
+ (point)))
+ (sh-goto-match-for-done))
+ (sh-debug "match for done found on THIS line")
+ (list '(+ sh-indent-after-loop-construct)))
+ ((sh-goto-match-for-done)
+ (sh-debug "match for done found on PREV line")
+ (list '(+ sh-indent-after-do)))
+ (t
+ (message "match for done NOT found")
+ nil)))
+
+;; for rc:
+(defun sh-find-prev-switch ()
+ "Find the line for the switch keyword matching this line's case keyword."
+ (re-search-backward "\\<switch\\>" nil t))
+
+(defun sh-handle-this-rc-case ()
+ (if (sh-find-prev-switch)
+ (list '(+ sh-indent-after-switch))
+ ;; (list '(+ sh-indent-for-case-label))
+ nil))
+
+(defun sh-handle-prev-rc-case ()
+ (list '(+ sh-indent-after-case)))
+
+(defun sh-check-rule (n thing)
+ (let ((rule (nth n (assoc thing sh-kw-alist)))
+ (val nil))
+ (if rule
+ (progn
+ (setq val (funcall rule))
+ (sh-debug "rule (%d) for %s at %d is %s\n-> returned %s"
+ n thing (point) rule val)))
+ val))
+
+
+(defun sh-get-indent-info ()
+ "Return indent-info for this line.
+This is a list. nil means the line is to be left as is.
+Otherwise it contains one or more of the following sublists:
+\(t NUMBER\) NUMBER is the base location in the buffer that indentation is
+ relative to. If present, this is always the first of the
+ sublists. The indentation of the line in question is
+ derived from the indentation of this point, possibly
+ modified by subsequent sublists.
+\(+ VAR\)
+\(- VAR\) Get the value of variable VAR and add to or subtract from
+ the indentation calculated so far.
+\(= VAR\) Get the value of variable VAR and *replace* the
+ indentation with its value. This only occurs for
+ special variables such as `sh-indent-comment'.
+STRING This is ignored for the purposes of calculating
+ indentation, it is printed in certain cases to help show
+ what the indentation is based on."
+ ;; See comments before `sh-kw'.
+ (save-excursion
+ (let ((prev-kw nil)
+ (prev-stmt nil)
+ (have-result nil)
+ depth-bol depth-eol
+ this-kw
+ (state nil)
+ state-bol
+ (depth-prev-bol nil)
+ start
+ func val
+ (result nil)
+ prev-lines-indent
+ (prev-list nil)
+ (this-list nil)
+ (align-point nil)
+ prev-line-end x)
+ (beginning-of-line)
+ ;; Note: setting result to t means we are done and will return nil.
+ ;;(This function never returns just t.)
+ (cond
+ ((or (and (boundp 'font-lock-string-face)
+ (eq (get-text-property (point) 'face) font-lock-string-face))
+ (eq (get-text-property (point) 'face) sh-heredoc-face))
+ (setq result t)
+ (setq have-result t))
+ ((looking-at "\\s-*#") ; was (equal this-kw "#")
+ (if (bobp)
+ (setq result t) ;; return nil if 1st line!
+ (setq result (list '(= sh-indent-comment)))
+ ;; we still need to get previous line in case
+ ;; sh-indent-comment is t (indent as normal)
+ (setq align-point (sh-prev-line nil))
+ (setq have-result nil)
+ ))
+ ) ;; cond
+
+ (unless have-result
+ ;; Continuation lines are handled specially
+ (if (sh-this-is-a-continuation)
+ (progn
+ ;; We assume the line being continued is already
+ ;; properly indented...
+ ;; (setq prev-line-end (sh-prev-line))
+ (setq align-point (sh-prev-line nil))
+ (setq result (list '(+ sh-indent-for-continuation)))
+ (setq have-result t))
+ (beginning-of-line)
+ (skip-chars-forward " \t")
+ (setq this-kw (sh-get-kw)))
+
+ ;; Handle "this" keyword: first word on the line we're
+ ;; calculating indentation info for.
+ (if this-kw
+ (if (setq val (sh-check-rule 1 this-kw))
+ (progn
+ (setq align-point (point))
+ (sh-debug
+ "this - setting align-point to %d" align-point)
+ (setq result (append result val))
+ (setq have-result t)
+ ;; set prev-line to continue processing remainder
+ ;; of this line as a previous line
+ (setq prev-line-end (point))
+ ))))
+
+ (unless have-result
+ (setq prev-line-end (sh-prev-line 'end)))
+
+ (if prev-line-end
+ (save-excursion
+ ;; We start off at beginning of this line.
+ ;; Scan previous statements while this is <=
+ ;; start of previous line.
+ (setq start (point)) ;; for debug only
+ (goto-char prev-line-end)
+ (setq x t)
+ (while (and x (setq x (sh-prev-thing)))
+ (sh-debug "at %d x is: %s result is: %s" (point) x result)
+ (cond
+ ((and (equal x ")")
+ (equal (get-text-property (1- (point)) 'syntax-table)
+ sh-st-punc))
+ (sh-debug "Case label) here")
+ (setq x 'case-label)
+ (if (setq val (sh-check-rule 2 x))
+ (progn
+ (setq result (append result val))
+ (setq align-point (point))))
+ (forward-char -1)
+ (skip-chars-forward "[a-z0-9]*?")
+ )
+ ((string-match "[])}]" x)
+ (setq x (sh-safe-forward-sexp -1))
+ (if x
+ (progn
+ (setq align-point (point))
+ (setq result (append result
+ (list "aligned to opening paren")))
+ )))
+ ((string-match "[[({]" x)
+ (sh-debug "Checking special thing: %s" x)
+ (if (setq val (sh-check-rule 2 x))
+ (setq result (append result val)))
+ (forward-char -1)
+ (setq align-point (point)))
+ ((string-match "[\"'`]" x)
+ (sh-debug "Skipping back for %s" x)
+ ;; this was oops-2
+ (setq x (sh-safe-forward-sexp -1)))
+ ((stringp x)
+ (sh-debug "Checking string %s at %s" x (point))
+ (if (setq val (sh-check-rule 2 x))
+ ;; (or (eq t (car val))
+ ;; (eq t (car (car val))))
+ (setq result (append result val)))
+ ;; not sure about this test Wed Jan 27 23:48:35 1999
+ (setq align-point (point))
+ (unless (bolp)
+ (forward-char -1)))
+ (t
+ (error "Don't know what to do with %s" x))
+ )
+ ) ;; while
+ (sh-debug "result is %s" result)
+ )
+ (sh-debug "No prev line!")
+ (sh-debug "result: %s align-point: %s" result align-point)
+ )
+
+ (if align-point
+ ;; was: (setq result (append result (list (list t align-point))))
+ (setq result (append (list (list t align-point)) result))
+ )
+ (sh-debug "result is now: %s" result)
+
+ (or result
+ (if prev-line-end
+ (setq result (list (list t prev-line-end)))
+ (setq result (list (list '= 'sh-first-lines-indent)))
+ ))
+
+ (if (eq result t)
+ (setq result nil))
+ (sh-debug "result is: %s" result)
+ result
+ ) ;; let
+ ))
+
+
+(defun sh-get-indent-var-for-line (&optional info)
+ "Return the variable controlling indentation for this line.
+If there is not [just] one such variable, return a string
+indicating the problem.
+If INFO is supplied it is used, else it is calculated."
+ (let ((var nil)
+ (result nil)
+ (reason nil)
+ sym elt)
+ (or info
+ (setq info (sh-get-indent-info)))
+ (if (null info)
+ (setq result "this line to be left as is")
+ (while (and info (null result))
+ (setq elt (car info))
+ (cond
+ ((stringp elt)
+ (setq reason elt)
+ )
+ ((not (listp elt))
+ (error "sh-get-indent-var-for-line invalid elt: %s" elt))
+ ;; so it is a list
+ ((eq t (car elt))
+ ) ;; nothing
+ ((symbolp (setq sym (nth 1 elt)))
+ ;; A bit of a kludge - when we see the sh-indent-comment
+ ;; ignore other variables. Otherwise it is tricky to
+ ;; "learn" the comment indentation.
+ (if (eq var 'sh-indent-comment)
+ (setq result var)
+ (if var
+ (setq result
+ "this line is controlled by more than 1 variable.")
+ (setq var sym))))
+ (t
+ (error "sh-get-indent-var-for-line invalid list elt: %s" elt)))
+ (setq info (cdr info))
+ ))
+ (or result
+ (setq result var))
+ (or result
+ (setq result reason))
+ (if (null result)
+ ;; e.g. just had (t POS)
+ (setq result "line has default indentation"))
+ result))
+
+
+
+;; Finding the previous line isn't trivial.
+;; We must *always* go back one more and see if that is a continuation
+;; line -- it is the PREVIOUS line which is continued, not the one
+;; we are going to!
+;; Also, we want to treat a whole "here document" as one big line,
+;; because we may want to a align to the beginning of it.
+;;
+;; What we do:
+;; - go back to previous non-empty line
+;; - if this is in a here-document, go to the beginning of it
+;; - while previous line is continued, go back one line
+(defun sh-prev-line (&optional end)
+ "Back to end of previous non-comment non-empty line.
+Go to beginning of logical line unless END is non-nil, in which case
+we go to the end of the previous line and do not check for continuations."
+ (sh-must-be-shell-mode)
+ (save-excursion
+ (beginning-of-line)
+ (forward-comment (- (point-max)))
+ (unless end (beginning-of-line))
+ (when (and (not (bobp))
+ (equal (get-text-property (1- (point)) 'face)
+ sh-heredoc-face))
+ (let ((p1 (previous-single-property-change (1- (point)) 'face)))
+ (when p1
+ (goto-char p1)
+ (if end
+ (end-of-line)
+ (beginning-of-line)))))
+ (unless end
+ ;; we must check previous lines to see if they are continuation lines
+ ;; if so, we must return position of first of them
+ (while (and (sh-this-is-a-continuation)
+ (>= 0 (forward-line -1))))
+ (beginning-of-line)
+ (skip-chars-forward " \t"))
+ (point)))
+
+
+(defun sh-prev-stmt ()
+ "Return the address of the previous stmt or nil."
+ ;; This is used when we are trying to find a matching keyword.
+ ;; Searching backward for the keyword would certainly be quicker, but
+ ;; it is hard to remove "false matches" -- such as if the keyword
+ ;; appears in a string or quote. This way is slower, but (I think) safer.
+ (interactive)
+ (save-excursion
+ (let ((going t)
+ (start (point))
+ (found nil)
+ (prev nil))
+ (skip-chars-backward " \t;|&({[")
+ (while (and (not found)
+ (not (bobp))
+ going)
+ ;; Do a backward-sexp if possible, else backup bit by bit...
+ (if (sh-safe-forward-sexp -1)
+ (progn
+ (if (looking-at sh-special-keywords)
+ (progn
+ (setq found prev))
+ (setq prev (point))
+ ))
+ ;; backward-sexp failed
+ (if (zerop (skip-chars-backward " \t()[\]{};`'"))
+ (forward-char -1))
+ (if (bolp)
+ (let ((back (sh-prev-line nil)))
+ (if back
+ (goto-char back)
+ (setq going nil)))))
+ (unless found
+ (skip-chars-backward " \t")
+ (if (or (and (bolp) (not (sh-this-is-a-continuation)))
+ (eq (char-before) ?\;)
+ (looking-at "\\s-*[|&]"))
+ (setq found (point)))))
+ (if found
+ (goto-char found))
+ (if found
+ (progn
+ (skip-chars-forward " \t|&({[")
+ (setq found (point))))
+ (if (>= (point) start)
+ (progn
+ (debug "We didn't move!")
+ (setq found nil))
+ (or found
+ (sh-debug "Did not find prev stmt.")))
+ found)))
+
+
+(defun sh-get-word ()
+ "Get a shell word skipping whitespace from point."
+ (interactive)
+ (skip-chars-forward "\t ")
+ (let ((start (point)))
+ (while
+ (if (looking-at "[\"'`]")
+ (sh-safe-forward-sexp)
+ ;; (> (skip-chars-forward "^ \t\n\"'`") 0)
+ (> (skip-chars-forward "-_a-zA-Z\$0-9") 0)
+ ))
+ (buffer-substring start (point))
+ ))
+
+(defun sh-prev-thing ()
+ "Return the previous thing this logical line."
+ ;; This is called when `sh-get-indent-info' is working backwards on
+ ;; the previous line(s) finding what keywords may be relevant for
+ ;; indenting. It moves over sexps if possible, and will stop
+ ;; on a ; and at the beginning of a line if it is not a continuation
+ ;; line.
+ ;;
+ ;; Added a kludge for ";;"
+ ;; Possible return values:
+ ;; nil - nothing
+ ;; a string - possibly a keyword
+ ;;
+ (if (bolp)
+ nil
+ (let ((going t)
+ c n
+ min-point
+ (start (point))
+ (found nil))
+ (save-restriction
+ (narrow-to-region
+ (if (sh-this-is-a-continuation)
+ (setq min-point (sh-prev-line nil))
+ (save-excursion
+ (beginning-of-line)
+ (setq min-point (point))))
+ (point))
+ (skip-chars-backward " \t;")
+ (unless (looking-at "\\s-*;;")
+ (skip-chars-backward "^)}];\"'`({[")
+ (setq c (char-before))))
+ (sh-debug "stopping at %d c is %s start=%d min-point=%d"
+ (point) c start min-point)
+ (if (< (point) min-point)
+ (error "point %d < min-point %d" (point) min-point))
+ (cond
+ ((looking-at "\\s-*;;")
+ ;; (message "Found ;; !")
+ ";;")
+ ((or (eq c ?\n)
+ (eq c nil)
+ (eq c ?\;))
+ (save-excursion
+ ;; skip forward over white space newline and \ at eol
+ (skip-chars-forward " \t\n\\\\")
+ (sh-debug "Now at %d start=%d" (point) start)
+ (if (>= (point) start)
+ (progn
+ (sh-debug "point: %d >= start: %d" (point) start)
+ nil)
+ (sh-get-word))
+ ))
+ (t
+ ;; c -- return a string
+ (char-to-string c)
+ ))
+ )))
+
+
+(defun sh-this-is-a-continuation ()
+ "Return non-nil if current line is a continuation of previous line."
+ (save-excursion
+ (and (zerop (forward-line -1))
+ (looking-at ".*\\\\$")
+ (not (nth 4 (parse-partial-sexp (match-beginning 0) (match-end 0)
+ nil nil nil t))))))
+
+(defun sh-get-kw (&optional where and-move)
+ "Return first word of line from WHERE.
+If AND-MOVE is non-nil then move to end of word."
+ (let ((start (point)))
+ (if where
+ (goto-char where))
+ (prog1
+ (buffer-substring (point)
+ (progn (skip-chars-forward "^ \t\n;")(point)))
+ (unless and-move
+ (goto-char start)))))
+
+(defun sh-find-prev-matching (open close &optional depth)
+ "Find a matching token for a set of opening and closing keywords.
+This takes into account that there may be nested open..close pairings.
+OPEN and CLOSE are regexps denoting the tokens to be matched.
+Optional parameter DEPTH (usually 1) says how many to look for."
+ (let ((parse-sexp-ignore-comments t)
+ prev)
+ (setq depth (or depth 1))
+ (save-excursion
+ (condition-case nil
+ (while (and
+ (/= 0 depth)
+ (not (bobp))
+ (setq prev (sh-prev-stmt)))
+ (goto-char prev)
+ (save-excursion
+ (if (looking-at "\\\\\n")
+ (progn
+ (forward-char 2)
+ (skip-chars-forward " \t")))
+ (cond
+ ((looking-at open)
+ (setq depth (1- depth))
+ (sh-debug "found open at %d - depth = %d" (point) depth))
+ ((looking-at close)
+ (setq depth (1+ depth))
+ (sh-debug "found close - depth = %d" depth))
+ (t
+ ))))
+ (error nil))
+ (if (eq depth 0)
+ prev ;; (point)
+ nil)
+ )))
+
+
+(defun sh-var-value (var &optional ignore-error)
+ "Return the value of variable VAR, interpreting symbols.
+It can also return t or nil.
+If an illegal value is found, throw an error unless Optional argument
+IGNORE-ERROR is non-nil."
+ (let ((val (symbol-value var)))
+ (cond
+ ((numberp val)
+ val)
+ ((eq val t)
+ val)
+ ((null val)
+ val)
+ ((eq val '+)
+ sh-basic-offset)
+ ((eq val '-)
+ (- sh-basic-offset))
+ ((eq val '++)
+ (* 2 sh-basic-offset))
+ ((eq val '--)
+ (* 2 (- sh-basic-offset)))
+ ((eq val '*)
+ (/ sh-basic-offset 2))
+ ((eq val '/)
+ (/ (- sh-basic-offset) 2))
+ (t
+ (if ignore-error
+ (progn
+ (message "Don't know how to handle %s's value of %s" var val)
+ 0)
+ (error "Don't know how to handle %s's value of %s" var val))
+ ))))
+
+(defun sh-set-var-value (var value &optional no-symbol)
+ "Set variable VAR to VALUE.
+Unless optional argument NO-SYMBOL is non-nil, then if VALUE is
+can be represented by a symbol then do so."
+ (cond
+ (no-symbol
+ (set var value))
+ ((= value sh-basic-offset)
+ (set var '+))
+ ((= value (- sh-basic-offset))
+ (set var '-))
+ ((eq value (* 2 sh-basic-offset))
+ (set var '++))
+ ((eq value (* 2 (- sh-basic-offset)))
+ (set var '--))
+ ((eq value (/ sh-basic-offset 2))
+ (set var '*))
+ ((eq value (/ (- sh-basic-offset) 2))
+ (set var '/))
+ (t
+ (set var value)))
+ )
+
+
+(defun sh-calculate-indent (&optional info)
+ "Return the indentation for the current line.
+If INFO is supplied it is used, else it is calculated from current line."
+ (let ((ofs 0)
+ (base-value 0)
+ elt a b var val)
+ (or info
+ (setq info (sh-get-indent-info)))
+ (when info
+ (while info
+ (sh-debug "info: %s ofs=%s" info ofs)
+ (setq elt (car info))
+ (cond
+ ((stringp elt)) ;; do nothing?
+ ((listp elt)
+ (setq a (car (car info)))
+ (setq b (nth 1 (car info)))
+ (cond
+ ((eq a t)
+ (save-excursion
+ (goto-char b)
+ (setq val (current-indentation)))
+ (setq base-value val))
+ ((symbolp b)
+ (setq val (sh-var-value b))
+ (cond
+ ((eq a '=)
+ (cond
+ ((null val)
+ ;; no indentation
+ ;; set info to nil so we stop immediately
+ (setq base-value nil ofs nil info nil))
+ ((eq val t) (setq ofs 0)) ;; indent as normal line
+ (t
+ ;; The following assume the (t POS) come first!
+ (setq ofs val base-value 0)
+ (setq info nil)))) ;; ? stop now
+ ((eq a '+) (setq ofs (+ ofs val)))
+ ((eq a '-) (setq ofs (- ofs val)))
+ (t
+ (error "sh-calculate-indent invalid a a=%s b=%s" a b))))
+ (t
+ (error "sh-calculate-indent invalid elt: a=%s b=%s" a b))))
+ (t
+ (error "sh-calculate-indent invalid elt %s" elt)))
+ (sh-debug "a=%s b=%s val=%s base-value=%s ofs=%s"
+ a b val base-value ofs)
+ (setq info (cdr info)))
+ ;; return value:
+ (sh-debug "at end: base-value: %s ofs: %s" base-value ofs)
+
+ (cond
+ ((or (null base-value)(null ofs))
+ nil)
+ ((and (numberp base-value)(numberp ofs))
+ (sh-debug "base (%d) + ofs (%d) = %d"
+ base-value ofs (+ base-value ofs))
+ (+ base-value ofs)) ;; return value
+ (t
+ (error "sh-calculate-indent: Help. base-value=%s ofs=%s"
+ base-value ofs)
+ nil)))))
+
+
+(defun sh-indent-line (&optional prefix-arg)
+ "Indent the current line."
+ (interactive)
+ (sh-must-be-shell-mode)
+ (let ((indent (sh-calculate-indent)) shift-amt beg end
+ (pos (- (point-max) (point))))
+ (when indent
+ (beginning-of-line)
+ (setq beg (point))
+ (skip-chars-forward " \t")
+ (setq shift-amt (- indent (current-column)))
+ (unless (zerop shift-amt)
+ (delete-region beg (point))
+ (indent-to indent))
+ ;; If initial point was within line's indentation,
+ ;; position after the indentation. Else stay at same point in text.
+ (if (> (- (point-max) pos) (point))
+ (goto-char (- (point-max) pos))))))
+
+
+(defun sh-blink (blinkpos &optional msg)
+ "Move cursor momentarily to BLINKPOS and display MSG."
+ ;; We can get here without it being a number on first line
+ (if (numberp blinkpos)
+ (save-excursion
+ (goto-char blinkpos)
+ (message msg)
+ (sit-for blink-matching-delay))
+ (message msg)))
+
+(defun sh-show-indent (arg)
+ "Show the how the currently line would be indented.
+This tells you which variable, if any, controls the indentation of
+this line.
+If optional arg ARG is non-null (called interactively with a prefix),
+a pop up window describes this variable.
+If variable `sh-blink' is non-nil then momentarily go to the line
+we are indenting relative to, if applicable."
+ (interactive "P")
+ (sh-must-support-indent)
+ (let* ((info (sh-get-indent-info))
+ (var (sh-get-indent-var-for-line info))
+ (curr-indent (current-indentation))
+ val msg)
+ (if (stringp var)
+ (message (setq msg var))
+ (setq val (sh-calculate-indent info))
+
+ (if (eq curr-indent val)
+ (setq msg (format "%s is %s" var (symbol-value var)))
+ (setq msg
+ (if val
+ (format "%s (%s) would change indent from %d to: %d"
+ var (symbol-value var) curr-indent val)
+ (format "%s (%s) would leave line as is"
+ var (symbol-value var)))
+ ))
+ (if (and arg var)
+ (describe-variable var)))
+ (if sh-blink
+ (let ((info (sh-get-indent-info)))
+ (if (and info (listp (car info))
+ (eq (car (car info)) t))
+ (sh-blink (nth 1 (car info)) msg)
+ (message msg)))
+ (message msg))
+ ))
+
+(defun sh-set-indent ()
+ "Set the indentation for the current line.
+If the current line is controlled by an indentation variable, prompt
+for a new value for it."
+ (interactive)
+ (sh-must-support-indent)
+ (let* ((info (sh-get-indent-info))
+ (var (sh-get-indent-var-for-line info))
+ val val0 new-val old-val indent-val)
+ (if (stringp var)
+ (message (format "Cannot set indent - %s" var))
+ (setq old-val (symbol-value var))
+ (setq val (sh-read-variable var))
+ (condition-case nil
+ (progn
+ (set var val)
+ (setq indent-val (sh-calculate-indent info))
+ (if indent-val
+ (message "Variable: %s Value: %s would indent to: %d"
+ var (symbol-value var) indent-val)
+ (message "Variable: %s Value: %s would leave line as is."
+ var (symbol-value var)))
+ ;; I'm not sure about this, indenting it now?
+ ;; No. Because it would give the impression that an undo would
+ ;; restore thing, but the value has been altered.
+ ;; (sh-indent-line)
+ )
+ (error
+ (set var old-val)
+ (message "Bad value for %s, restoring to previous value %s"
+ var old-val)
+ (sit-for 1)
+ nil))
+ )))
+
+
+(defun sh-learn-line-indent (arg)
+ "Learn how to indent a line as it currently is indented.
+
+If there is an indentation variable which controls this line's indentation,
+then set it to a value which would indent the line the way it
+presently is.
+
+If the value can be represented by one of the symbols then do so
+unless optional argument ARG (the prefix when interactive) is non-nil."
+ (interactive "*P")
+ (sh-must-support-indent)
+ ;; I'm not sure if we show allow learning on an empty line.
+ ;; Though it might occasionally be useful I think it usually
+ ;; would just be confusing.
+ (if (save-excursion
+ (beginning-of-line)
+ (looking-at "\\s-*$"))
+ (message "sh-learn-line-indent ignores empty lines.")
+ (let* ((info (sh-get-indent-info))
+ (var (sh-get-indent-var-for-line info))
+ ival sval diff new-val
+ (no-symbol arg)
+ (curr-indent (current-indentation)))
+ (cond
+ ((stringp var)
+ (message (format "Cannot learn line - %s" var)))
+ ((eq var 'sh-indent-comment)
+ ;; This is arbitrary...
+ ;; - if curr-indent is 0, set to curr-indent
+ ;; - else if it has the indentation of a "normal" line,
+ ;; then set to t
+ ;; - else set to curr-indent.
+ (setq sh-indent-comment
+ (if (= curr-indent 0)
+ 0
+ (let* ((sh-indent-comment t)
+ (val2 (sh-calculate-indent info)))
+ (if (= val2 curr-indent)
+ t
+ curr-indent))))
+ (message "%s set to %s" var (symbol-value var))
+ )
+ ((numberp (setq sval (sh-var-value var)))
+ (setq ival (sh-calculate-indent info))
+ (setq diff (- curr-indent ival))
+
+ (sh-debug "curr-indent: %d ival: %d diff: %d var:%s sval %s"
+ curr-indent ival diff var sval)
+ (setq new-val (+ sval diff))
+;;; I commented out this because someone might want to replace
+;;; a value of `+' with the current value of sh-basic-offset
+;;; or vice-versa.
+;;; (if (= 0 diff)
+;;; (message "No change needed!")
+ (sh-set-var-value var new-val no-symbol)
+ (message "%s set to %s" var (symbol-value var))
+ )
+ (t
+ (debug)
+ (message "Cannot change %s" var))))))
+
+
+
+(defun sh-mark-init (buffer)
+ "Initialize a BUFFER to be used by `sh-mark-line'."
+ (let ((main-buffer (current-buffer)))
+ (save-excursion
+ (set-buffer (get-buffer-create buffer))
+ (erase-buffer)
+ (occur-mode)
+ (setq occur-buffer main-buffer)
+ )))
+
+
+(defun sh-mark-line (message point buffer &optional add-linenum occur-point)
+ "Insert MESSAGE referring to location POINT in current buffer into BUFFER.
+Buffer BUFFER is in `occur-mode'.
+If ADD-LINENUM is non-nil the message is preceded by the line number.
+If OCCUR-POINT is non-nil then the line is marked as a new occurrence
+so that `occur-next' and `occur-prev' will work."
+ (let ((m1 (make-marker))
+ (main-buffer (current-buffer))
+ start
+ (line ""))
+ (when point
+ (set-marker m1 point (current-buffer))
+ (if add-linenum
+ (setq line (format "%d: " (1+ (count-lines 1 point))))))
+ (save-excursion
+ (if (get-buffer buffer)
+ (set-buffer (get-buffer buffer))
+ (set-buffer (get-buffer-create buffer))
+ (occur-mode)
+ (setq occur-buffer main-buffer)
+ )
+ (goto-char (point-max))
+ (setq start (point))
+ (insert line)
+ (if occur-point
+ (setq occur-point (point)))
+ (insert message)
+ (if point
+ (add-text-properties
+ start (point)
+ '(mouse-face highlight
+ help-echo "mouse-2: go to the line where I learned this")))
+ (insert "\n")
+ (if point
+ (progn
+ (put-text-property start (point) 'occur m1)
+ (if occur-point
+ (put-text-property occur-point (1+ occur-point)
+ 'occur-point t))
+ ))
+ )))
+
+
+
+;; Is this really worth having?
+(defvar sh-learned-buffer-hook nil
+ "*An abnormal hook, called with an alist of learned variables.")
+;;; Example of how to use sh-learned-buffer-hook
+;;
+;; (defun what-i-learned (list)
+;; (let ((p list))
+;; (save-excursion
+;; (set-buffer "*scratch*")
+;; (goto-char (point-max))
+;; (insert "(setq\n")
+;; (while p
+;; (insert (format " %s %s \n"
+;; (nth 0 (car p)) (nth 1 (car p))))
+;; (setq p (cdr p)))
+;; (insert ")\n")
+;; )))
+;;
+;; (add-hook 'sh-learned-buffer-hook 'what-i-learned)
+
+
+;; Originally this was sh-learn-region-indent (beg end)
+;; However, in practice this was awkward so I changed it to
+;; use the whole buffer. Use narrowing if needbe.
+(defun sh-learn-buffer-indent (&optional arg)
+ "Learn how to indent the buffer the way it currently is.
+
+Output in buffer \"*indent*\" shows any lines which have conflicting
+values of a variable, and the final value of all variables learned.
+This buffer is popped to automatically if there are any discrepancies.
+
+If no prefix ARG is given, then variables are set to numbers.
+If a prefix arg is given, then variables are set to symbols when
+applicable -- e.g. to symbol `+' if the value is that of the
+basic indent.
+If a positive numerical prefix is given, then `sh-basic-offset'
+is set to the prefix's numerical value.
+Otherwise, sh-basic-offset may or may not be changed, according
+to the value of variable `sh-learn-basic-offset'.
+
+Abnormal hook `sh-learned-buffer-hook' if non-nil is called when the
+function completes. The function is abnormal because it is called
+with an alist of variables learned. This feature may be changed or
+removed in the future.
+
+This command can often take a long time to run."
+ (interactive "P")
+ (sh-must-support-indent)
+ (save-excursion
+ (goto-char (point-min))
+ (let ((learned-var-list nil)
+ (out-buffer "*indent*")
+ (num-diffs 0)
+ last-pos
+ previous-set-info
+ (max 17)
+ vec
+ msg
+ (comment-col nil) ;; number if all same, t if seen diff values
+ (comments-always-default t) ;; nil if we see one not default
+ initial-msg
+ (specified-basic-offset (and arg (numberp arg)
+ (> arg 0)))
+ (linenum 0)
+ suggested)
+ (setq vec (make-vector max 0))
+ (sh-mark-init out-buffer)
+
+ (if specified-basic-offset
+ (progn
+ (setq sh-basic-offset arg)
+ (setq initial-msg
+ (format "Using specified sh-basic-offset of %d"
+ sh-basic-offset)))
+ (setq initial-msg
+ (format "Initial value of sh-basic-offset: %s"
+ sh-basic-offset)))
+
+ (while (< (point) (point-max))
+ (setq linenum (1+ linenum))
+ ;; (if (zerop (% linenum 10))
+ (message "line %d" linenum)
+ ;; )
+ (unless (looking-at "\\s-*$") ;; ignore empty lines!
+ (let* ((sh-indent-comment t) ;; info must return default indent
+ (info (sh-get-indent-info))
+ (var (sh-get-indent-var-for-line info))
+ sval ival diff new-val
+ (curr-indent (current-indentation)))
+ (cond
+ ((null var)
+ nil)
+ ((stringp var)
+ nil)
+ ((numberp (setq sval (sh-var-value var 'no-error)))
+ ;; the numberp excludes comments since sval will be t.
+ (setq ival (sh-calculate-indent))
+ (setq diff (- curr-indent ival))
+ (setq new-val (+ sval diff))
+ (sh-set-var-value var new-val 'no-symbol)
+ (unless (looking-at "\\s-*#") ;; don't learn from comments
+ (if (setq previous-set-info (assoc var learned-var-list))
+ (progn
+ ;; it was already there, is it same value ?
+ (unless (eq (symbol-value var)
+ (nth 1 previous-set-info))
+ (sh-mark-line
+ (format "Variable %s was set to %s"
+ var (symbol-value var))
+ (point) out-buffer t t)
+ (sh-mark-line
+ (format " but was previously set to %s"
+ (nth 1 previous-set-info))
+ (nth 2 previous-set-info) out-buffer t)
+ (setq num-diffs (1+ num-diffs))
+ ;; (delete previous-set-info learned-var-list)
+ (setcdr previous-set-info
+ (list (symbol-value var) (point)))
+ )
+ )
+ (setq learned-var-list
+ (append (list (list var (symbol-value var)
+ (point)))
+ learned-var-list)))
+ (if (numberp new-val)
+ (progn
+ (sh-debug
+ "This line's indent value: %d" new-val)
+ (if (< new-val 0)
+ (setq new-val (- new-val)))
+ (if (< new-val max)
+ (aset vec new-val (1+ (aref vec new-val))))))
+ ))
+ ((eq var 'sh-indent-comment)
+ (unless (= curr-indent (sh-calculate-indent info))
+ ;; this is not the default indentation
+ (setq comments-always-default nil)
+ (if comment-col ;; then we have see one before
+ (or (eq comment-col curr-indent)
+ (setq comment-col t)) ;; seen a different one
+ (setq comment-col curr-indent))
+ ))
+ (t
+ (sh-debug "Cannot learn this line!!!")
+ ))
+ (sh-debug
+ "at %s learned-var-list is %s" (point) learned-var-list)
+ ))
+ (forward-line 1)
+ ) ;; while
+ (if sh-debug
+ (progn
+ (setq msg (format
+ "comment-col = %s comments-always-default = %s"
+ comment-col comments-always-default))
+ ;; (message msg)
+ (sh-mark-line msg nil out-buffer)))
+ (cond
+ ((eq comment-col 0)
+ (setq msg "\nComments are all in 1st column.\n"))
+ (comments-always-default
+ (setq msg "\nComments follow default indentation.\n")
+ (setq comment-col t))
+ ((numberp comment-col)
+ (setq msg (format "\nComments are in col %d." comment-col)))
+ (t
+ (setq msg "\nComments seem to be mixed, leaving them as is.\n")
+ (setq comment-col nil)
+ ))
+ (sh-debug msg)
+ (sh-mark-line msg nil out-buffer)
+
+ (sh-mark-line initial-msg nil out-buffer t t)
+
+ (setq suggested (sh-guess-basic-offset vec))
+
+ (if (and suggested (not specified-basic-offset))
+ (let ((new-value
+ (cond
+ ;; t => set it if we have a single value as a number
+ ((and (eq sh-learn-basic-offset t) (numberp suggested))
+ suggested)
+ ;; other non-nil => set it if only one value was found
+ (sh-learn-basic-offset
+ (if (numberp suggested)
+ suggested
+ (if (= (length suggested) 1)
+ (car suggested))))
+ (t
+ nil))))
+ (if new-value
+ (progn
+ (setq learned-var-list
+ (append (list (list 'sh-basic-offset
+ (setq sh-basic-offset new-value)
+ (point-max)))
+ learned-var-list))
+ ;; Not sure if we need to put this line in, since
+ ;; it will appear in the "Learned variable settings".
+ (sh-mark-line
+ (format "Changed sh-basic-offset to: %d" sh-basic-offset)
+ nil out-buffer))
+ (sh-mark-line
+ (if (listp suggested)
+ (format "Possible value(s) for sh-basic-offset: %s"
+ (mapconcat 'int-to-string suggested " "))
+ (format "Suggested sh-basic-offset: %d" suggested))
+ nil out-buffer))))
+
+
+ (setq learned-var-list
+ (append (list (list 'sh-indent-comment comment-col (point-max)))
+ learned-var-list))
+ (setq sh-indent-comment comment-col)
+ (let ((name (buffer-name))
+ (lines (if (and (eq (point-min) 1)
+ (eq (point-max) (1+ (buffer-size))))
+ ""
+ (format "lines %d to %d of "
+ (1+ (count-lines 1 (point-min)))
+ (1+ (count-lines 1 (point-max))))))
+ )
+ (sh-mark-line "\nLearned variable settings:" nil out-buffer)
+ (if arg
+ ;; Set learned variables to symbolic rather than numeric
+ ;; values where possible.
+ (dolist (learned-var (reverse learned-var-list))
+ (let ((var (car learned-var))
+ (val (nth 1 learned-var)))
+ (when (and (not (eq var 'sh-basic-offset))
+ (numberp val))
+ (sh-set-var-value var val)))))
+ (dolist (learned-var (reverse learned-var-list))
+ (let ((var (car learned-var)))
+ (sh-mark-line (format " %s %s" var (symbol-value var))
+ (nth 2 learned-var) out-buffer)))
+ (save-excursion
+ (set-buffer out-buffer)
+ (goto-char (point-min))
+ (insert
+ (format "Indentation values for buffer %s.\n" name)
+ (format "%d indentation variable%s different values%s\n\n"
+ num-diffs
+ (if (= num-diffs 1)
+ " has" "s have")
+ (if (zerop num-diffs)
+ "." ":"))
+ )))
+ ;; Are abnormal hooks considered bad form?
+ (run-hook-with-args 'sh-learned-buffer-hook learned-var-list)
+ (if (or sh-popup-occur-buffer (> num-diffs 0))
+ (pop-to-buffer out-buffer))
+ )))
+
+(defun sh-guess-basic-offset (vec)
+ "See if we can determine a reasonable value for `sh-basic-offset'.
+This is experimental, heuristic and arbitrary!
+Argument VEC is a vector of information collected by
+`sh-learn-buffer-indent'.
+Return values:
+ number - there appears to be a good single value
+ list of numbers - no obvious one, here is a list of one or more
+ reasonable choices
+ nil - we couldn't find a reasonable one."
+ (let* ((max (1- (length vec)))
+ (i 1)
+ (totals (make-vector max 0))
+ (return nil)
+ j)
+ (while (< i max)
+ (aset totals i (+ (aref totals i) (* 4 (aref vec i))))
+ (setq j (/ i 2))
+ (if (zerop (% i 2))
+ (aset totals i (+ (aref totals i) (aref vec (/ i 2)))))
+ (if (< (* i 2) max)
+ (aset totals i (+ (aref totals i) (aref vec (* i 2)))))
+ (setq i (1+ i)))
+
+ (let ((x nil)
+ (result nil)
+ tot sum p)
+ (setq i 1)
+ (while (< i max)
+ (if (/= (aref totals i) 0)
+ (setq x (append x (list (cons i (aref totals i))))))
+ (setq i (1+ i)))
+
+ (setq x (sort x (lambda (a b) (> (cdr a) (cdr b)))))
+ (setq tot (apply '+ (append totals nil)))
+ (sh-debug (format "vec: %s\ntotals: %s\ntot: %d"
+ vec totals tot))
+ (cond
+ ((zerop (length x))
+ (message "no values!")) ;; we return nil
+ ((= (length x) 1)
+ (message "only value is %d" (car (car x)))
+ (setq result (car (car x)))) ;; return single value
+ ((> (cdr (car x)) (/ tot 2))
+ ;; 1st is > 50%
+ (message "basic-offset is probably %d" (car (car x)))
+ (setq result (car (car x)))) ;; again, return a single value
+ ((>= (cdr (car x)) (* 2 (cdr (car (cdr x)))))
+ ;; 1st is >= 2 * 2nd
+ (message "basic-offset could be %d" (car (car x)))
+ (setq result (car (car x))))
+ ((>= (+ (cdr (car x))(cdr (car (cdr x)))) (/ tot 2))
+ ;; 1st & 2nd together >= 50% - return a list
+ (setq p x sum 0 result nil)
+ (while (and p
+ (<= (setq sum (+ sum (cdr (car p)))) (/ tot 2)))
+ (setq result (append result (list (car (car p)))))
+ (setq p (cdr p)))
+ (message "Possible choices for sh-basic-offset: %s"
+ (mapconcat 'int-to-string result " ")))
+ (t
+ (message "No obvious value for sh-basic-offset. Perhaps %d"
+ (car (car x)))
+ ;; result is nil here
+ ))
+ result)))
+
+;; ========================================================================
+
+;; Styles -- a quick and dirty way of saving the indentation settings.
+
+(defvar sh-styles-alist nil
+ "A list of all known shell indentation styles.")
+
+(defun sh-name-style (name &optional confirm-overwrite)
+ "Name the current indentation settings as a style called NAME.
+If this name exists, the command will prompt whether it should be
+overwritten if
+- - it was called interactively with a prefix argument, or
+- - called non-interactively with optional CONFIRM-OVERWRITE non-nil."
+ ;; (interactive "sName for this style: ")
+ (interactive
+ (list
+ (read-from-minibuffer "Name for this style? " )
+ (not current-prefix-arg)))
+ (let ((slist (cons name
+ (mapcar (lambda (var) (cons var (symbol-value var)))
+ sh-var-list)))
+ (style (assoc name sh-styles-alist)))
+ (if style
+ (if (and confirm-overwrite
+ (not (y-or-n-p "This style exists. Overwrite it? ")))
+ (message "Not changing style %s" name)
+ (message "Updating style %s" name)
+ (setcdr style (cdr slist)))
+ (message "Creating new style %s" name)
+ (push slist sh-styles-alist))))
+
+(defun sh-load-style (name)
+ "Set shell indentation values for this buffer from those in style NAME."
+ (interactive (list (completing-read
+ "Which style to use for this buffer? "
+ sh-styles-alist nil t)))
+ (let ((sl (assoc name sh-styles-alist)))
+ (if (null sl)
+ (error "sh-load-style - style %s not known" name)
+ (dolist (var (cdr sl))
+ (set (car var) (cdr var))))))
+
+(defun sh-save-styles-to-buffer (buff)
+ "Save all current styles in elisp to buffer BUFF.
+This is always added to the end of the buffer."
+ (interactive (list
+ (read-from-minibuffer "Buffer to save styles in? " "*scratch*")))
+ (with-current-buffer (get-buffer-create buff)
+ (goto-char (point-max))
+ (insert "\n")
+ (pp `(setq sh-styles-alist ',sh-styles-alist) (current-buffer))))
+
+
+
;; statement syntax-commands for various shells
;; You are welcome to add the syntax or even completely new statements as
＠＠ -1153,47 +3121,51 ＠＠
< < "endsw")
(es)
(rc "expression: "
- "switch( " str " ) {" \n
+ > "switch( " str " ) {" \n
> "case " (read-string "pattern: ") \n
> _ \n
( "other pattern, %s: "
- < "case " str \n
+ "case " str > \n
> _ \n)
- < "case *" \n
+ "case *" > \n
> _ \n
resume:
- < < ?})
+ ?} > )
(sh "expression: "
- "case " str " in" \n
- > (read-string "pattern: ") ?\) \n
+ > "case " str " in" \n
+ > (read-string "pattern: ")
+ (propertize ")" 'syntax-table sh-st-punc)
+ \n
> _ \n
";;" \n
( "other pattern, %s: "
- < str ?\) \n
+ > str (propertize ")" 'syntax-table sh-st-punc) \n
> _ \n
";;" \n)
- < "*)" \n
+ > "*" (propertize ")" 'syntax-table sh-st-punc) \n
> _ \n
resume:
- < < "esac"))
+ "esac" > ))
(define-skeleton sh-for
"Insert a for loop. See `sh-feature'."
(csh eval sh-modify sh
- 1 "foreach "
- 3 " ( "
- 5 " )"
- 15 "end")
+ 1 ""
+ 2 "foreach "
+ 4 " ( "
+ 6 " )"
+ 15 '<
+ 16 "end")
(es eval sh-modify rc
- 3 " = ")
+ 4 " = ")
(rc eval sh-modify sh
- 1 "for( "
- 5 " ) {"
- 15 ?})
+ 2 "for( "
+ 6 " ) {"
+ 15 ?} )
(sh "Index variable: "
- "for " str " in " _ "; do" \n
+ > "for " str " in " _ "; do" \n
> _ | ?$ & (sh-remember-variable str) \n
- < "done"))
+ "done" > ))
＠＠ -1207,34 +3179,34 ＠＠
"＠ " str "++" \n
< "end")
(es eval sh-modify rc
- 3 " =")
+ 4 " =")
(ksh88 "Index variable: "
- "integer " str "=0" \n
- "while (( ( " str " += 1 ) <= "
+ > "integer " str "=0" \n
+ > "while (( ( " str " += 1 ) <= "
(read-string "upper limit: ")
" )); do" \n
- > _ ?$ (sh-remember-variable str) \n
- < "done")
+ > _ ?$ (sh-remember-variable str) > \n
+ "done" > )
(posix "Index variable: "
- str "=1" \n
+ > str "=1" \n
"while [ $" str " -le "
(read-string "upper limit: ")
" ]; do" \n
> _ ?$ str \n
str ?= (sh-add (sh-remember-variable str) 1) \n
- < "done")
+ "done" > )
(rc "Index variable: "
- "for( " str " in" " `{awk 'BEGIN { for( i=1; i<="
+ > "for( " str " in" " `{awk 'BEGIN { for( i=1; i<="
(read-string "upper limit: ")
- "; i++ ) print i }'}) {" \n
+ "; i++ ) print i }'`}) {" \n
> _ ?$ (sh-remember-variable str) \n
- < ?})
+ ?} >)
(sh "Index variable: "
- "for " str " in `awk 'BEGIN { for( i=1; i<="
+ > "for " str " in `awk 'BEGIN { for( i=1; i<="
(read-string "upper limit: ")
"; i++ ) print i }'`; do" \n
> _ ?$ (sh-remember-variable str) \n
- < "done"))
+ "done" > ))
(defun sh-shell-initialize-variables ()
＠＠ -1313,7 +3285,7 ＠＠
> _ \n
< "}")
(rc eval sh-modify ksh88
- 1 "fn ")
+ 1 "fn ")
(sh ()
"() {" \n
> _ \n
＠＠ -1334,46 +3306,51 ＠＠
resume:
< "endif")
(es "condition: "
- "if { " str " } {" \n
- > _ \n
- ( "other condition, %s: "
- < "} { " str " } {" \n
- > _ \n)
- < "} {" \n
- > _ \n
- resume:
- < ?})
- (rc eval sh-modify csh
- 3 " ) {"
- 8 '( "other condition, %s: "
- < "} else if( " str " ) {" \n
- > _ \n)
- 10 "} else {"
- 17 ?})
- (sh "condition: "
- '(setq input (sh-feature sh-test))
- "if " str "; then" \n
+ > "if { " str " } {" \n
> _ \n
( "other condition, %s: "
- < "elif " str "; then" \n
+ "} { " str " } {" > \n
> _ \n)
- < "else" \n
+ "} {" > \n
+ > _ \n
+ resume:
+ ?} > )
+ (rc "condition: "
+ > "if( " str " ) {" \n
+ > _ \n
+ ( "other condition, %s: "
+ "} else if( " str " ) {" > \n
+ > _ \n)
+ "} else {" > \n
+ > _ \n
+ resume:
+ ?} >
+ )
+ (sh "condition: "
+ '(setq input (sh-feature sh-test))
+ > "if " str "; then" \n
> _ \n
+ ( "other condition, %s: "
+ > "elif " str "; then" > \n
+ > \n)
+ "else" > \n
+ > \n
resume:
- < "fi"))
+ "fi" > ))
(define-skeleton sh-repeat
"Insert a repeat loop definition. See `sh-feature'."
(es nil
- "forever {" \n
+ > "forever {" \n
> _ \n
- < ?})
+ ?} > )
(zsh "factor: "
- "repeat " str "; do"\n
- > _ \n
- < "done"))
+ > "repeat " str "; do" > \n
+ > \n
+ "done" > ))
+
;;;(put 'sh-repeat 'menu-enable '(sh-feature sh-repeat))
＠＠ -1381,9 +3358,10 ＠＠
(define-skeleton sh-select
"Insert a select statement. See `sh-feature'."
(ksh88 "Index variable: "
- "select " str " in " _ "; do" \n
+ > "select " str " in " _ "; do" \n
> ?$ str \n
- < "done"))
+ "done" > )
+ (bash eval sh-append ksh88))
;;;(put 'sh-select 'menu-enable '(sh-feature sh-select))
＠＠ -1400,21 +3378,22 ＠＠
"exit:\n"
"rm $tmp* >&/dev/null" >)
(es (file-name-nondirectory (buffer-file-name))
- "local( signals = $signals sighup sigint; tmp = /tmp/" str ".$pid ) {" \n
+ > "local( signals = $signals sighup sigint; tmp = /tmp/" str
+ ".$pid ) {" \n
> "catch ＠ e {" \n
> "rm $tmp^* >[2]/dev/null" \n
"throw $e" \n
- < "} {" \n
- > _ \n
- < ?} \n
- < ?})
+ "} {" > \n
+ _ \n
+ ?} > \n
+ ?} > )
(ksh88 eval sh-modify sh
- 6 "EXIT")
+ 7 "EXIT")
(rc (file-name-nondirectory (buffer-file-name))
- "tmp = /tmp/" str ".$pid" \n
- "fn sigexit { rm $tmp^* >[2]/dev/null }")
+ > "tmp = /tmp/" str ".$pid" \n
+ "fn sigexit { rm $tmp^* >[2]/dev/null }")
(sh (file-name-nondirectory (buffer-file-name))
- "TMP=/tmp/" str ".$$" \n
+ > "TMP=${TMPDIR:-/tmp}/" str ".$$" \n
"trap \"rm $TMP* 2>/dev/null\" " ?0))
＠＠ -1423,9 +3402,9 ＠＠
"Insert an until loop. See `sh-feature'."
(sh "condition: "
'(setq input (sh-feature sh-test))
- "until " str "; do" \n
+ > "until " str "; do" \n
> _ \n
- < "done"))
+ "done" > ))
;;;(put 'sh-until 'menu-enable '(sh-feature sh-until))
＠＠ -1433,20 +3412,24 ＠＠
(define-skeleton sh-while
"Insert a while loop. See `sh-feature'."
(csh eval sh-modify sh
- 2 "while( "
- 4 " )"
- 10 "end")
- (es eval sh-modify rc
- 2 "while { "
- 4 " } {")
- (rc eval sh-modify csh
- 4 " ) {"
- 10 ?})
+ 2 ""
+ 3 "while( "
+ 5 " )"
+ 10 '<
+ 11 "end")
+ (es eval sh-modify sh
+ 3 "while { "
+ 5 " } {"
+ 10 ?} )
+ (rc eval sh-modify sh
+ 3 "while( "
+ 5 " ) {"
+ 10 ?} )
(sh "condition: "
'(setq input (sh-feature sh-test))
- "while " str "; do" \n
+ > "while " str "; do" \n
> _ \n
- < "done"))
+ "done" > ))
＠＠ -1486,9 +3469,8 ＠＠
(posix eval sh-modify sh
18 "$(basename $0)")
(sh "optstring: "
- "while getopts :" str " OPT; do" \n
+ > "while getopts :" str " OPT; do" \n
> "case $OPT in" \n
- > >
'(setq v1 (append (vconcat str) nil))
( (prog1 (if v1 (char-to-string (car v1)))
(if (eq (nth 1 v1) ?:)
＠＠ -1496,20 +3478,22 ＠＠
v2 "\"$OPTARG\"")
(setq v1 (cdr v1)
v2 nil)))
- < str "|+" str ?\) \n
+ > str "|+" str (propertize ")" 'syntax-table sh-st-punc) \n
> _ v2 \n
- ";;" \n)
- < "*)" \n
+ > ";;" \n)
+ > "*" (propertize ")" 'syntax-table sh-st-punc) \n
> "echo" " \"usage: " "`basename $0`"
" [+-" '(setq v1 (point)) str
'(save-excursion
(while (search-backward ":" v1 t)
(replace-match " ARG] [+-" t t)))
(if (eq (preceding-char) ?-) -5)
- "] [--] ARGS...\"" \n
- "exit 2" \n
- < < "esac" \n
- < "done" \n
+ (if (and (sequencep v1) (length v1)) "] " "} ")
+ "[--] ARGS...\"" \n
+ "exit 2" > \n
+ "esac" >
+ \n "done"
+ > \n
"shift " (sh-add "OPTIND" -1)))
＠＠ -1530,7 +3514,7 ＠＠
(defun sh-maybe-here-document (arg)
- "Inserts self. Without prefix, following unquoted `<' inserts here document.
+ "Insert self. Without prefix, following unquoted `<' inserts here document.
The document is bounded by `sh-here-document-word'."
(interactive "*P")
(self-insert-command (prefix-numeric-value arg))
＠＠ -1578,22 +3562,19 ＠＠
(point)))
(newline))))
-
-
(defun sh-beginning-of-command ()
"Move point to successive beginnings of commands."
(interactive)
(if (re-search-backward sh-beginning-of-command nil t)
(goto-char (match-beginning 2))))
-
(defun sh-end-of-command ()
"Move point to successive ends of commands."
(interactive)
(if (re-search-forward sh-end-of-command nil t)
(goto-char (match-end 1))))
-;; XEmacs additions
+;; XEmacs change
;;;###autoload(add-to-list 'auto-mode-alist '("/\\.\\(?:bash_\\|z\\)?\\(profile\\|login\\|logout\\)\\'" . sh-mode))
;;;###autoload(add-to-list 'auto-mode-alist '("/\\.\\(?:[ckz]sh\\|bash\\|tcsh\\|es\\|xinit\\|startx\\)rc\\'" . sh-mode))
;;;###autoload(add-to-list 'auto-mode-alist '("/\\.\\(?:[kz]shenv\\|xsession\\)\\'" . sh-mode))
--
Jérôme Marant
- 4 participants
- 10 comments
[PATCH] Aliasing --enable to --with.
18 years, 6 months
Malcolm Purvis
Malcolm Purvis
This patch makes the following changes to configure.ac:
1. Aliases all --enable- options to --with (see the macro
XE_ARG_ENABLE_OR_WITH below).
2. Requires that only autoconf 2.59 be used to generate the configure script
3. Replaces numerous blank lines with the proper m4 'blank line' macro. This
prevents stray blan lines appearing at the wrong places in the configure
script.
The aliasing means that any option that was previously available only as
--enable now can be set with --with as well (and --without instead of
--disable). In addition the option appears in the help output in both forms.
Existing --with options are not aliased to --enable.
Malcolm
ChangeLog addition:
2005-10-07 Malcolm Purvis <malcolmp(a)xemacs.org>
* configure: Added XE_ARG_ENABLE_OR_WITH and alias all --enable
options to --with. configure can only be built with autoconf
2.59. Prevent many unwanted blank lines from appearing in
configure.
xemacs-autoconf-2.5 source patch:
Diff command: cvs -q diff -u
Files affected: configure.ac
Index: configure.ac
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/configure.ac,v
retrieving revision 1.14
diff -u -r1.14 configure.ac
--- configure.ac 2005/10/04 17:51:13 1.14
+++ configure.ac 2005/10/07 13:07:54
＠＠ -15,13 +15,17 ＠＠
ac_link='$CC -o conftest$ac_exeext $CFLAGS '"$xe_cppflags $xe_ldflags"' conftest.$ac_ext '"$xe_libs"' >&AS_MESSAGE_LOG_FD'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
])
-
+dnl
dnl -------------------------------------------------------------------------
dnl Autoconf startup.
-
+dnl
+dnl Due to a dependence on the implementation of certain internal autoconf
+dnl macros, die if any version other than 2.59 is used.
AC_PREREQ(2.59)dnl
+m4_if(m4_version_compare(m4_defn([m4_PACKAGE_VERSION]), [2.59]), 1,
+ [m4_fatal([This script can only be generated with autoconf 2.59])], [])dnl
AC_INIT(src/lisp.h)dnl
-
+dnl
dnl -------------------------------------------------------------------------
dnl Local copyright notices.
＠＠ -85,39 +89,39 ＠＠
dnl If there's reason to prefer $0 over this, make sure you fix all the
dnl uses in this script!!
progname="`echo $0 | sed 's:^\./\./:\./:'`"
-
+dnl
dnl -------------------------------------------------------------------------
dnl Local macros
-
+dnl
define([USAGE_ERROR],
[(echo "$progname: Usage error:"
echo " " $1
-echo " Use \`$progname --help' to show usage.") >&2 && exit 1])
-
+echo " Use \`$progname --help' to show usage.") >&2 && exit 1])dnl
+dnl
dnl PRINT_VAR(var var ...) prints values of shell variables
define([PRINT_VAR],[for var in patsubst([$1],[[
-]+],[ ]); do eval "echo \"$var = '\$$var'\""; done])
-
+]+],[ ]); do eval "echo \"$var = '\$$var'\""; done])dnl
+dnl
dnl XE_ADD_OBJS(foo.o)
define([XE_ADD_OBJS],
[extra_objs="$extra_objs [$1]" && dnl
if test "$verbose" = "yes"; then
echo " xemacs will be linked with \"[$1]\""
fi])dnl XE_ADD_OBJS
-
+dnl
dnl XE_APPEND(value, varname)
define([XE_APPEND],
[[$2]="$[$2] [$1]" && dnl
- if test "$verbose" = "yes"; then echo " Appending \"[$1]\" to \$[$2]"; fi])
-
+ if test "$verbose" = "yes"; then echo " Appending \"[$1]\" to \$[$2]"; fi])dnl
+dnl
dnl XE_PREPEND(value, varname)
define([XE_PREPEND],
[[$2]="[$1] $[$2]" && dnl
- if test "$verbose" = "yes"; then echo " Prepending \"[$1]\" to \$[$2]"; fi])
-
+ if test "$verbose" = "yes"; then echo " Prepending \"[$1]\" to \$[$2]"; fi])dnl
+dnl
dnl XE_DIE(message)
-define([XE_DIE], [{ echo "Error:" $1 >&2; exit 1; }])
-
+define([XE_DIE], [{ echo "Error:" $1 >&2; exit 1; }])dnl
+dnl
dnl XE_CHECK_FEATURE_DEPENDENCY(feature1, feature2)
define([XE_CHECK_FEATURE_DEPENDENCY],
[if test "$with_[$1] $with_[$2]" = "yes no"; then
＠＠ -125,13 +129,13 ＠＠
elif test "$with_[$2]" = "no" ; then with_[$1]=no
elif test "$with_[$1]" = "yes"; then with_[$2]=yes
fi
-])
-
+])dnl
+dnl
dnl XE_STRIP_4TH_COMPONENT(var)
dnl Changes i986-pc-linux-gnu to i986-pc-linux, as God (not RMS) intended.
define([XE_STRIP_4TH_COMPONENT],
-[$1=`echo "$$1" | sed '[s/^\([^-][^-]*-[^-][^-]*-[^-][^-]*\)-.*$/\1/]'`])
-
+[$1=`echo "$$1" | sed '[s/^\([^-][^-]*-[^-][^-]*-[^-][^-]*\)-.*$/\1/]'`])dnl
+dnl
dnl Do our best to deal with automounter brokenness
dnl CANONICALIZE_PATH(varname)
define([CANONICALIZE_PATH],
＠＠ -140,7 +144,7 ＠＠
$1=`echo "[$]$1" | \
sed -e "s|^${tdir}/|/net/|" -e "s|^/a/|/net/|" -e "s|^/amd/|/net/|"`
fi])dnl
-
+dnl
dnl XE_PROTECT_LINKER_FLAGS(shell_var)
define([XE_PROTECT_LINKER_FLAGS], [
if test "$GCC" = "yes"; then
＠＠ -155,11 +159,11 ＠＠
shift
done
fi])dnl
-
+dnl
dnl Allow use of either ":" or spaces for lists of directories
define(COLON_TO_SPACE,
[case "$[$1]" in *:* [)] [$1]="`echo '' $[$1] | sed -e 's/^ //' -e 's/:/ /g'`";; esac])dnl
-
+dnl
dnl XE_ADD_RUNPATH_DIR(directory)
define([XE_ADD_RUNPATH_DIR],[{
xe_runpath_dir=$1
＠＠ -169,7 +173,7 ＠＠
-n "`ls ${xe_runpath_dir}/*.s[[ol]] 2>/dev/null`" && \
eval "$xe_add_unique_runpath_dir"
}])dnl
-
+dnl
dnl XE_COMPUTE_RUNPATH()
define([XE_COMPUTE_RUNPATH],[
if test "$add_runtime_path" = "yes" -a -n "$dash_r"; then
＠＠ -217,7 +221,7 ＠＠
fi
fi
])dnl
-
+dnl
dnl The construct foo=`echo $w1 $w2 $w3` fails on some systems if $w1 = -e or -n
dnl So we use the following instead.
dnl XE_SPACE(var, words)
＠＠ -226,7 +230,40 ＠＠
for W in $2; do if test -z "$T"; then T="$W"; else T="$T $W"; fi; done
$1="$T"
])dnl XE_SPACE
-
+dnl
+dnl XE_ARG_ENABLE_OR_WITH(FEATURE, HELP-STRING, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
+dnl ------------------------------------------------------------------------
+dnl
+dnl Arguments that can be specified with either --enable or --with. For some
+dnl XEmacs arguments the division between --enable or --with is arbitrary, so
+dnl all those to be specified by either argument. The value is stored in
+dnl enable_FEATURE.
+AC_DEFUN([XE_ARG_ENABLE_OR_WITH],
+[m4_divert_once([HELP_ENABLE], [[
+Optional Features:
+ --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)
+ --enable-FEATURE[=ARG] include FEATURE [ARG=yes]]])dnl
+m4_divert_once([HELP_WITH], [[
+Optional Packages:
+ --with-PACKAGE[=ARG] use PACKAGE [ARG=yes]
+ --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)]])
+m4_divert_once([HELP_ENABLE], [$2])dnl
+m4_divert_once([HELP_WITH], m4_bpatsubst([[$2]],[--enable\([^ ]+\) ],[--with\1 ]))dnl
+# If --with-$1 or --without-$1 were given then copy the value to the
+# equivalent enable_$1 variable.
+if test "[${with_]m4_bpatsubst([$1], -, _)+set}" = set; then
+ [enable_]m4_bpatsubst([$1], -, _)="[$with_]m4_bpatsubst([$1], -, _)"
+ echo Setting
+fi;
+# Check whether --enable-$1 or --disable-$1 was given.
+if test "[${enable_]m4_bpatsubst([$1], -, _)+set}" = set; then
+ enableval="[$enable_]m4_bpatsubst([$1], -, _)"
+ $3
+m4_ifvaln([$4], [else
+ $4])dnl
+fi; dnl
+])dnl XE_ARG_ENABLE_OR_WITH
+dnl
dnl XEmacs keyword option support
dnl =============================
dnl
＠＠ -258,7 +295,7 ＠＠
fi
unset _[$1]_bogus
undefine([XE_KEYWORD_LIST])dnl
-undefine([XE_KEYWORD_VALUES])])
+undefine([XE_KEYWORD_VALUES])])dnl
dnl
dnl XE_KEYWORD(keyword)
dnl --------------------------------
＠＠ -269,7 +306,7 ＠＠
dnl Separate with a ':' instead of a ',' (see the parsing code above) to avoid
dnl confusion with marco parameter lists.
m4_append([XE_KEYWORD_VALUES],[\`$1'],[:])dnl
-])
+])dnl
dnl
dnl XE_KEYWORD_ARG_WITH(PACKAGE, HELP-STRING, ACTION-IF-TRUE, ACTION-IF-FALSE,
dnl [XE_KEYWORD(keyword), ....])
＠＠ -283,7 +320,7 ＠＠
AC_ARG_WITH([$1],[$2],
[XE_PARSE_KEYWORD_OPTION([with_]patsubst([$1], -, _), [--with-$1])
$3
-],[$4])])
+],[$4])])dnl
dnl
dnl XE_KEYWORD_ARG_ENABLE(FEATURE, HELP-STRING, ACTION-IF-TRUE, ACTION-IF-FALSE,
dnl [XE_KEYWORD(keyword), ....])
＠＠ -294,10 +331,10 ＠＠
dnl
define([XE_KEYWORD_ARG_ENABLE],
[m4_map([XE_KEYWORD],m4_shiftn(4, $＠))
-AC_ARG_ENABLE([$1],[$2],
+XE_ARG_ENABLE_OR_WITH([$1],[$2],
[XE_PARSE_KEYWORD_OPTION([enable_]patsubst([$1], -, _), [--enable-$1])
$3
-],[$4])])
+],[$4])])dnl
dnl
dnl XEmacs complex option support
dnl =============================
＠＠ -335,7 +372,7 ＠＠
define([XE_EXPAND_COMPLEX_OPTIONS],
[m4_if([$2], [[]], [],
[XE_EXPAND_COMPLEX_OPTION([$1], m4_fst($2))[]dnl
-XE_EXPAND_COMPLEX_OPTIONS([$1], m4_cdr($2))])])
+XE_EXPAND_COMPLEX_OPTIONS([$1], m4_cdr($2))])])dnl
dnl
dnl XE_INIT_COMPLEX_OPTION(prefix, option_list)
dnl -------------------------------------------
＠＠ -356,8 +393,8 ＠＠
dnl options.
undefine([XE_COMPONENT_LIST])
undefine([XE_COMPONENT_DEFAULT])
-])
-
+])dnl
+dnl
dnl XE_PARSE_COMPLEX_OPTION(prefix, cmdline-flag)
dnl ---------------------------------------------
dnl
＠＠ -405,8 +442,8 ＠＠
done
unset _[$1]_bogus _[$1]_found _[$1]_notfirst _[$1]_types
unset _[$1]_default _[$1]_all_default x y
-])
-
+])dnl
+dnl
dnl XE_COMPLEX_OPTION(option, yesno)
dnl --------------------------------
dnl
＠＠ -423,7 +460,7 ＠＠
define([XE_COMPLEX_OPTION_HELP_STRING],
[AC_HELP_STRING([$1],[Compile with support for $2. Components that can use
$3 are $4. Prefix component with `no' to disable its use of $3. Requires
-$5 support. Default is $6.])])
+$5 support. Default is $6.])])dnl
dnl
dnl XE_COMPLEX_ARG_WITH(PACKAGE, HELP-STRING, ACTION-IF-TRUE, ACTION-IF-FALSE,
dnl [XE_COMPLEX_OPTION(a,yes), ....])
＠＠ -437,7 +474,7 ＠＠
AC_ARG_WITH([$1],[$2],
[XE_PARSE_COMPLEX_OPTION([with_]patsubst([$1], -, _), [--with-$1])
$3
-],[$4])])
+],[$4])])dnl
dnl
dnl XE_COMPLEX_ARG_ENABLE(FEATURE, HELP-STRING, ACTION-IF-TRUE, ACTION-IF-FALSE,
dnl [XE_COMPLEX_OPTION, ....])
＠＠ -448,10 +485,10 ＠＠
dnl
define([XE_COMPLEX_ARG_ENABLE],
[XE_INIT_COMPLEX_OPTION([enable_]patsubst([$1], -, _), m4_shiftn(4, $＠))
-AC_ARG_ENABLE([$1],[$2],
+XE_ARG_ENABLE_OR_WITH([$1],[$2],
[XE_PARSE_COMPLEX_OPTION([enable_]patsubst([$1], -, _), [--enable-$1])
$3
-],[$4])])
+],[$4])])dnl
dnl
dnl -------------------------------------------------------------------------
XE_APPEND(lib-src, MAKE_SUBDIR)
＠＠ -462,19 +499,6 ＠＠
dnl Note that AC_HELP_STRING compresses whitespace, wraps, and indents the
dnl string to fit the --help display; there's no need to preformat.
dnl
-dnl Error-checking on old-style flags
-AC_ARG_WITH([mule],[],[XE_DIE([--enable-mule, NOT --with-mule])],[])
-AC_ARG_WITH([menubars],[],[XE_DIE([--enable-menubars, NOT --with-menubars])],[])
-AC_ARG_WITH([scrollbars],[],[XE_DIE([--enable-scrollbars, NOT --with-scrollbars])],[])
-AC_ARG_WITH([dialogs],[],[XE_DIE([--enable-dialogs, NOT --with-dialogs])],[])
-AC_ARG_WITH([widgets],[],[XE_DIE([--enable-widgets, NOT --with-widgets])],[])
-AC_ARG_WITH([sound],[],[XE_DIE([--enable-sound, NOT --with-sound])],[])
-AC_ARG_WITH([default-eol-detection],[],[XE_DIE([--enable-default-eol-detection, NOT --with-default-eol-detection])],[])
-AC_ARG_WITH([clash-detection],[],[XE_DIE([--enable-clash-detection, NOT --with-clash-detection])],[])
-AC_ARG_WITH([database],[],[XE_DIE([--enable-database, NOT --with-database])],[])
-AC_ARG_WITH([modules],[],[XE_DIE([--enable-modules, NOT --with-modules])],[])
-AC_ARG_WITH([toolbars],[],[XE_DIE([--enable-toolbars, NOT --with-toolbars])],[])
-
dnl I think these will be caught by autoconf internal checks,
dnl only --with-* are unchecked
dnl --external-widget --enable-external-widget
＠＠ -489,7 +513,7 ＠＠
dnl --use-union-type --enable-union-type
dnl --pdump --enable-pdump
dnl --use-kkcc --enable-kkcc
-
+dnl
dnl parse flags
AC_ARG_WITH([prefix],
AC_HELP_STRING([--with-prefix=no],[Don't compile the value for `prefix' into the executable.]),
＠＠ -589,8 +613,8 ＠＠
AC_ARG_WITH([quantify],
AC_HELP_STRING([--with-quantify],[Support performance debugging using Quantify.]),
[], [])
-AC_ARG_ENABLE([toolbars],
- AC_HELP_STRING([--with-toolbars],[Enable toolbar support. Default: yes.]),
+XE_ARG_ENABLE_OR_WITH([toolbars],
+ AC_HELP_STRING([--enable-toolbars],[Enable toolbar support. Default: yes.]),
[], [])
AC_ARG_WITH([tty],
AC_HELP_STRING([--with-tty],[Enable TTY support. Default: yes.]),
＠＠ -600,12 +624,12 ＠＠
menubar. Incompatible with `--with-xim=motif'.
`--enable-menubars=lucid' (the default) is desirable.]),
[], [])
-AC_ARG_ENABLE([mule],
- AC_HELP_STRING([--enable-mule],[Compile with Mule (MUlti-Lingual Emacs) support,
+XE_ARG_ENABLE_OR_WITH([mule],
+ AC_HELP_STRING([--enable-mule],[Compile with Mule (Multi-Lingual Emacs) support,
needed to support non-Latin-1 (including Asian)
languages.]),
[], [])
-AC_ARG_ENABLE([default-eol-detection],
+XE_ARG_ENABLE_OR_WITH([default-eol-detection],
AC_HELP_STRING([--enable-default-eol-detection],[Turns on by default auto-detection of end-of-line type
when reading a file. Applies to those platforms where
auto-detection is off by default (non-Mule Unix). Has
＠＠ -702,44 +726,44 ＠＠
AC_ARG_WITH([package-path],
AC_HELP_STRING([--with-package-path],[Search path for package hierarchies.]),
[AC_DEFINE(PACKAGE_PATH_USER_DEFINED)], [])
-AC_ARG_ENABLE([external-widget],
+XE_ARG_ENABLE_OR_WITH([external-widget],
AC_HELP_STRING([--enable-external-widget],[Support XEmacs server for text widgets in other applications.]),
[], [])
-AC_ARG_ENABLE([kkcc],
+XE_ARG_ENABLE_OR_WITH([kkcc],
AC_HELP_STRING([--enable-kkcc],[Enable new GC algorithms.]),
- [], [])
-AC_ARG_ENABLE([mc-alloc],
+ [], [enable_kkcc=yes])
+XE_ARG_ENABLE_OR_WITH([mc-alloc],
AC_HELP_STRING([--enable-mc-alloc],[Enable new allocator.]),
- [], [])
-AC_ARG_ENABLE([union-type],
+ [], [enable_mc_alloc=yes])
+XE_ARG_ENABLE_OR_WITH([union-type],
AC_HELP_STRING([--enable-union-type],[Use union definition of Lisp_Object type. Known to trigger bugs in some compilers.]),
[], [])
-AC_ARG_ENABLE([pdump],
+XE_ARG_ENABLE_OR_WITH([pdump],
AC_HELP_STRING([--enable-pdump],[Enable portable LISP preloader.]),
[], [])
-AC_ARG_ENABLE([dump-in-exec],
+XE_ARG_ENABLE_OR_WITH([dump-in-exec],
AC_HELP_STRING([--enable-dump-in-exec],[Enable dumping into executable (enabled by default
for `pdump', not enabled by default in combination
with `mc-alloc').]),
[], [])
-AC_ARG_ENABLE([debug],
+XE_ARG_ENABLE_OR_WITH([debug],
AC_HELP_STRING([--enable-debug],[Enable additional debugging information. No time cost.]),
[], [])
-AC_ARG_ENABLE([assertions],
+XE_ARG_ENABLE_OR_WITH([assertions],
AC_HELP_STRING([--enable-assertions],[]),
[], [])
-AC_ARG_ENABLE([memory-usage-stats],
+XE_ARG_ENABLE_OR_WITH([memory-usage-stats],
AC_HELP_STRING([--enable-memory-usage-stats],[Enable LISP memory usage API.]),
[], [])
-AC_ARG_ENABLE([clash-detection],
+XE_ARG_ENABLE_OR_WITH([clash-detection],
AC_HELP_STRING([--enable-clash-detection],[Disable use of lock files to detect multiple edits
of the same file.]),
[], [])
-AC_ARG_ENABLE([modules],
+XE_ARG_ENABLE_OR_WITH([modules],
AC_HELP_STRING([--enable-modules],[Compile in experimental support for dynamically
loaded libraries (Dynamic Shared Objects).]),
[], [])
-AC_ARG_ENABLE([quick-build],
+XE_ARG_ENABLE_OR_WITH([quick-build],
AC_HELP_STRING([--enable-quick-build],[Speed up the build cycle by leaving out steps where
XEmacs will still work (more or less) without them.
Potentially dangerous if you don't know what you're
--
Malcolm Purvis <malcolmp(a)xemacs.org>
- 3 participants
- 4 comments
[COMMIT] document need to rebase under cygwin in faq
18 years, 6 months
Ben Wing
Ben Wing
NOTE: This patch has been committed.
man/ChangeLog addition:
2005-10-13 Ben Wing <ben(a)xemacs.org>
* xemacs-faq.texi (Top):
* xemacs-faq.texi (External Subsystems):
* xemacs-faq.texi (Q5.4.4):
* xemacs-faq.texi (Q5.4.5):
* xemacs-faq.texi (Q5.4.6):
Add question about need to run `rebaseall' under Cygwin.
build source patch:
Diff command: bash -ci "cvs-diff --show-c-function -no-changelog "
Files affected: man/xemacs-faq.texi
Index: man/xemacs-faq.texi
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/man/xemacs-faq.texi,v
retrieving revision 1.85
diff -u -p -r1.85 xemacs-faq.texi
--- man/xemacs-faq.texi 2005/05/10 17:56:15 1.85
+++ man/xemacs-faq.texi 2005/10/14 02:11:03
＠＠ -455,6 +455,7 ＠＠ library directory>/info/}. For example i
* Q5.4.3:: Telnet from shell filters too much
* Q5.4.4:: Strange things are happening in Shell Mode.
* Q5.4.5:: XEmacs complains "No such file or directory, diff"
+* Q5.4.6:: Cygwin error "fork_copy: linked dll/bss pass 0 failed"
5.5: Multiple Device Support
* Q5.5.1:: How do I open a frame on another screen of my multi-headed display?
＠＠ -6091,6 +6092,7 ＠＠ as speakers and the printer.
* Q5.4.3:: Telnet from shell filters too much
* Q5.4.4:: Strange things are happening in Shell Mode.
* Q5.4.5:: XEmacs complains "No such file or directory, diff"
+* Q5.4.6:: Cygwin error "fork_copy: linked dll/bss pass 0 failed"
5.5: Multiple Device Support
* Q5.5.1:: How do I open a frame on another screen of my multi-headed display?
＠＠ -6527,7 +6529,7 ＠＠ if ( "$TERM" == emacs || "$TERM" == unkn
＠end example
＠end quotation
-＠node Q5.4.5, Q5.5.1, Q5.4.4, External Subsystems
+＠node Q5.4.5, Q5.4.6, Q5.4.4, External Subsystems
＠unnumberedsubsec Q5.4.5: XEmacs complains "No such file or directory, diff"
or "ispell" or other commands that seem related to whatever you just
＠＠ -6542,9 +6544,43 ＠＠ Unix utilities nearly trivial). Another
MinGW (＠uref{http://www.mingw.org/msys.shtml}). If you know of others,
please let us know!
+＠node Q5.4.6, Q5.5.1, Q5.4.5, External Subsystems
+＠unnumberedsubsec Q5.4.6: Cygwin error "fork_copy: linked dll/bss pass 0 failed"
+
+If you are getting an error like
+
+＠example
+17797832 [main] bash 3468 fork_copy: linked dll/bss pass 0 failed,
+0x675000..0x6756A0, done 0, windows pid 2708, Win 32 error 487
+bash: fork: resource temporarily unavailable
+＠end example
+
+when trying to run bash using ＠kbd{M-x shell}, then you need to rebase
+your Cygwin DLL's. This is a known problem with Cygwin. To fix:
+
+＠enumerate
+＠item
+Download the ＠file{rebase} utility from Cygwin setup (it's under
+＠samp{System}).
+＠item
+Kill ＠strong{all} of your Cygwin processes, including all of your
+shells and all background processes. Use ＠code{ps -a} to list all the
+processes you need to kill.
+＠item
+From a DOS prompt, run ＠file{ash} (＠strong{not} ＠file{bash},
+＠file{tcsh} or ＠file{zsh}). Do not try to be clever and ＠code{exec
+/bin/ash} from your last shell; it won't work.
+＠item
+Type ＠code{/bin/rebaseall -v}.
+＠end enumerate
+
+The problem should now be fixed -- at least, until you install another
+Cygwin package with DLL's, in which case you may have to repeat the
+procedure.
+
＠unnumberedsec 5.5: Multiple Device Support
-＠node Q5.5.1, Q5.5.2, Q5.4.5, External Subsystems
+＠node Q5.5.1, Q5.5.2, Q5.4.6, External Subsystems
＠unnumberedsubsec Q5.5.1: How do I open a frame on another screen of my multi-headed display?
Use the command ＠kbd{M-x make-frame-on-display}. This command is also
- 1 participants
- 0 comments
[COMMIT] add gc percentage threshold to mc-alloc
18 years, 6 months
Ben Wing
Ben Wing
NOTE: This patch has been committed.
src/ChangeLog addition:
2005-10-13 Ben Wing <ben(a)xemacs.org>
* config.h.in:
* alloc.c:
* alloc.c (struct):
* alloc.c (alloc_lrecord):
* alloc.c (noseeum_alloc_lrecord):
* alloc.c (finalize_string):
* alloc.c (make_uninit_string):
* alloc.c (make_string_nocopy):
* alloc.c (garbage_collect_1):
* alloc.c (object_memory_usage_stats):
* alloc.c (HACK_O_MATIC):
* alloc.c (Fgarbage_collect):
* alloc.c (Ftotal_memory_usage):
* alloc.c (recompute_need_to_garbage_collect):
* alloc.c (common_init_alloc_early):
* alloc.c (syms_of_alloc):
* alloc.c (vars_of_alloc):
* dumper.c (pdump_load_finish):
* emacs.c:
* emacs.c (main_1):
* emacs.c (shut_down_emacs):
* lrecord.h:
* lrecord.h (MC_ALLOC_CALL_FINALIZER):
* mc-alloc.c (remove_cell):
* mc-alloc.h:
* symbols.c (init_symbols_once_early):
Rename MC_ALLOC_TYPE_STATS to ALLOC_TYPE_STATS, since
(with refactoring) this is not really specific to mc-alloc.
Generalize code to implement the GC % threshold for garbage
collecting. Rename `lrecord-stats' to `object-memory-usage-stats'
(defined when not mc-alloc, too). Rename `memory-usage' to
`total-memory-usage' and add `object-memory-usage'. Bump
gc_cons_threshold to 2,000,000 (suggestion by Stephen Turnbull).
Avoid use of C++ reserved word `catch'.
Change address for crash reporting to xemacs-beta(a)xemacs.org from
crashes(a)xemacs.org.
new -> new_ in emacs.c.
Turn on _CRT_SECURE_NO_DEPRECATE under Visual C++ to avoid tons of
warnings in VC8.
build source patch:
Diff command: bash -ci "cvs-diff --show-c-function -no-changelog "
Files affected: src/symbols.c src/mc-alloc.h src/mc-alloc.c src/lrecord.h src/emacs.c src/dumper.c src/alloc.c src/config.h.in
Index: src/config.h.in
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/src/config.h.in,v
retrieving revision 1.100
diff -u -p -r1.100 config.h.in
--- src/config.h.in 2005/04/08 23:11:20 1.100
+++ src/config.h.in 2005/10/14 01:13:23
＠＠ -1,6 +1,6 ＠＠
/* XEmacs site configuration template file. -*- C -*-
Copyright (C) 1986, 1991-1994, 1998, 1999 Free Software Foundation, Inc.
- Copyright (C) 2000, 2001, 2002, 2004 Ben Wing.
+ Copyright (C) 2000, 2001, 2002, 2004, 2005 Ben Wing.
This file is part of XEmacs.
＠＠ -815,6 +815,13 ＠＠ things are arranged in config.h.in. In
#endif /* WIN32_NO_CONFIGURE */
+#ifdef _MSC_VER
+/* Turn off tons of C4996 warnings in VC 8 about standard functions being
+ "deprecated" in favor of Microsoft-specific "secure" ones (!)
+ This must go *before* the inclusion of any system files. */
+#define _CRT_SECURE_NO_DEPRECATE
+#endif
+
/* alloca twiddling.
Because we might be #including alloca.h here, feature test macros
such as _XOPEN_SOURCE must be defined above.
＠＠ -907,6 +914,16 ＠＠ extern "C" {
#if defined (USE_SYSTEM_MALLOC) && !defined (SYSTEM_MALLOC)
#define SYSTEM_MALLOC
+#endif
+
+/* This enables type based information (updated during gc). The output
+ is used by show-memory-usage to print memory information for each
+ type. Since the new allocator does not distinguish between types
+ anymore, this functionality is additionally implemented and
+ consumes a lot of time. That is why this functionality can be
+ disabled; for the moment, we keep it enabled. */
+#if !defined (MC_ALLOC) || 1
+# define ALLOC_TYPE_STATS 1
#endif
/* Define the return type of signal handlers if the s/xxx.h file
Index: src/alloc.c
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/src/alloc.c,v
retrieving revision 1.115
diff -u -p -r1.115 alloc.c
--- src/alloc.c 2005/10/04 16:47:10 1.115
+++ src/alloc.c 2005/10/14 01:13:26
＠＠ -1,7 +1,7 ＠＠
/* Storage allocation and gc for XEmacs Lisp interpreter.
Copyright (C) 1985-1998 Free Software Foundation, Inc.
Copyright (C) 1995 Sun Microsystems, Inc.
- Copyright (C) 1995, 1996, 2001, 2002, 2003, 2004 Ben Wing.
+ Copyright (C) 1995, 1996, 2001, 2002, 2003, 2004, 2005 Ben Wing.
This file is part of XEmacs.
＠＠ -94,6 +94,8 ＠＠ static Fixnum debug_allocation_backtrace
/* Number of bytes of consing done since the last gc */
static EMACS_INT consing_since_gc;
EMACS_UINT total_consing;
+EMACS_INT total_gc_usage;
+int total_gc_usage_set;
int need_to_garbage_collect;
int need_to_check_c_alloca;
＠＠ -510,7 +512,7 ＠＠ allocate_lisp_storage (Bytecount size)
}
#endif /* not MC_ALLOC */
-#ifdef MC_ALLOC_TYPE_STATS
+#if defined (MC_ALLOC) && defined (ALLOC_TYPE_STATS)
static struct
{
int instances_in_use;
＠＠ -579,7 +581,7 ＠＠ dec_lrecord_stats (Bytecount size_includ
DECREMENT_CONS_COUNTER (size);
}
-#endif /* not MC_ALLOC_TYPE_STATS */
+#endif /* not (MC_ALLOC && ALLOC_TYPE_STATS) */
#ifndef MC_ALLOC
/* lcrecords are chained together through their "next" field.
＠＠ -605,9 +607,9 ＠＠ alloc_lrecord (Bytecount size,
gc_checking_assert (LRECORD_FREE_P (lheader));
set_lheader_implementation (lheader, implementation);
lheader->uid = lrecord_uid_counter++;
-#ifdef MC_ALLOC_TYPE_STATS
+#ifdef ALLOC_TYPE_STATS
inc_lrecord_stats (size, lheader);
-#endif /* not MC_ALLOC_TYPE_STATS */
+#endif /* ALLOC_TYPE_STATS */
INCREMENT_CONS_COUNTER (size, implementation->name);
return lheader;
}
＠＠ -627,9 +629,9 ＠＠ noseeum_alloc_lrecord (Bytecount size,
gc_checking_assert (LRECORD_FREE_P (lheader));
set_lheader_implementation (lheader, implementation);
lheader->uid = lrecord_uid_counter++;
-#ifdef MC_ALLOC_TYPE_STATS
+#ifdef ALLOC_TYPE_STATS
inc_lrecord_stats (size, lheader);
-#endif /* not MC_ALLOC_TYPE_STATS */
+#endif /* ALLOC_TYPE_STATS */
NOSEEUM_INCREMENT_CONS_COUNTER (size, implementation->name);
return lheader;
}
＠＠ -2492,9 +2494,9 ＠＠ finalize_string (void *header, int for_d
{
Lisp_String *s = (Lisp_String *) header;
Bytecount size = s->size_;
-#ifdef MC_ALLOC_TYPE_STATS
+#ifdef ALLOC_TYPE_STATS
dec_lrecord_string_data_stats (size);
-#endif /* MC_ALLOC_TYPE_STATS */
+#endif /* ALLOC_TYPE_STATS */
if (BIG_STRING_SIZE_P (size))
xfree (s->data_, Ibyte *);
}
＠＠ -2614,9 +2616,9 ＠＠ make_uninit_string (Bytecount length)
#ifdef MC_ALLOC
s = alloc_lrecord_type (Lisp_String, &lrecord_string);
-#ifdef MC_ALLOC_TYPE_STATS
+#ifdef ALLOC_TYPE_STATS
inc_lrecord_string_data_stats (length);
-#endif /* MC_ALLOC_TYPE_STATS */
+#endif /* ALLOC_TYPE_STATS */
#else /* not MC_ALLOC */
/* Allocate the string header */
ALLOCATE_FIXED_TYPE (string, Lisp_String, s);
＠＠ -3000,9 +3002,9 ＠＠ make_string_nocopy (const Ibyte *content
#ifdef MC_ALLOC
s = alloc_lrecord_type (Lisp_String, &lrecord_string);
-#ifdef MC_ALLOC_TYPE_STATS
+#ifdef ALLOC_TYPE_STATS
inc_lrecord_string_data_stats (length);
-#endif /* MC_ALLOC_TYPE_STATS */
+#endif /* ALLOC_TYPE_STATS */
mcpro (wrap_pointer_1 (s)); /* otherwise nocopy_strings get
collected and static data is tried to
be freed. */
＠＠ -5525,13 +5527,13 ＠＠ garbage_collect_1 (void)
}
{
- struct catchtag *catch;
- for (catch = catchlist; catch; catch = catch->next)
+ struct catchtag *c;
+ for (c = catchlist; c; c = c->next)
{
- mark_object (catch->tag);
- mark_object (catch->val);
- mark_object (catch->actual_tag);
- mark_object (catch->backtrace);
+ mark_object (c->tag);
+ mark_object (c->val);
+ mark_object (c->actual_tag);
+ mark_object (c->backtrace);
}
}
＠＠ -5667,10 +5669,10 ＠＠ garbage_collect_1 (void)
return;
}
-#ifdef MC_ALLOC
-#ifdef MC_ALLOC_TYPE_STATS
+#ifdef ALLOC_TYPE_STATS
+
static Lisp_Object
-gc_plist_hack (const Ascbyte *name, int value, Lisp_Object tail)
+gc_plist_hack (const Ascbyte *name, EMACS_INT value, Lisp_Object tail)
{
/* C doesn't have local functions (or closures, or GC, or readable syntax,
or portable numeric datatypes, or bit-vectors, or characters, or
＠＠ -5678,13 +5680,14 ＠＠ gc_plist_hack (const Ascbyte *name, int
return cons3 (intern (name), make_int (value), tail);
}
-DEFUN("lrecord-stats", Flrecord_stats, 0, 0 ,"", /*
-Return statistics about lrecords in a property list.
-*/
- ())
+static Lisp_Object
+object_memory_usage_stats (int set_total_gc_usage)
{
Lisp_Object pl = Qnil;
int i;
+ EMACS_INT tgu_val = 0;
+
+#ifdef MC_ALLOC
for (i = 0; i < (countof (lrecord_implementations_table)
+ MODULE_DEFINABLE_TYPE_COUNT); i++)
＠＠ -5709,6 +5712,7 ＠＠ Return statistics about lrecords in a pr
pl = gc_plist_hack (buf,
lrecord_stats[i].bytes_in_use,
pl);
+ tgu_val += lrecord_stats[i].bytes_in_use_including_overhead;
if (name[len-1] == 's')
sprintf (buf, "%ses-used", name);
＠＠ -5723,85 +5727,18 ＠＠ Return statistics about lrecords in a pr
lrecord_string_data_bytes_in_use, pl);
pl = gc_plist_hack ("string-data-used",
lrecord_string_data_instances_in_use, pl);
-
- return pl;
-}
-#endif /* not MC_ALLOC_TYPE_STATS */
+ tgu_val += lrecord_string_data_bytes_in_use_including_overhead;
-DEFUN ("garbage-collect", Fgarbage_collect, 0, 0, "", /*
-Reclaim storage for Lisp objects no longer needed.
-Return info on amount of space in use:
- ((USED-CONSES . STORAGE-CONSES) (USED-SYMS . STORAGE-SYMS)
- (USED-MARKERS . STORAGE-MARKERS) USED-STRING-CHARS USED-VECTOR-SLOTS
- PLIST)
- where `PLIST' is a list of alternating keyword/value pairs providing
- more detailed information.
-Garbage collection happens automatically if you cons more than
-`gc-cons-threshold' bytes of Lisp data since previous garbage collection.
-*/
- ())
-{
- garbage_collect_1 ();
-
-#ifdef MC_ALLOC_TYPE_STATS
- /* The things we do for backwards-compatibility */
- return
- list6
- (Fcons (make_int (lrecord_stats[lrecord_type_cons].instances_in_use),
- make_int (lrecord_stats[lrecord_type_cons]
- .bytes_in_use_including_overhead)),
- Fcons (make_int (lrecord_stats[lrecord_type_symbol].instances_in_use),
- make_int (lrecord_stats[lrecord_type_symbol]
- .bytes_in_use_including_overhead)),
- Fcons (make_int (lrecord_stats[lrecord_type_marker].instances_in_use),
- make_int (lrecord_stats[lrecord_type_marker]
- .bytes_in_use_including_overhead)),
- make_int (lrecord_stats[lrecord_type_string]
- .bytes_in_use_including_overhead),
- make_int (lrecord_stats[lrecord_type_vector]
- .bytes_in_use_including_overhead),
- Flrecord_stats ());
-#else /* not MC_ALLOC_TYPE_STATS */
- return Qnil;
-#endif /* not MC_ALLOC_TYPE_STATS */
-}
#else /* not MC_ALLOC */
-/* Debugging aids. */
-static Lisp_Object
-gc_plist_hack (const Ascbyte *name, int value, Lisp_Object tail)
-{
- /* C doesn't have local functions (or closures, or GC, or readable syntax,
- or portable numeric datatypes, or bit-vectors, or characters, or
- arrays, or exceptions, or ...) */
- return cons3 (intern (name), make_int (value), tail);
-}
-
#define HACK_O_MATIC(type, name, pl) do { \
- int s = 0; \
+ EMACS_INT s = 0; \
struct type##_block *x = current_##type##_block; \
while (x) { s += sizeof (*x) + MALLOC_OVERHEAD; x = x->prev; } \
+ tgu_val += s; \
(pl) = gc_plist_hack ((name), s, (pl)); \
} while (0)
-DEFUN ("garbage-collect", Fgarbage_collect, 0, 0, "", /*
-Reclaim storage for Lisp objects no longer needed.
-Return info on amount of space in use:
- ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)
- (USED-MARKERS . FREE-MARKERS) USED-STRING-CHARS USED-VECTOR-SLOTS
- PLIST)
- where `PLIST' is a list of alternating keyword/value pairs providing
- more detailed information.
-Garbage collection happens automatically if you cons more than
-`gc-cons-threshold' bytes of Lisp data since previous garbage collection.
-*/
- ())
-{
- Lisp_Object pl = Qnil;
- int i;
- int gc_count_vector_total_size = 0;
- garbage_collect_1 ();
-
for (i = 0; i < lrecord_type_count; i++)
{
if (lcrecord_stats[i].bytes_in_use != 0
＠＠ -5811,13 +5748,10 ＠＠ Garbage collection happens automatically
char buf [255];
const char *name = lrecord_implementations_table[i]->name;
int len = strlen (name);
- /* save this for the FSFmacs-compatible part of the summary */
- if (i == lrecord_type_vector)
- gc_count_vector_total_size =
- lcrecord_stats[i].bytes_in_use + lcrecord_stats[i].bytes_freed;
sprintf (buf, "%s-storage", name);
pl = gc_plist_hack (buf, lcrecord_stats[i].bytes_in_use, pl);
+ tgu_val += lcrecord_stats[i].bytes_in_use;
/* Okay, simple pluralization check for `symbol-value-varalias' */
if (name[len-1] == 's')
sprintf (buf, "%ses-freed", name);
＠＠ -5895,7 +5829,70 ＠＠ Garbage collection happens automatically
pl = gc_plist_hack ("conses-free", gc_count_num_cons_freelist, pl);
pl = gc_plist_hack ("conses-used", gc_count_num_cons_in_use, pl);
+#undef HACK_O_MATIC
+
+#endif /* MC_ALLOC */
+
+ if (set_total_gc_usage)
+ {
+ total_gc_usage = tgu_val;
+ total_gc_usage_set = 1;
+ }
+
+ return pl;
+}
+
+DEFUN("object-memory-usage-stats", Fobject_memory_usage_stats, 0, 0 ,"", /*
+Return statistics about memory usage of Lisp objects.
+*/
+ ())
+{
+ return object_memory_usage_stats (0);
+}
+
+#endif /* ALLOC_TYPE_STATS */
+
+/* Debugging aids. */
+
+DEFUN ("garbage-collect", Fgarbage_collect, 0, 0, "", /*
+Reclaim storage for Lisp objects no longer needed.
+Return info on amount of space in use:
+ ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)
+ (USED-MARKERS . FREE-MARKERS) USED-STRING-CHARS USED-VECTOR-SLOTS
+ PLIST)
+ where `PLIST' is a list of alternating keyword/value pairs providing
+ more detailed information.
+Garbage collection happens automatically if you cons more than
+`gc-cons-threshold' bytes of Lisp data since previous garbage collection.
+*/
+ ())
+{
+ /* Record total usage for purposes of determining next GC */
+ garbage_collect_1 ();
+
+ /* This will get set to 1, and total_gc_usage computed, as part of the
+ call to object_memory_usage_stats() -- if ALLOC_TYPE_STATS is enabled. */
+ total_gc_usage_set = 0;
+#ifdef ALLOC_TYPE_STATS
/* The things we do for backwards-compatibility */
+#ifdef MC_ALLOC
+ return
+ list6
+ (Fcons (make_int (lrecord_stats[lrecord_type_cons].instances_in_use),
+ make_int (lrecord_stats[lrecord_type_cons]
+ .bytes_in_use_including_overhead)),
+ Fcons (make_int (lrecord_stats[lrecord_type_symbol].instances_in_use),
+ make_int (lrecord_stats[lrecord_type_symbol]
+ .bytes_in_use_including_overhead)),
+ Fcons (make_int (lrecord_stats[lrecord_type_marker].instances_in_use),
+ make_int (lrecord_stats[lrecord_type_marker]
+ .bytes_in_use_including_overhead)),
+ make_int (lrecord_stats[lrecord_type_string]
+ .bytes_in_use_including_overhead),
+ make_int (lrecord_stats[lrecord_type_vector]
+ .bytes_in_use_including_overhead),
+ object_memory_usage_stats (1));
+#else /* not MC_ALLOC */
return
list6 (Fcons (make_int (gc_count_num_cons_in_use),
make_int (gc_count_num_cons_freelist)),
＠＠ -5904,11 +5901,14 ＠＠ Garbage collection happens automatically
Fcons (make_int (gc_count_num_marker_in_use),
make_int (gc_count_num_marker_freelist)),
make_int (gc_count_string_total_size),
- make_int (gc_count_vector_total_size),
- pl);
-}
-#undef HACK_O_MATIC
+ make_int (lcrecord_stats[lrecord_type_vector].bytes_in_use +
+ lcrecord_stats[lrecord_type_vector].bytes_freed),
+ object_memory_usage_stats (1));
#endif /* not MC_ALLOC */
+#else /* not ALLOC_TYPE_STATS */
+ return Qnil;
+#endif /* ALLOC_TYPE_STATS */
+}
DEFUN ("consing-since-gc", Fconsing_since_gc, 0, 0, "", /*
Return the number of bytes consed since the last garbage collection.
＠＠ -5934,15 +5934,30 ＠＠ The value is divided by 1024 to make sur
}
#endif
-DEFUN ("memory-usage", Fmemory_usage, 0, 0, 0, /*
+DEFUN ("total-memory-usage", Ftotal_memory_usage, 0, 0, 0, /*
Return the total number of bytes used by the data segment in XEmacs.
This may be helpful in debugging XEmacs's memory usage.
+NOTE: This may or may not be accurate! It is hard to determine this
+value in a system-independent fashion. On Windows, for example, the
+returned number tends to be much greater than reality.
*/
())
{
return make_int (total_data_usage ());
}
+#ifdef ALLOC_TYPE_STATS
+DEFUN ("object-memory-usage", Fobject_memory_usage, 0, 0, 0, /*
+Return total number of bytes used for object storage in XEmacs.
+This may be helpful in debugging XEmacs's memory usage.
+See also `consing-since-gc' and `object-memory-usage-stats'.
+*/
+ ())
+{
+ return make_int (total_gc_usage + consing_since_gc);
+}
+#endif /* ALLOC_TYPE_STATS */
+
void
recompute_funcall_allocation_flag (void)
{
＠＠ -5961,11 +5976,15 ＠＠ recompute_need_to_garbage_collect (void)
else
need_to_garbage_collect =
(consing_since_gc > gc_cons_threshold
-#if 0 /* #### implement this better */
&&
+#if 0 /* #### implement this better */
(100 * consing_since_gc) / total_data_usage () >=
gc_cons_percentage
-#endif /* 0 */
+#else
+ (!total_gc_usage_set ||
+ (100 * consing_since_gc) / total_gc_usage >=
+ gc_cons_percentage)
+#endif
);
recompute_funcall_allocation_flag ();
}
＠＠ -6216,13 +6235,12 ＠＠ common_init_alloc_early (void)
funcall_alloca_count = 0;
#if 1
- gc_cons_threshold = 500000; /* XEmacs change */
+ gc_cons_threshold = 2000000; /* XEmacs change */
#else
gc_cons_threshold = 15000; /* debugging */
#endif
- gc_cons_percentage = 0; /* #### 20; Don't have an accurate measure of
- memory usage on Windows; not verified on other
- systems */
+ gc_cons_percentage = 40; /* #### what is optimal? */
+ total_gc_usage_set = 0;
lrecord_uid_counter = 259;
#ifndef MC_ALLOC
debug_string_purity = 0;
＠＠ -6347,14 +6365,15 ＠＠ syms_of_alloc (void)
DEFSUBR (Fmake_symbol);
DEFSUBR (Fmake_marker);
DEFSUBR (Fpurecopy);
-#ifdef MC_ALLOC_TYPE_STATS
- DEFSUBR (Flrecord_stats);
-#endif /* MC_ALLOC_TYPE_STATS */
+#ifdef ALLOC_TYPE_STATS
+ DEFSUBR (Fobject_memory_usage_stats);
+ DEFSUBR (Fobject_memory_usage);
+#endif /* ALLOC_TYPE_STATS */
DEFSUBR (Fgarbage_collect);
#if 0
DEFSUBR (Fmemory_limit);
#endif
- DEFSUBR (Fmemory_usage);
+ DEFSUBR (Ftotal_memory_usage);
DEFSUBR (Fconsing_since_gc);
}
＠＠ -6386,26 +6405,22 ＠＠ effective way to check GCPRO problems, b
will be unusable! You almost certainly won't have the patience to wait
long enough to be able to set it back.
-See also `consing-since-gc'.
+See also `consing-since-gc' and `gc-cons-percentage'.
*/ );
DEFVAR_INT ("gc-cons-percentage", &gc_cons_percentage /*
*Percentage of memory allocated between garbage collections.
Garbage collection will happen if this percentage of the total amount of
-memory used for data has been allocated since the last garbage collection.
-However, it will not happen if less than `gc-cons-threshold' bytes have
-been allocated -- this sets an absolute minimum in case very little data
-has been allocated or the percentage is set very low. Set this to 0 to
-have garbage collection always happen after `gc-cons-threshold' bytes have
-been allocated, regardless of current memory usage.
-
-Garbage collection happens automatically when `eval' or `funcall' are
-called. (Note that `funcall' is called implicitly as part of evaluation.)
-By binding this temporarily to a large number, you can effectively
-prevent garbage collection during a part of the program.
+memory used for data (see `lisp-object-memory-usage') has been allocated
+since the last garbage collection. However, it will not happen if less
+than `gc-cons-threshold' bytes have been allocated -- this sets an absolute
+minimum in case very little data has been allocated or the percentage is
+set very low. Set this to 0 to have garbage collection always happen after
+`gc-cons-threshold' bytes have been allocated, regardless of current memory
+usage.
-See also `consing-since-gc'.
+See also `consing-since-gc' and `gc-cons-threshold'.
*/ );
#ifdef DEBUG_XEMACS
Index: src/dumper.c
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/src/dumper.c,v
retrieving revision 1.30
diff -u -p -r1.30 dumper.c
--- src/dumper.c 2005/06/23 11:48:47 1.30
+++ src/dumper.c 2005/10/14 01:13:29
＠＠ -2164,7 +2164,7 ＠＠ pdump_load_finish (void)
if (count == 2)
{
mc_addr = (Rawbyte *) mc_alloc (real_size);
-#ifdef MC_ALLOC_TYPE_STATS
+#ifdef ALLOC_TYPE_STATS
inc_lrecord_stats (real_size,
(const struct lrecord_header *)
((char *) rdata + delta));
＠＠ -2173,7 +2173,7 ＠＠ pdump_load_finish (void)
== lrecord_type_string)
inc_lrecord_string_data_stats
(((Lisp_String *) ((char *) rdata + delta))->size_);
-#endif /* not MC_ALLOC_TYPE_STATS */
+#endif /* ALLOC_TYPE_STATS */
}
else
mc_addr = (Rawbyte *) xmalloc_and_zero (real_size);
Index: src/emacs.c
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/src/emacs.c,v
retrieving revision 1.158
diff -u -p -r1.158 emacs.c
--- src/emacs.c 2005/10/04 17:51:24 1.158
+++ src/emacs.c 2005/10/14 01:13:32
＠＠ -919,9 +919,9 ＠＠ main_1 (int argc, Wexttext **argv, Wextt
if (!restart)
{
init_mc_allocator ();
-#ifdef MC_ALLOC_TYPE_STATS
+#ifdef ALLOC_TYPE_STATS
init_lrecord_stats ();
-#endif /* not MC_ALLOC_TYPE_STATS */
+#endif /* ALLOC_TYPE_STATS */
}
}
#endif /* MC_ALLOC */
＠＠ -1217,16 +1217,16 ＠＠ main_1 (int argc, Wexttext **argv, Wextt
This requires inserting a new element into argv. */
if (dpy != 0 && skip_args - count_before == 1)
{
- Wexttext **new = xnew_array (Wexttext *, argc + 2);
+ Wexttext **new_ = xnew_array (Wexttext *, argc + 2);
int j;
for (j = 0; j < count_before + 1; j++)
- new[j] = argv[j];
- new[count_before + 1] = WEXTSTRING ("-d");
- new[count_before + 2] = dpy;
+ new_[j] = argv[j];
+ new_[count_before + 1] = WEXTSTRING ("-d");
+ new_[count_before + 2] = dpy;
for (j = count_before + 2; j <argc; j++)
- new[j + 1] = argv[j];
- argv = new;
+ new_[j + 1] = argv[j];
+ argv = new_;
argc++;
}
/* Change --display to -d, when its arg is separate. */
＠＠ -2913,7 +2913,7 ＠＠ DEFUN_NORETURN ("run-emacs-from-temacs",
Do not call this. It will reinitialize your XEmacs. You'll be sorry.
*/
/* If this function is called from startup.el, it will be possible to run
- temacs as an editor using 'temacs -batch -l loadup.el run-temacs', instead
+ temacs as an editor using `temacs -batch -l loadup.el run-temacs', instead
of having to dump an emacs and then run that (when debugging emacs itself,
this can be much faster)). [Actually, the speed difference isn't that
much as long as your filesystem is local, and you don't end up with
＠＠ -3472,17 +3472,17 ＠＠ shut_down_emacs (int sig, Lisp_Object st
"the crash anyway.\n\n"
#ifdef INFODOCK
"Please report this bug by selecting `Report-Bug' in the InfoDock menu, or\n"
-"(last resort) by emailing `crashes(a)xemacs.org' -- note that this is for XEmacs\n"
-"in general, not just Infodock."
+"(last resort) by emailing `xemacs-beta(a)xemacs.org' -- note that this is for\n"
+"XEmacs in general, not just Infodock."
#else
"Please report this bug by invoking M-x report-emacs-bug, or by selecting\n"
"`Send Bug Report' from the Help menu. If that won't work, send ordinary\n"
-"email to `crashes(a)xemacs.org'."
+"email to `xemacs-beta(a)xemacs.org'."
#endif
-" *MAKE SURE* to include this entire output\n"
-"from this crash, especially including the Lisp backtrace, as well as the\n"
-"XEmacs configuration from M-x describe-installation (or equivalently, the\n"
-"file `Installation' in the top of the build tree).\n"
+" *MAKE SURE* to include this entire\n"
+"output from this crash, especially including the Lisp backtrace, as well as\n"
+"the XEmacs configuration from M-x describe-installation (or equivalently,\n"
+"the file `Installation' in the top of the build tree).\n"
#ifdef _MSC_VER
"\n"
"If you are fortunate enough to have some sort of debugging aid installed\n"
Index: src/lrecord.h
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/src/lrecord.h,v
retrieving revision 1.38
diff -u -p -r1.38 lrecord.h
--- src/lrecord.h 2005/05/15 16:38:13 1.38
+++ src/lrecord.h 2005/10/14 01:13:34
＠＠ -376,18 +376,16 ＠＠ extern int gc_in_progress;
#ifdef MC_ALLOC
#include "mc-alloc.h"
-#endif /* MC_ALLOC */
-#ifdef MC_ALLOC_TYPE_STATS
+#ifdef ALLOC_TYPE_STATS
void init_lrecord_stats (void);
void inc_lrecord_string_data_stats (Bytecount size);
void dec_lrecord_string_data_stats (Bytecount size);
void inc_lrecord_stats (Bytecount size, const struct lrecord_header *h);
void dec_lrecord_stats (Bytecount size_including_overhead,
const struct lrecord_header *h);
-#endif /* MC_ALLOC_TYPE_STATS */
+#endif /* ALLOC_TYPE_STATS */
-#ifdef MC_ALLOC
/* Tell mc-alloc how to call a finalizer. */
#define MC_ALLOC_CALL_FINALIZER(ptr) \
{ \
Index: src/mc-alloc.c
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/src/mc-alloc.c,v
retrieving revision 1.4
diff -u -p -r1.4 mc-alloc.c
--- src/mc-alloc.c 2005/09/14 14:24:30 1.4
+++ src/mc-alloc.c 2005/10/14 01:13:36
＠＠ -1486,10 +1486,10 ＠＠ remove_cell (void *ptr, page_header *ph)
#endif
if (PH_ON_USED_LIST_P (ph))
{
-#ifdef MC_ALLOC_TYPE_STATS
+#ifdef ALLOC_TYPE_STATS
dec_lrecord_stats (PH_CELL_SIZE (ph),
(const struct lrecord_header *) ptr);
-#endif /* MC_ALLOC_TYPE_STATS */
+#endif /* ALLOC_TYPE_STATS */
#ifdef ERROR_CHECK_GC
assert (!LRECORD_FREE_P (ptr));
deadbeef_memory (ptr, PH_CELL_SIZE (ph));
Index: src/mc-alloc.h
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/src/mc-alloc.h,v
retrieving revision 1.1
diff -u -p -r1.1 mc-alloc.h
--- src/mc-alloc.h 2005/04/08 23:11:29 1.1
+++ src/mc-alloc.h 2005/10/14 01:13:37
＠＠ -35,18 +35,6 ＠＠ Boston, MA 02111-1307, USA. */
# endif
#endif /* MALLOC_OVERHEAD */
-
-/* This enables type based information (updated during gc). The output
- is used by show-memory-usage to print memory information for each
- type. Since the new allocator does not distinguish between types
- anymore, this functionality is additionally implemented and
- consumes a lot of time. That is why it is kept conditioned on a
- separate flag called MC_ALLOC_TYPE_STATS. */
-#if 1
-# define MC_ALLOC_TYPE_STATS 1
-#endif
-
-
/*--- prototypes -------------------------------------------------------*/
BEGIN_C_DECLS
Index: src/symbols.c
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/src/symbols.c,v
retrieving revision 1.51
diff -u -p -r1.51 symbols.c
--- src/symbols.c 2005/09/29 11:41:22 1.51
+++ src/symbols.c 2005/10/14 01:13:40
＠＠ -3331,10 +3331,10 ＠＠ init_symbols_once_early (void)
mcpro (wrap_pointer_1 (tem));
tem->value = 0;
tem->type = SYMVAL_UNBOUND_MARKER;
-#ifdef MC_ALLOC_TYPE_STATS
+#ifdef ALLOC_TYPE_STATS
inc_lrecord_stats (sizeof (struct symbol_value_magic),
(const struct lrecord_header *) tem);
-#endif /* not MC_ALLOC_TYPE_STATS */
+#endif /* ALLOC_TYPE_STATS */
#else /* not MC_ALLOC */
const struct symbol_value_magic *tem = &guts_of_unbound_marker;
#endif /* not MC_ALLOC */
- 1 participants
- 0 comments