/* Lisp functions pertaining to editing.
- Copyright (C) 1985, 1986, 1987, 1989, 1993 Free Software Foundation, Inc.
+ Copyright (C) 1985,86,87,89,93,94 Free Software Foundation, Inc.
This file is part of GNU Emacs.
Lisp_Object tem;
/* Set up system_name even when dumping. */
-
- Vsystem_name = build_string (get_system_name ());
- p = XSTRING (Vsystem_name)->data;
- while (*p)
- {
- if (*p == ' ' || *p == '\t')
- *p = '-';
- p++;
- }
+ init_system_name ();
#ifndef CANNOT_DUMP
/* Don't bother with this on initial start when just dumping out */
#endif /* not CANNOT_DUMP */
pw = (struct passwd *) getpwuid (getuid ());
+#ifdef MSDOS
+ /* We let the real user name default to "root" because that's quite
+ accurate on MSDOG and because it lets Emacs find the init file.
+ (The DVX libraries override the Djgpp libraries here.) */
+ Vuser_real_name = build_string (pw ? pw->pw_name : "root");
+#else
Vuser_real_name = build_string (pw ? pw->pw_name : "unknown");
+#endif
/* Get the effective user name, by consulting environment variables,
or the effective uid if those are unset. */
p = XSTRING (str);
if (p->size)
- XFASTINT (val) = ((unsigned char *) p->data)[0];
+ XSETFASTINT (val, ((unsigned char *) p->data)[0]);
else
- XFASTINT (val) = 0;
+ XSETFASTINT (val, 0);
return val;
}
\f
()
{
Lisp_Object temp;
- XFASTINT (temp) = point;
+ XSETFASTINT (temp, point);
return temp;
}
save_excursion_restore (info)
register Lisp_Object info;
{
- register Lisp_Object tem, tem1;
+ register Lisp_Object tem, tem1, omark, nmark;
tem = Fmarker_buffer (Fcar (info));
/* If buffer being returned to is now deleted, avoid error */
Fgoto_char (tem);
unchain_marker (tem);
tem = Fcar (Fcdr (info));
+ omark = Fmarker_position (current_buffer->mark);
Fset_marker (current_buffer->mark, tem, Fcurrent_buffer ());
+ nmark = Fmarker_position (tem);
unchain_marker (tem);
tem = Fcdr (Fcdr (info));
#if 0 /* We used to make the current buffer visible in the selected window
current_buffer->mark_active = Fcdr (tem);
if (!NILP (Vrun_hooks))
{
+ /* If mark is active now, and either was not active
+ or was at a different place, run the activate hook. */
if (! NILP (current_buffer->mark_active))
- call1 (Vrun_hooks, intern ("activate-mark-hook"));
+ {
+ if (! EQ (omark, nmark))
+ call1 (Vrun_hooks, intern ("activate-mark-hook"));
+ }
+ /* If mark has ceased to be active, run deactivate hook. */
else if (! NILP (tem1))
call1 (Vrun_hooks, intern ("deactivate-mark-hook"));
}
()
{
Lisp_Object temp;
- XFASTINT (temp) = Z - BEG;
+ XSETFASTINT (temp, Z - BEG);
return temp;
}
()
{
Lisp_Object temp;
- XFASTINT (temp) = BEGV;
+ XSETFASTINT (temp, BEGV);
return temp;
}
()
{
Lisp_Object temp;
- XFASTINT (temp) = ZV;
+ XSETFASTINT (temp, ZV);
return temp;
}
{
Lisp_Object temp;
if (point >= ZV)
- XFASTINT (temp) = 0;
+ XSETFASTINT (temp, 0);
else
- XFASTINT (temp) = FETCH_CHAR (point);
+ XSETFASTINT (temp, FETCH_CHAR (point));
return temp;
}
{
Lisp_Object temp;
if (point <= BEGV)
- XFASTINT (temp) = 0;
+ XSETFASTINT (temp, 0);
else
- XFASTINT (temp) = FETCH_CHAR (point - 1);
+ XSETFASTINT (temp, FETCH_CHAR (point - 1));
return temp;
}
n = XINT (pos);
if (n < BEGV || n >= ZV) return Qnil;
- XFASTINT (val) = FETCH_CHAR (n);
+ XSETFASTINT (val, FETCH_CHAR (n));
return val;
}
\f
-DEFUN ("user-login-name", Fuser_login_name, Suser_login_name, 0, 0, 0,
+DEFUN ("user-login-name", Fuser_login_name, Suser_login_name, 0, 1, 0,
"Return the name under which the user logged in, as a string.\n\
This is based on the effective uid, not the real uid.\n\
Also, if the environment variable LOGNAME or USER is set,\n\
-that determines the value of this function.")
- ()
+that determines the value of this function.\n\n\
+If optional argument UID is an integer, return the login name of the user\n\
+with that uid, or nil if there is no such user.")
+ (uid)
+ Lisp_Object uid;
{
- return Vuser_name;
+ struct passwd *pw;
+
+ /* Set up the user name info if we didn't do it before.
+ (That can happen if Emacs is dumpable
+ but you decide to run `temacs -l loadup' and not dump. */
+ if (INTEGERP (Vuser_name))
+ init_editfns ();
+
+ if (NILP (uid))
+ return Vuser_name;
+
+ CHECK_NUMBER (uid, 0);
+ pw = (struct passwd *) getpwuid (XINT (uid));
+ return (pw ? build_string (pw->pw_name) : Qnil);
}
DEFUN ("user-real-login-name", Fuser_real_login_name, Suser_real_login_name,
0, 0, 0,
"Return the name of the user's real uid, as a string.\n\
-This ignores the environment variables LOGNAME and USER, so it differs from
+This ignores the environment variables LOGNAME and USER, so it differs from\n\
`user-login-name' when running under `su'.")
()
{
+ /* Set up the user name info if we didn't do it before.
+ (That can happen if Emacs is dumpable
+ but you decide to run `temacs -l loadup' and not dump. */
+ if (INTEGERP (Vuser_name))
+ init_editfns ();
return Vuser_real_name;
}
return Vsystem_name;
}
+/* For the benefit of callers who don't want to include lisp.h */
+char *
+get_system_name ()
+{
+ return (char *) XSTRING (Vsystem_name)->data;
+}
+
DEFUN ("emacs-pid", Femacs_pid, Semacs_pid, 0, 0, 0,
"Return the process ID of Emacs, as an integer.")
()
Lisp_Object result[3];
EMACS_GET_TIME (t);
- XSET (result[0], Lisp_Int, (EMACS_SECS (t) >> 16) & 0xffff);
- XSET (result[1], Lisp_Int, (EMACS_SECS (t) >> 0) & 0xffff);
- XSET (result[2], Lisp_Int, EMACS_USECS (t));
+ XSETINT (result[0], (EMACS_SECS (t) >> 16) & 0xffff);
+ XSETINT (result[1], (EMACS_SECS (t) >> 0) & 0xffff);
+ XSETINT (result[2], EMACS_USECS (t));
return Flist (3, result);
}
high = Fcar (specified_time);
CHECK_NUMBER (high, 0);
low = Fcdr (specified_time);
- if (XTYPE (low) == Lisp_Cons)
+ if (CONSP (low))
low = Fcar (low);
CHECK_NUMBER (low, 0);
*result = (XINT (high) << 16) + (XINT (low) & 0xffff);
}
}
+DEFUN ("format-time-string", Fformat_time_string, Sformat_time_string, 2, 2, 0,
+ "Use FORMAT-STRING to format the time TIME.\n\
+TIME is specified as (HIGH LOW . IGNORED) or (HIGH . LOW), as from\n\
+`current-time' and `file-attributes'.\n\
+FORMAT-STRING may contain %-sequences to substitute parts of the time.\n\
+%a is replaced by the abbreviated name of the day of week.\n\
+%A is replaced by the full name of the day of week.\n\
+%b is replaced by the abbreviated name of the month.\n\
+%B is replaced by the full name of the month.\n\
+%c is a synonym for \"%x %X\".\n\
+%C is a locale-specific synonym, which defaults to \"%A, %B %e, %Y\" in the C locale.\n\
+%d is replaced by the day of month, zero-padded.\n\
+%D is a synonym for \"%m/%d/%y\".\n\
+%e is replaced by the day of month, blank-padded.\n\
+%h is a synonym for \"%b\".\n\
+%H is replaced by the hour (00-23).\n\
+%I is replaced by the hour (00-12).\n\
+%j is replaced by the day of the year (001-366).\n\
+%k is replaced by the hour (0-23), blank padded.\n\
+%l is replaced by the hour (1-12), blank padded.\n\
+%m is replaced by the month (01-12).\n\
+%M is replaced by the minut (00-59).\n\
+%n is a synonym for \"\\n\".\n\
+%p is replaced by AM or PM, as appropriate.\n\
+%r is a synonym for \"%I:%M:%S %p\".\n\
+%R is a synonym for \"%H:%M\".\n\
+%S is replaced by the seconds (00-60).\n\
+%t is a synonym for \"\\t\".\n\
+%T is a synonym for \"%H:%M:%S\".\n\
+%U is replaced by the week of the year (01-52), first day of week is Sunday.\n\
+%w is replaced by the day of week (0-6), Sunday is day 0.\n\
+%W is replaced by the week of the year (01-52), first day of week is Monday.\n\
+%x is a locale-specific synonym, which defaults to \"%D\" in the C locale.\n\
+%X is a locale-specific synonym, which defaults to \"%T\" in the C locale.\n\
+%y is replaced by the year without century (00-99).\n\
+%Y is replaced by the year with century.\n\
+%Z is replaced by the time zone abbreviation.\n\
+\n\
+The number of options reflects the strftime(3) function.")
+ (format_string, time)
+ Lisp_Object format_string, time;
+{
+ time_t value;
+ int size;
+
+ CHECK_STRING (format_string, 1);
+
+ if (! lisp_time_argument (time, &value))
+ error ("Invalid time specification");
+
+ /* This is probably enough. */
+ size = XSTRING (format_string)->size * 6 + 50;
+
+ while (1)
+ {
+ char *buf = (char *) alloca (size);
+ if (strftime (buf, size, XSTRING (format_string)->data,
+ localtime (&value)))
+ return build_string (buf);
+ /* If buffer was too small, make it bigger. */
+ size *= 2;
+ }
+}
+
DEFUN ("current-time-string", Fcurrent_time_string, Scurrent_time_string, 0, 1, 0,
"Return the current time, as a human-readable string.\n\
Programs can use this function to decode a time,\n\
int ay = a->tm_year + (TM_YEAR_ORIGIN - 1);
int by = b->tm_year + (TM_YEAR_ORIGIN - 1);
/* Some compilers can't handle this as a single return statement. */
- int days = (
+ long days = (
/* difference in day of year */
a->tm_yday - b->tm_yday
/* + intervening leap days */
s = 0;
#ifdef HAVE_TM_ZONE
if (t->tm_zone)
- s = t->tm_zone;
+ s = (char *)t->tm_zone;
#else /* not HAVE_TM_ZONE */
#ifdef HAVE_TZNAME
if (t->tm_isdst == 0 || t->tm_isdst == 1)
{
tem = args[argnum];
retry:
- if (XTYPE (tem) == Lisp_Int)
+ if (INTEGERP (tem))
{
str[0] = XINT (tem);
insert (str, 1);
}
- else if (XTYPE (tem) == Lisp_String)
+ else if (STRINGP (tem))
{
insert_from_string (tem, 0, XSTRING (tem)->size, 0);
}
{
tem = args[argnum];
retry:
- if (XTYPE (tem) == Lisp_Int)
+ if (INTEGERP (tem))
{
str[0] = XINT (tem);
- insert (str, 1);
+ insert_and_inherit (str, 1);
}
- else if (XTYPE (tem) == Lisp_String)
+ else if (STRINGP (tem))
{
insert_from_string (tem, 0, XSTRING (tem)->size, 1);
}
{
tem = args[argnum];
retry:
- if (XTYPE (tem) == Lisp_Int)
+ if (INTEGERP (tem))
{
str[0] = XINT (tem);
insert_before_markers (str, 1);
}
- else if (XTYPE (tem) == Lisp_String)
+ else if (STRINGP (tem))
{
insert_from_string_before_markers (tem, 0, XSTRING (tem)->size, 0);
}
{
tem = args[argnum];
retry:
- if (XTYPE (tem) == Lisp_Int)
+ if (INTEGERP (tem))
{
str[0] = XINT (tem);
- insert_before_markers (str, 1);
+ insert_before_markers_and_inherit (str, 1);
}
- else if (XTYPE (tem) == Lisp_String)
+ else if (STRINGP (tem))
{
insert_from_string_before_markers (tem, 0, XSTRING (tem)->size, 1);
}
return Qnil;
}
\f
-DEFUN ("insert-char", Finsert_char, Sinsert_char, 2, 2, 0,
+DEFUN ("insert-char", Finsert_char, Sinsert_char, 2, 3, 0,
"Insert COUNT (second arg) copies of CHAR (first arg).\n\
Point and all markers are affected as in the function `insert'.\n\
-Both arguments are required.")
- (chr, count)
- Lisp_Object chr, count;
+Both arguments are required.\n\
+The optional third arg INHERIT, if non-nil, says to inherit text properties\n\
+from adjoining text, if those properties are sticky.")
+ (chr, count, inherit)
+ Lisp_Object chr, count, inherit;
{
register unsigned char *string;
register int strlen;
string[i] = XFASTINT (chr);
while (n >= strlen)
{
- insert (string, strlen);
+ if (!NILP (inherit))
+ insert_and_inherit (string, strlen);
+ else
+ insert (string, strlen);
n -= strlen;
}
if (n > 0)
}
}
- XFASTINT (z) = cnt;
+ XSETFASTINT (z, cnt);
return (z);
}
(b, e)
register Lisp_Object b, e;
{
- register int i;
+ register EMACS_INT i;
CHECK_NUMBER_COERCE_MARKER (b, 0);
CHECK_NUMBER_COERCE_MARKER (e, 1);
{
i = XFASTINT (b);
b = e;
- XFASTINT (e) = i;
+ XSETFASTINT (e, i);
}
if (!(BEG <= XINT (b) && XINT (b) <= XINT (e) && XINT (e) <= Z))
/* Note: I tried using markers here, but it does not win
because insertion at the end of the saved region
does not advance mh and is considered "outside" the saved region. */
- XFASTINT (bottom) = BEGV - BEG;
- XFASTINT (top) = Z - ZV;
+ XSETFASTINT (bottom, BEGV - BEG);
+ XSETFASTINT (top, Z - ZV);
return Fcons (Fcurrent_buffer (), Fcons (bottom, top));
}
}
}
+DEFUN ("message-box", Fmessage_box, Smessage_box, 1, MANY, 0,
+ "Display a message, in a dialog box if possible.\n\
+If a dialog box is not available, use the echo area.\n\
+The first argument is a control string.\n\
+It may contain %s or %d or %c to print successive following arguments.\n\
+%s means print an argument as a string, %d means print as number in decimal,\n\
+%c means print a number as a single character.\n\
+The argument used by %s must be a string or a symbol;\n\
+the argument used by %d or %c must be a number.\n\
+If the first argument is nil, clear any existing message; let the\n\
+minibuffer contents show.")
+ (nargs, args)
+ int nargs;
+ Lisp_Object *args;
+{
+ if (NILP (args[0]))
+ {
+ message (0);
+ return Qnil;
+ }
+ else
+ {
+ register Lisp_Object val;
+ val = Fformat (nargs, args);
+#ifdef HAVE_X_MENU
+ {
+ Lisp_Object pane, menu, obj;
+ struct gcpro gcpro1;
+ pane = Fcons (Fcons (build_string ("OK"), Qt), Qnil);
+ GCPRO1 (pane);
+ menu = Fcons (val, pane);
+ obj = Fx_popup_dialog (Qt, menu);
+ UNGCPRO;
+ return val;
+ }
+#else
+ /* Copy the data so that it won't move when we GC. */
+ if (! message_text)
+ {
+ message_text = (char *)xmalloc (80);
+ message_length = 80;
+ }
+ if (XSTRING (val)->size > message_length)
+ {
+ message_length = XSTRING (val)->size;
+ message_text = (char *)xrealloc (message_text, message_length);
+ }
+ bcopy (XSTRING (val)->data, message_text, XSTRING (val)->size);
+ message2 (message_text, XSTRING (val)->size);
+ return val;
+#endif
+ }
+}
+#ifdef HAVE_X_MENU
+extern Lisp_Object last_nonmenu_event;
+#endif
+DEFUN ("message-or-box", Fmessage_or_box, Smessage_or_box, 1, MANY, 0,
+ "Display a message in a dialog box or in the echo area.\n\
+If this command was invoked with the mouse, use a dialog box.\n\
+Otherwise, use the echo area.\n\
+\n\
+The first argument is a control string.\n\
+It may contain %s or %d or %c to print successive following arguments.\n\
+%s means print an argument as a string, %d means print as number in decimal,\n\
+%c means print a number as a single character.\n\
+The argument used by %s must be a string or a symbol;\n\
+the argument used by %d or %c must be a number.\n\
+If the first argument is nil, clear any existing message; let the\n\
+minibuffer contents show.")
+ (nargs, args)
+ int nargs;
+ Lisp_Object *args;
+{
+#ifdef HAVE_X_MENU
+ if (NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
+ return Fmessage_box (nargs, args);
+#endif
+ return Fmessage (nargs, args);
+}
+
DEFUN ("format", Fformat, Sformat, 1, MANY, 0,
"Format a string out of a control-string and arguments.\n\
The first argument is a control string.\n\
args[n] = tem;
goto string;
}
- else if (XTYPE (args[n]) == Lisp_Symbol)
+ else if (SYMBOLP (args[n]))
{
- XSET (args[n], Lisp_String, XSYMBOL (args[n])->name);
+ XSETSTRING (args[n], XSYMBOL (args[n])->name);
goto string;
}
- else if (XTYPE (args[n]) == Lisp_String)
+ else if (STRINGP (args[n]))
{
string:
if (*format != 's' && *format != 'S')
total += XSTRING (args[n])->size;
}
/* Would get MPV otherwise, since Lisp_Int's `point' to low memory. */
- else if (XTYPE (args[n]) == Lisp_Int && *format != 's')
+ else if (INTEGERP (args[n]) && *format != 's')
{
#ifdef LISP_FLOAT_TYPE
/* The following loop assumes the Lisp type indicates
total += 10;
}
#ifdef LISP_FLOAT_TYPE
- else if (XTYPE (args[n]) == Lisp_Float && *format != 's')
+ else if (FLOATP (args[n]) && *format != 's')
{
if (! (*format == 'e' || *format == 'f' || *format == 'g'))
args[n] = Ftruncate (args[n]);
{
if (n >= nargs)
strings[i++] = (unsigned char *) "";
- else if (XTYPE (args[n]) == Lisp_Int)
+ else if (INTEGERP (args[n]))
/* We checked above that the corresponding format effector
isn't %s, which would cause MPV. */
strings[i++] = (unsigned char *) XINT (args[n]);
#ifdef LISP_FLOAT_TYPE
- else if (XTYPE (args[n]) == Lisp_Float)
+ else if (FLOATP (args[n]))
{
union { double d; int half[2]; } u;
Lisp_Object
#ifdef NO_ARG_ARRAY
format1 (string1, arg0, arg1, arg2, arg3, arg4)
- int arg0, arg1, arg2, arg3, arg4;
+ EMACS_INT arg0, arg1, arg2, arg3, arg4;
#else
format1 (string1)
#endif
{
char buf[100];
#ifdef NO_ARG_ARRAY
- int args[5];
+ EMACS_INT args[5];
args[0] = arg0;
args[1] = arg1;
args[2] = arg2;
return Qt;
return Qnil;
}
+\f
+/* Transpose the markers in two regions of the current buffer, and
+ adjust the ones between them if necessary (i.e.: if the regions
+ differ in size).
+
+ Traverses the entire marker list of the buffer to do so, adding an
+ appropriate amount to some, subtracting from some, and leaving the
+ rest untouched. Most of this is copied from adjust_markers in insdel.c.
+
+ It's the caller's job to see that (start1 <= end1 <= start2 <= end2). */
+
+void
+transpose_markers (start1, end1, start2, end2)
+ register int start1, end1, start2, end2;
+{
+ register int amt1, amt2, diff, mpos;
+ register Lisp_Object marker;
+
+ /* Update point as if it were a marker. */
+ if (PT < start1)
+ ;
+ else if (PT < end1)
+ TEMP_SET_PT (PT + (end2 - end1));
+ else if (PT < start2)
+ TEMP_SET_PT (PT + (end2 - start2) - (end1 - start1));
+ else if (PT < end2)
+ TEMP_SET_PT (PT - (start2 - start1));
+
+ /* We used to adjust the endpoints here to account for the gap, but that
+ isn't good enough. Even if we assume the caller has tried to move the
+ gap out of our way, it might still be at start1 exactly, for example;
+ and that places it `inside' the interval, for our purposes. The amount
+ of adjustment is nontrivial if there's a `denormalized' marker whose
+ position is between GPT and GPT + GAP_SIZE, so it's simpler to leave
+ the dirty work to Fmarker_position, below. */
+
+ /* The difference between the region's lengths */
+ diff = (end2 - start2) - (end1 - start1);
+
+ /* For shifting each marker in a region by the length of the other
+ * region plus the distance between the regions.
+ */
+ amt1 = (end2 - start2) + (start2 - end1);
+ amt2 = (end1 - start1) + (start2 - end1);
+
+ for (marker = current_buffer->markers; !NILP (marker);
+ marker = XMARKER (marker)->chain)
+ {
+ mpos = Fmarker_position (marker);
+ if (mpos >= start1 && mpos < end2)
+ {
+ if (mpos < end1)
+ mpos += amt1;
+ else if (mpos < start2)
+ mpos += diff;
+ else
+ mpos -= amt2;
+ if (mpos > GPT) mpos += GAP_SIZE;
+ XMARKER (marker)->bufpos = mpos;
+ }
+ }
+}
+
+DEFUN ("transpose-regions", Ftranspose_regions, Stranspose_regions, 4, 5, 0,
+ "Transpose region START1 to END1 with START2 to END2.\n\
+The regions may not be overlapping, because the size of the buffer is\n\
+never changed in a transposition.\n\
+\n\
+Optional fifth arg LEAVE_MARKERS, if non-nil, means don't transpose\n\
+any markers that happen to be located in the regions.\n\
+\n\
+Transposing beyond buffer boundaries is an error.")
+ (startr1, endr1, startr2, endr2, leave_markers)
+ Lisp_Object startr1, endr1, startr2, endr2, leave_markers;
+{
+ register int start1, end1, start2, end2,
+ gap, len1, len_mid, len2;
+ unsigned char *start1_addr, *start2_addr, *temp;
+
+#ifdef USE_TEXT_PROPERTIES
+ INTERVAL cur_intv, tmp_interval1, tmp_interval_mid, tmp_interval2;
+ cur_intv = current_buffer->intervals;
+#endif /* USE_TEXT_PROPERTIES */
+
+ validate_region (&startr1, &endr1);
+ validate_region (&startr2, &endr2);
+
+ start1 = XFASTINT (startr1);
+ end1 = XFASTINT (endr1);
+ start2 = XFASTINT (startr2);
+ end2 = XFASTINT (endr2);
+ gap = GPT;
+
+ /* Swap the regions if they're reversed. */
+ if (start2 < end1)
+ {
+ register int glumph = start1;
+ start1 = start2;
+ start2 = glumph;
+ glumph = end1;
+ end1 = end2;
+ end2 = glumph;
+ }
+
+ len1 = end1 - start1;
+ len2 = end2 - start2;
+
+ if (start2 < end1)
+ error ("transposed regions not properly ordered");
+ else if (start1 == end1 || start2 == end2)
+ error ("transposed region may not be of length 0");
+
+ /* The possibilities are:
+ 1. Adjacent (contiguous) regions, or separate but equal regions
+ (no, really equal, in this case!), or
+ 2. Separate regions of unequal size.
+
+ The worst case is usually No. 2. It means that (aside from
+ potential need for getting the gap out of the way), there also
+ needs to be a shifting of the text between the two regions. So
+ if they are spread far apart, we are that much slower... sigh. */
+
+ /* It must be pointed out that the really studly thing to do would
+ be not to move the gap at all, but to leave it in place and work
+ around it if necessary. This would be extremely efficient,
+ especially considering that people are likely to do
+ transpositions near where they are working interactively, which
+ is exactly where the gap would be found. However, such code
+ would be much harder to write and to read. So, if you are
+ reading this comment and are feeling squirrely, by all means have
+ a go! I just didn't feel like doing it, so I will simply move
+ the gap the minimum distance to get it out of the way, and then
+ deal with an unbroken array. */
+
+ /* Make sure the gap won't interfere, by moving it out of the text
+ we will operate on. */
+ if (start1 < gap && gap < end2)
+ {
+ if (gap - start1 < end2 - gap)
+ move_gap (start1);
+ else
+ move_gap (end2);
+ }
+
+ /* Hmmm... how about checking to see if the gap is large
+ enough to use as the temporary storage? That would avoid an
+ allocation... interesting. Later, don't fool with it now. */
+
+ /* Working without memmove, for portability (sigh), so must be
+ careful of overlapping subsections of the array... */
+
+ if (end1 == start2) /* adjacent regions */
+ {
+ modify_region (current_buffer, start1, end2);
+ record_change (start1, len1 + len2);
+
+#ifdef USE_TEXT_PROPERTIES
+ tmp_interval1 = copy_intervals (cur_intv, start1, len1);
+ tmp_interval2 = copy_intervals (cur_intv, start2, len2);
+ Fset_text_properties (start1, end2, Qnil, Qnil);
+#endif /* USE_TEXT_PROPERTIES */
+
+ /* First region smaller than second. */
+ if (len1 < len2)
+ {
+ /* We use alloca only if it is small,
+ because we want to avoid stack overflow. */
+ if (len2 > 20000)
+ temp = (unsigned char *) xmalloc (len2);
+ else
+ temp = (unsigned char *) alloca (len2);
+
+ /* Don't precompute these addresses. We have to compute them
+ at the last minute, because the relocating allocator might
+ have moved the buffer around during the xmalloc. */
+ start1_addr = BUF_CHAR_ADDRESS (current_buffer, start1);
+ start2_addr = BUF_CHAR_ADDRESS (current_buffer, start2);
+
+ bcopy (start2_addr, temp, len2);
+ bcopy (start1_addr, start1_addr + len2, len1);
+ bcopy (temp, start1_addr, len2);
+ if (len2 > 20000)
+ free (temp);
+ }
+ else
+ /* First region not smaller than second. */
+ {
+ if (len1 > 20000)
+ temp = (unsigned char *) xmalloc (len1);
+ else
+ temp = (unsigned char *) alloca (len1);
+ start1_addr = BUF_CHAR_ADDRESS (current_buffer, start1);
+ start2_addr = BUF_CHAR_ADDRESS (current_buffer, start2);
+ bcopy (start1_addr, temp, len1);
+ bcopy (start2_addr, start1_addr, len2);
+ bcopy (temp, start1_addr + len2, len1);
+ if (len1 > 20000)
+ free (temp);
+ }
+#ifdef USE_TEXT_PROPERTIES
+ graft_intervals_into_buffer (tmp_interval1, start1 + len2,
+ len1, current_buffer, 0);
+ graft_intervals_into_buffer (tmp_interval2, start1,
+ len2, current_buffer, 0);
+#endif /* USE_TEXT_PROPERTIES */
+ }
+ /* Non-adjacent regions, because end1 != start2, bleagh... */
+ else
+ {
+ if (len1 == len2)
+ /* Regions are same size, though, how nice. */
+ {
+ modify_region (current_buffer, start1, end1);
+ modify_region (current_buffer, start2, end2);
+ record_change (start1, len1);
+ record_change (start2, len2);
+#ifdef USE_TEXT_PROPERTIES
+ tmp_interval1 = copy_intervals (cur_intv, start1, len1);
+ tmp_interval2 = copy_intervals (cur_intv, start2, len2);
+ Fset_text_properties (start1, end1, Qnil, Qnil);
+ Fset_text_properties (start2, end2, Qnil, Qnil);
+#endif /* USE_TEXT_PROPERTIES */
+
+ if (len1 > 20000)
+ temp = (unsigned char *) xmalloc (len1);
+ else
+ temp = (unsigned char *) alloca (len1);
+ start1_addr = BUF_CHAR_ADDRESS (current_buffer, start1);
+ start2_addr = BUF_CHAR_ADDRESS (current_buffer, start2);
+ bcopy (start1_addr, temp, len1);
+ bcopy (start2_addr, start1_addr, len2);
+ bcopy (temp, start2_addr, len1);
+ if (len1 > 20000)
+ free (temp);
+#ifdef USE_TEXT_PROPERTIES
+ graft_intervals_into_buffer (tmp_interval1, start2,
+ len1, current_buffer, 0);
+ graft_intervals_into_buffer (tmp_interval2, start1,
+ len2, current_buffer, 0);
+#endif /* USE_TEXT_PROPERTIES */
+ }
+
+ else if (len1 < len2) /* Second region larger than first */
+ /* Non-adjacent & unequal size, area between must also be shifted. */
+ {
+ len_mid = start2 - end1;
+ modify_region (current_buffer, start1, end2);
+ record_change (start1, (end2 - start1));
+#ifdef USE_TEXT_PROPERTIES
+ tmp_interval1 = copy_intervals (cur_intv, start1, len1);
+ tmp_interval_mid = copy_intervals (cur_intv, end1, len_mid);
+ tmp_interval2 = copy_intervals (cur_intv, start2, len2);
+ Fset_text_properties (start1, end2, Qnil, Qnil);
+#endif /* USE_TEXT_PROPERTIES */
+
+ /* holds region 2 */
+ if (len2 > 20000)
+ temp = (unsigned char *) xmalloc (len2);
+ else
+ temp = (unsigned char *) alloca (len2);
+ start1_addr = BUF_CHAR_ADDRESS (current_buffer, start1);
+ start2_addr = BUF_CHAR_ADDRESS (current_buffer, start2);
+ bcopy (start2_addr, temp, len2);
+ bcopy (start1_addr, start1_addr + len_mid + len2, len1);
+ safe_bcopy (start1_addr + len1, start1_addr + len2, len_mid);
+ bcopy (temp, start1_addr, len2);
+ if (len2 > 20000)
+ free (temp);
+#ifdef USE_TEXT_PROPERTIES
+ graft_intervals_into_buffer (tmp_interval1, end2 - len1,
+ len1, current_buffer, 0);
+ graft_intervals_into_buffer (tmp_interval_mid, start1 + len2,
+ len_mid, current_buffer, 0);
+ graft_intervals_into_buffer (tmp_interval2, start1,
+ len2, current_buffer, 0);
+#endif /* USE_TEXT_PROPERTIES */
+ }
+ else
+ /* Second region smaller than first. */
+ {
+ len_mid = start2 - end1;
+ record_change (start1, (end2 - start1));
+ modify_region (current_buffer, start1, end2);
+
+#ifdef USE_TEXT_PROPERTIES
+ tmp_interval1 = copy_intervals (cur_intv, start1, len1);
+ tmp_interval_mid = copy_intervals (cur_intv, end1, len_mid);
+ tmp_interval2 = copy_intervals (cur_intv, start2, len2);
+ Fset_text_properties (start1, end2, Qnil, Qnil);
+#endif /* USE_TEXT_PROPERTIES */
+
+ /* holds region 1 */
+ if (len1 > 20000)
+ temp = (unsigned char *) xmalloc (len1);
+ else
+ temp = (unsigned char *) alloca (len1);
+ start1_addr = BUF_CHAR_ADDRESS (current_buffer, start1);
+ start2_addr = BUF_CHAR_ADDRESS (current_buffer, start2);
+ bcopy (start1_addr, temp, len1);
+ bcopy (start2_addr, start1_addr, len2);
+ bcopy (start1_addr + len1, start1_addr + len2, len_mid);
+ bcopy (temp, start1_addr + len2 + len_mid, len1);
+ if (len1 > 20000)
+ free (temp);
+#ifdef USE_TEXT_PROPERTIES
+ graft_intervals_into_buffer (tmp_interval1, end2 - len1,
+ len1, current_buffer, 0);
+ graft_intervals_into_buffer (tmp_interval_mid, start1 + len2,
+ len_mid, current_buffer, 0);
+ graft_intervals_into_buffer (tmp_interval2, start1,
+ len2, current_buffer, 0);
+#endif /* USE_TEXT_PROPERTIES */
+ }
+ }
+
+ /* todo: this will be slow, because for every transposition, we
+ traverse the whole friggin marker list. Possible solutions:
+ somehow get a list of *all* the markers across multiple
+ transpositions and do it all in one swell phoop. Or maybe modify
+ Emacs' marker code to keep an ordered list or tree. This might
+ be nicer, and more beneficial in the long run, but would be a
+ bunch of work. Plus the way they're arranged now is nice. */
+ if (NILP (leave_markers))
+ {
+ transpose_markers (start1, end1, start2, end2);
+ fix_overlays_in_range (start1, end2);
+ }
+
+ return Qnil;
+}
\f
void
syms_of_editfns ()
{
- staticpro (&Vuser_name);
- staticpro (&Vuser_full_name);
- staticpro (&Vuser_real_name);
- staticpro (&Vsystem_name);
+ DEFVAR_LISP ("system-name", &Vsystem_name,
+ "The name of the machine Emacs is running on.");
+
+ DEFVAR_LISP ("user-full-name", &Vuser_full_name,
+ "The full name of the user logged in.");
+
+ DEFVAR_LISP ("user-name", &Vuser_name,
+ "The user's name, taken from environment variables if possible.");
+
+ DEFVAR_LISP ("user-real-name", &Vuser_real_name,
+ "The user's name, based upon the real uid only.");
defsubr (&Schar_equal);
defsubr (&Sgoto_char);
defsubr (&Suser_full_name);
defsubr (&Semacs_pid);
defsubr (&Scurrent_time);
+ defsubr (&Sformat_time_string);
defsubr (&Scurrent_time_string);
defsubr (&Scurrent_time_zone);
defsubr (&Ssystem_name);
defsubr (&Smessage);
+ defsubr (&Smessage_box);
+ defsubr (&Smessage_or_box);
defsubr (&Sformat);
defsubr (&Sinsert_buffer_substring);
defsubr (&Swiden);
defsubr (&Snarrow_to_region);
defsubr (&Ssave_restriction);
+ defsubr (&Stranspose_regions);
}
HCoop / bpt / emacs.git / blobdiff