[COMMIT] Don't delete everything from the popup menu in easy-menu-remove
19 years, 1 month
Aidan Kehoe
Aidan Kehoe
NOTE: This patch has been committed.
Also affects 21.4, and is worth considering for it.
lisp/ChangeLog addition:
2005-03-25 Ralf Angeli <angeli(a)iwi.uni-sb.de>
* easymenu.el (easy-menu-remove): As described in
E1D4Nn5-0001lq-EU(a)neutrino.iwi.uni-sb.de; don't strip everything
except the "Command" menu from mode-popup-menu.
XEmacs Trunk source patch:
Diff command: cvs -q diff -u
Files affected: lisp/easymenu.el
Index: lisp/easymenu.el
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/lisp/easymenu.el,v
retrieving revision 1.7
diff -u -u -r1.7 easymenu.el
--- lisp/easymenu.el 2005/02/03 05:03:38 1.7
+++ lisp/easymenu.el 2005/03/25 16:12:14
＠＠ -203,7 +203,7 ＠＠
"Remove MENU from the current menu bar."
(when (featurep 'menubar)
(setq easy-menu-all-popups (delq menu easy-menu-all-popups)
- mode-popup-menu (if (< (length easy-menu-all-popups) 1)
+ mode-popup-menu (if (> (length easy-menu-all-popups) 1)
(cons (easy-menu-title)
(reverse easy-menu-all-popups))
(let ((same-as-menu
--
“I, for instance, am gung-ho about open source because my family is being
held hostage in Rob Malda’s basement. But who fact-checks me, or Enderle,
when we say something in public? No-one!” -- Danny O’Brien
- 2 participants
- 1 comments
[COMMIT] Fix pixel-to-point conversion arithmetic in font.el
19 years, 1 month
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT 21.5
NOTE: This patch has been committed.
This should be considered for 21.4, Vin.
lisp/ChangeLog addition:
2005-03-25 Ralf Angeli <angeli(a)iwi.uni-sb.de>
* font.el (font-spatial-to-canonical): Correct calculation of
return value for pixel-based input value.
XEmacs Trunk source patch:
Diff command: cvs -q diff -u
Files affected: lisp/font.el
Index: lisp/font.el
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/lisp/font.el,v
retrieving revision 1.16
diff -u -u -r1.16 font.el
--- lisp/font.el 2005/01/28 02:58:40 1.16
+++ lisp/font.el 2005/03/25 15:56:05
＠＠ -311,8 +311,8 ＠＠
a number, it is interpreted as the desired point size and returned unchanged.
Otherwise SPEC must be a string consisting of a number and an optional type.
The type may be the strings \"px\", \"pix\", or \"pixel\" (pixels), \"pt\" or
-\"point\" (points), \"pa\" or \"pica\" (picas), \"in\" or \"inch\" (inches), \"cm\"
-(centimeters), or \"mm\" (millimeters).
+\"point\" (points), \"pa\" or \"pica\" (picas), \"in\" or \"inch\" (inches),
+\"cm\" (centimeters), or \"mm\" (millimeters).
1 in = 2.54 cm = 6 pa = 25.4 mm = 72 pt. Pixel size is device-dependent."
(cond
＠＠ -351,7 +351,7 ＠＠
(setq num (string-to-number spec))
(cond
((member type '("pixel" "px" "pix"))
- (setq retval (* num (/ pix-width mm-width) (/ 25.4 72.0))))
+ (setq retval (* num (/ mm-width pix-width) (/ 72.0 25.4))))
((member type '("point" "pt"))
(setq retval num))
((member type '("pica" "pa"))
--
“I, for instance, am gung-ho about open source because my family is being
held hostage in Rob Malda’s basement. But who fact-checks me, or Enderle,
when we say something in public? No-one!” -- Danny O’Brien
- 3 participants
- 2 comments
[AC21.5R21.4] Stop geometry thrashing in tabs widget
19 years, 1 month
Stephen J. Turnbull
Stephen J. Turnbull
APPROVE COMMIT 21.5 RECOMMEND 21.4
Vin: applies with offset +5 and fuzz 1 on hunk 3. Not yet tested in 21.4.
If you put a printf in xlwtabs.c (TabsGeometryManager) immediately
_after_ the test for "position changed or not resizable" at the top of
the function, you should see that without the patch the printf spews
output on every window, frame, or buffer change; with the patch, you
should _never_ see it.
It turns out that the tabs widget has two parts: the row of tabs, and
the children that it controls. In XEmacs, the children are irrelevant
and never displayed; they're only used for their label/name
resources. (What a waste, but never mind....) So there's no point in
doing any geometry negotiation with them ever.
The existing code attempts to set the XtNresizable resource to NULL,
but does so on the _parent_ widget which doesn't actually have such a
resource, not on the individual children. This patch fixes that.
Index: lwlib/ChangeLog
===================================================================
RCS file: /Users/steve/Software/Repositories/cvs.xemacs.org/XEmacs/xemacs/lwlib/ChangeLog,v
retrieving revision 1.65
diff -u -r1.65 ChangeLog
--- lwlib/ChangeLog 18 Feb 2005 06:29:19 -0000 1.65
+++ lwlib/ChangeLog 8 Mar 2005 15:06:21 -0000
＠＠ -0,0 +1,6 ＠＠
+2005-03-07 Stephen J. Turnbull <stephen(a)xemacs.org>
+
+ * lwlib-Xlw.c (build_tabs_in_widget): Correctly disable geometry
+ negotiation for tab children.
+ (xlw_create_tab_control): Don't set nonexistent resizable resource.
+
Index: lwlib/lwlib-Xlw.c
===================================================================
RCS file: /Users/steve/Software/Repositories/cvs.xemacs.org/XEmacs/xemacs/lwlib/lwlib-Xlw.c,v
retrieving revision 1.13
diff -u -r1.13 lwlib-Xlw.c
--- lwlib/lwlib-Xlw.c 20 Sep 2004 19:19:16 -0000 1.13
+++ lwlib/lwlib-Xlw.c 9 Mar 2005 01:00:58 -0000
＠＠ -319,13 +319,21 ＠＠
#ifdef LWLIB_TABS_LUCID
/* tab control
- lwlib is such an incredible hairy crock. I just cannot believe
+ [[ lwlib is such an incredible hairy crock. I just cannot believe
it! There are random dependencies between functions, there is a
total lack of genericity, even though it initially appears to be
generic. It should all be junked and begun again. Building tabs are
an example - in theory we should be able to reuse a lot of the
general stuff because we want to put labels of whatever toolkit we
- are using in the tab. Instead we have to hack it by hand. */
+ are using in the tab. Instead we have to hack it by hand. ]]
+ While lwlib is a hairy crock, whoever wrote that seems to misunderstand
+ Falk's tab control widget. The tab control widget has *two* kinds of
+ children: *widgets*, which all occupy a *single* pane below the row of
+ tabs---this is where the labels created in build_tabs_in_widget go, and
+ *gadgets*, the tabs themselves, which do *not* draw themselves, but
+ rather are drawn by the control. In fact, in XEmacs the true widget
+ children are *never* visible! So this case is not a problem in the
+ design of lwlib, but rather of Falk's widget. -- sjt */
static void
xlw_tab_control_callback (Widget w, XtPointer client_data, XtPointer call_data)
{
＠＠ -375,9 +383,8 ＠＠
widget_value* val = instance->info->val;
XtSetArg (al [ac], XtNsensitive, val->enabled); ac++;
- XtSetArg (al [ac], XtNmappedWhenManaged, FALSE); ac++;
+ XtSetArg (al [ac], XtNmappedWhenManaged, False); ac++;
XtSetArg (al [ac], XtNorientation, XtorientHorizontal); ac++;
- XtSetArg (al [ac], XtNresizable, False); ac++;
/* add any args the user supplied for creation time */
lw_add_value_args_to_args (val, al, &ac);
＠＠ -396,15 +403,22 ＠＠
Widget widget, widget_value* val)
{
widget_value* cur = val;
+ Arg al[1];
+
+ /* Children are always invisible, don't permit resizing. */
+ XtSetArg (al[0], XtNresizable, False);
+
for (cur = val; cur; cur = cur->next)
{
if (cur->value)
{
+ Widget w;
#ifdef LWLIB_WIDGETS_MOTIF
- xm_create_label (widget, cur);
+ w = xm_create_label (widget, cur);
#else
- xaw_create_label (widget, cur);
+ w = xaw_create_label (widget, cur);
#endif
+ XtSetValues (w, al, 1);
}
cur->change = NO_CHANGE;
}
--
Institute of Policy and Planning Sciences http://turnbull.sk.tsukuba.ac.jp
University of Tsukuba Tennodai 1-1-1 Tsukuba 305-8573 JAPAN
Ask not how you can "do" free software business;
ask what your business can "do for" free software.
- 2 participants
- 1 comments
[R21.4] document CCL example
19 years, 1 month
Stephen J. Turnbull
Stephen J. Turnbull
RECOMMEND 21.4
Vin: this is actually work by Aidan that I found on the floor. I'm
sure Aidan recommends it, too. :-) This patch is against 21.4.
Index: man/ChangeLog
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/man/ChangeLog,v
retrieving revision 1.290
diff -u -U0 -r1.290 ChangeLog
--- man/ChangeLog 23 Feb 2005 15:33:32 -0000 1.290
+++ man/ChangeLog 9 Mar 2005 05:16:46 -0000
＠＠ -0,0 +1,5 ＠＠
+2005-01-19 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * lispref/mule.texi (CCL Example): Detail an implementation of the
+ web's URL encoding as a CCL coding system example.
+
Index: man/lispref/mule.texi
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/man/lispref/mule.texi,v
retrieving revision 1.4.2.2
diff -u -r1.4.2.2 mule.texi
--- man/lispref/mule.texi 20 Aug 2002 11:35:49 -0000 1.4.2.2
+++ man/lispref/mule.texi 9 Mar 2005 05:42:38 -0000
＠＠ -1723,7 +1723,7 ＠＠
* CCL Statements:: Semantics of CCL statements.
* CCL Expressions:: Operators and expressions in CCL.
* Calling CCL:: Running CCL programs.
-* CCL Examples:: The encoding functions for Big5 and KOI-8.
+* CCL Example:: A trivial program to transform the Web's URL encoding.
＠end menu
＠node CCL Syntax, CCL Statements, , CCL
＠＠ -1942,7 +1942,7 ＠＠
Shift JIS. CCL_DECODE_SJIS is its inverse.) It is somewhat odd to
represent the SJIS operations in infix form.
-＠node Calling CCL, CCL Examples, CCL Expressions, CCL
+＠node Calling CCL, CCL Example, CCL Expressions, CCL
＠comment Node, Next, Previous, Up
＠subsection Calling CCL
＠＠ -2008,11 +2008,277 ＠＠
Resets the CCL interpreter's internal elapsed time registers.
＠end defun
-＠node CCL Examples, , Calling CCL, CCL
+＠node CCL Example, , Calling CCL, CCL
＠comment Node, Next, Previous, Up
-＠subsection CCL Examples
+＠subsection CCL Example
- This section is not yet written.
+ In this section, we describe the implementation of a trivial coding
+system to transform from the Web's URL encoding to XEmacs' internal
+coding. Many people will have been first exposed to URL encoding when
+they saw ``%20'' where they expected a space in a file's name on their
+local hard disk; this can happen when a browser saves a file from the
+web and doesn't encode the name, as passed from the server, properly.
+
+ URL encoding itself is underspecified with regard to encodings beyond
+ASCII. The relevant document, RFC 1738, explicitly doesn't give any
+information on how to encode non-ASCII characters, and the ``obvious''
+way---use the %xx values for the octets of the eight bit MIME character
+set in which the page was served---breaks when a user types a character
+outside that character set. Best practice for web development is to
+serve all pages as UTF-8 and treat incoming form data as using that
+coding system. (Oh, and gamble that your clients won't ever want to
+type anything outside Unicode. But that's not so much of a gamble with
+today's client operating systems.) We don't treat non-ASCII in this
+example, as dealing with ＠samp{(read-multibyte-character ...)} and
+errors therewith would make it much harder to understand.
+
+ Since CCL isn't a very rich language, we move much of the logic that
+would ordinarily be computed from operations like ＠code{(member ..)},
+＠code{(and ...)} and ＠code{(or ...)} into tables, from which register
+values are read and written, and on which ＠code{if} statements are
+predicated. Much more of the implementation of this coding system is
+occupied with constructing these tables---in normal Emacs Lisp---than it
+is with actual CCL code.
+
+ All the ＠code{defvar} statements we deal with in the next few sections
+are surrounded by a ＠code{(eval-and-compile ...)}, which means that the
+logic which initializes these variables executes at compile time, and if
+XEmacs loads the compiled version of the file, these variables are
+initialized as constants.
+
+＠menu
+* Four bits to ASCII:: Two tables used for getting hex digits from ASCII.
+* URI Encoding constants:: Useful predefined characters.
+* Numeric to ASCII-hexadecimal conversion:: Trivial in Lisp, not so in CCL.
+* Characters to be preserved:: No transformation needed for these characters.
+* The program to decode to internal format:: .
+* The program to encode from internal format:: .
+
+＠end menu
+
+＠node Four bits to ASCII, URI Encoding constants, , CCL Example
+＠subsubsection Four bits to ASCII
+
+ The first ＠code{defvar} is for
+＠code{url-coding-high-order-nybble-as-ascii}, a 256-entry table that
+maps from an octet's value to the ASCII encoding for the hex value of
+its most significant four bits. That might sound complex, but it isn't;
+for decimal 65, hex value ＠samp{#x41}, the entry in the table is the
+ASCII encoding of `4'. For decimal 122, ASCII `z', hex value
+＠code{#x7a}, ＠code{(elt url-coding-high-order-nybble-as-ascii #x7a)}
+after this file is loaded gives the ASCII encoding of 7.
+
+＠example
+(defvar url-coding-high-order-nybble-as-ascii
+ (let ((val (make-vector 256 0))
+ (i 0))
+ (while (< i (length val))
+ (aset val i (char-int (aref (format "%02X" i) 0)))
+ (setq i (1+ i)))
+ val)
+ "Table to find an ASCII version of an octet's most significant 4 bits.")
+＠end example
+
+ The next table, ＠code{url-coding-low-order-nybble-as-ascii} is almost
+the same thing, but this time it has a map for the hex encoding of the
+low-order four bits. So the sixty-fifth entry (offset ＠samp{#x51}) is
+the ASCII encoding of `1', the hundred-and-twenty-second (offset
+＠samp{#x7a}) is the ASCII encoding of `A'.
+
+＠example
+(defvar url-coding-low-order-nybble-as-ascii
+ (let ((val (make-vector 256 0))
+ (i 0))
+ (while (< i (length val))
+ (aset val i (char-int (aref (format "%02X" i) 1)))
+ (setq i (1+ i)))
+ val)
+ "Table to find an ASCII version of an octet's least significant 4 bits.")
+＠end example
+
+＠node URI Encoding constants, Numeric to ASCII-hexadecimal conversion, Four bits to ASCII, CCL Example
+＠subsubsection URI Encoding constants
+
+ Next, we have a couple of variables that make the CCL code more
+readable. The first is the ASCII encoding of the percentage sign; this
+character is used as an escape code, to start the encoding of a
+non-printable character. For historical reasons, URL encoding allows
+the space character to be encoded as a plus sign--it does make typing
+URLs like ＠samp{http://google.com/search?q=XEmacs+home+page} easier--and
+as such, we have to check when decoding for this value, and map it to
+the space character. When doing this in CCL, we use the
+＠code{url-coding-escaped-space-code} variable.
+
+＠example
+(defvar url-coding-escape-character-code (char-int ?%)
+ "The code point for the percentage sign, in ASCII.")
+
+(defvar url-coding-escaped-space-code (char-int ?+)
+ "The URL-encoded value of the space character, that is, +.")
+＠end example
+
+＠node Numeric to ASCII-hexadecimal conversion
+＠subsubsection Numeric to ASCII-hexadecimal conversion
+
+ Now, we have a couple of utility tables that wouldn't be necessary in
+a more expressive programming language than is CCL. The first is sixteen
+in length, and maps a hexadecimal number to the ASCII encoding of that
+number; so zero maps to ASCII `0', ten maps to ASCII `A.' The second
+does the reverse; that is, it maps an ASCII character to its value when
+interpreted as a hexadecimal digit. ('A' => 10, 'c' => 12, '2' => 2, as
+a few examples.)
+
+＠example
+(defvar url-coding-hex-digit-table
+ (let ((i 0)
+ (val (make-vector 16 0)))
+ (while (< i 16)
+ (aset val i (char-int (aref (format "%X" i) 0)))
+ (setq i (1+ i)))
+ val)
+ "A map from a hexadecimal digit's numeric value to its encoding in ASCII.")
+
+(defvar url-coding-latin-1-as-hex-table
+ (let ((val (make-vector 256 0))
+ (i 0))
+ (while (< i (length val))
+ ;; Get a hex val for this ASCII character.
+ (aset val i (string-to-int (format "%c" i) 16))
+ (setq i (1+ i)))
+ val)
+ "A map from Latin 1 code points to their values as hexadecimal digits.")
+＠end example
+
+＠node Characters to be preserved
+＠subsubsection Characters to be preserved
+
+ And finally, the last of these tables. URL encoding says that
+alphanumeric characters, the underscore, hyphen and the full stop
+＠footnote{That's what the standards call it, though my North American
+readers will be more familiar with it as the period character.} retain
+their ASCII encoding, and don't undergo transformation.
+＠code{url-coding-should-preserve-table} is an array in which the entries
+are one if the corresponding ASCII character should be left as-is, and
+zero if they should be transformed. So the entries for all the control
+and most of the punctuation charcters are zero. Lisp programmers will
+observe that this initialization is particularly inefficient, but
+they'll also be aware that this is a long way from an inner loop where
+every nanosecond counts.
+
+＠example
+(defvar url-coding-should-preserve-table
+ (let ((preserve
+ (list ?- ?_ ?. ?a ?b ?c ?d ?e ?f ?g ?h ?i ?j ?k ?l ?m ?n ?o
+ ?p ?q ?r ?s ?t ?u ?v ?w ?x ?y ?z ?A ?B ?C ?D ?E ?F ?G
+ ?H ?I ?J ?K ?L ?M ?N ?O ?P ?Q ?R ?S ?T ?U ?V ?W ?X ?Y
+ ?Z ?0 ?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))
+ (i 0)
+ (res (make-vector 256 0)))
+ (while (< i 256)
+ (when (member (int-char i) preserve)
+ (aset res i 1))
+ (setq i (1+ i)))
+ res)
+ "A 256-entry array of flags, indicating whether or not to preserve an
+octet as its ASCII encoding.")
+＠end example
+
+＠node The program to decode to internal format
+＠subsubsection The program to decode to internal format
+
+ After the almost interminable tables, we get to the CCL. The first
+CCL program, ＠code{ccl-decode-urlcoding} decodes from the URL coding to
+our internal format; since this version of CCL doesn't have support for
+error checking on the input, we don't do any verification on it.
+
+The buffer magnification--approximate ratio of the size of the output
+buffer to the size of the input buffer--is declared as one, because
+fractional values aren't allowed. (Since all those %20's will map to
+` ', the length of the output text will be less than that of the input
+text.)
+
+So, first we read an octet from the input buffer into register
+＠samp{r0}, to set up the loop. Next, we start the loop, with a
+＠code{(loop ...)} statement, and we check if the value in ＠samp{r0} is a
+percentage sign. (Note the comma before
+＠code{url-coding-escape-character-code}; since CCL is a Lisp macro
+language, we can break out of the macro evaluation with a comman, and as
+such, ``＠code{,url-coding-escape-character-code}'' will be evaluated as a
+literal `37.')
+
+If it is a percentage sign, we read the next two octets into ＠samp{r2}
+and ＠samp{r3}, and convert them into their hexadecimal numeric values,
+using the ＠code{url-coding-latin-1-as-hex-table} array declared above.
+(But again, it'll be interpreted as a literal array.) We then left
+shift the first by four bits, mask the two together, and write the
+result to the output buffer.
+
+If it isn't a percentage sign, and it is a `+' sign, we write a
+space--hexadecimal 20--to the output buffer.
+
+If none of those things are true, we pass the octet to the output buffer
+untransformed. (This could be a place to put error checking, in a more
+expressive language.) We then read one more octet from the input
+buffer, and move to the next iteration of the loop.
+
+＠example
+(define-ccl-program ccl-decode-urlcoding
+ `(1
+ ((read r0)
+ (loop
+ (if (r0 == ,url-coding-escape-character-code)
+ ((read r2 r3)
+ ;; Assign the value at offset r2 in the url-coding-hex-digit-table
+ ;; to r3.
+ (r2 = r2 ,url-coding-latin-1-as-hex-table)
+ (r3 = r3 ,url-coding-latin-1-as-hex-table)
+ (r2 <<= 4)
+ (r3 |= r2)
+ (write r3))
+ (if (r0 == ,url-coding-escaped-space-code)
+ (write #x20)
+ (write r0)))
+ (read r0)
+ (repeat))))
+ "CCL program to take URI-encoded ASCII text and transform it to our
+internal encoding. ")
+＠end example
+
+＠node The program to encode from internal format
+＠subsubsection The program to encode from internal format
+
+ Next, we see the CCL program to encode ASCII text as URL coded text.
+Here, the buffer magnification is specified as three, to account for ` '
+mapping to %20, etc. As before, we read an octet from the input into
+＠samp{r0}, and move into the body of the loop. Next, we check if we
+should preserve the value of this octet, by reading from offset
+＠samp{r0} in the ＠code{url-coding-should-preserve-table} into ＠samp{r1}.
+Then we have an ＠samp{if} statement predicated on the value in
+＠samp{r1}; for the true branch, we write the input octet directly. For
+the false branch, we write a percentage sign, the ASCII encoding of the
+high four bits in hex, and then the ASCII encoding of the low four bits
+in hex.
+
+We then read an octet from the input into ＠samp{r0}, and repeat the loop.
+
+＠example
+(define-ccl-program ccl-encode-urlcoding
+ `(3
+ ((read r0)
+ (loop
+ (r1 = r0 ,url-coding-should-preserve-table)
+ ;; If we should preserve the value, just write the octet directly.
+ (if r1
+ (write r0)
+ ;; else, write a percentage sign, and the hex value of the octet, in
+ ;; an ASCII-friendly format.
+ ((write ,url-coding-escape-character-code)
+ (write r0 ,url-coding-high-order-nybble-as-ascii)
+ (write r0 ,url-coding-low-order-nybble-as-ascii)))
+ (read r0)
+ (repeat))))
+ "CCL program to encode octets (almost) according to RFC 1738")
+＠end example
＠node Category Tables, , CCL, MULE
＠section Category Tables
--
Institute of Policy and Planning Sciences http://turnbull.sk.tsukuba.ac.jp
University of Tsukuba Tennodai 1-1-1 Tsukuba 305-8573 JAPAN
Ask not how you can "do" free software business;
ask what your business can "do for" free software.
- 4 participants
- 3 comments
[PATCH] Sync of occur-mode with GNU Emacs CVS.
19 years, 1 month
Malcolm Purvis
Malcolm Purvis
This is a sync of occur-mode with GNU Emacs 22.0.50.1 (CVS). Note that these
are 21.5 core lisp files.
New features include syntax hightlighting of the matched regular expression,
the ability to rename the occur buffer, the ability to search multiple buffers
and minor mode that allows movement between the matching lines while remaining
in the occur buffer.
Since the occur code has started using font-lock features it has been moved
out of replace.el into its own files because the necessary functions are not
available to replace.el during the dumping stage.
This patch also changes the behaviour of read-buffer slightly to conform with
GNU Emacs usage: It can return an empty string if 'require-match' is t and
'default' is nil. Previously it would insist that a buffer be entered. A
search through the package code has shown that this is the only place that
relies of this combination of argument values.
Malcolm
lisp/ChangeLog addition:
2005-10-10 Malcolm Purvis <malcolmp(a)xemacs.org>
* minibuf.el:
* minibuf.el (read-buffer): Follow GNU Emacs behaviour: Can return
empty string if require-match is t and default is nil.
* replace.el: Moved occur code to occur.el
* simple.el:
* simple.el (line-number-at-pos): New.
* subr.el:
* subr.el (delete-dups): New.
* occur.el: New. Sync with 22.0.50.1 (CVS)
* next-error.el: New. Sync with 22.0.50.1 (CVS)
xemacs-occur source patch:
Diff command: cvs -q diff -u
Files affected: lisp/subr.el lisp/simple.el lisp/replace.el lisp/minibuf.el
Index: lisp/minibuf.el
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/lisp/minibuf.el,v
retrieving revision 1.29
diff -u -r1.29 minibuf.el
--- lisp/minibuf.el 2005/04/14 05:58:46 1.29
+++ lisp/minibuf.el 2005/10/09 20:52:48
＠＠ -23,8 +23,8 ＠＠
;; 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, 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
;;; Synched up with: all the minibuffer history stuff is synched with
;;; 19.30. Not sure about the rest.
＠＠ -1495,7 +1495,7 ＠＠
(setq result default)
nil)
((not default)
- t)
+ nil)
((not (get-buffer default))
t)
(t
Index: lisp/replace.el
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/lisp/replace.el,v
retrieving revision 1.11
diff -u -r1.11 replace.el
--- lisp/replace.el 2005/02/23 22:09:15 1.11
+++ lisp/replace.el 2005/10/09 20:52:50
＠＠ -19,8 +19,8 ＠＠
;; 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: FSF 19.34 [Partially].
＠＠ -455,271 +455,7 ＠＠
(message "%d occurrences" count)))))
-(defvar occur-mode-map ())
-(if occur-mode-map
- ()
- (setq occur-mode-map (make-sparse-keymap))
- (set-keymap-name occur-mode-map 'occur-mode-map) ; XEmacs
- (define-key occur-mode-map 'button2 'occur-mode-mouse-goto) ; XEmacs
- (define-key occur-mode-map "\C-c\C-c" 'occur-mode-goto-occurrence)
- (define-key occur-mode-map "\C-m" 'occur-mode-goto-occurrence))
-
-(defvar occur-buffer nil)
-(defvar occur-nlines nil)
-(defvar occur-pos-list nil)
-
-(defun occur-mode ()
- "Major mode for output from \\[occur].
-\\<occur-mode-map>Move point to one of the items in this buffer, then use
-\\[occur-mode-goto-occurrence] to go to the occurrence that the item refers to.
-Alternatively, click \\[occur-mode-mouse-goto] on an item to go to it.
-
-\\{occur-mode-map}"
- (kill-all-local-variables)
- (use-local-map occur-mode-map)
- (setq major-mode 'occur-mode)
- (setq mode-name (gettext "Occur")) ; XEmacs
- (make-local-variable 'occur-buffer)
- (make-local-variable 'occur-nlines)
- (make-local-variable 'occur-pos-list)
- (require 'mode-motion) ; XEmacs
- (setq mode-motion-hook 'mode-motion-highlight-line) ; XEmacs
- (run-hooks 'occur-mode-hook))
-
-;; FSF Version of next function:
-; (let (buffer pos)
-; (save-excursion
-; (set-buffer (window-buffer (posn-window (event-end event))))
-; (save-excursion
-; (goto-char (posn-point (event-end event)))
-; (setq pos (occur-mode-find-occurrence))
-; (setq buffer occur-buffer)))
-; (pop-to-buffer buffer)
-; (goto-char (marker-position pos))))
-
-(defun occur-mode-mouse-goto (event)
- "Go to the occurrence highlighted by mouse.
-This function should be bound to a mouse key in the `*Occur*' buffer."
- (interactive "e")
- (let ((window-save (selected-window))
- (frame-save (selected-frame)))
- ;; preserve the window/frame setup
- (unwind-protect
- (progn
- (mouse-set-point event)
- (occur-mode-goto-occurrence))
- (select-frame frame-save)
- (select-window window-save))))
-
-;; Called occur-mode-find-occurrence in FSF
-(defun occur-mode-goto-occurrence ()
- "Go to the occurrence the current line describes."
- (interactive)
- (if (or (null occur-buffer)
- (null (buffer-name occur-buffer)))
- (progn
- (setq occur-buffer nil
- occur-pos-list nil)
- (error "Buffer in which occurrences were found is deleted")))
- (let* ((line-count
- (count-lines (point-min)
- (save-excursion
- (beginning-of-line)
- (point))))
- (occur-number (save-excursion
- (beginning-of-line)
- (/ (1- line-count)
- (cond ((< occur-nlines 0)
- (- 2 occur-nlines))
- ((> occur-nlines 0)
- (+ 2 (* 2 occur-nlines)))
- (t 1)))))
- (pos (nth occur-number occur-pos-list))
- ;; removed t arg from Bob Weiner, 10/6/95
- (window (get-buffer-window occur-buffer))
- (occur-source-buffer occur-buffer))
- (if (< line-count 1)
- (error "No occurrence on this line"))
- (or pos
- (error "No occurrence on this line"))
- ;; XEmacs: don't raise window unless it isn't visible
- ;; allow for the possibility that the occur buffer is on another frame
- (or (and window
- (window-live-p window)
- (frame-visible-p (window-frame window))
- (set-buffer occur-source-buffer))
- (and (pop-to-buffer occur-source-buffer)
- (setq window (get-buffer-window occur-source-buffer))))
- (goto-char pos)
- (set-window-point window pos)))
-
-
-(defvar list-matching-lines-default-context-lines 0
- "*Default number of context lines to include around a `list-matching-lines'
-match. A negative number means to include that many lines before the match.
-A positive number means to include that many lines both before and after.")
-
-;; XEmacs addition
-;;; Damn you Jamie, this is utter trash.
-(defvar list-matching-lines-whole-buffer t
- "If t, occur operates on whole buffer, otherwise occur starts from point.
-default is t.")
-
-(define-function 'occur 'list-matching-lines)
-(defun list-matching-lines (regexp &optional nlines)
- "Show all lines in the current buffer containing a match for REGEXP.
-
-If a match spreads across multiple lines, all those lines are shown.
-
-If variable `list-matching-lines-whole-buffer' is non-nil, the entire
-buffer is searched, otherwise search begins at point.
-
-Each line is displayed with NLINES lines before and after, or -NLINES
-before if NLINES is negative.
-NLINES defaults to `list-matching-lines-default-context-lines'.
-Interactively it is the prefix arg.
-
-The lines are shown in a buffer named `*Occur*'.
-It serves as a menu to find any of the occurrences in this buffer.
-\\[describe-mode] in that buffer will explain how."
- (interactive
- ;; XEmacs change
- (list (let* ((default (or (symbol-near-point)
- (and regexp-history
- (car regexp-history))))
- (minibuffer-history-minimum-string-length 0)
- (input
- (if default
- ;; rewritten for I18N3 snarfing
- (read-from-minibuffer
- (format "List lines matching regexp (default `%s'): "
- default) nil nil nil 'regexp-history nil
- default)
- (read-from-minibuffer
- "List lines matching regexp: "
- nil nil nil
- 'regexp-history))))
- (if (and (equal input "") default)
- (progn
- (setq input default)
- (setcar regexp-history default)))
- ;; clear extra entries
- (setcdr regexp-history (delete (car regexp-history)
- (cdr regexp-history)))
- input)
- current-prefix-arg))
- (if (equal regexp "")
- (error "Must pass non-empty regexp to `list-matching-lines'"))
- (setq nlines (if nlines (prefix-numeric-value nlines)
- list-matching-lines-default-context-lines))
- (let ((first t)
- (dir default-directory)
- (buffer (current-buffer))
- (linenum 1)
- (prevpos (point-min))
- ;; The rest of this function is very different from FSF.
- ;; Presumably that's due to Jamie's misfeature
- (final-context-start (make-marker)))
- (if (not list-matching-lines-whole-buffer)
- (save-excursion
- (beginning-of-line)
- (setq linenum (1+ (count-lines (point-min) (point))))
- (setq prevpos (point))))
- (with-output-to-temp-buffer "*Occur*"
- (save-excursion
- (set-buffer standard-output)
- (setq default-directory dir)
- ;; We will insert the number of lines, and "lines", later.
- ;; #### Needs fixing for I18N3
- (let ((print-escape-newlines t))
- (insert (format " matching %s in buffer %s.\n"
- regexp (buffer-name buffer))))
- (occur-mode)
- (setq occur-buffer buffer)
- (setq occur-nlines nlines)
- (setq occur-pos-list ()))
- (if (eq buffer standard-output)
- (goto-char (point-max)))
- (with-interactive-search-caps-disable-folding regexp t
- (save-excursion
- (if list-matching-lines-whole-buffer
- (beginning-of-buffer))
- (message "Searching for %s ..." regexp)
- ;; Find next match, but give up if prev match was at end of buffer.
- (while (and (not (= prevpos (point-max)))
- (re-search-forward regexp nil t))
- (goto-char (match-beginning 0))
- (beginning-of-line)
- (save-match-data
- (setq linenum (+ linenum (count-lines prevpos (point)))))
- (setq prevpos (point))
- (goto-char (match-end 0))
- (let* ((start (save-excursion
- (goto-char (match-beginning 0))
- (forward-line (if (< nlines 0) nlines (- nlines)))
- (point)))
- (end (save-excursion
- (goto-char (match-end 0))
- (if (> nlines 0)
- (forward-line (1+ nlines))
- (forward-line 1))
- (point)))
- (tag (format "%5d" linenum))
- (empty (make-string (length tag) ?\ ))
- tem)
- (save-excursion
- (setq tem (make-marker))
- (set-marker tem (point))
- (set-buffer standard-output)
- (setq occur-pos-list (cons tem occur-pos-list))
- (or first (zerop nlines)
- (insert "--------\n"))
- (setq first nil)
- (insert-buffer-substring buffer start end)
- (set-marker final-context-start
- (- (point) (- end (match-end 0))))
- (backward-char (- end start))
- (setq tem (if (< nlines 0) (- nlines) nlines))
- (while (> tem 0)
- (insert empty ?:)
- (forward-line 1)
- (setq tem (1- tem)))
- (let ((this-linenum linenum))
- (while (< (point) final-context-start)
- (if (null tag)
- (setq tag (format "%5d" this-linenum)))
- (insert tag ?:)
- ;; FSFmacs --
- ;; we handle this using mode-motion-highlight-line, above.
- ;; (put-text-property (save-excursion
- ;; (beginning-of-line)
- ;; (point))
- ;; (save-excursion
- ;; (end-of-line)
- ;; (point))
- ;; 'mouse-face 'highlight)
- (forward-line 1)
- (setq tag nil)
- (setq this-linenum (1+ this-linenum)))
- (while (<= (point) final-context-start)
- (insert empty ?:)
- (forward-line 1)
- (setq this-linenum (1+ this-linenum))))
- (while (< tem nlines)
- (insert empty ?:)
- (forward-line 1)
- (setq tem (1+ tem)))
- (goto-char (point-max)))
- (forward-line 1)))
- (set-buffer standard-output)
- ;; Put positions in increasing order to go with buffer.
- (setq occur-pos-list (nreverse occur-pos-list))
- (goto-char (point-min))
- (if (= (length occur-pos-list) 1)
- (insert "1 line")
- (insert (format "%d lines" (length occur-pos-list))))
- (if (interactive-p)
- (message "%d matching lines." (length occur-pos-list))))))))
+;;; occur code moved to occur.el
;; It would be nice to use \\[...], but there is no reasonable way
;; to make that display both SPC and Y.
Index: lisp/simple.el
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/lisp/simple.el,v
retrieving revision 1.52
diff -u -r1.52 simple.el
--- lisp/simple.el 2005/10/05 04:32:45 1.52
+++ lisp/simple.el 2005/10/09 20:53:02
＠＠ -21,12 +21,12 ＠＠
;; 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: FSF 19.34 [But not very closely].
-;;; Occasional synching to FSF 21.2, as marked. Comment stuff also
-;;; synched, and in newcomment.el.
+;;; Occasional synching to FSF 21.2 and FSF 22.0, as marked. Comment stuff
+;;; also synched, and in newcomment.el.
;;; Commentary:
＠＠ -745,6 +745,10 ＠＠
(goto-char pos)
(line-number nil respect-narrowing))
(1+ (count-lines (if respect-narrowing (point-min) 1) (point-at-bol)))))
+
+;; FSF 22.0.50.1 (CVS) version of above.
+(defun line-number-at-pos (&optional pos)
+ (line-number pos t))
(defun count-lines (start end &optional ignore-invisible-lines-flag)
"Return number of lines between START and END.
Index: lisp/subr.el
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/lisp/subr.el,v
retrieving revision 1.36
diff -u -r1.36 subr.el
--- lisp/subr.el 2005/01/28 02:05:05 1.36
+++ lisp/subr.el 2005/10/09 20:53:06
＠＠ -23,8 +23,8 ＠＠
;; 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: FSF 19.34. Some things synched up with later versions.
＠＠ -1619,6 +1619,20 ＠＠
(make-compatible 'eval-next-after-load "")
;; END SYNC WITH FSF 21.2
+
+;; BEGIN SYNC WITH FSF 22.0.50.1 (CVS)
+(defun delete-dups (list)
+ "Destructively remove `equal' duplicates from LIST.
+Store the result in LIST and return it. LIST must be a proper list.
+Of several `equal' occurrences of an element in LIST, the first
+one is kept."
+ (let ((tail list))
+ (while tail
+ (setcdr tail (delete (car tail) (cdr tail)))
+ (setq tail (cdr tail))))
+ list)
+
+;; END SYNC WITH FSF 22.0.50.1 (CVS)
;; (defun shell-quote-argument (argument) in process.el.
---------------------------------------------------------------------------
;;; occur.el --- Show all lines in the current buffer containing a match for REGEXP.
;; Copyright (C) 1985, 1986, 1987, 1992, 1994, 1996, 1997, 2000, 2001,
;; 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
;; Maintainer: XEmacs Development Team
;; Keywords: internal
;; This file is part of XEmacs.
;; XEmacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;; XEmacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; 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., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.
;;; Synched up with: FSF 22.0.50.1 (CVS)
(require 'next-error)
(defun query-replace-descr (string)
(mapconcat 'isearch-text-char-description string ""))
(defvar occur-mode-map ()
"Keymap for `occur-mode'.")
(if occur-mode-map
()
(setq occur-mode-map (make-sparse-keymap))
(set-keymap-name occur-mode-map 'occur-mode-map) ; XEmacs
(define-key occur-mode-map 'button2 'occur-mode-mouse-goto) ; XEmacs
(define-key occur-mode-map "\C-c\C-c" 'occur-mode-goto-occurrence)
(define-key occur-mode-map "\C-m" 'occur-mode-goto-occurrence)
(define-key occur-mode-map "o" 'occur-mode-goto-occurrence-other-window)
(define-key occur-mode-map "\C-o" 'occur-mode-display-occurrence)
(define-key occur-mode-map "\M-n" 'occur-next)
(define-key occur-mode-map "\M-p" 'occur-prev)
(define-key occur-mode-map "r" 'occur-rename-buffer)
(define-key occur-mode-map "c" 'clone-buffer)
(define-key occur-mode-map "g" 'revert-buffer)
(define-key occur-mode-map "q" 'quit-window)
(define-key occur-mode-map "z" 'kill-this-buffer)
(define-key occur-mode-map "\C-c\C-f" 'next-error-follow-minor-mode))
(defvar occur-revert-arguments nil
"Arguments to pass to `occur-1' to revert an Occur mode buffer.
See `occur-revert-function'.")
(defcustom occur-mode-hook nil ; XEmacs
"Hook run when entering Occur mode."
:type 'hook
:group 'matching)
(defcustom occur-hook nil
"Hook run by Occur when there are any matches."
:type 'hook
:group 'matching)
(put 'occur-mode 'mode-class 'special)
;;;###autoload
(defun occur-mode ()
"Major mode for output from \\[occur].
\\<occur-mode-map>Move point to one of the items in this buffer, then use
\\[occur-mode-goto-occurrence] to go to the occurrence that the item refers to.
Alternatively, click \\[occur-mode-mouse-goto] on an item to go to it.
\\{occur-mode-map}"
(interactive)
(kill-all-local-variables)
(use-local-map occur-mode-map)
(setq major-mode 'occur-mode)
(setq mode-name (gettext "Occur")) ; XEmacs
(set (make-local-variable 'revert-buffer-function) 'occur-revert-function)
(make-local-variable 'occur-revert-arguments)
(add-hook 'change-major-mode-hook 'turn-off-font-lock t t)
(setq next-error-function 'occur-next-error)
(require 'mode-motion) ; XEmacs
(setq mode-motion-hook 'mode-motion-highlight-line) ; XEmacs
(run-mode-hooks 'occur-mode-hook))
(defun occur-revert-function (ignore1 ignore2)
"Handle `revert-buffer' for Occur mode buffers."
(apply 'occur-1 (append occur-revert-arguments (list (buffer-name)))))
;; FSF Version of next function:
; (defun occur-mode-mouse-goto (event)
; "In Occur mode, go to the occurrence whose line you click on."
; (interactive "e")
; (let (pos)
; (save-excursion
; (set-buffer (window-buffer (posn-window (event-end event))))
; (save-excursion
; (goto-char (posn-point (event-end event)))
; (setq pos (occur-mode-find-occurrence))))
; (pop-to-buffer (marker-buffer pos))
; (goto-char pos)))
(defun occur-mode-mouse-goto (event)
"Go to the occurrence highlighted by mouse.
This function should be bound to a mouse key in the `*Occur*' buffer."
(interactive "e")
(let ((window-save (selected-window))
(frame-save (selected-frame)))
;; preserve the window/frame setup
(unwind-protect
(progn
(mouse-set-point event)
(occur-mode-goto-occurrence))
(select-frame frame-save)
(select-window window-save))))
(defun occur-mode-find-occurrence ()
(let ((pos (get-text-property (point) 'occur-target)))
(unless pos
(error "No occurrence on this line"))
(unless (buffer-live-p (marker-buffer pos))
(error "Buffer for this occurrence was killed"))
pos))
(defun occur-mode-goto-occurrence ()
"Go to the occurrence the current line describes."
(interactive)
(let ((pos (occur-mode-find-occurrence)))
(pop-to-buffer (marker-buffer pos))
(goto-char pos)))
(defun occur-mode-goto-occurrence-other-window ()
"Go to the occurrence the current line describes, in another window."
(interactive)
(let ((pos (occur-mode-find-occurrence)))
(switch-to-buffer-other-window (marker-buffer pos))
(goto-char pos)))
(defun occur-mode-display-occurrence ()
"Display in another window the occurrence the current line describes."
(interactive)
(let ((pos (occur-mode-find-occurrence))
window
;; Bind these to ensure `display-buffer' puts it in another window.
same-window-buffer-names
same-window-regexps)
(setq window (display-buffer (marker-buffer pos)))
;; This is the way to set point in the proper window.
(save-selected-window
(select-window window)
(goto-char pos))))
(defun occur-find-match (n search message)
(if (not n) (setq n 1))
(let ((r))
(while (> n 0)
(setq r (funcall search (point) 'occur-match))
(and r
(get-text-property r 'occur-match)
(setq r (funcall search r 'occur-match)))
(if r
(goto-char r)
(error message))
(setq n (1- n)))))
(defun occur-next (&optional n)
"Move to the Nth (default 1) next match in an Occur mode buffer."
(interactive "p")
(occur-find-match n #'next-single-property-change "No more matches"))
(defun occur-prev (&optional n)
"Move to the Nth (default 1) previous match in an Occur mode buffer."
(interactive "p")
(occur-find-match n #'previous-single-property-change "No earlier matches"))
(defun occur-next-error (&optional argp reset)
"Move to the Nth (default 1) next match in an Occur mode buffer.
Compatibility function for \\[next-error] invocations."
(interactive "p")
;; we need to run occur-find-match from within the Occur buffer
(with-current-buffer
;; Choose the buffer and make it current.
(if (next-error-buffer-p (current-buffer))
(current-buffer)
(next-error-find-buffer nil nil
(lambda ()
(eq major-mode 'occur-mode))))
(goto-char (cond (reset (point-min))
((< argp 0) (line-beginning-position))
((line-end-position))))
(occur-find-match
(abs argp)
(if (> 0 argp)
#'previous-single-property-change
#'next-single-property-change)
"No more matches")
;; In case the *Occur* buffer is visible in a nonselected window.
(set-window-point (get-buffer-window (current-buffer)) (point))
(occur-mode-goto-occurrence)))
(defface match
'((((class color) (background light))
(:background "Tan"))
(((class color) (background dark))
(:background "RoyalBlue3"))
(((class color))
(:background "blue" :foreground "white"))
(((type tty) (class mono))
(:inverse-video t))
(t (:background "gray")))
"Face used to highlight matches permanently."
:group 'matching
:version "22.1")
(defcustom list-matching-lines-default-context-lines 0
"*Default number of context lines included around `list-matching-lines' matches.
A negative number means to include that many lines before the match.
A positive number means to include that many lines both before and after."
:type 'integer
:group 'matching)
(defalias 'list-matching-lines 'occur)
(defcustom list-matching-lines-face 'match
"*Face used by \\[list-matching-lines] to show the text that matches.
If the value is nil, don't highlight the matching portions specially."
:type 'face
:group 'matching)
(defcustom list-matching-lines-buffer-name-face 'underline
"*Face used by \\[list-matching-lines] to show the names of buffers.
If the value is nil, don't highlight the buffer names specially."
:type 'face
:group 'matching)
(defun occur-accumulate-lines (count &optional keep-props)
(save-excursion
(let ((forwardp (> count 0))
result beg end)
(while (not (or (zerop count)
(if forwardp
(eobp)
(bobp))))
(setq count (+ count (if forwardp -1 1)))
(setq beg (line-beginning-position)
end (line-end-position))
(if (and keep-props (if (boundp 'jit-lock-mode) jit-lock-mode)
(text-property-not-all beg end 'fontified t))
(if (fboundp 'jit-lock-fontify-now)
(jit-lock-fontify-now beg end)))
(push
(funcall (if keep-props
#'buffer-substring
#'buffer-substring-no-properties)
beg end)
result)
(forward-line (if forwardp 1 -1)))
(nreverse result))))
(defun occur-read-primary-args ()
(list (let* ((default (or (symbol-near-point)
(and regexp-history
(car regexp-history))))
(minibuffer-history-minimum-string-length 0)
(input
(if default
;; XEmacs: rewritten for I18N3 snarfing
(read-from-minibuffer
(format "List lines matching regexp (default `%s'): "
default) nil nil nil 'regexp-history nil
default)
(read-from-minibuffer
"List lines matching regexp: "
nil nil nil
'regexp-history))))
(if (equal input "")
default
input))
(when current-prefix-arg
(prefix-numeric-value current-prefix-arg))))
;;;###autoload
(defun occur-rename-buffer (&optional unique-p interactive-p)
"Rename the current *Occur* buffer to *Occur: original-buffer-name*.
Here `original-buffer-name' is the buffer name were Occur was originally run.
When given the prefix argument, or called non-interactively, the renaming
will not clobber the existing buffer(s) of that name, but use
`generate-new-buffer-name' instead. You can add this to `occur-hook'
if you always want a separate *Occur* buffer for each buffer where you
invoke `occur'."
(interactive "P\np")
(with-current-buffer
(if (eq major-mode 'occur-mode) (current-buffer) (get-buffer "*Occur*"))
(rename-buffer (concat "*Occur: "
(mapconcat #'buffer-name
(car (cddr occur-revert-arguments)) "/")
"*")
(or unique-p (not interactive-p)))))
;;;###autoload
(defun occur (regexp &optional nlines)
"Show all lines in the current buffer containing a match for REGEXP.
This function can not handle matches that span more than one line.
Each line is displayed with NLINES lines before and after, or -NLINES
before if NLINES is negative.
NLINES defaults to `list-matching-lines-default-context-lines'.
Interactively it is the prefix arg.
The lines are shown in a buffer named `*Occur*'.
It serves as a menu to find any of the occurrences in this buffer.
\\<occur-mode-map>\\[describe-mode] in that buffer will explain how.
If REGEXP contains upper case characters (excluding those preceded by `\\'),
the matching is case-sensitive."
(interactive (occur-read-primary-args))
(occur-1 regexp nlines (list (current-buffer))))
;;;###autoload
(defun multi-occur (bufs regexp &optional nlines)
"Show all lines in buffers BUFS containing a match for REGEXP.
This function acts on multiple buffers; otherwise, it is exactly like
`occur'."
(interactive
(cons
(let* ((bufs (list (read-buffer "First buffer to search: "
(current-buffer) t)))
(buf nil)
(ido-ignore-item-temp-list bufs))
(while (not (string-equal
(setq buf (read-buffer
(if (and-boundp 'read-buffer-function
'(eq read-buffer-function 'ido-read-buffer))
"Next buffer to search (C-j to end): "
"Next buffer to search (RET to end): ")
nil t))
""))
(add-to-list 'bufs buf)
(setq ido-ignore-item-temp-list bufs))
(nreverse (mapcar #'get-buffer bufs)))
(occur-read-primary-args)))
(occur-1 regexp nlines bufs))
;;;###autoload
(defun multi-occur-by-filename-regexp (bufregexp regexp &optional nlines)
"Show all lines matching REGEXP in buffers named by BUFREGEXP.
See also `multi-occur'."
(interactive
(cons
(let* ((default (car regexp-history))
(input
(read-from-minibuffer
"List lines in buffers whose filename matches regexp: "
nil
nil
nil
'regexp-history)))
(if (equal input "")
default
input))
(occur-read-primary-args)))
(when bufregexp
(occur-1 regexp nlines
(delq nil
(mapcar (lambda (buf)
(when (and (buffer-file-name buf)
(string-match bufregexp
(buffer-file-name buf)))
buf))
(buffer-list))))))
(defun occur-1 (regexp nlines bufs &optional buf-name)
(unless buf-name
(setq buf-name "*Occur*"))
(let (occur-buf
(active-bufs (delq nil (mapcar #'(lambda (buf)
(when (buffer-live-p buf) buf))
bufs))))
;; Handle the case where one of the buffers we're searching is the
;; output buffer. Just rename it.
(when (member buf-name (mapcar 'buffer-name active-bufs))
(with-current-buffer (get-buffer buf-name)
(rename-uniquely)))
;; Now find or create the output buffer.
;; If we just renamed that buffer, we will make a new one here.
(setq occur-buf (get-buffer-create buf-name))
(with-current-buffer occur-buf
(occur-mode)
(let ((inhibit-read-only t))
(erase-buffer)
(let ((count (occur-engine
regexp active-bufs occur-buf
(or nlines list-matching-lines-default-context-lines)
(and case-fold-search
(no-upper-case-p regexp t))
list-matching-lines-buffer-name-face
nil list-matching-lines-face t)))
(let* ((bufcount (length active-bufs))
(diff (- (length bufs) bufcount)))
(message "Searched %d buffer%s%s; %s match%s for `%s'"
bufcount (if (= bufcount 1) "" "s")
(if (zerop diff) "" (format " (%d killed)" diff))
(if (zerop count) "no" (format "%d" count))
(if (= count 1) "" "es")
regexp))
(setq occur-revert-arguments (list regexp nlines bufs))
(if (= count 0)
(kill-buffer occur-buf)
(display-buffer occur-buf)
(setq next-error-last-buffer occur-buf)
(setq buffer-read-only t)
(set-buffer-modified-p nil)
(run-hooks 'occur-hook)))))))
(defun occur-engine-add-prefix (lines)
(mapcar
#'(lambda (line)
(concat " :" line "\n"))
lines))
(defun occur-engine (regexp buffers out-buf nlines case-fold-search
title-face prefix-face match-face keep-props)
(with-current-buffer out-buf
(let ((globalcount 0)
;; Don't generate undo entries for creation of the initial contents.
(buffer-undo-list t)
(coding nil))
;; Map over all the buffers
(dolist (buf buffers)
(when (buffer-live-p buf)
(let ((matches 0) ;; count of matched lines
(lines 1) ;; line count
(matchbeg 0)
(origpt nil)
(begpt nil)
(endpt nil)
(marker nil)
(curstring "")
(headerpt (with-current-buffer out-buf (point))))
(save-excursion
(set-buffer buf)
(or coding
;; Set CODING only if the current buffer locally
;; binds buffer-file-coding-system.
(not (local-variable-p 'buffer-file-coding-system (current-buffer)))
(setq coding buffer-file-coding-system))
(save-excursion
(goto-char (point-min)) ;; begin searching in the buffer
(while (not (eobp))
(setq origpt (point))
(when (setq endpt (re-search-forward regexp nil t))
(setq matches (1+ matches)) ;; increment match count
(setq matchbeg (match-beginning 0))
(setq lines (+ lines (1- (count-lines origpt endpt))))
(save-excursion
(goto-char matchbeg)
(setq begpt (line-beginning-position)
endpt (line-end-position)))
(setq marker (make-marker))
(set-marker marker matchbeg)
(if (and keep-props
(if (boundp 'jit-lock-mode) jit-lock-mode)
(text-property-not-all begpt endpt 'fontified t))
(if (fboundp 'jit-lock-fontify-now)
(jit-lock-fontify-now begpt endpt)))
(setq curstring (buffer-substring begpt endpt))
;; Depropertize the string, and maybe
;; highlight the matches
(let ((len (length curstring))
(start 0))
(unless keep-props
(set-text-properties 0 len nil curstring))
(while (and (< start len)
(string-match regexp curstring start))
(add-text-properties
(match-beginning 0) (match-end 0)
(append
`(occur-match t)
(when match-face
;; Use `face' rather than `font-lock-face' here
;; so as to override faces copied from the buffer.
`(face ,match-face)))
curstring)
(setq start (match-end 0))))
;; Generate the string to insert for this match
(let* ((out-line
(concat
;; Using 7 digits aligns tabs properly.
(apply #'propertize (format "%7d:" lines)
(append
(when prefix-face
`(font-lock-face prefix-face))
'(occur-prefix t)))
;; We don't put `mouse-face' on the newline,
;; because that loses. And don't put it
;; on context lines to reduce flicker.
(propertize curstring 'mouse-face 'highlight)
"\n"))
(data
(if (= nlines 0)
;; The simple display style
out-line
;; The complex multi-line display
;; style. Generate a list of lines,
;; concatenate them all together.
(apply #'concat
(nconc
(occur-engine-add-prefix (nreverse (cdr (occur-accumulate-lines (- (1+ (abs nlines))) keep-props))))
(list out-line)
(if (> nlines 0)
(occur-engine-add-prefix
(cdr (occur-accumulate-lines (1+ nlines) keep-props)))))))))
;; Actually insert the match display data
(with-current-buffer out-buf
(let ((beg (point))
(end (progn (insert data) (point))))
(unless (= nlines 0)
(insert "-------\n"))
(add-text-properties
beg end
`(occur-target ,marker help-echo "mouse-2: go to this occurrence")))))
(goto-char endpt))
(if endpt
(progn
(setq lines (1+ lines))
;; On to the next match...
(forward-line 1))
(goto-char (point-max))))))
(when (not (zerop matches)) ;; is the count zero?
(setq globalcount (+ globalcount matches))
(with-current-buffer out-buf
(goto-char headerpt)
(let ((beg (point))
end)
(insert (format "%d match%s for \"%s\" in buffer: %s\n"
matches (if (= matches 1) "" "es")
regexp (buffer-name buf)))
(setq end (point))
(add-text-properties beg end
(append
(when title-face
`(font-lock-face ,title-face))
`(occur-title ,buf))))
(goto-char (point-min)))))))
(if coding
;; CODING is buffer-file-coding-system of the first buffer
;; that locally binds it. Let's use it also for the output
;; buffer.
(set-buffer-file-coding-system coding))
;; Return the number of matches
globalcount)))
(provide 'occur)
---------------------------------------------------------------------------
;;; next-error.el --- Next error support framework
;; Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
;; 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
;; Maintainer: XEmacs Development Team
;; Keywords: internal
;; This file is part of XEmacs.
;; XEmacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;; XEmacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; 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., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.
;;; Synched up with: FSF 22.0.50.1 (CVS)
(defgroup next-error nil
"`next-error' support framework."
:group 'compilation
:version "22.1")
(defface next-error
'((t (:inherit region)))
"Face used to highlight next error locus."
:group 'next-error
:version "22.1")
(defcustom next-error-highlight 0.1
"*Highlighting of locations in selected source buffers.
If number, highlight the locus in `next-error' face for given time in seconds.
If t, use persistent overlays fontified in `next-error' face.
If nil, don't highlight the locus in the source buffer.
If `fringe-arrow', indicate the locus by the fringe arrow."
:type '(choice (number :tag "Delay")
(const :tag "Persistent overlay" t)
(const :tag "No highlighting" nil)
(const :tag "Fringe arrow" 'fringe-arrow))
:group 'next-error
:version "22.1")
(defcustom next-error-highlight-no-select 0.1
"*Highlighting of locations in non-selected source buffers.
If number, highlight the locus in `next-error' face for given time in seconds.
If t, use persistent overlays fontified in `next-error' face.
If nil, don't highlight the locus in the source buffer.
If `fringe-arrow', indicate the locus by the fringe arrow."
:type '(choice (number :tag "Delay")
(const :tag "Persistent overlay" t)
(const :tag "No highlighting" nil)
(const :tag "Fringe arrow" 'fringe-arrow))
:group 'next-error
:version "22.1")
(defcustom next-error-hook nil
"*List of hook functions run by `next-error' after visiting source file."
:type 'hook
:group 'next-error)
(defvar next-error-highlight-timer nil)
;(defvar next-error-overlay-arrow-position nil)
;(put 'next-error-overlay-arrow-position 'overlay-arrow-string "=>")
;(add-to-list 'overlay-arrow-variable-list 'next-error-overlay-arrow-position)
(defvar next-error-last-buffer nil
"The most recent `next-error' buffer.
A buffer becomes most recent when its compilation, grep, or
similar mode is started, or when it is used with \\[next-error]
or \\[compile-goto-error].")
(defvar next-error-function nil
"Function to use to find the next error in the current buffer.
The function is called with 2 parameters:
ARG is an integer specifying by how many errors to move.
RESET is a boolean which, if non-nil, says to go back to the beginning
of the errors before moving.
Major modes providing compile-like functionality should set this variable
to indicate to `next-error' that this is a candidate buffer and how
to navigate in it.")
(make-variable-buffer-local 'next-error-function)
(defsubst next-error-buffer-p (buffer
&optional avoid-current
extra-test-inclusive
extra-test-exclusive)
"Test if BUFFER is a `next-error' capable buffer.
If AVOID-CURRENT is non-nil, treat the current buffer
as an absolute last resort only.
The function EXTRA-TEST-INCLUSIVE, if non-nil, is called in each buffer
that normally would not qualify. If it returns t, the buffer
in question is treated as usable.
The function EXTRA-TEST-EXCLUSIVE, if non-nil is called in each buffer
that would normally be considered usable. If it returns nil,
that buffer is rejected."
(and (buffer-name buffer) ;First make sure it's live.
(not (and avoid-current (eq buffer (current-buffer))))
(with-current-buffer buffer
(if next-error-function ; This is the normal test.
;; Optionally reject some buffers.
(if extra-test-exclusive
(funcall extra-test-exclusive)
t)
;; Optionally accept some other buffers.
(and extra-test-inclusive
(funcall extra-test-inclusive))))))
(defun next-error-find-buffer (&optional avoid-current
extra-test-inclusive
extra-test-exclusive)
"Return a `next-error' capable buffer.
If AVOID-CURRENT is non-nil, treat the current buffer
as an absolute last resort only.
The function EXTRA-TEST-INCLUSIVE, if non-nil, is called in each buffer
that normally would not qualify. If it returns t, the buffer
in question is treated as usable.
The function EXTRA-TEST-EXCLUSIVE, if non-nil is called in each buffer
that would normally be considered usable. If it returns nil,
that buffer is rejected."
(or
;; 1. If one window on the selected frame displays such buffer, return it.
(let ((window-buffers
(delete-dups
(delq nil (mapcar (lambda (w)
(if (next-error-buffer-p
(window-buffer w)
avoid-current
extra-test-inclusive extra-test-exclusive)
(window-buffer w)))
(window-list))))))
(if (eq (length window-buffers) 1)
(car window-buffers)))
;; 2. If next-error-last-buffer is an acceptable buffer, use that.
(if (and next-error-last-buffer
(next-error-buffer-p next-error-last-buffer avoid-current
extra-test-inclusive extra-test-exclusive))
next-error-last-buffer)
;; 3. If the current buffer is acceptable, choose it.
(if (next-error-buffer-p (current-buffer) avoid-current
extra-test-inclusive extra-test-exclusive)
(current-buffer))
;; 4. Look for any acceptable buffer.
(let ((buffers (buffer-list)))
(while (and buffers
(not (next-error-buffer-p
(car buffers) avoid-current
extra-test-inclusive extra-test-exclusive)))
(setq buffers (cdr buffers)))
(car buffers))
;; 5. Use the current buffer as a last resort if it qualifies,
;; even despite AVOID-CURRENT.
(and avoid-current
(next-error-buffer-p (current-buffer) nil
extra-test-inclusive extra-test-exclusive)
(progn
(message "This is the only next-error capable buffer")
(current-buffer)))
;; 6. Give up.
(error "No next-error capable buffer found")))
;;;###autoload
(defun next-error (&optional arg reset)
"Visit next `next-error' message and corresponding source code.
If all the error messages parsed so far have been processed already,
the message buffer is checked for new ones.
A prefix ARG specifies how many error messages to move;
negative means move back to previous error messages.
Just \\[universal-argument] as a prefix means reparse the error message buffer
and start at the first error.
The RESET argument specifies that we should restart from the beginning.
\\[next-error] normally uses the most recently started
compilation, grep, or occur buffer. It can also operate on any
buffer with output from the \\[compile], \\[grep] commands, or,
more generally, on any buffer in Compilation mode or with
Compilation Minor mode enabled, or any buffer in which
`next-error-function' is bound to an appropriate function.
To specify use of a particular buffer for error messages, type
\\[next-error] in that buffer when it is the only one displayed
in the current frame.
Once \\[next-error] has chosen the buffer for error messages, it
runs `next-error-hook' with `run-hooks', and stays with that buffer
until you use it in some other buffer which uses Compilation mode
or Compilation Minor mode.
See variables `compilation-parse-errors-function' and
\`compilation-error-regexp-alist' for customization ideas."
(interactive "P")
(if (consp arg) (setq reset t arg nil))
(when (setq next-error-last-buffer (next-error-find-buffer))
;; we know here that next-error-function is a valid symbol we can funcall
(with-current-buffer next-error-last-buffer
(funcall next-error-function (prefix-numeric-value arg) reset)
(run-hooks 'next-error-hook))))
(defalias 'goto-next-locus 'next-error)
(defalias 'next-match 'next-error)
(defun previous-error (&optional n)
"Visit previous `next-error' message and corresponding source code.
Prefix arg N says how many error messages to move backwards (or
forwards, if negative).
This operates on the output from the \\[compile] and \\[grep] commands."
(interactive "p")
(next-error (- (or n 1))))
(defun first-error (&optional n)
"Restart at the first error.
Visit corresponding source code.
With prefix arg N, visit the source code of the Nth error.
This operates on the output from the \\[compile] command, for instance."
(interactive "p")
(next-error n t))
(defun next-error-no-select (&optional n)
"Move point to the next error in the `next-error' buffer and highlight match.
Prefix arg N says how many error messages to move forwards (or
backwards, if negative).
Finds and highlights the source line like \\[next-error], but does not
select the source buffer."
(interactive "p")
(let ((next-error-highlight next-error-highlight-no-select))
(next-error n))
(pop-to-buffer next-error-last-buffer))
(defun previous-error-no-select (&optional n)
"Move point to the previous error in the `next-error' buffer and highlight match.
Prefix arg N says how many error messages to move backwards (or
forwards, if negative).
Finds and highlights the source line like \\[previous-error], but does not
select the source buffer."
(interactive "p")
(next-error-no-select (- (or n 1))))
;;; Internal variable for `next-error-follow-mode-post-command-hook'.
(defvar next-error-follow-last-line nil)
(define-minor-mode next-error-follow-minor-mode
"Minor mode for compilation, occur and diff modes.
When turned on, cursor motion in the compilation, grep, occur or diff
buffer causes automatic display of the corresponding source code
location."
:group 'next-error :init-value nil :lighter " Fol"
(if (not next-error-follow-minor-mode)
(remove-hook 'post-command-hook 'next-error-follow-mode-post-command-hook t)
(add-hook 'post-command-hook 'next-error-follow-mode-post-command-hook nil t)
(make-local-variable 'next-error-follow-last-line)))
;;; Used as a `post-command-hook' by `next-error-follow-mode'
;;; for the *Compilation* *grep* and *Occur* buffers.
(defun next-error-follow-mode-post-command-hook ()
(unless (equal next-error-follow-last-line (line-number-at-pos))
(setq next-error-follow-last-line (line-number-at-pos))
(condition-case nil
(let ((compilation-context-lines nil))
(setq compilation-current-error (point))
(next-error-no-select 0))
(error t))))
(provide 'next-error)
---------------------------------------------------------------------------
--
Malcolm Purvis <malcolmp(a)xemacs.org>
- 2 participants
- 3 comments
[AC21.5R21.4] [CORE (21.5)] Fix data types in unexelf.c
19 years, 1 month
Steve Youngs
Steve Youngs
APPROVE COMMIT 21.5 RECOMMEND 21.4
Thanks very much for this patch, Andrey. Please send your future
XEmacs contributions to xemacs-patches(a)xemacs.org.
Vin, looks to me like this is needed in 21.4 too.
NOTE: This patch has been committed.
21.5 patch:
ChangeLog files diff command: cvs -q diff -U 0
Files affected: src/ChangeLog
Source files diff command: cvs -q diff -uN
Files affected: src/unexelf.c
Index: src/ChangeLog
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/src/ChangeLog,v
retrieving revision 1.878
diff -u -p -U0 -r1.878 ChangeLog
--- src/ChangeLog 26 Oct 2005 15:14:53 -0000 1.878
+++ src/ChangeLog 29 Oct 2005 07:11:42 -0000
＠＠ -0,0 +1,5 ＠＠
+2005-10-29 Steve Youngs <steve(a)sxemacs.org>
+
+ * unexelf.c (unexec): Fix data types.
+ From: Andrey Slusar <anrays(a)gmail.com>
+
Index: src/unexelf.c
===================================================================
RCS file: /pack/xemacscvs/XEmacs/xemacs/src/unexelf.c,v
retrieving revision 1.19
diff -u -p -u -r1.19 unexelf.c
--- src/unexelf.c 10 Oct 2005 03:16:25 -0000 1.19
+++ src/unexelf.c 29 Oct 2005 07:11:06 -0000
＠＠ -565,8 +565,8 ＠＠ round_up (ElfW(Addr) x, ElfW(Addr) y)
*
*/
int
-unexec (Extbyte *new_name, Extbyte *old_name, unsigned int UNUSED (data_start),
- unsigned int UNUSED (bss_start), unsigned int UNUSED (entry_address))
+unexec (Extbyte *new_name, Extbyte *old_name, uintptr_t UNUSED (data_start),
+ uintptr_t UNUSED (bss_start), uintptr_t UNUSED (entry_address))
{
int new_file, old_file, new_file_size;
--
|---<Steve Youngs>---------------<GnuPG KeyID: A94B3003>---|
| I am Dyslexic of Borg. |
| Fusistance is retile. Your arse will be laminated. |
|------------------------------------<steve(a)sxemacs.org>---|
- 4 participants
- 6 comments
edit-utils/crm.el (completing-read-multiple) in XEmacs
19 years, 1 month
Reiner Steib
Reiner Steib
[ I've suggested to add `crm.el' (completing-read-multiple) which is
available in Emacs 21 and Emacs 22 (CVS[2]) to XEmacs on xemacs-beta.
Please keep <auctex-devel(a)gnu.org> in Cc when replying. ]
>From the discussion on xemacs-beta[1]:
On Sun, Oct 23 2005, Reiner Steib wrote:
> On Sun, Oct 23 2005, Ben Wing wrote:
>> i think this sounds great. probably crm.el should go in edit-utils.
>> does this need to be ported or does it work already under xemacs?
>
> Thank you for your response. I've done some testing with XEmacs
> 21.4.15:
>
> `crm.el' from Emacs 21 (21.3 or 21.4) works without any modifications
> in XEmacs. The version from Emacs 22 (CVS) uses the function
> `minibuffer-prompt-end' (a `diff -w -u' of those versions is
> attached), a built-in function in Emacs 22, not present in XEmacs.
>
> AfAICS, it would be sufficient if you'd include the Emacs 21 version
> of `crm.el' in edit-utils. [My understanding is, that XEmacs users
> (regardless whether they use a recent XEmacs 21.4 or XEmacs 21.5)
> would then just need to upgrade the edit-utils package to get this.
> Please CMIIW.]
>
> It would be great if you could include `crm.el' in the next packages
> updates. TIA.
On Mon, Oct 24 2005, Stephen J. Turnbull wrote:
> If you want to help something to get done a lot faster, you can post
> a full patch (in the case of a new file, either a patch against
> /dev/null or the file as an attachment is OK), with appropriate
> XEmacs-format changelog, to XEmacs Patches
> <xemacs-patches(a)xemacs.org>.
Attached is revision 1.5 [2] from Emacs CVS plus the update of FSF
address (done in revision 1.8 in Emacs CVS). The changes from
revision 1.6 and 1.7 cannot be applied because XEmacs doesn't have
`minibuffer-prompt-end'. I propose to add the attached file to the
edit-utils package as suggested by Ben.
Suggested ChangeLog entry:
--8<---------------cut here---------------start------------->8---
2005-10-26 Reiner Steib <Reiner.Steib(a)gmx.de>
* crm.el: New file. Revison 1.5 of lisp/emacs-lisp/crm.el in
Emacs. Update FSF's address.
--8<---------------cut here---------------end--------------->8---
> An analysis of any extra work needed to make the package compatible
> with both XEmacs 21.4 (preferably tested with the most recent release,
> but that's not absolutely necessary) and XEmacs 21.5 (tested with CVS
> head by preference, or at least the most recent beta release) is very
> helpful. (For example, the information you posted in response to Ben
> in <v9wtk4a86h.fsf(a)marauder.physik.uni-ulm.de> later in this thread is
> excellent.)
I've tested the attached version of `crm.el' with these versions of
XEmacs:
"XEmacs 21.5 (beta18) \"chestnut\" (+CVS-20041021) [Lucid]
(i386-suse-linux, Mule) of Tue Mar 22 2005 on mozart"
"XEmacs 21.4 (patch 15) \"Security Through Obscurity\" [Lucid]
(x86_64-suse-linux, Mule) of Fri Feb 11 2005 on helvede"
Sorry, I didn't download an compile a XEmacs 21.5 or the most recent
beta release. But I think it's quite unlikely that `crm.el' wont work
with current CVS. Maybe people using current XEmacs from CVS and/or
current AUCTeX[3] from CVS could report success or problems. There
are some testing examples at the end of `crm.el'.
Bye, Reiner.
[1] http://thread.gmane.org/xemacs-crm-2005-10-11-a%40marauder.physik.uni-ulm.de
[2] <URL:http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/emacs/emacs/lisp/e...>
[3] `C-c C-m \usepackage RET amsmath RET ...'
If you don't have CVS, you may try...
http://theotp1.physik.uni-ulm.de/~ste/comp/emacs/auctex/snapshots/
--
,,,
(o o)
---ooO-(_)-Ooo--- | PGP key available | http://rsteib.home.pages.de/
- 3 participants
- 3 comments
configure and Sun WorkShop patch
19 years, 1 month
Paul Keusemann
Paul Keusemann
The attached patch was require to buile XEmacs-21.5-b23 on Solaris 7
with Sun ToolTalk, Sun WorkShop and LDAP support.
--
Paul Keusemann pkeusem(a)visi.com
4266 Joppa Court (952) 894-7805
Savage, MN 55378
- 2 participants
- 1 comments
htmlize update
19 years, 2 months
Hrvoje Niksic
Hrvoje Niksic
Please note that a new version of htmlize is now available. It now
properly supports buffer-invisibility-spec.
As usual, it is available at:
http://fly.srk.fer.hr/~hniksic/emacs/htmlize.el
- 1 participants
- 0 comments
[AC] [PACKAGES (supercite)] Customisable mail address extract func.
19 years, 2 months
Steve Youngs
Steve Youngs
APPROVE COMMIT
NOTE: This patch has been committed.
supercite patch:
ChangeLog files diff command: cvs -q diff -U 0
Files affected: ChangeLog
Source files diff command: cvs -q diff -uN
Files affected: supercite.el
Index: ChangeLog
===================================================================
RCS file: /pack/xemacscvs/XEmacs/packages/xemacs-packages/supercite/ChangeLog,v
retrieving revision 1.20
diff -u -p -U0 -r1.20 ChangeLog
--- ChangeLog 31 Oct 2003 17:10:26 -0000 1.20
+++ ChangeLog 29 Oct 2005 06:46:25 -0000
＠＠ -0,0 +1,6 ＠＠
+2005-10-29 Steve Youngs <steve(a)sxemacs.org>
+
+ * supercite.el (sc-extract-address-components): New.
+ (sc-attribs-extract-namestring): Use it.
+ From: Nelson Ferreira <nelson.ferreira(a)ieee.org>
+
Index: supercite.el
===================================================================
RCS file: /pack/xemacscvs/XEmacs/packages/xemacs-packages/supercite/supercite.el,v
retrieving revision 1.12
diff -u -p -u -r1.12 supercite.el
--- supercite.el 14 Aug 2001 07:26:20 -0000 1.12
+++ supercite.el 29 Oct 2005 06:46:15 -0000
＠＠ -35,6 +35,7 ＠＠
;; |Mail and news reply citation package
;; |1993/09/22 18:58:46|3.1|
+;; njsf 2005/10/28: Added customize for extract address components
;; sb 1997/May/07: Add autoloads
;; sb 1997/Apr/02: Added attribution function sc-header-author-email-writes
;; which gives attribution in the form -
＠＠ -96,6 +97,13 ＠＠ It should take as its only parameter an
:type 'function
:group 'supercite)
+(defcustom sc-extract-address-components 'mail-extract-address-components
+ "*Function for extracting address components from a From header.
+One pre-defined function exist: `mail-extract-address-components'."
+:group 'supercite
+:type '(radio (function-item mail-extract-address-components)
+ (function :tag "Other")))
+
(defcustom sc-auto-fill-region-p t
"*If non-nil, automatically fill each paragraph after it has been cited."
:type 'boolean
＠＠ -1079,7 +1087,7 ＠＠ substring."
(defun sc-attribs-extract-namestring (from)
"Extract the name string from FROM.
This should be the author's full name minus an optional title."
- (let ((from-parts (mail-extract-address-components from)))
+ (let ((from-parts (funcall sc-extract-address-components from)))
(or (car from-parts)
(and (cadr from-parts)
(sc-attribs-emailname (cadr from-parts)))
--
|---<Steve Youngs>---------------<GnuPG KeyID: A94B3003>---|
| I am Dyslexic of Borg. |
| Fusistance is retile. Your arse will be laminated. |
|------------------------------------<steve(a)sxemacs.org>---|
- 1 participants
- 0 comments