2011-04-06 Juanma Barranquero <lekktu@gmail.com>
* files.el (after-find-file-from-revert-buffer): Remove variable.
- (after-find-file): Dont' bind it.
+ (after-find-file): Don't bind it.
(revert-buffer-in-progress-p): New variable.
(revert-buffer): Bind it.
Pass nil for `after-find-file-from-revert-buffer'.
+2011-04-16 Teodor Zlatanov <tzz@lifelogs.com>
+
+ * registry.el (registry-reindex): New method to recreate the secondary
+ registry indices.
+
+ * gnus-registry.el (gnus-registry-fixup-registry): Use it if the
+ tracked field changes.
+ (gnus-registry-unfollowed-addresses, gnus-registry-track-extra)
+ (gnus-registry-action, gnus-registry-spool-action)
+ (gnus-registry-handle-action)
+ (gnus-registry--split-fancy-with-parent-internal)
+ (gnus-registry-split-fancy-with-parent)
+ (gnus-registry-register-message-ids): Add recipient tracking on spool,
+ move, and delete actions, and for fancy splitting with parent.
+ (gnus-registry-extract-addresses)
+ (gnus-registry-fetch-recipients-fast)
+ (gnus-registry-fetch-header-fast): Convenience functions.
+ (gnus-registry-misc-test): ERT test of
+ `gnus-registry-extract-addresses'.
+
2011-04-15 Teodor Zlatanov <tzz@lifelogs.com>
* gnus-registry.el (gnus-registry--split-fancy-with-parent-internal):
;; Put this in your startup file (~/.gnus.el for instance) or use Customize:
;; (setq gnus-registry-max-entries 2500
-;; gnus-registry-track-extra '(sender subject))
+;; gnus-registry-track-extra '(sender subject recipient))
;; (gnus-registry-initialize)
(defcustom gnus-registry-unfollowed-addresses
(list (regexp-quote user-mail-address))
"List of addresses that gnus-registry-split-fancy-with-parent won't trace.
-The addresses are matched, they don't have to be fully qualified."
+The addresses are matched, they don't have to be fully qualified.
+In the messages, these addresses can be the sender or the
+recipients."
:group 'gnus-registry
:type '(repeat regexp))
(make-obsolete-variable 'gnus-registry-entry-caching nil "23.4")
(make-obsolete-variable 'gnus-registry-trim-articles-without-groups nil "23.4")
-(defcustom gnus-registry-track-extra '(subject sender)
+(defcustom gnus-registry-track-extra '(subject sender recipient)
"Whether the registry should track extra data about a message.
-The Subject and Sender (From:) headers are tracked this way by
-default."
+The subject, recipients (To: and Cc:), and Sender (From:) headers
+are tracked this way by default."
:group 'gnus-registry
:type
'(set :tag "Tracking choices"
(const :tag "Track by subject (Subject: header)" subject)
+ (const :tag "Track by recipient (To: and Cc: headers)" recipient)
(const :tag "Track by sender (From: header)" sender)))
(defcustom gnus-registry-split-strategy nil
(defun gnus-registry-fixup-registry (db)
(when db
- (oset db :precious
- (append gnus-registry-extra-entries-precious
- '()))
- (oset db :max-hard
- (or gnus-registry-max-entries
- most-positive-fixnum))
- (oset db :max-soft
- (or gnus-registry-max-pruned-entries
- most-positive-fixnum))
- (oset db :tracked
- (append gnus-registry-track-extra
- '(mark group keyword))))
+ (let ((old (oref db :tracked)))
+ (oset db :precious
+ (append gnus-registry-extra-entries-precious
+ '()))
+ (oset db :max-hard
+ (or gnus-registry-max-entries
+ most-positive-fixnum))
+ (oset db :max-soft
+ (or gnus-registry-max-pruned-entries
+ most-positive-fixnum))
+ (oset db :tracked
+ (append gnus-registry-track-extra
+ '(mark group keyword)))
+ (when (not (equal old (oref db :tracked)))
+ (gnus-message 4 "Reindexing the Gnus registry (tracked change)")
+ (registry-reindex db))))
db)
(defun gnus-registry-make-db (&optional file)
(defun gnus-registry-action (action data-header from &optional to method)
(let* ((id (mail-header-id data-header))
(subject (mail-header-subject data-header))
- (sender (mail-header-from data-header))
+ (recipients (sort (mapcan 'gnus-registry-extract-addresses
+ (list
+ (or (ignore-errors
+ (mail-header "Cc" data-header))
+ "")
+ (or (ignore-errors
+ (mail-header "To" data-header))
+ "")))
+ 'string-lessp))
+ (sender (nth 0 (gnus-registry-extract-addresses
+ (mail-header-from data-header))))
(from (gnus-group-guess-full-name-from-command-method from))
(to (if to (gnus-group-guess-full-name-from-command-method to) nil))
(to-name (if to to "the Bit Bucket")))
id
;; unless copying, remove the old "from" group
(if (not (equal 'copy action)) from nil)
- to subject sender)))
+ to subject sender recipients)))
-(defun gnus-registry-spool-action (id group &optional subject sender)
+(defun gnus-registry-spool-action (id group &optional subject sender recipients)
(let ((to (gnus-group-guess-full-name-from-command-method group))
+ (recipients (or recipients
+ (sort (mapcan 'gnus-registry-extract-addresses
+ (list
+ (or (message-fetch-field "cc") "")
+ (or (message-fetch-field "to") "")))
+ 'string-lessp)))
(subject (or subject (message-fetch-field "subject")))
(sender (or sender (message-fetch-field "from"))))
(when (and (stringp id) (string-match "\r$" id))
(gnus-message 7 "Gnus registry: article %s spooled to %s"
id
to)
- (gnus-registry-handle-action id nil to subject sender)))
+ (gnus-registry-handle-action id nil to subject sender recipients)))
-(defun gnus-registry-handle-action (id from to subject sender)
+(defun gnus-registry-handle-action (id from to subject sender
+ &optional recipients)
(gnus-message
10
- "gnus-registry-handle-action %S" (list id from to subject sender))
+ "gnus-registry-handle-action %S" (list id from to subject sender recipients))
(let ((db gnus-registry-db)
;; safe if not found
(entry (gnus-registry-get-or-make-entry id))
(setq entry (cons (delete from (assoc 'group entry))
(assq-delete-all 'group entry))))
- (dolist (kv `((group ,to) (sender ,sender) (subject ,subject)))
+ (dolist (kv `((group ,to)
+ (sender ,sender)
+ (recipient ,@recipients)
+ (subject ,subject)))
(when (second kv)
(let ((new (or (assq (first kv) entry)
(list (first kv)))))
- (add-to-list 'new (second kv) t)
+ (dolist (toadd (cdr kv))
+ (add-to-list 'new toadd t))
(setq entry (cons new
(assq-delete-all (first kv) entry))))))
(gnus-message 10 "Gnus registry: new entry for %s is %S"
;; these may not be used, but the code is cleaner having them up here
(sender (gnus-string-remove-all-properties
(message-fetch-field "from")))
+ (recipients (sort (mapcan 'gnus-registry-extract-addresses
+ (list
+ (or (message-fetch-field "cc") "")
+ (or (message-fetch-field "to") "")))
+ 'string-lessp))
(subject (gnus-string-remove-all-properties
(gnus-registry-simplify-subject
(message-fetch-field "subject"))))
:references references
:refstr refstr
:sender sender
+ :recipients recipients
:subject subject
:log-agent "Gnus registry fancy splitting with parent")))
(defun* gnus-registry--split-fancy-with-parent-internal
(&rest spec
- &key references refstr sender subject log-agent
+ &key references refstr sender subject recipients log-agent
&allow-other-keys)
(gnus-message
10
(setq found (gnus-registry-post-process-groups
"sender" sender found)))
+ ;; else: there were no matches, try the extra tracking by recipient
+ (when (and (null found)
+ (memq 'recipient gnus-registry-track-extra)
+ recipients)
+ (dolist (recp recipients)
+ (when (and (null found)
+ (not (gnus-grep-in-list
+ recp
+ gnus-registry-unfollowed-addresses)))
+ (let ((groups (apply 'append
+ (mapcar
+ (lambda (reference)
+ (gnus-registry-get-id-key reference 'group))
+ (registry-lookup-secondary-value
+ db 'recipient recp)))))
+ (setq found
+ (loop for group in groups
+ when (gnus-registry-follow-group-p group)
+ do (gnus-message
+ ;; warn more if gnus-registry-track-extra
+ (if gnus-registry-track-extra 7 9)
+ "%s (extra tracking) traced recipient '%s' to %s"
+ log-agent recp group)
+ collect group)))))
+
+ ;; filter the found groups and return them
+ ;; the found groups are NOT the full groups
+ (setq found (gnus-registry-post-process-groups
+ "recipients" (mapconcat 'identity recipients ", ") found)))
+
;; after the (cond) we extract the actual value safely
(car-safe found)))
article gnus-newsgroup-name)
(gnus-registry-handle-action id nil gnus-newsgroup-name
(gnus-registry-fetch-simplified-message-subject-fast article)
- (gnus-registry-fetch-sender-fast article)))))))
+ (gnus-registry-fetch-sender-fast article)
+ (gnus-registry-fetch-recipients-fast article)))))))
;; message field fetchers
(defun gnus-registry-fetch-message-id-fast (article)
(mail-header-id (gnus-data-header (assoc article (gnus-data-list nil))))
nil))
+(defun gnus-registry-extract-addresses (text)
+ "Extract all the addresses in a normalized way from TEXT.
+Returns an unsorted list of strings in the name <address> format.
+Addresses without a name will say \"noname\"."
+ (mapcar (lambda (add)
+ (gnus-string-remove-all-properties
+ (let* ((name (or (nth 0 add) "noname"))
+ (addr (nth 1 add))
+ (addr (if (bufferp addr)
+ (with-current-buffer addr
+ (buffer-string))
+ addr)))
+ (format "%s <%s>" name addr))))
+ (mail-extract-address-components text t)))
+
(defun gnus-registry-simplify-subject (subject)
(if (stringp subject)
(gnus-simplify-subject subject)
nil))
(defun gnus-registry-fetch-sender-fast (article)
- "Fetch the Sender quickly, using the internal gnus-data-list function"
+ (gnus-registry-fetch-header-fast "from" article))
+
+(defun gnus-registry-fetch-recipients-fast (article)
+ (sort (mapcan 'gnus-registry-extract-addresses
+ (list
+ (or (ignore-errors
+ (gnus-registry-fetch-header-fast "Cc" article))
+ "")
+ (or (ignore-errors
+ (gnus-registry-fetch-header-fast "To" article))
+ "")))
+ 'string-lessp))
+
+(defun gnus-registry-fetch-header-fast (article header)
+ "Fetch the HEADER quickly, using the internal gnus-data-list function"
(if (and (numberp article)
(assoc article (gnus-data-list nil)))
(gnus-string-remove-all-properties
- (mail-header-from (gnus-data-header
- (assoc article (gnus-data-list nil)))))
+ (mail-header header (gnus-data-header
+ (assoc article (gnus-data-list nil)))))
nil))
;; registry marks glue
(gnus-registry-set-id-key id key val))))
(message "Import done, collected %d entries" count))))
+(ert-deftest gnus-registry-misc-test ()
+ (should-error (gnus-registry-extract-addresses '("" "")))
+
+ (should (equal '("Ted Zlatanov <tzz@lifelogs.com>"
+ "noname <ed@you.me>"
+ "noname <cyd@stupidchicken.com>"
+ "noname <tzz@lifelogs.com>")
+ (gnus-registry-extract-addresses
+ (concat "Ted Zlatanov <tzz@lifelogs.com>, "
+ "ed <ed@you.me>, " ; "ed" is not a valid name here
+ "cyd@stupidchicken.com, "
+ "tzz@lifelogs.com")))))
+
(ert-deftest gnus-registry-usage-test ()
(let* ((n 100)
(tempfile (make-temp-file "gnus-registry-persist"))
(registry-lookup-secondary-value db tr val value-keys))))
entry)
+(defmethod registry-reindex ((db registry-db))
+ "Rebuild the secondary indices of registry-db THIS."
+ (let ((count 0)
+ (expected (* (length (oref db :tracked)) (registry-size db))))
+ (dolist (tr (oref db :tracked))
+ (let (values)
+ (maphash
+ (lambda (key v)
+ (incf count)
+ (when (and (< 0 expected)
+ (= 0 (mod count 1000)))
+ (message "reindexing: %d of %d (%.2f%%)"
+ count expected (/ (* 1000 count) expected)))
+ (dolist (val (cdr-safe (assq tr v)))
+ (let* ((value-keys (registry-lookup-secondary-value db tr val)))
+ (push key value-keys)
+ (registry-lookup-secondary-value db tr val value-keys))))
+ (oref db :data))))))
+
(defmethod registry-size ((db registry-db))
"Returns the size of the registry-db object THIS.
This is the key count of the :data slot."
(when (boundp 'lexical-binding)
(message "Individual lookup (breaks before lexbind)")
(should (= 58
- (caadr (registry-lookup-breaks-before-lexbind db '(1 58 99)))))
+ (caadr (registry-lookup-breaks-before-lexbind db '(1 58 99)))))
(message "Grouped individual lookup (breaks before lexbind)")
(should (= 3
- (length (registry-lookup-breaks-before-lexbind db '(1 58 99))))))
+ (length (registry-lookup-breaks-before-lexbind db
+ '(1 58 99))))))
(message "Search")
(should (= n (length (registry-search db :all t))))
(should (= n (length (registry-search db :member '((sender "me"))))))
+2011-04-16 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * url-http.el (url-http-wait-for-headers-change-function): Protect
+ against malformed headerless responses from servers.
+
2011-04-02 Chong Yidong <cyd@stupidchicken.com>
* url-gw.el (url-open-stream): Use new open-network-stream
(downcase url-http-transfer-encoding)))
(cond
+ ((null url-http-response-status)
+ ;; We got back a headerless malformed response from the
+ ;; server.
+ (url-http-activate-callback))
((or (= url-http-response-status 204)
(= url-http-response-status 205))
(url-http-debug "%d response must have headers only (%s)."
* xdisp.c, dispextern.h (set_vertical_scroll_bar): Now extern if
USE_TOOLKIT_SCROLL_BARS && !USE_GTK, as xterm.c needs it then.
+2011-04-16 Eli Zaretskii <eliz@gnu.org>
+
+ * gnutls.c (Fgnutls_boot): Don't pass Lisp_Object to `error'.
+
+ Fix regex.c, syntax.c and friends for buffers > 2GB.
+ * syntax.h (struct gl_state_s): Declare character position members
+ EMACS_INT.
+
+ * syntax.c (update_syntax_table): Declare 2nd argument EMACS_INT.
+
+ * textprop.c (verify_interval_modification, interval_of): Declare
+ arguments EMACS_INT.
+
+ * intervals.c (adjust_intervals_for_insertion): Declare arguments
+ EMACS_INT.
+
+ * intervals.h (CHECK_TOTAL_LENGTH): Cast to EMACS_INT, not `int'.
+
+ * indent.c (Fvertical_motion): Local variable it_start is now
+ EMACS_INT.
+
+ * regex.c (re_match, re_match_2, re_match_2_internal)
+ (bcmp_translate, regcomp, regexec, print_double_string)
+ (group_in_compile_stack, re_search, re_search_2, regex_compile)
+ (re_compile_pattern, re_exec): Declare arguments and local
+ variables `size_t' and `ssize_t' and return values `regoff_t', as
+ appropriate.
+ (POP_FAILURE_REG_OR_COUNT) <pfreg>: Declare `long'.
+ (CHECK_INFINITE_LOOP) <failure>: Declare `ssize_t'.
+ <compile_stack_type>: `size' and `avail' are now `size_t'.
+
+ * regex.h <regoff_t>: Use ssize_t, not int.
+ (re_search, re_search_2, re_match, re_match_2): Arguments that
+ specify buffer/string position and length are now ssize_t and
+ size_t. Return type is regoff_t.
+
+2011-04-16 Ben Key <bkey76@gmail.com>
+
+ * nsfont.m: Fixed bugs in ns_get_family and
+ ns_descriptor_to_entity that were caused by using free to
+ deallocate memory blocks that were allocated by xmalloc (via
+ xstrdup). This caused Emacs to crash when compiled with
+ XMALLOC_OVERRUN_CHECK defined (when Emacs was configured with
+ --enable-checking=xmallocoverrun). xfree is now used to
+ deallocate these memory blocks.
+
2011-04-15 Paul Eggert <eggert@cs.ucla.edu>
* sysdep.c (emacs_read): Remove unnecessary check vs MAX_RW_COUNT.
2011-04-15 Ben Key <bkey76@gmail.com>
- * keyboard.c (Qundefined): Don't declare static since it is
- used in nsfns.m.
- * xfaces.c (Qbold, Qexpanded, Qitalic, Qcondensed): Don't
- declare static since they are used in nsfont.m.
+ * keyboard.c (Qundefined): Don't declare static since it is used
+ in nsfns.m.
+ * xfaces.c (Qbold, Qexpanded, Qitalic, Qcondensed): Don't declare
+ static since they are used in nsfont.m.
2011-04-15 Stefan Monnier <monnier@iro.umontreal.ca>
else
{
error ("Sorry, GnuTLS can't use non-string trustfile %s",
- trustfile);
+ SDATA (trustfile));
}
}
else
{
error ("Sorry, GnuTLS can't use non-string keyfile %s",
- keyfile);
+ SDATA (keyfile));
}
}
}
}
else
{
- int it_start, first_x, it_overshoot_expected IF_LINT (= 0);
+ EMACS_INT it_start;
+ int first_x, it_overshoot_expected IF_LINT (= 0);
SET_TEXT_POS (pt, PT, PT_BYTE);
start_display (&it, w, pt);
static INTERVAL
adjust_intervals_for_insertion (tree, position, length)
INTERVAL tree;
- int position, length;
+ EMACS_INT position, length;
{
- register int relative_position;
+ register EMACS_INT relative_position;
register INTERVAL this;
if (TOTAL_LENGTH (tree) == 0) /* Paranoia */
(INTERVAL_HAS_PARENT (i) ? INTERVAL_PARENT (i) : 0)
/* Abort if interval I's size is negative. */
-#define CHECK_TOTAL_LENGTH(i) \
- do \
- { \
- if ((int) (i)->total_length < 0) \
- abort (); \
- } \
+#define CHECK_TOTAL_LENGTH(i) \
+ do \
+ { \
+ if ((EMACS_INT) (i)->total_length < 0) \
+ abort (); \
+ } \
while (0)
/* Reset this interval to its vanilla, or no-property state. */
extern void offset_intervals (struct buffer *, EMACS_INT, EMACS_INT);
extern void graft_intervals_into_buffer (INTERVAL, EMACS_INT, EMACS_INT,
struct buffer *, int);
-extern void verify_interval_modification (struct buffer *, int, int);
+extern void verify_interval_modification (struct buffer *,
+ EMACS_INT, EMACS_INT);
extern INTERVAL balance_intervals (INTERVAL);
extern void copy_intervals_to_string (Lisp_Object, struct buffer *,
EMACS_INT, EMACS_INT);
extern void set_intervals_multibyte (int);
extern INTERVAL validate_interval_range (Lisp_Object, Lisp_Object *,
Lisp_Object *, int);
-extern INTERVAL interval_of (int, Lisp_Object);
+extern INTERVAL interval_of (EMACS_INT, Lisp_Object);
/* Defined in xdisp.c */
extern int invisible_p (Lisp_Object, Lisp_Object);
NSString *family;
ns_unescape_name (tmp);
family = [NSString stringWithUTF8String: tmp];
- free (tmp);
+ xfree (tmp);
return family;
}
}
debug_print (font_entity);
}
- free (escapedFamily);
+ xfree (escapedFamily);
return font_entity;
}
#define false 0
#define true 1
-static int re_match_2_internal _RE_ARGS ((struct re_pattern_buffer *bufp,
- re_char *string1, int size1,
- re_char *string2, int size2,
- int pos,
- struct re_registers *regs,
- int stop));
+static regoff_t re_match_2_internal _RE_ARGS ((struct re_pattern_buffer *bufp,
+ re_char *string1, size_t size1,
+ re_char *string2, size_t size2,
+ ssize_t pos,
+ struct re_registers *regs,
+ ssize_t stop));
\f
/* These are the command codes that appear in compiled regular
expressions. Some opcodes are followed by argument bytes. A
re_char *where;
re_char *string1;
re_char *string2;
- int size1;
- int size2;
+ ssize_t size1;
+ ssize_t size2;
{
- int this_char;
+ ssize_t this_char;
if (where == NULL)
printf ("(null)");
/* Pop a saved register off the stack. */
#define POP_FAILURE_REG_OR_COUNT() \
do { \
- int pfreg = POP_FAILURE_INT (); \
+ long pfreg = POP_FAILURE_INT (); \
if (pfreg == -1) \
{ \
/* It's a counter. */ \
/* Check that we are not stuck in an infinite loop. */
#define CHECK_INFINITE_LOOP(pat_cur, string_place) \
do { \
- int failure = TOP_FAILURE_HANDLE (); \
+ ssize_t failure = TOP_FAILURE_HANDLE (); \
/* Check for infinite matching loops */ \
while (failure > 0 \
&& (FAILURE_STR (failure) == string_place \
typedef struct
{
compile_stack_elt_t *stack;
- unsigned size;
- unsigned avail; /* Offset of next open position. */
+ size_t size;
+ size_t avail; /* Offset of next open position. */
} compile_stack_type;
if (many_times_ok)
{
boolean simple = skip_one_char (laststart) == b;
- unsigned int startoffset = 0;
+ size_t startoffset = 0;
re_opcode_t ofj =
/* Check if the loop can match the empty string. */
(simple || !analyse_first (laststart, b, NULL, 0))
_____ _____
| | | |
| v | v
- a | b | c
+ a | b | c
If we are at `b', then fixup_alt_jump right now points to a
three-byte space after `a'. We'll put in the jump, set
static boolean
group_in_compile_stack (compile_stack_type compile_stack, regnum_t regnum)
{
- int this_element;
+ ssize_t this_element;
for (this_element = compile_stack.avail - 1;
this_element >= 0;
/* Like re_search_2, below, but only one string is specified, and
doesn't let you say where to stop matching. */
-int
-re_search (struct re_pattern_buffer *bufp, const char *string, int size, int startpos, int range, struct re_registers *regs)
+regoff_t
+re_search (struct re_pattern_buffer *bufp, const char *string, size_t size,
+ ssize_t startpos, ssize_t range, struct re_registers *regs)
{
return re_search_2 (bufp, NULL, 0, string, size, startpos, range,
regs, size);
found, -1 if no match, or -2 if error (such as failure
stack overflow). */
-int
-re_search_2 (struct re_pattern_buffer *bufp, const char *str1, int size1, const char *str2, int size2, int startpos, int range, struct re_registers *regs, int stop)
+regoff_t
+re_search_2 (struct re_pattern_buffer *bufp, const char *str1, size_t size1,
+ const char *str2, size_t size2, ssize_t startpos, ssize_t range,
+ struct re_registers *regs, ssize_t stop)
{
- int val;
+ regoff_t val;
re_char *string1 = (re_char*) str1;
re_char *string2 = (re_char*) str2;
register char *fastmap = bufp->fastmap;
register RE_TRANSLATE_TYPE translate = bufp->translate;
- int total_size = size1 + size2;
- int endpos = startpos + range;
+ size_t total_size = size1 + size2;
+ ssize_t endpos = startpos + range;
boolean anchored_start;
/* Nonzero if we are searching multibyte string. */
const boolean multibyte = RE_TARGET_MULTIBYTE_P (bufp);
#ifdef emacs
gl_state.object = re_match_object; /* Used by SYNTAX_TABLE_BYTE_TO_CHAR. */
{
- int charpos = SYNTAX_TABLE_BYTE_TO_CHAR (POS_AS_IN_BUFFER (startpos));
+ ssize_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (POS_AS_IN_BUFFER (startpos));
SETUP_SYNTAX_TABLE_FOR_OBJECT (re_match_object, charpos, 1);
}
if (range > 0) /* Searching forwards. */
{
register int lim = 0;
- int irange = range;
+ ssize_t irange = range;
if (startpos < size1 && startpos + range >= size1)
lim = range - (size1 - startpos);
/* Declarations and macros for re_match_2. */
static int bcmp_translate _RE_ARGS((re_char *s1, re_char *s2,
- register int len,
+ register ssize_t len,
RE_TRANSLATE_TYPE translate,
const int multibyte));
&& ((p2[2 + idx] & ~ p1[2 + idx]) == 0))))
break;
- if (idx == p2[1])
- {
- DEBUG_PRINT1 (" No match => fast loop.\n");
- return 1;
- }
+ if (idx == p2[1])
+ {
+ DEBUG_PRINT1 (" No match => fast loop.\n");
+ return 1;
+ }
}
}
}
#ifndef emacs /* Emacs never uses this. */
/* re_match is like re_match_2 except it takes only a single string. */
-int
+regoff_t
re_match (struct re_pattern_buffer *bufp, const char *string,
- int size, int pos, struct re_registers *regs)
+ size_t size, ssize_t pos, struct re_registers *regs)
{
- int result = re_match_2_internal (bufp, NULL, 0, (re_char*) string, size,
- pos, regs, size);
+ regoff_t result = re_match_2_internal (bufp, NULL, 0, (re_char*) string,
+ size, pos, regs, size);
return result;
}
WEAK_ALIAS (__re_match, re_match)
failure stack overflowing). Otherwise, we return the length of the
matched substring. */
-int
-re_match_2 (struct re_pattern_buffer *bufp, const char *string1, int size1, const char *string2, int size2, int pos, struct re_registers *regs, int stop)
+regoff_t
+re_match_2 (struct re_pattern_buffer *bufp, const char *string1,
+ size_t size1, const char *string2, size_t size2, ssize_t pos,
+ struct re_registers *regs, ssize_t stop)
{
- int result;
+ regoff_t result;
#ifdef emacs
- int charpos;
+ ssize_t charpos;
gl_state.object = re_match_object; /* Used by SYNTAX_TABLE_BYTE_TO_CHAR. */
charpos = SYNTAX_TABLE_BYTE_TO_CHAR (POS_AS_IN_BUFFER (pos));
SETUP_SYNTAX_TABLE_FOR_OBJECT (re_match_object, charpos, 1);
/* This is a separate function so that we can force an alloca cleanup
afterwards. */
-static int
-re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int size1, const re_char *string2, int size2, int pos, struct re_registers *regs, int stop)
+static regoff_t
+re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
+ size_t size1, const re_char *string2, size_t size2,
+ ssize_t pos, struct re_registers *regs, ssize_t stop)
{
/* General temporaries. */
- int mcnt;
+ ssize_t mcnt;
size_t reg;
/* Just past the end of the corresponding string. */
int s1, s2;
int dummy;
#ifdef emacs
- int offset = PTR_TO_OFFSET (d - 1);
- int charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
+ ssize_t offset = PTR_TO_OFFSET (d - 1);
+ ssize_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
UPDATE_SYNTAX_TABLE (charpos);
#endif
GET_CHAR_BEFORE_2 (c1, d, string1, end1, string2, end2);
int s1, s2;
int dummy;
#ifdef emacs
- int offset = PTR_TO_OFFSET (d);
- int charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
+ ssize_t offset = PTR_TO_OFFSET (d);
+ ssize_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
UPDATE_SYNTAX_TABLE (charpos);
#endif
PREFETCH ();
int s1, s2;
int dummy;
#ifdef emacs
- int offset = PTR_TO_OFFSET (d) - 1;
- int charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
+ ssize_t offset = PTR_TO_OFFSET (d) - 1;
+ ssize_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
UPDATE_SYNTAX_TABLE (charpos);
#endif
GET_CHAR_BEFORE_2 (c1, d, string1, end1, string2, end2);
re_wchar_t c1, c2;
int s1, s2;
#ifdef emacs
- int offset = PTR_TO_OFFSET (d);
- int charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
+ ssize_t offset = PTR_TO_OFFSET (d);
+ ssize_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
UPDATE_SYNTAX_TABLE (charpos);
#endif
PREFETCH ();
re_wchar_t c1, c2;
int s1, s2;
#ifdef emacs
- int offset = PTR_TO_OFFSET (d) - 1;
- int charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
+ ssize_t offset = PTR_TO_OFFSET (d) - 1;
+ ssize_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
UPDATE_SYNTAX_TABLE (charpos);
#endif
GET_CHAR_BEFORE_2 (c1, d, string1, end1, string2, end2);
PREFETCH ();
#ifdef emacs
{
- int offset = PTR_TO_OFFSET (d);
- int pos1 = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
+ ssize_t offset = PTR_TO_OFFSET (d);
+ ssize_t pos1 = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
UPDATE_SYNTAX_TABLE (pos1);
}
#endif
bytes; nonzero otherwise. */
static int
-bcmp_translate (const re_char *s1, const re_char *s2, register int len,
+bcmp_translate (const re_char *s1, const re_char *s2, register ssize_t len,
RE_TRANSLATE_TYPE translate, const int target_multibyte)
{
register re_char *p1 = s1, *p2 = s2;
We call regex_compile to do the actual compilation. */
const char *
-re_compile_pattern (const char *pattern, size_t length, struct re_pattern_buffer *bufp)
+re_compile_pattern (const char *pattern, size_t length,
+ struct re_pattern_buffer *bufp)
{
reg_errcode_t ret;
}
-int
+regoff_t
# ifdef _LIBC
weak_function
# endif
-re_exec (s)
- const char *s;
+re_exec (const char *s)
{
- const int len = strlen (s);
+ const size_t len = strlen (s);
return
0 <= re_search (&re_comp_buf, s, len, 0, len, (struct re_registers *) 0);
}
It returns 0 if it succeeds, nonzero if it doesn't. (See regex.h for
the return codes and their meanings.) */
-int
+reg_errcode_t
regcomp (regex_t *__restrict preg, const char *__restrict pattern,
int cflags)
{
preg->fastmap = NULL;
}
}
- return (int) ret;
+ return ret;
}
WEAK_ALIAS (__regcomp, regcomp)
We return 0 if we find a match and REG_NOMATCH if not. */
-int
+reg_errcode_t
regexec (const regex_t *__restrict preg, const char *__restrict string,
size_t nmatch, regmatch_t pmatch[__restrict_arr], int eflags)
{
- int ret;
+ reg_errcode_t ret;
struct re_registers regs;
regex_t private_preg;
- int len = strlen (string);
+ size_t len = strlen (string);
boolean want_reg_info = !preg->no_sub && nmatch > 0 && pmatch;
private_preg = *preg;
regs.num_regs = nmatch;
regs.start = TALLOC (nmatch * 2, regoff_t);
if (regs.start == NULL)
- return (int) REG_NOMATCH;
+ return REG_NOMATCH;
regs.end = regs.start + nmatch;
}
}
/* We want zero return to mean success, unlike `re_search'. */
- return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH;
+ return ret >= 0 ? REG_NOERROR : REG_NOMATCH;
}
WEAK_ALIAS (__regexec, regexec)
typedef struct re_pattern_buffer regex_t;
\f
-/* Type for byte offsets within the string. POSIX mandates this. */
-typedef int regoff_t;
+/* Type for byte offsets within the string. POSIX mandates this to be an int,
+ but the Open Group has signalled its intention to change the requirement to
+ be that regoff_t be at least as wide as ptrdiff_t and ssize_t. Current
+ gnulib sources also use ssize_t, and we need this for supporting buffers and
+ strings > 2GB on 64-bit hosts. */
+typedef ssize_t regoff_t;
/* This is the structure we store register match data in. See
characters. Return the starting position of the match, -1 for no
match, or -2 for an internal error. Also return register
information in REGS (if REGS and BUFFER->no_sub are nonzero). */
-extern int re_search
+extern regoff_t re_search
_RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
- int length, int start, int range, struct re_registers *regs));
+ size_t length, ssize_t start, ssize_t range,
+ struct re_registers *regs));
/* Like `re_search', but search in the concatenation of STRING1 and
STRING2. Also, stop searching at index START + STOP. */
-extern int re_search_2
+extern regoff_t re_search_2
_RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
- int length1, const char *string2, int length2,
- int start, int range, struct re_registers *regs, int stop));
+ size_t length1, const char *string2, size_t length2,
+ ssize_t start, ssize_t range, struct re_registers *regs,
+ ssize_t stop));
/* Like `re_search', but return how many characters in STRING the regexp
in BUFFER matched, starting at position START. */
-extern int re_match
+extern regoff_t re_match
_RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
- int length, int start, struct re_registers *regs));
+ size_t length, ssize_t start, struct re_registers *regs));
/* Relates to `re_match' as `re_search_2' relates to `re_search'. */
-extern int re_match_2
+extern regoff_t re_match_2
_RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
- int length1, const char *string2, int length2,
- int start, struct re_registers *regs, int stop));
+ size_t length1, const char *string2, size_t length2,
+ ssize_t start, struct re_registers *regs, ssize_t stop));
/* Set REGS to hold NUM_REGS registers, storing them in STARTS and
#endif
/* POSIX compatibility. */
-extern int regcomp _RE_ARGS ((regex_t *__restrict __preg,
- const char *__restrict __pattern,
- int __cflags));
-
-extern int regexec _RE_ARGS ((const regex_t *__restrict __preg,
- const char *__restrict __string, size_t __nmatch,
- regmatch_t __pmatch[__restrict_arr],
- int __eflags));
+extern reg_errcode_t regcomp _RE_ARGS ((regex_t *__restrict __preg,
+ const char *__restrict __pattern,
+ int __cflags));
+
+extern reg_errcode_t regexec _RE_ARGS ((const regex_t *__restrict __preg,
+ const char *__restrict __string,
+ size_t __nmatch,
+ regmatch_t __pmatch[__restrict_arr],
+ int __eflags));
extern size_t regerror _RE_ARGS ((int __errcode, const regex_t *__preg,
char *__errbuf, size_t __errbuf_size));
start/end of OBJECT. */
void
-update_syntax_table (EMACS_INT charpos, int count, int init,
+update_syntax_table (EMACS_INT charpos, EMACS_INT count, int init,
Lisp_Object object)
{
Lisp_Object tmp_table;
along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
-extern void update_syntax_table (EMACS_INT, int, int, Lisp_Object);
+extern void update_syntax_table (EMACS_INT, EMACS_INT, int, Lisp_Object);
/* The standard syntax table is stored where it will automatically
be used in all new buffers. */
struct gl_state_s
{
Lisp_Object object; /* The object we are scanning. */
- int start; /* Where to stop. */
- int stop; /* Where to stop. */
+ EMACS_INT start; /* Where to stop. */
+ EMACS_INT stop; /* Where to stop. */
int use_global; /* Whether to use global_code
or c_s_t. */
Lisp_Object global_code; /* Syntax code of current char. */
Lisp_Object current_syntax_table; /* Syntax table for current pos. */
Lisp_Object old_prop; /* Syntax-table prop at prev pos. */
- int b_property; /* First index where c_s_t is valid. */
- int e_property; /* First index where c_s_t is
+ EMACS_INT b_property; /* First index where c_s_t is valid. */
+ EMACS_INT e_property; /* First index where c_s_t is
not valid. */
INTERVAL forward_i; /* Where to start lookup on forward */
INTERVAL backward_i; /* or backward movement. The
intervals too, depending
on: */
/* Offset for positions specified to UPDATE_SYNTAX_TABLE. */
- int offset;
+ EMACS_INT offset;
};
extern struct gl_state_s gl_state;
POSITION is BEG-based. */
INTERVAL
-interval_of (int position, Lisp_Object object)
+interval_of (EMACS_INT position, Lisp_Object object)
{
register INTERVAL i;
EMACS_INT beg, end;
those hooks in order, with START and END - 1 as arguments. */
void
-verify_interval_modification (struct buffer *buf, int start, int end)
+verify_interval_modification (struct buffer *buf,
+ EMACS_INT start, EMACS_INT end)
{
register INTERVAL intervals = BUF_INTERVALS (buf);
register INTERVAL i;