mirror of
git://git.sv.gnu.org/emacs.git
synced 2026-02-17 01:34:21 +00:00
entered into RCS
This commit is contained in:
Jim Blandy
parent
4d4c4e027f
commit
fbfed6f05f
10 changed files with 282 additions and 203 deletions
|
|
@ -17,7 +17,14 @@
|
|||
|
||||
#include <stdio.h>
|
||||
#include <time.h>
|
||||
|
||||
#include "../src/config.h"
|
||||
|
||||
#ifdef USG
|
||||
#include <string.h>
|
||||
#else
|
||||
#include <strings.h>
|
||||
#endif
|
||||
|
||||
/* BSD's strings.h does not declare the type of strtok. */
|
||||
extern char *strtok ();
|
||||
|
|
|
|||
346
lib-src/timer.c
346
lib-src/timer.c
|
|
@ -1,17 +1,17 @@
|
|||
/*
|
||||
* timer.c --- daemon to provide a tagged interval timer service
|
||||
*
|
||||
* This little daemon runs forever waiting for signals. SIGIO (or SIGUSR1)
|
||||
* causes it to read an event spec from stdin; that is, a date followed by
|
||||
* colon followed by an event label. SIGALRM causes it to check its queue
|
||||
* for events attached to the current second; if one is found, its label
|
||||
* is written to stdout. SIGTERM causes it to terminate, printing a list
|
||||
* of pending events.
|
||||
*
|
||||
* This program is intended to be used with the lisp package called timer.el.
|
||||
* It was written anonymously in 1990. This version was documented and
|
||||
* rewritten for portability by esr@snark,thyrsus.com, Aug 7 1992.
|
||||
*/
|
||||
/* timer.c --- daemon to provide a tagged interval timer service
|
||||
|
||||
This little daemon runs forever waiting for signals. SIGIO (or
|
||||
SIGUSR1) causes it to read an event spec from stdin; that is, a
|
||||
date followed by colon followed by an event label. SIGALRM causes
|
||||
it to check its queue for events attached to the current second; if
|
||||
one is found, its label is written to stdout. SIGTERM causes it to
|
||||
terminate, printing a list of pending events.
|
||||
|
||||
This program is intended to be used with the lisp package called
|
||||
timer.el. It was written anonymously in 1990. This version was
|
||||
documented and rewritten for portability by esr@snark,thyrsus.com,
|
||||
Aug 7 1992. */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <signal.h>
|
||||
#include <fcntl.h> /* FASYNC */
|
||||
|
|
@ -24,10 +24,8 @@
|
|||
#endif
|
||||
|
||||
extern int errno;
|
||||
extern char *sys_errlist[], *malloc();
|
||||
extern time_t time();
|
||||
|
||||
#define MAXEVENTS 256
|
||||
extern char *sys_errlist[], *malloc ();
|
||||
extern time_t time ();
|
||||
|
||||
/*
|
||||
* The field separator for input. This character shouldn't be legal in a date,
|
||||
|
|
@ -37,185 +35,235 @@ extern time_t time();
|
|||
#define FS '@'
|
||||
|
||||
struct event
|
||||
{
|
||||
{
|
||||
char *token;
|
||||
time_t reply_at;
|
||||
}
|
||||
events[MAXEVENTS];
|
||||
};
|
||||
int events_size; /* How many slots have we allocated? */
|
||||
int num_events; /* How many are actually scheduled? */
|
||||
struct event *events; /* events[0 .. num_events-1] are the
|
||||
valid events. */
|
||||
|
||||
char *pname; /* programme name for error messages */
|
||||
|
||||
/* Accepts a string of two fields seperated by FS.
|
||||
* First field is string for getdate, saying when to wake-up.
|
||||
* Second field is a token to identify the request.
|
||||
*/
|
||||
void schedule(str)
|
||||
char *str;
|
||||
{
|
||||
extern time_t getdate();
|
||||
extern char *strcpy();
|
||||
time_t now;
|
||||
register char *p;
|
||||
static struct event *ep;
|
||||
|
||||
#ifdef DEBUG
|
||||
(void) fprintf(stderr, "Timer sees: %s", str);
|
||||
#endif /* DEBUG */
|
||||
|
||||
/* check entry format */
|
||||
for(p = str; *p && *p != FS; p++)
|
||||
continue;
|
||||
if (!*p)
|
||||
{
|
||||
(void)fprintf(stderr, "%s: bad input format: %s", pname, str);
|
||||
return;
|
||||
}
|
||||
*p++ = 0;
|
||||
|
||||
/* allocate an event slot */
|
||||
for(ep = events; ep < events + MAXEVENTS; ep++)
|
||||
if (ep->token == (char *)NULL)
|
||||
break;
|
||||
if (ep == events + MAXEVENTS)
|
||||
(void) fprintf(stderr, "%s: too many events: %s", pname, str);
|
||||
|
||||
/* don't allow users to schedule events in past time */
|
||||
else if ((ep->reply_at = get_date(str, NULL)) - time(&now) < 0)
|
||||
(void)fprintf(stderr, "%s: bad time spec: %s%c%s", pname, str, FS, p);
|
||||
|
||||
/* save the event description */
|
||||
else if ((ep->token = malloc((unsigned)strlen(p) + 1)) == NULL)
|
||||
(void)fprintf(stderr, "%s: malloc %s: %s%c%s",
|
||||
pname, sys_errlist[errno], str, FS, p);
|
||||
else
|
||||
{
|
||||
(void)strcpy(ep->token, p);
|
||||
|
||||
#ifdef DEBUG
|
||||
(void) fprintf(stderr,
|
||||
"New event: %ld: %s", ep->reply_at, ep->token);
|
||||
#endif /* DEBUG */
|
||||
}
|
||||
}
|
||||
|
||||
First field is string for getdate, saying when to wake-up.
|
||||
Second field is a token to identify the request. */
|
||||
void
|
||||
notify()
|
||||
schedule (str)
|
||||
char *str;
|
||||
{
|
||||
time_t now, tdiff, waitfor = -1;
|
||||
register struct event *ep;
|
||||
extern time_t getdate ();
|
||||
extern char *strcpy ();
|
||||
time_t now;
|
||||
register char *p;
|
||||
static struct event *ep;
|
||||
|
||||
now = time((time_t *)NULL);
|
||||
/* check entry format */
|
||||
for (p = str; *p && *p != FS; p++)
|
||||
continue;
|
||||
if (!*p)
|
||||
{
|
||||
fprintf (stderr, "%s: bad input format: %s", pname, str);
|
||||
return;
|
||||
}
|
||||
*p++ = 0;
|
||||
|
||||
/* allocate an event slot */
|
||||
ep = events + num_events;
|
||||
|
||||
for(ep = events; ep < events + MAXEVENTS; ep++)
|
||||
if (ep->token)
|
||||
/* If the event array is full, stretch it. After stretching, we know
|
||||
that ep will be pointing to an available event spot. */
|
||||
if (ep == events + events_size)
|
||||
{
|
||||
int old_size = events_size;
|
||||
|
||||
events_size *= 2;
|
||||
events = ((struct event *)
|
||||
realloc (events, events_size * sizeof (struct event)));
|
||||
if (! events)
|
||||
{
|
||||
/* any events ready to fire? */
|
||||
if (ep->reply_at <= now)
|
||||
{
|
||||
#ifdef DEBUG
|
||||
(void) fprintf(stderr,
|
||||
"Event %d firing: %ld @ %s",
|
||||
(ep - events), ep->reply_at, ep->token);
|
||||
#endif /* DEBUG */
|
||||
(void)fputs(ep->token, stdout);
|
||||
free(ep->token);
|
||||
ep->token = (char *)NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef DEBUG
|
||||
(void) fprintf(stderr,
|
||||
"Event %d still waiting: %ld @ %s",
|
||||
(ep - events), ep->reply_at, ep->token);
|
||||
#endif /* DEBUG */
|
||||
fprintf (stderr, "%s: virtual memory exhausted.\n", pname);
|
||||
|
||||
/* next timeout should be the soonest of any remaining */
|
||||
if ((tdiff = ep->reply_at - now) < waitfor || waitfor < 0)
|
||||
waitfor = (long)tdiff;
|
||||
}
|
||||
/* Should timer exit now? Well, we've still got other
|
||||
events in the queue, and more memory might become
|
||||
available in the future, so we'll just toss this event.
|
||||
This will screw up whoever scheduled the event, but
|
||||
maybe someone else will survive. */
|
||||
return;
|
||||
}
|
||||
|
||||
/* If there's no more events, SIGIO should be next wake-up */
|
||||
if (waitfor != -1)
|
||||
{
|
||||
#ifdef DEBUG
|
||||
(void) fprintf(stderr,
|
||||
"Setting %d-second alarm\n", waitfor);
|
||||
#endif /* DEBUG */
|
||||
(void)alarm(waitfor);
|
||||
while (old_size < events_size)
|
||||
events[old_size++].token = NULL;
|
||||
}
|
||||
|
||||
/* Don't allow users to schedule events in past time. */
|
||||
ep->reply_at = get_date (str, NULL);
|
||||
if (ep->reply_at - time (&now) < 0)
|
||||
{
|
||||
fprintf (stderr, "%s: bad time spec: %s%c%s", pname, str, FS, p);
|
||||
return;
|
||||
}
|
||||
|
||||
/* save the event description */
|
||||
ep->token = (char *) malloc ((unsigned) strlen (p) + 1);
|
||||
if (! ep->token)
|
||||
{
|
||||
fprintf (stderr, "%s: malloc %s: %s%c%s",
|
||||
pname, sys_errlist[errno], str, FS, p);
|
||||
return;
|
||||
}
|
||||
|
||||
strcpy (ep->token, p);
|
||||
num_events++;
|
||||
}
|
||||
|
||||
void
|
||||
getevent()
|
||||
notify ()
|
||||
{
|
||||
extern char *fgets();
|
||||
struct event *ep;
|
||||
char buf[BUFSIZ];
|
||||
time_t now, tdiff, waitfor;
|
||||
register struct event *ep;
|
||||
|
||||
/* in principle the itimer should be disabled on entry to this function,
|
||||
but it really doesn't make any important difference if it isn't */
|
||||
now = time ((time_t *) NULL);
|
||||
|
||||
if (fgets(buf, sizeof(buf), stdin) == NULL)
|
||||
exit(0);
|
||||
for (ep = events; ep < events + num_events; ep++)
|
||||
/* Are any events ready to fire? */
|
||||
if (ep->reply_at <= now)
|
||||
{
|
||||
fputs (ep->token, stdout);
|
||||
free (ep->token);
|
||||
|
||||
/* register the event */
|
||||
schedule(buf);
|
||||
/* We now have a hole in the event array; fill it with the last
|
||||
event. */
|
||||
ep->token = events[num_events].token;
|
||||
ep->reply_at = events[num_events].reply_at;
|
||||
num_events--;
|
||||
|
||||
/* Who knows what this interrupted, or if it said "now"? */
|
||||
notify();
|
||||
/* We ought to scan this event again. */
|
||||
ep--;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* next timeout should be the soonest of any remaining */
|
||||
if ((tdiff = ep->reply_at - now) < waitfor || waitfor < 0)
|
||||
waitfor = (long)tdiff;
|
||||
}
|
||||
|
||||
/* If there are no more events, we needn't bother setting an alarm. */
|
||||
if (num_events > 0)
|
||||
alarm (waitfor);
|
||||
}
|
||||
|
||||
void
|
||||
sigcatch(sig)
|
||||
getevent ()
|
||||
{
|
||||
int i;
|
||||
char *buf;
|
||||
int buf_size;
|
||||
|
||||
/* In principle the itimer should be disabled on entry to this
|
||||
function, but it really doesn't make any important difference
|
||||
if it isn't. */
|
||||
|
||||
buf_size = 80;
|
||||
buf = (char *) malloc (buf_size);
|
||||
|
||||
/* Read a line from standard input, expanding buf if it is too short
|
||||
to hold the line. */
|
||||
for (i = 0; ; i++)
|
||||
{
|
||||
int c;
|
||||
|
||||
if (i >= buf_size)
|
||||
{
|
||||
buf_size *= 2;
|
||||
buf = (char *) realloc (buf, buf_size);
|
||||
|
||||
/* If we're out of memory, toss this event. */
|
||||
do
|
||||
{
|
||||
c = getchar ();
|
||||
}
|
||||
while (c != '\n' && c != EOF);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
c = getchar ();
|
||||
|
||||
if (c == EOF)
|
||||
exit (0);
|
||||
|
||||
if (c == '\n')
|
||||
{
|
||||
buf[i] = '\0';
|
||||
break;
|
||||
}
|
||||
|
||||
buf[i] = c;
|
||||
}
|
||||
|
||||
/* Register the event. */
|
||||
schedule (buf);
|
||||
free (buf);
|
||||
|
||||
/* Who knows what this interrupted, or if it said "now"? */
|
||||
notify ();
|
||||
}
|
||||
|
||||
void
|
||||
sigcatch (sig)
|
||||
int sig;
|
||||
/* dispatch on incoming signal, then restore it */
|
||||
{
|
||||
struct event *ep;
|
||||
struct event *ep;
|
||||
|
||||
switch(sig)
|
||||
switch (sig)
|
||||
{
|
||||
case SIGALRM:
|
||||
#ifdef DEBUG
|
||||
(void) fprintf(stderr, "Alarm signal received\n");
|
||||
#endif /* DEBUG */
|
||||
notify();
|
||||
break;
|
||||
notify ();
|
||||
break;
|
||||
case SIGIO:
|
||||
getevent();
|
||||
break;
|
||||
getevent ();
|
||||
break;
|
||||
case SIGTERM:
|
||||
(void) fprintf(stderr, "Events still queued:\n");
|
||||
for (ep = events; ep < events + MAXEVENTS; ep++)
|
||||
if (ep->token)
|
||||
(void) fprintf(stderr, "%d = %ld @ %s",
|
||||
ep - events, ep->reply_at, ep->token);
|
||||
exit(0);
|
||||
break;
|
||||
fprintf (stderr, "Events still queued:\n");
|
||||
for (ep = events; ep < events + num_events; ep++)
|
||||
fprintf (stderr, "%d = %ld @ %s",
|
||||
ep - events, ep->reply_at, ep->token);
|
||||
exit (0);
|
||||
break;
|
||||
}
|
||||
|
||||
/* required on older UNIXes; harmless on newer ones */
|
||||
(void) signal(sig, sigcatch);
|
||||
/* required on older UNIXes; harmless on newer ones */
|
||||
signal (sig, sigcatch);
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
int
|
||||
main(argc, argv)
|
||||
main (argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
for (pname = argv[0] + strlen(argv[0]); *pname != '/' && pname != argv[0];
|
||||
for (pname = argv[0] + strlen (argv[0]);
|
||||
*pname != '/' && pname != argv[0];
|
||||
pname--);
|
||||
if (*pname == '/') pname++;
|
||||
if (*pname == '/')
|
||||
pname++;
|
||||
|
||||
(void)signal(SIGIO, sigcatch);
|
||||
(void)signal(SIGALRM, sigcatch);
|
||||
(void)signal(SIGTERM, sigcatch);
|
||||
events_size = 16;
|
||||
events = ((struct event *) malloc (events_size * sizeof (*events)));
|
||||
num_events = 0;
|
||||
|
||||
signal (SIGIO, sigcatch);
|
||||
signal (SIGALRM, sigcatch);
|
||||
signal (SIGTERM, sigcatch);
|
||||
|
||||
#ifndef USG
|
||||
(void)fcntl(0, F_SETFL, FASYNC);
|
||||
fcntl (0, F_SETFL, FASYNC);
|
||||
#endif /* USG */
|
||||
|
||||
while (1) pause();
|
||||
while (1) pause ();
|
||||
}
|
||||
|
||||
/* timer.c ends here */
|
||||
|
|
|
|||
|
|
@ -328,40 +328,40 @@ latitude, time zone, and date.
|
|||
|
||||
This function is suitable for execution in a .emacs file."
|
||||
(interactive "p")
|
||||
(if (< arg 16)
|
||||
(if (not (and calendar-latitude calendar-longitude calendar-time-zone))
|
||||
(solar-setup)))
|
||||
(if (and (< arg 16)
|
||||
(not (and calendar-latitude calendar-longitude calendar-time-zone)))
|
||||
(solar-setup))
|
||||
(let* ((calendar-longitude
|
||||
(if (< arg 16)
|
||||
calendar-longitude
|
||||
(if (< arg 16) calendar-longitude
|
||||
(solar-get-number
|
||||
"Enter longitude (decimal fraction; + east, - west): ")))
|
||||
(calendar-latitude
|
||||
(if (< arg 16)
|
||||
calendar-latitude
|
||||
(if (< arg 16) calendar-latitude
|
||||
(solar-get-number
|
||||
"Enter latitude (decimal fraction; + north, - south): ")))
|
||||
(calendar-time-zone
|
||||
(if (< arg 16)
|
||||
calendar-time-zone
|
||||
(if (< arg 16) calendar-time-zone
|
||||
(solar-get-number
|
||||
"Enter difference from Universal Time (in minutes): ")))
|
||||
(calendar-location-name
|
||||
(let ((float-output-format "%.1f"))
|
||||
(format "%s%s, %s%s"
|
||||
(abs calendar-latitude)
|
||||
(if (> calendar-latitude 0) "N" "S")
|
||||
(abs calendar-longitude)
|
||||
(if (> calendar-longitude 0) "E" "W"))))
|
||||
(if (< arg 16) calendar-location-name
|
||||
(let ((float-output-format "%.1f"))
|
||||
(format "%s%s, %s%s"
|
||||
(abs calendar-latitude)
|
||||
(if (> calendar-latitude 0) "N" "S")
|
||||
(abs calendar-longitude)
|
||||
(if (> calendar-longitude 0) "E" "W")))))
|
||||
(calendar-standard-time-zone-name
|
||||
(cond ((= calendar-time-zone 0) "UT")
|
||||
((< calendar-time-zone 0) (format "UT%dmin" calendar-time-zone))
|
||||
(t (format "UT+%dmin" calendar-time-zone))))
|
||||
(calendar-daylight-savings-starts nil)
|
||||
(calendar-daylight-savings-ends nil)
|
||||
(date (if (< arg 4)
|
||||
(calendar-current-date)
|
||||
(calendar-read-date)))
|
||||
(if (< arg 16) calendar-standard-time-zone-name
|
||||
(cond ((= calendar-time-zone 0) "UT")
|
||||
((< calendar-time-zone 0)
|
||||
(format "UT%dmin" calendar-time-zone))
|
||||
(t (format "UT+%dmin" calendar-time-zone)))))
|
||||
(calendar-daylight-savings-starts
|
||||
(if (< arg 16) calendar-daylight-savings-starts))
|
||||
(calendar-daylight-savings-ends
|
||||
(if (< arg 16) calendar-daylight-savings-ends))
|
||||
(date (if (< arg 4) (calendar-current-date) (calendar-read-date)))
|
||||
(date-string (calendar-date-string date t))
|
||||
(time-string (solar-sunrise-sunset date))
|
||||
(msg (format "%s: %s" date-string time-string))
|
||||
|
|
|
|||
|
|
@ -179,7 +179,7 @@ to read a file name from the minibuffer."
|
|||
(insert-buffer-substring buf)
|
||||
(set-marker Info-tag-table-marker
|
||||
(match-end 0))))
|
||||
(set-marker Info-tag-table-marker pos))))
|
||||
(set-marker Info-tag-table-marker pos))))
|
||||
(setq Info-current-file
|
||||
(file-name-sans-versions buffer-file-name))))
|
||||
(if (equal nodename "*")
|
||||
|
|
|
|||
|
|
@ -198,6 +198,7 @@ before `hide-ifdef-mode' modifies it.")
|
|||
(cons '(hide-ifdef-mode " Ifdef")
|
||||
minor-mode-alist)))
|
||||
|
||||
;;;###autoload
|
||||
(defun hide-ifdef-mode (arg)
|
||||
"Toggle Hide-Ifdef mode. This is a minor mode, albeit a large one.
|
||||
With ARG, turn Hide-Ifdef mode on iff arg is positive.
|
||||
|
|
@ -845,6 +846,7 @@ to redo on a recursive entry."
|
|||
|
||||
;===%%SF%% exports (Start) ===
|
||||
|
||||
;;;###autoload
|
||||
(defvar hide-ifdef-initially nil
|
||||
"*Non-nil if `hide-ifdefs' should be called when Hide-Ifdef mode
|
||||
is first activated.")
|
||||
|
|
@ -852,12 +854,14 @@ is first activated.")
|
|||
(defvar hide-ifdef-hiding nil
|
||||
"Non-nil if text might be hidden.")
|
||||
|
||||
;;;###autoload
|
||||
(defvar hide-ifdef-read-only nil
|
||||
"*Set to non-nil if you want buffer to be read-only while hiding text.")
|
||||
|
||||
(defvar hif-outside-read-only nil
|
||||
"Internal variable. Saves the value of `buffer-read-only' while hiding.")
|
||||
|
||||
;;;###autoload
|
||||
(defvar hide-ifdef-lines nil
|
||||
"*Set to t if you don't want to see the #ifX, #else, and #endif lines.")
|
||||
|
||||
|
|
|
|||
33
lisp/sort.el
33
lisp/sort.el
|
|
@ -29,9 +29,10 @@
|
|||
Arguments are REVERSE NEXTRECFUN ENDRECFUN &optional STARTKEYFUN ENDKEYFUN.
|
||||
|
||||
We divide the accessible portion of the buffer into disjoint pieces
|
||||
called sort records. A portion of each sort record (perhaps all of it)
|
||||
is designated as the sort key. The records are rearranged in the buffer
|
||||
in order by their sort keys. The records may or may not be contiguous.
|
||||
called sort records. A portion of each sort record (perhaps all of
|
||||
it) is designated as the sort key. The records are rearranged in the
|
||||
buffer in order by their sort keys. The records may or may not be
|
||||
contiguous.
|
||||
|
||||
Usually the records are rearranged in order of ascending sort key.
|
||||
If REVERSE is non-nil, they are rearranged in order of descending sort key.
|
||||
|
|
@ -78,19 +79,19 @@ same as ENDRECFUN."
|
|||
'buffer-substring-lessp)
|
||||
(t
|
||||
'string<)))
|
||||
(sort sort-lists
|
||||
(cond ((numberp (car (car sort-lists)))
|
||||
(function
|
||||
(lambda (a b)
|
||||
(< (car a) (car b)))))
|
||||
((consp (car (car sort-lists)))
|
||||
(function
|
||||
(lambda (a b)
|
||||
(buffer-substring-lessp (car a) (car b)))))
|
||||
(t
|
||||
(function
|
||||
(lambda (a b)
|
||||
(string< (car a) (car b)))))))))
|
||||
(sort sort-lists
|
||||
(cond ((numberp (car (car sort-lists)))
|
||||
(function
|
||||
(lambda (a b)
|
||||
(< (car a) (car b)))))
|
||||
((consp (car (car sort-lists)))
|
||||
(function
|
||||
(lambda (a b)
|
||||
(buffer-substring-lessp (car a) (car b)))))
|
||||
(t
|
||||
(function
|
||||
(lambda (a b)
|
||||
(string< (car a) (car b)))))))))
|
||||
(if reverse (setq sort-lists (nreverse sort-lists)))
|
||||
(if messages (message "Reordering buffer..."))
|
||||
(sort-reorder-buffer sort-lists old)))
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ the call to the function."
|
|||
(continue-process timer-process)))
|
||||
;; There should be a living, breathing timer process now
|
||||
(let ((token (concat (current-time-string) "-" (length timer-alist))))
|
||||
(send-string timer-process (concat time "\001" token "\n"))
|
||||
(send-string timer-process (concat time "@" token "\n"))
|
||||
(setq timer-alist (cons (list token repeat function args) timer-alist))))
|
||||
|
||||
(defun timer-process-filter (proc str)
|
||||
|
|
@ -63,9 +63,9 @@ the call to the function."
|
|||
(cond
|
||||
(do (apply (nth 2 do) (nth 3 do)) ; do it
|
||||
(if (natnump (nth 1 do)) ; reschedule it
|
||||
(send-string proc (concat (nth 1 do) " sec\001" (car do) "\n"))
|
||||
(send-string proc (concat (nth 1 do) " sec@" (car do) "\n"))
|
||||
(setq timer-alist (delq do timer-alist))))
|
||||
((string-match "timer: \\([^:]+\\): \\([^\001]*\\)\001\\(.*\\)$" token)
|
||||
((string-match "timer: \\([^:]+\\): \\([^@]*\\)@\\(.*\\)$" token)
|
||||
(setq error (substring token (match-beginning 1) (match-end 1))
|
||||
do (substring token (match-beginning 2) (match-end 2))
|
||||
token (assoc (substring token (match-beginning 3) (match-end 3))
|
||||
|
|
|
|||
13
src/buffer.h
13
src/buffer.h
|
|
@ -1,11 +1,11 @@
|
|||
/* Header file for the buffer manipulation primitives.
|
||||
Copyright (C) 1985, 1986, 1990 Free Software Foundation, Inc.
|
||||
Copyright (C) 1985, 1986, 1990, 1992 Free Software Foundation, Inc.
|
||||
|
||||
This file is part of GNU Emacs.
|
||||
|
||||
GNU Emacs 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 1, or (at your option)
|
||||
the Free Software Foundation; either version 2, or (at your option)
|
||||
any later version.
|
||||
|
||||
GNU Emacs is distributed in the hope that it will be useful,
|
||||
|
|
@ -296,6 +296,15 @@ extern struct buffer buffer_local_flags;
|
|||
|
||||
extern struct buffer buffer_local_symbols;
|
||||
|
||||
/* This structure holds the required types for the values in the
|
||||
buffer-local slots. If a slot contains Qnil, then the
|
||||
corresponding buffer slot may contain a value of any type. If a
|
||||
slot contains an integer, then prospective values' tags must be
|
||||
equal to that integer. When a tag does not match, the function
|
||||
buffer_slot_type_mismatch will signal an error. The value Qnil may
|
||||
always be safely stored in any slot. */
|
||||
struct buffer buffer_local_types;
|
||||
|
||||
/* Point in the current buffer. */
|
||||
|
||||
#define point (current_buffer->text.pt + 0)
|
||||
|
|
|
|||
12
src/frame.h
12
src/frame.h
|
|
@ -73,7 +73,7 @@ struct frame
|
|||
/* New height and width for pending size change. 0 if no change pending. */
|
||||
int new_height, new_width;
|
||||
|
||||
/* Name of this frame: a Lisp string. */
|
||||
/* Name of this frame: a Lisp string. See also `explicit_name'. */
|
||||
Lisp_Object name;
|
||||
|
||||
/* The frame which should recieve keystrokes that occur in this
|
||||
|
|
@ -143,6 +143,12 @@ struct frame
|
|||
/* True if frame's root window can't be split. */
|
||||
char no_split;
|
||||
|
||||
/* If this is set, then Emacs won't change the frame name to indicate
|
||||
the current buffer, etcetera. If the user explicitly sets the frame
|
||||
name, this gets set. If the user sets the name to Qnil, this is
|
||||
cleared. */
|
||||
char explicit_name;
|
||||
|
||||
/* Storage for messages to this frame. */
|
||||
char *message_buf;
|
||||
|
||||
|
|
@ -285,8 +291,8 @@ extern int message_buf_print;
|
|||
#define FRAME_NO_SPLIT_P(f) 0
|
||||
#define FRAME_WANTS_MODELINE_P(f) 1
|
||||
#define FRAME_ICONIFIED_P(f) 0
|
||||
#define FRAME_MINIBUF_WINDOW(f) (minibuf_window)
|
||||
#define FRAME_ROOT_WINDOW(f) (XWINDOW (minibuf_window)->prev)
|
||||
#define FRAME_MINIBUF_WINDOW(f) (the_only_frame.root_window)
|
||||
#define FRAME_ROOT_WINDOW(f) (the_only_frame.root_window)
|
||||
#define FRAME_SELECTED_WINDOW(f) (selected_window)
|
||||
#define SET_GLYPHS_FRAME(glyphs,frame) do ; while (0)
|
||||
#define FRAME_INSERT_COST(frame) (the_only_frame.insert_line_cost)
|
||||
|
|
|
|||
16
src/window.h
16
src/window.h
|
|
@ -63,11 +63,12 @@ initially the root window is a leaf window, but if more windows
|
|||
are created then that leaf window ceases to be root and a newly
|
||||
made combination window becomes root instead.
|
||||
|
||||
In any case, prev of the minibuf window is the root window and
|
||||
next of the root window is the minibuf window. To find the
|
||||
root window at any time, do XWINDOW (minibuf_window)->prev.
|
||||
In any case, on screens which have an ordinary window and a
|
||||
minibuffer, prev of the minibuf window is the root window and next of
|
||||
the root window is the minibuf window. On minibufferless screens or
|
||||
minibuffer-only screens, the root window and the minibuffer window are
|
||||
one and the same, so its prev and next members are nil. */
|
||||
|
||||
*/
|
||||
|
||||
struct window
|
||||
{
|
||||
|
|
@ -174,8 +175,7 @@ extern int window_select_count;
|
|||
|
||||
/* The minibuffer window of the selected frame.
|
||||
Note that you cannot test for minibufferness of an arbitrary window
|
||||
by comparing against this; but you can test for minibufferness of
|
||||
the selected window or of any window that is displayed. */
|
||||
by comparing against this; use the MINI_WINDOW_P macro instead. */
|
||||
|
||||
extern Lisp_Object minibuf_window;
|
||||
|
||||
|
|
@ -247,3 +247,7 @@ extern int windows_or_buffers_changed;
|
|||
/* Number of windows displaying the selected buffer.
|
||||
Normally this is 1, but it can be more. */
|
||||
extern int buffer_shared;
|
||||
|
||||
/* If *ROWS or *COLS are too small a size for FRAME, set them to the
|
||||
minimum allowable size. */
|
||||
extern void check_frame_size ( /* FRAME_PTR frame, int *rows, int *cols */ );
|
||||
|
|
|
|||
Loading…
Reference in a new issue