Merge from gnus--rel--5.10
[emacs.git] / src / editfns.c
blobc9acebd9d298e2cdcf7b67bcf76bd2ed1325a217
1 /* Lisp functions pertaining to editing.
2 Copyright (C) 1985, 1986, 1987, 1989, 1993, 1994, 1995, 1996,
3 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
24 #include <config.h>
25 #include <sys/types.h>
26 #include <stdio.h>
28 #ifdef HAVE_PWD_H
29 #include <pwd.h>
30 #endif
32 #ifdef HAVE_UNISTD_H
33 #include <unistd.h>
34 #endif
36 #ifdef HAVE_SYS_UTSNAME_H
37 #include <sys/utsname.h>
38 #endif
40 #include "lisp.h"
42 /* systime.h includes <sys/time.h> which, on some systems, is required
43 for <sys/resource.h>; thus systime.h must be included before
44 <sys/resource.h> */
45 #include "systime.h"
47 #if defined HAVE_SYS_RESOURCE_H
48 #include <sys/resource.h>
49 #endif
51 #include <ctype.h>
53 #include "intervals.h"
54 #include "buffer.h"
55 #include "charset.h"
56 #include "coding.h"
57 #include "frame.h"
58 #include "window.h"
59 #include "blockinput.h"
61 #ifdef STDC_HEADERS
62 #include <float.h>
63 #define MAX_10_EXP DBL_MAX_10_EXP
64 #else
65 #define MAX_10_EXP 310
66 #endif
68 #ifndef NULL
69 #define NULL 0
70 #endif
72 #ifndef USE_CRT_DLL
73 extern char **environ;
74 #endif
76 #define TM_YEAR_BASE 1900
78 /* Nonzero if TM_YEAR is a struct tm's tm_year value that causes
79 asctime to have well-defined behavior. */
80 #ifndef TM_YEAR_IN_ASCTIME_RANGE
81 # define TM_YEAR_IN_ASCTIME_RANGE(tm_year) \
82 (1000 - TM_YEAR_BASE <= (tm_year) && (tm_year) <= 9999 - TM_YEAR_BASE)
83 #endif
85 extern size_t emacs_strftimeu P_ ((char *, size_t, const char *,
86 const struct tm *, int));
87 static int tm_diff P_ ((struct tm *, struct tm *));
88 static void find_field P_ ((Lisp_Object, Lisp_Object, Lisp_Object, int *, Lisp_Object, int *));
89 static void update_buffer_properties P_ ((int, int));
90 static Lisp_Object region_limit P_ ((int));
91 int lisp_time_argument P_ ((Lisp_Object, time_t *, int *));
92 static size_t emacs_memftimeu P_ ((char *, size_t, const char *,
93 size_t, const struct tm *, int));
94 static void general_insert_function P_ ((void (*) (const unsigned char *, int),
95 void (*) (Lisp_Object, int, int, int,
96 int, int),
97 int, int, Lisp_Object *));
98 static Lisp_Object subst_char_in_region_unwind P_ ((Lisp_Object));
99 static Lisp_Object subst_char_in_region_unwind_1 P_ ((Lisp_Object));
100 static void transpose_markers P_ ((int, int, int, int, int, int, int, int));
102 #ifdef HAVE_INDEX
103 extern char *index P_ ((const char *, int));
104 #endif
106 Lisp_Object Vbuffer_access_fontify_functions;
107 Lisp_Object Qbuffer_access_fontify_functions;
108 Lisp_Object Vbuffer_access_fontified_property;
110 Lisp_Object Fuser_full_name P_ ((Lisp_Object));
112 /* Non-nil means don't stop at field boundary in text motion commands. */
114 Lisp_Object Vinhibit_field_text_motion;
116 /* Some static data, and a function to initialize it for each run */
118 Lisp_Object Vsystem_name;
119 Lisp_Object Vuser_real_login_name; /* login name of current user ID */
120 Lisp_Object Vuser_full_name; /* full name of current user */
121 Lisp_Object Vuser_login_name; /* user name from LOGNAME or USER */
122 Lisp_Object Voperating_system_release; /* Operating System Release */
124 /* Symbol for the text property used to mark fields. */
126 Lisp_Object Qfield;
128 /* A special value for Qfield properties. */
130 Lisp_Object Qboundary;
133 void
134 init_editfns ()
136 char *user_name;
137 register unsigned char *p;
138 struct passwd *pw; /* password entry for the current user */
139 Lisp_Object tem;
141 /* Set up system_name even when dumping. */
142 init_system_name ();
144 #ifndef CANNOT_DUMP
145 /* Don't bother with this on initial start when just dumping out */
146 if (!initialized)
147 return;
148 #endif /* not CANNOT_DUMP */
150 pw = (struct passwd *) getpwuid (getuid ());
151 #ifdef MSDOS
152 /* We let the real user name default to "root" because that's quite
153 accurate on MSDOG and because it lets Emacs find the init file.
154 (The DVX libraries override the Djgpp libraries here.) */
155 Vuser_real_login_name = build_string (pw ? pw->pw_name : "root");
156 #else
157 Vuser_real_login_name = build_string (pw ? pw->pw_name : "unknown");
158 #endif
160 /* Get the effective user name, by consulting environment variables,
161 or the effective uid if those are unset. */
162 user_name = (char *) getenv ("LOGNAME");
163 if (!user_name)
164 #ifdef WINDOWSNT
165 user_name = (char *) getenv ("USERNAME"); /* it's USERNAME on NT */
166 #else /* WINDOWSNT */
167 user_name = (char *) getenv ("USER");
168 #endif /* WINDOWSNT */
169 if (!user_name)
171 pw = (struct passwd *) getpwuid (geteuid ());
172 user_name = (char *) (pw ? pw->pw_name : "unknown");
174 Vuser_login_name = build_string (user_name);
176 /* If the user name claimed in the environment vars differs from
177 the real uid, use the claimed name to find the full name. */
178 tem = Fstring_equal (Vuser_login_name, Vuser_real_login_name);
179 Vuser_full_name = Fuser_full_name (NILP (tem)? make_number (geteuid())
180 : Vuser_login_name);
182 p = (unsigned char *) getenv ("NAME");
183 if (p)
184 Vuser_full_name = build_string (p);
185 else if (NILP (Vuser_full_name))
186 Vuser_full_name = build_string ("unknown");
188 #ifdef HAVE_SYS_UTSNAME_H
190 struct utsname uts;
191 uname (&uts);
192 Voperating_system_release = build_string (uts.release);
194 #else
195 Voperating_system_release = Qnil;
196 #endif
199 DEFUN ("char-to-string", Fchar_to_string, Schar_to_string, 1, 1, 0,
200 doc: /* Convert arg CHAR to a string containing that character.
201 usage: (char-to-string CHAR) */)
202 (character)
203 Lisp_Object character;
205 int len;
206 unsigned char str[MAX_MULTIBYTE_LENGTH];
208 CHECK_NUMBER (character);
210 len = (SINGLE_BYTE_CHAR_P (XFASTINT (character))
211 ? (*str = (unsigned char)(XFASTINT (character)), 1)
212 : char_to_string (XFASTINT (character), str));
213 return make_string_from_bytes (str, 1, len);
216 DEFUN ("string-to-char", Fstring_to_char, Sstring_to_char, 1, 1, 0,
217 doc: /* Convert arg STRING to a character, the first character of that string.
218 A multibyte character is handled correctly. */)
219 (string)
220 register Lisp_Object string;
222 register Lisp_Object val;
223 CHECK_STRING (string);
224 if (SCHARS (string))
226 if (STRING_MULTIBYTE (string))
227 XSETFASTINT (val, STRING_CHAR (SDATA (string), SBYTES (string)));
228 else
229 XSETFASTINT (val, SREF (string, 0));
231 else
232 XSETFASTINT (val, 0);
233 return val;
236 static Lisp_Object
237 buildmark (charpos, bytepos)
238 int charpos, bytepos;
240 register Lisp_Object mark;
241 mark = Fmake_marker ();
242 set_marker_both (mark, Qnil, charpos, bytepos);
243 return mark;
246 DEFUN ("point", Fpoint, Spoint, 0, 0, 0,
247 doc: /* Return value of point, as an integer.
248 Beginning of buffer is position (point-min). */)
251 Lisp_Object temp;
252 XSETFASTINT (temp, PT);
253 return temp;
256 DEFUN ("point-marker", Fpoint_marker, Spoint_marker, 0, 0, 0,
257 doc: /* Return value of point, as a marker object. */)
260 return buildmark (PT, PT_BYTE);
264 clip_to_bounds (lower, num, upper)
265 int lower, num, upper;
267 if (num < lower)
268 return lower;
269 else if (num > upper)
270 return upper;
271 else
272 return num;
275 DEFUN ("goto-char", Fgoto_char, Sgoto_char, 1, 1, "NGoto char: ",
276 doc: /* Set point to POSITION, a number or marker.
277 Beginning of buffer is position (point-min), end is (point-max).
279 The return value is POSITION. */)
280 (position)
281 register Lisp_Object position;
283 int pos;
285 if (MARKERP (position)
286 && current_buffer == XMARKER (position)->buffer)
288 pos = marker_position (position);
289 if (pos < BEGV)
290 SET_PT_BOTH (BEGV, BEGV_BYTE);
291 else if (pos > ZV)
292 SET_PT_BOTH (ZV, ZV_BYTE);
293 else
294 SET_PT_BOTH (pos, marker_byte_position (position));
296 return position;
299 CHECK_NUMBER_COERCE_MARKER (position);
301 pos = clip_to_bounds (BEGV, XINT (position), ZV);
302 SET_PT (pos);
303 return position;
307 /* Return the start or end position of the region.
308 BEGINNINGP non-zero means return the start.
309 If there is no region active, signal an error. */
311 static Lisp_Object
312 region_limit (beginningp)
313 int beginningp;
315 extern Lisp_Object Vmark_even_if_inactive; /* Defined in callint.c. */
316 Lisp_Object m;
318 if (!NILP (Vtransient_mark_mode)
319 && NILP (Vmark_even_if_inactive)
320 && NILP (current_buffer->mark_active))
321 xsignal0 (Qmark_inactive);
323 m = Fmarker_position (current_buffer->mark);
324 if (NILP (m))
325 error ("The mark is not set now, so there is no region");
327 if ((PT < XFASTINT (m)) == (beginningp != 0))
328 m = make_number (PT);
329 return m;
332 DEFUN ("region-beginning", Fregion_beginning, Sregion_beginning, 0, 0, 0,
333 doc: /* Return position of beginning of region, as an integer. */)
336 return region_limit (1);
339 DEFUN ("region-end", Fregion_end, Sregion_end, 0, 0, 0,
340 doc: /* Return position of end of region, as an integer. */)
343 return region_limit (0);
346 DEFUN ("mark-marker", Fmark_marker, Smark_marker, 0, 0, 0,
347 doc: /* Return this buffer's mark, as a marker object.
348 Watch out! Moving this marker changes the mark position.
349 If you set the marker not to point anywhere, the buffer will have no mark. */)
352 return current_buffer->mark;
356 /* Find all the overlays in the current buffer that touch position POS.
357 Return the number found, and store them in a vector in VEC
358 of length LEN. */
360 static int
361 overlays_around (pos, vec, len)
362 int pos;
363 Lisp_Object *vec;
364 int len;
366 Lisp_Object overlay, start, end;
367 struct Lisp_Overlay *tail;
368 int startpos, endpos;
369 int idx = 0;
371 for (tail = current_buffer->overlays_before; tail; tail = tail->next)
373 XSETMISC (overlay, tail);
375 end = OVERLAY_END (overlay);
376 endpos = OVERLAY_POSITION (end);
377 if (endpos < pos)
378 break;
379 start = OVERLAY_START (overlay);
380 startpos = OVERLAY_POSITION (start);
381 if (startpos <= pos)
383 if (idx < len)
384 vec[idx] = overlay;
385 /* Keep counting overlays even if we can't return them all. */
386 idx++;
390 for (tail = current_buffer->overlays_after; tail; tail = tail->next)
392 XSETMISC (overlay, tail);
394 start = OVERLAY_START (overlay);
395 startpos = OVERLAY_POSITION (start);
396 if (pos < startpos)
397 break;
398 end = OVERLAY_END (overlay);
399 endpos = OVERLAY_POSITION (end);
400 if (pos <= endpos)
402 if (idx < len)
403 vec[idx] = overlay;
404 idx++;
408 return idx;
411 /* Return the value of property PROP, in OBJECT at POSITION.
412 It's the value of PROP that a char inserted at POSITION would get.
413 OBJECT is optional and defaults to the current buffer.
414 If OBJECT is a buffer, then overlay properties are considered as well as
415 text properties.
416 If OBJECT is a window, then that window's buffer is used, but
417 window-specific overlays are considered only if they are associated
418 with OBJECT. */
419 Lisp_Object
420 get_pos_property (position, prop, object)
421 Lisp_Object position, object;
422 register Lisp_Object prop;
424 CHECK_NUMBER_COERCE_MARKER (position);
426 if (NILP (object))
427 XSETBUFFER (object, current_buffer);
428 else if (WINDOWP (object))
429 object = XWINDOW (object)->buffer;
431 if (!BUFFERP (object))
432 /* pos-property only makes sense in buffers right now, since strings
433 have no overlays and no notion of insertion for which stickiness
434 could be obeyed. */
435 return Fget_text_property (position, prop, object);
436 else
438 int posn = XINT (position);
439 int noverlays;
440 Lisp_Object *overlay_vec, tem;
441 struct buffer *obuf = current_buffer;
443 set_buffer_temp (XBUFFER (object));
445 /* First try with room for 40 overlays. */
446 noverlays = 40;
447 overlay_vec = (Lisp_Object *) alloca (noverlays * sizeof (Lisp_Object));
448 noverlays = overlays_around (posn, overlay_vec, noverlays);
450 /* If there are more than 40,
451 make enough space for all, and try again. */
452 if (noverlays > 40)
454 overlay_vec = (Lisp_Object *) alloca (noverlays * sizeof (Lisp_Object));
455 noverlays = overlays_around (posn, overlay_vec, noverlays);
457 noverlays = sort_overlays (overlay_vec, noverlays, NULL);
459 set_buffer_temp (obuf);
461 /* Now check the overlays in order of decreasing priority. */
462 while (--noverlays >= 0)
464 Lisp_Object ol = overlay_vec[noverlays];
465 tem = Foverlay_get (ol, prop);
466 if (!NILP (tem))
468 /* Check the overlay is indeed active at point. */
469 Lisp_Object start = OVERLAY_START (ol), finish = OVERLAY_END (ol);
470 if ((OVERLAY_POSITION (start) == posn
471 && XMARKER (start)->insertion_type == 1)
472 || (OVERLAY_POSITION (finish) == posn
473 && XMARKER (finish)->insertion_type == 0))
474 ; /* The overlay will not cover a char inserted at point. */
475 else
477 return tem;
482 { /* Now check the text-properties. */
483 int stickiness = text_property_stickiness (prop, position, object);
484 if (stickiness > 0)
485 return Fget_text_property (position, prop, object);
486 else if (stickiness < 0
487 && XINT (position) > BUF_BEGV (XBUFFER (object)))
488 return Fget_text_property (make_number (XINT (position) - 1),
489 prop, object);
490 else
491 return Qnil;
496 /* Find the field surrounding POS in *BEG and *END. If POS is nil,
497 the value of point is used instead. If BEG or END is null,
498 means don't store the beginning or end of the field.
500 BEG_LIMIT and END_LIMIT serve to limit the ranged of the returned
501 results; they do not effect boundary behavior.
503 If MERGE_AT_BOUNDARY is nonzero, then if POS is at the very first
504 position of a field, then the beginning of the previous field is
505 returned instead of the beginning of POS's field (since the end of a
506 field is actually also the beginning of the next input field, this
507 behavior is sometimes useful). Additionally in the MERGE_AT_BOUNDARY
508 true case, if two fields are separated by a field with the special
509 value `boundary', and POS lies within it, then the two separated
510 fields are considered to be adjacent, and POS between them, when
511 finding the beginning and ending of the "merged" field.
513 Either BEG or END may be 0, in which case the corresponding value
514 is not stored. */
516 static void
517 find_field (pos, merge_at_boundary, beg_limit, beg, end_limit, end)
518 Lisp_Object pos;
519 Lisp_Object merge_at_boundary;
520 Lisp_Object beg_limit, end_limit;
521 int *beg, *end;
523 /* Fields right before and after the point. */
524 Lisp_Object before_field, after_field;
525 /* 1 if POS counts as the start of a field. */
526 int at_field_start = 0;
527 /* 1 if POS counts as the end of a field. */
528 int at_field_end = 0;
530 if (NILP (pos))
531 XSETFASTINT (pos, PT);
532 else
533 CHECK_NUMBER_COERCE_MARKER (pos);
535 after_field
536 = get_char_property_and_overlay (pos, Qfield, Qnil, NULL);
537 before_field
538 = (XFASTINT (pos) > BEGV
539 ? get_char_property_and_overlay (make_number (XINT (pos) - 1),
540 Qfield, Qnil, NULL)
541 /* Using nil here would be a more obvious choice, but it would
542 fail when the buffer starts with a non-sticky field. */
543 : after_field);
545 /* See if we need to handle the case where MERGE_AT_BOUNDARY is nil
546 and POS is at beginning of a field, which can also be interpreted
547 as the end of the previous field. Note that the case where if
548 MERGE_AT_BOUNDARY is non-nil (see function comment) is actually the
549 more natural one; then we avoid treating the beginning of a field
550 specially. */
551 if (NILP (merge_at_boundary))
553 Lisp_Object field = get_pos_property (pos, Qfield, Qnil);
554 if (!EQ (field, after_field))
555 at_field_end = 1;
556 if (!EQ (field, before_field))
557 at_field_start = 1;
558 if (NILP (field) && at_field_start && at_field_end)
559 /* If an inserted char would have a nil field while the surrounding
560 text is non-nil, we're probably not looking at a
561 zero-length field, but instead at a non-nil field that's
562 not intended for editing (such as comint's prompts). */
563 at_field_end = at_field_start = 0;
566 /* Note about special `boundary' fields:
568 Consider the case where the point (`.') is between the fields `x' and `y':
570 xxxx.yyyy
572 In this situation, if merge_at_boundary is true, we consider the
573 `x' and `y' fields as forming one big merged field, and so the end
574 of the field is the end of `y'.
576 However, if `x' and `y' are separated by a special `boundary' field
577 (a field with a `field' char-property of 'boundary), then we ignore
578 this special field when merging adjacent fields. Here's the same
579 situation, but with a `boundary' field between the `x' and `y' fields:
581 xxx.BBBByyyy
583 Here, if point is at the end of `x', the beginning of `y', or
584 anywhere in-between (within the `boundary' field), we merge all
585 three fields and consider the beginning as being the beginning of
586 the `x' field, and the end as being the end of the `y' field. */
588 if (beg)
590 if (at_field_start)
591 /* POS is at the edge of a field, and we should consider it as
592 the beginning of the following field. */
593 *beg = XFASTINT (pos);
594 else
595 /* Find the previous field boundary. */
597 Lisp_Object p = pos;
598 if (!NILP (merge_at_boundary) && EQ (before_field, Qboundary))
599 /* Skip a `boundary' field. */
600 p = Fprevious_single_char_property_change (p, Qfield, Qnil,
601 beg_limit);
603 p = Fprevious_single_char_property_change (p, Qfield, Qnil,
604 beg_limit);
605 *beg = NILP (p) ? BEGV : XFASTINT (p);
609 if (end)
611 if (at_field_end)
612 /* POS is at the edge of a field, and we should consider it as
613 the end of the previous field. */
614 *end = XFASTINT (pos);
615 else
616 /* Find the next field boundary. */
618 if (!NILP (merge_at_boundary) && EQ (after_field, Qboundary))
619 /* Skip a `boundary' field. */
620 pos = Fnext_single_char_property_change (pos, Qfield, Qnil,
621 end_limit);
623 pos = Fnext_single_char_property_change (pos, Qfield, Qnil,
624 end_limit);
625 *end = NILP (pos) ? ZV : XFASTINT (pos);
631 DEFUN ("delete-field", Fdelete_field, Sdelete_field, 0, 1, 0,
632 doc: /* Delete the field surrounding POS.
633 A field is a region of text with the same `field' property.
634 If POS is nil, the value of point is used for POS. */)
635 (pos)
636 Lisp_Object pos;
638 int beg, end;
639 find_field (pos, Qnil, Qnil, &beg, Qnil, &end);
640 if (beg != end)
641 del_range (beg, end);
642 return Qnil;
645 DEFUN ("field-string", Ffield_string, Sfield_string, 0, 1, 0,
646 doc: /* Return the contents of the field surrounding POS as a string.
647 A field is a region of text with the same `field' property.
648 If POS is nil, the value of point is used for POS. */)
649 (pos)
650 Lisp_Object pos;
652 int beg, end;
653 find_field (pos, Qnil, Qnil, &beg, Qnil, &end);
654 return make_buffer_string (beg, end, 1);
657 DEFUN ("field-string-no-properties", Ffield_string_no_properties, Sfield_string_no_properties, 0, 1, 0,
658 doc: /* Return the contents of the field around POS, without text-properties.
659 A field is a region of text with the same `field' property.
660 If POS is nil, the value of point is used for POS. */)
661 (pos)
662 Lisp_Object pos;
664 int beg, end;
665 find_field (pos, Qnil, Qnil, &beg, Qnil, &end);
666 return make_buffer_string (beg, end, 0);
669 DEFUN ("field-beginning", Ffield_beginning, Sfield_beginning, 0, 3, 0,
670 doc: /* Return the beginning of the field surrounding POS.
671 A field is a region of text with the same `field' property.
672 If POS is nil, the value of point is used for POS.
673 If ESCAPE-FROM-EDGE is non-nil and POS is at the beginning of its
674 field, then the beginning of the *previous* field is returned.
675 If LIMIT is non-nil, it is a buffer position; if the beginning of the field
676 is before LIMIT, then LIMIT will be returned instead. */)
677 (pos, escape_from_edge, limit)
678 Lisp_Object pos, escape_from_edge, limit;
680 int beg;
681 find_field (pos, escape_from_edge, limit, &beg, Qnil, 0);
682 return make_number (beg);
685 DEFUN ("field-end", Ffield_end, Sfield_end, 0, 3, 0,
686 doc: /* Return the end of the field surrounding POS.
687 A field is a region of text with the same `field' property.
688 If POS is nil, the value of point is used for POS.
689 If ESCAPE-FROM-EDGE is non-nil and POS is at the end of its field,
690 then the end of the *following* field is returned.
691 If LIMIT is non-nil, it is a buffer position; if the end of the field
692 is after LIMIT, then LIMIT will be returned instead. */)
693 (pos, escape_from_edge, limit)
694 Lisp_Object pos, escape_from_edge, limit;
696 int end;
697 find_field (pos, escape_from_edge, Qnil, 0, limit, &end);
698 return make_number (end);
701 DEFUN ("constrain-to-field", Fconstrain_to_field, Sconstrain_to_field, 2, 5, 0,
702 doc: /* Return the position closest to NEW-POS that is in the same field as OLD-POS.
704 A field is a region of text with the same `field' property.
705 If NEW-POS is nil, then the current point is used instead, and set to the
706 constrained position if that is different.
708 If OLD-POS is at the boundary of two fields, then the allowable
709 positions for NEW-POS depends on the value of the optional argument
710 ESCAPE-FROM-EDGE: If ESCAPE-FROM-EDGE is nil, then NEW-POS is
711 constrained to the field that has the same `field' char-property
712 as any new characters inserted at OLD-POS, whereas if ESCAPE-FROM-EDGE
713 is non-nil, NEW-POS is constrained to the union of the two adjacent
714 fields. Additionally, if two fields are separated by another field with
715 the special value `boundary', then any point within this special field is
716 also considered to be `on the boundary'.
718 If the optional argument ONLY-IN-LINE is non-nil and constraining
719 NEW-POS would move it to a different line, NEW-POS is returned
720 unconstrained. This useful for commands that move by line, like
721 \\[next-line] or \\[beginning-of-line], which should generally respect field boundaries
722 only in the case where they can still move to the right line.
724 If the optional argument INHIBIT-CAPTURE-PROPERTY is non-nil, and OLD-POS has
725 a non-nil property of that name, then any field boundaries are ignored.
727 Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil. */)
728 (new_pos, old_pos, escape_from_edge, only_in_line, inhibit_capture_property)
729 Lisp_Object new_pos, old_pos;
730 Lisp_Object escape_from_edge, only_in_line, inhibit_capture_property;
732 /* If non-zero, then the original point, before re-positioning. */
733 int orig_point = 0;
734 int fwd;
735 Lisp_Object prev_old, prev_new;
737 if (NILP (new_pos))
738 /* Use the current point, and afterwards, set it. */
740 orig_point = PT;
741 XSETFASTINT (new_pos, PT);
744 CHECK_NUMBER_COERCE_MARKER (new_pos);
745 CHECK_NUMBER_COERCE_MARKER (old_pos);
747 fwd = (XFASTINT (new_pos) > XFASTINT (old_pos));
749 prev_old = make_number (XFASTINT (old_pos) - 1);
750 prev_new = make_number (XFASTINT (new_pos) - 1);
752 if (NILP (Vinhibit_field_text_motion)
753 && !EQ (new_pos, old_pos)
754 && (!NILP (Fget_char_property (new_pos, Qfield, Qnil))
755 || !NILP (Fget_char_property (old_pos, Qfield, Qnil))
756 /* To recognize field boundaries, we must also look at the
757 previous positions; we could use `get_pos_property'
758 instead, but in itself that would fail inside non-sticky
759 fields (like comint prompts). */
760 || (XFASTINT (new_pos) > BEGV
761 && !NILP (Fget_char_property (prev_new, Qfield, Qnil)))
762 || (XFASTINT (old_pos) > BEGV
763 && !NILP (Fget_char_property (prev_old, Qfield, Qnil))))
764 && (NILP (inhibit_capture_property)
765 /* Field boundaries are again a problem; but now we must
766 decide the case exactly, so we need to call
767 `get_pos_property' as well. */
768 || (NILP (get_pos_property (old_pos, inhibit_capture_property, Qnil))
769 && (XFASTINT (old_pos) <= BEGV
770 || NILP (Fget_char_property (old_pos, inhibit_capture_property, Qnil))
771 || NILP (Fget_char_property (prev_old, inhibit_capture_property, Qnil))))))
772 /* It is possible that NEW_POS is not within the same field as
773 OLD_POS; try to move NEW_POS so that it is. */
775 int shortage;
776 Lisp_Object field_bound;
778 if (fwd)
779 field_bound = Ffield_end (old_pos, escape_from_edge, new_pos);
780 else
781 field_bound = Ffield_beginning (old_pos, escape_from_edge, new_pos);
783 if (/* See if ESCAPE_FROM_EDGE caused FIELD_BOUND to jump to the
784 other side of NEW_POS, which would mean that NEW_POS is
785 already acceptable, and it's not necessary to constrain it
786 to FIELD_BOUND. */
787 ((XFASTINT (field_bound) < XFASTINT (new_pos)) ? fwd : !fwd)
788 /* NEW_POS should be constrained, but only if either
789 ONLY_IN_LINE is nil (in which case any constraint is OK),
790 or NEW_POS and FIELD_BOUND are on the same line (in which
791 case the constraint is OK even if ONLY_IN_LINE is non-nil). */
792 && (NILP (only_in_line)
793 /* This is the ONLY_IN_LINE case, check that NEW_POS and
794 FIELD_BOUND are on the same line by seeing whether
795 there's an intervening newline or not. */
796 || (scan_buffer ('\n',
797 XFASTINT (new_pos), XFASTINT (field_bound),
798 fwd ? -1 : 1, &shortage, 1),
799 shortage != 0)))
800 /* Constrain NEW_POS to FIELD_BOUND. */
801 new_pos = field_bound;
803 if (orig_point && XFASTINT (new_pos) != orig_point)
804 /* The NEW_POS argument was originally nil, so automatically set PT. */
805 SET_PT (XFASTINT (new_pos));
808 return new_pos;
812 DEFUN ("line-beginning-position",
813 Fline_beginning_position, Sline_beginning_position, 0, 1, 0,
814 doc: /* Return the character position of the first character on the current line.
815 With argument N not nil or 1, move forward N - 1 lines first.
816 If scan reaches end of buffer, return that position.
818 This function constrains the returned position to the current field
819 unless that would be on a different line than the original,
820 unconstrained result. If N is nil or 1, and a front-sticky field
821 starts at point, the scan stops as soon as it starts. To ignore field
822 boundaries bind `inhibit-field-text-motion' to t.
824 This function does not move point. */)
826 Lisp_Object n;
828 int orig, orig_byte, end;
829 int count = SPECPDL_INDEX ();
830 specbind (Qinhibit_point_motion_hooks, Qt);
832 if (NILP (n))
833 XSETFASTINT (n, 1);
834 else
835 CHECK_NUMBER (n);
837 orig = PT;
838 orig_byte = PT_BYTE;
839 Fforward_line (make_number (XINT (n) - 1));
840 end = PT;
842 SET_PT_BOTH (orig, orig_byte);
844 unbind_to (count, Qnil);
846 /* Return END constrained to the current input field. */
847 return Fconstrain_to_field (make_number (end), make_number (orig),
848 XINT (n) != 1 ? Qt : Qnil,
849 Qt, Qnil);
852 DEFUN ("line-end-position", Fline_end_position, Sline_end_position, 0, 1, 0,
853 doc: /* Return the character position of the last character on the current line.
854 With argument N not nil or 1, move forward N - 1 lines first.
855 If scan reaches end of buffer, return that position.
857 This function constrains the returned position to the current field
858 unless that would be on a different line than the original,
859 unconstrained result. If N is nil or 1, and a rear-sticky field ends
860 at point, the scan stops as soon as it starts. To ignore field
861 boundaries bind `inhibit-field-text-motion' to t.
863 This function does not move point. */)
865 Lisp_Object n;
867 int end_pos;
868 int orig = PT;
870 if (NILP (n))
871 XSETFASTINT (n, 1);
872 else
873 CHECK_NUMBER (n);
875 end_pos = find_before_next_newline (orig, 0, XINT (n) - (XINT (n) <= 0));
877 /* Return END_POS constrained to the current input field. */
878 return Fconstrain_to_field (make_number (end_pos), make_number (orig),
879 Qnil, Qt, Qnil);
883 Lisp_Object
884 save_excursion_save ()
886 int visible = (XBUFFER (XWINDOW (selected_window)->buffer)
887 == current_buffer);
889 return Fcons (Fpoint_marker (),
890 Fcons (Fcopy_marker (current_buffer->mark, Qnil),
891 Fcons (visible ? Qt : Qnil,
892 Fcons (current_buffer->mark_active,
893 selected_window))));
896 Lisp_Object
897 save_excursion_restore (info)
898 Lisp_Object info;
900 Lisp_Object tem, tem1, omark, nmark;
901 struct gcpro gcpro1, gcpro2, gcpro3;
902 int visible_p;
904 tem = Fmarker_buffer (XCAR (info));
905 /* If buffer being returned to is now deleted, avoid error */
906 /* Otherwise could get error here while unwinding to top level
907 and crash */
908 /* In that case, Fmarker_buffer returns nil now. */
909 if (NILP (tem))
910 return Qnil;
912 omark = nmark = Qnil;
913 GCPRO3 (info, omark, nmark);
915 Fset_buffer (tem);
917 /* Point marker. */
918 tem = XCAR (info);
919 Fgoto_char (tem);
920 unchain_marker (XMARKER (tem));
922 /* Mark marker. */
923 info = XCDR (info);
924 tem = XCAR (info);
925 omark = Fmarker_position (current_buffer->mark);
926 Fset_marker (current_buffer->mark, tem, Fcurrent_buffer ());
927 nmark = Fmarker_position (tem);
928 unchain_marker (XMARKER (tem));
930 /* visible */
931 info = XCDR (info);
932 visible_p = !NILP (XCAR (info));
934 #if 0 /* We used to make the current buffer visible in the selected window
935 if that was true previously. That avoids some anomalies.
936 But it creates others, and it wasn't documented, and it is simpler
937 and cleaner never to alter the window/buffer connections. */
938 tem1 = Fcar (tem);
939 if (!NILP (tem1)
940 && current_buffer != XBUFFER (XWINDOW (selected_window)->buffer))
941 Fswitch_to_buffer (Fcurrent_buffer (), Qnil);
942 #endif /* 0 */
944 /* Mark active */
945 info = XCDR (info);
946 tem = XCAR (info);
947 tem1 = current_buffer->mark_active;
948 current_buffer->mark_active = tem;
950 if (!NILP (Vrun_hooks))
952 /* If mark is active now, and either was not active
953 or was at a different place, run the activate hook. */
954 if (! NILP (current_buffer->mark_active))
956 if (! EQ (omark, nmark))
957 call1 (Vrun_hooks, intern ("activate-mark-hook"));
959 /* If mark has ceased to be active, run deactivate hook. */
960 else if (! NILP (tem1))
961 call1 (Vrun_hooks, intern ("deactivate-mark-hook"));
964 /* If buffer was visible in a window, and a different window was
965 selected, and the old selected window is still showing this
966 buffer, restore point in that window. */
967 tem = XCDR (info);
968 if (visible_p
969 && !EQ (tem, selected_window)
970 && (tem1 = XWINDOW (tem)->buffer,
971 (/* Window is live... */
972 BUFFERP (tem1)
973 /* ...and it shows the current buffer. */
974 && XBUFFER (tem1) == current_buffer)))
975 Fset_window_point (tem, make_number (PT));
977 UNGCPRO;
978 return Qnil;
981 DEFUN ("save-excursion", Fsave_excursion, Ssave_excursion, 0, UNEVALLED, 0,
982 doc: /* Save point, mark, and current buffer; execute BODY; restore those things.
983 Executes BODY just like `progn'.
984 The values of point, mark and the current buffer are restored
985 even in case of abnormal exit (throw or error).
986 The state of activation of the mark is also restored.
988 This construct does not save `deactivate-mark', and therefore
989 functions that change the buffer will still cause deactivation
990 of the mark at the end of the command. To prevent that, bind
991 `deactivate-mark' with `let'.
993 usage: (save-excursion &rest BODY) */)
994 (args)
995 Lisp_Object args;
997 register Lisp_Object val;
998 int count = SPECPDL_INDEX ();
1000 record_unwind_protect (save_excursion_restore, save_excursion_save ());
1002 val = Fprogn (args);
1003 return unbind_to (count, val);
1006 DEFUN ("save-current-buffer", Fsave_current_buffer, Ssave_current_buffer, 0, UNEVALLED, 0,
1007 doc: /* Save the current buffer; execute BODY; restore the current buffer.
1008 Executes BODY just like `progn'.
1009 usage: (save-current-buffer &rest BODY) */)
1010 (args)
1011 Lisp_Object args;
1013 Lisp_Object val;
1014 int count = SPECPDL_INDEX ();
1016 record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
1018 val = Fprogn (args);
1019 return unbind_to (count, val);
1022 DEFUN ("buffer-size", Fbufsize, Sbufsize, 0, 1, 0,
1023 doc: /* Return the number of characters in the current buffer.
1024 If BUFFER, return the number of characters in that buffer instead. */)
1025 (buffer)
1026 Lisp_Object buffer;
1028 if (NILP (buffer))
1029 return make_number (Z - BEG);
1030 else
1032 CHECK_BUFFER (buffer);
1033 return make_number (BUF_Z (XBUFFER (buffer))
1034 - BUF_BEG (XBUFFER (buffer)));
1038 DEFUN ("point-min", Fpoint_min, Spoint_min, 0, 0, 0,
1039 doc: /* Return the minimum permissible value of point in the current buffer.
1040 This is 1, unless narrowing (a buffer restriction) is in effect. */)
1043 Lisp_Object temp;
1044 XSETFASTINT (temp, BEGV);
1045 return temp;
1048 DEFUN ("point-min-marker", Fpoint_min_marker, Spoint_min_marker, 0, 0, 0,
1049 doc: /* Return a marker to the minimum permissible value of point in this buffer.
1050 This is the beginning, unless narrowing (a buffer restriction) is in effect. */)
1053 return buildmark (BEGV, BEGV_BYTE);
1056 DEFUN ("point-max", Fpoint_max, Spoint_max, 0, 0, 0,
1057 doc: /* Return the maximum permissible value of point in the current buffer.
1058 This is (1+ (buffer-size)), unless narrowing (a buffer restriction)
1059 is in effect, in which case it is less. */)
1062 Lisp_Object temp;
1063 XSETFASTINT (temp, ZV);
1064 return temp;
1067 DEFUN ("point-max-marker", Fpoint_max_marker, Spoint_max_marker, 0, 0, 0,
1068 doc: /* Return a marker to the maximum permissible value of point in this buffer.
1069 This is (1+ (buffer-size)), unless narrowing (a buffer restriction)
1070 is in effect, in which case it is less. */)
1073 return buildmark (ZV, ZV_BYTE);
1076 DEFUN ("gap-position", Fgap_position, Sgap_position, 0, 0, 0,
1077 doc: /* Return the position of the gap, in the current buffer.
1078 See also `gap-size'. */)
1081 Lisp_Object temp;
1082 XSETFASTINT (temp, GPT);
1083 return temp;
1086 DEFUN ("gap-size", Fgap_size, Sgap_size, 0, 0, 0,
1087 doc: /* Return the size of the current buffer's gap.
1088 See also `gap-position'. */)
1091 Lisp_Object temp;
1092 XSETFASTINT (temp, GAP_SIZE);
1093 return temp;
1096 DEFUN ("position-bytes", Fposition_bytes, Sposition_bytes, 1, 1, 0,
1097 doc: /* Return the byte position for character position POSITION.
1098 If POSITION is out of range, the value is nil. */)
1099 (position)
1100 Lisp_Object position;
1102 CHECK_NUMBER_COERCE_MARKER (position);
1103 if (XINT (position) < BEG || XINT (position) > Z)
1104 return Qnil;
1105 return make_number (CHAR_TO_BYTE (XINT (position)));
1108 DEFUN ("byte-to-position", Fbyte_to_position, Sbyte_to_position, 1, 1, 0,
1109 doc: /* Return the character position for byte position BYTEPOS.
1110 If BYTEPOS is out of range, the value is nil. */)
1111 (bytepos)
1112 Lisp_Object bytepos;
1114 CHECK_NUMBER (bytepos);
1115 if (XINT (bytepos) < BEG_BYTE || XINT (bytepos) > Z_BYTE)
1116 return Qnil;
1117 return make_number (BYTE_TO_CHAR (XINT (bytepos)));
1120 DEFUN ("following-char", Ffollowing_char, Sfollowing_char, 0, 0, 0,
1121 doc: /* Return the character following point, as a number.
1122 At the end of the buffer or accessible region, return 0. */)
1125 Lisp_Object temp;
1126 if (PT >= ZV)
1127 XSETFASTINT (temp, 0);
1128 else
1129 XSETFASTINT (temp, FETCH_CHAR (PT_BYTE));
1130 return temp;
1133 DEFUN ("preceding-char", Fprevious_char, Sprevious_char, 0, 0, 0,
1134 doc: /* Return the character preceding point, as a number.
1135 At the beginning of the buffer or accessible region, return 0. */)
1138 Lisp_Object temp;
1139 if (PT <= BEGV)
1140 XSETFASTINT (temp, 0);
1141 else if (!NILP (current_buffer->enable_multibyte_characters))
1143 int pos = PT_BYTE;
1144 DEC_POS (pos);
1145 XSETFASTINT (temp, FETCH_CHAR (pos));
1147 else
1148 XSETFASTINT (temp, FETCH_BYTE (PT_BYTE - 1));
1149 return temp;
1152 DEFUN ("bobp", Fbobp, Sbobp, 0, 0, 0,
1153 doc: /* Return t if point is at the beginning of the buffer.
1154 If the buffer is narrowed, this means the beginning of the narrowed part. */)
1157 if (PT == BEGV)
1158 return Qt;
1159 return Qnil;
1162 DEFUN ("eobp", Feobp, Seobp, 0, 0, 0,
1163 doc: /* Return t if point is at the end of the buffer.
1164 If the buffer is narrowed, this means the end of the narrowed part. */)
1167 if (PT == ZV)
1168 return Qt;
1169 return Qnil;
1172 DEFUN ("bolp", Fbolp, Sbolp, 0, 0, 0,
1173 doc: /* Return t if point is at the beginning of a line. */)
1176 if (PT == BEGV || FETCH_BYTE (PT_BYTE - 1) == '\n')
1177 return Qt;
1178 return Qnil;
1181 DEFUN ("eolp", Feolp, Seolp, 0, 0, 0,
1182 doc: /* Return t if point is at the end of a line.
1183 `End of a line' includes point being at the end of the buffer. */)
1186 if (PT == ZV || FETCH_BYTE (PT_BYTE) == '\n')
1187 return Qt;
1188 return Qnil;
1191 DEFUN ("char-after", Fchar_after, Schar_after, 0, 1, 0,
1192 doc: /* Return character in current buffer at position POS.
1193 POS is an integer or a marker and defaults to point.
1194 If POS is out of range, the value is nil. */)
1195 (pos)
1196 Lisp_Object pos;
1198 register int pos_byte;
1200 if (NILP (pos))
1202 pos_byte = PT_BYTE;
1203 XSETFASTINT (pos, PT);
1206 if (MARKERP (pos))
1208 pos_byte = marker_byte_position (pos);
1209 if (pos_byte < BEGV_BYTE || pos_byte >= ZV_BYTE)
1210 return Qnil;
1212 else
1214 CHECK_NUMBER_COERCE_MARKER (pos);
1215 if (XINT (pos) < BEGV || XINT (pos) >= ZV)
1216 return Qnil;
1218 pos_byte = CHAR_TO_BYTE (XINT (pos));
1221 return make_number (FETCH_CHAR (pos_byte));
1224 DEFUN ("char-before", Fchar_before, Schar_before, 0, 1, 0,
1225 doc: /* Return character in current buffer preceding position POS.
1226 POS is an integer or a marker and defaults to point.
1227 If POS is out of range, the value is nil. */)
1228 (pos)
1229 Lisp_Object pos;
1231 register Lisp_Object val;
1232 register int pos_byte;
1234 if (NILP (pos))
1236 pos_byte = PT_BYTE;
1237 XSETFASTINT (pos, PT);
1240 if (MARKERP (pos))
1242 pos_byte = marker_byte_position (pos);
1244 if (pos_byte <= BEGV_BYTE || pos_byte > ZV_BYTE)
1245 return Qnil;
1247 else
1249 CHECK_NUMBER_COERCE_MARKER (pos);
1251 if (XINT (pos) <= BEGV || XINT (pos) > ZV)
1252 return Qnil;
1254 pos_byte = CHAR_TO_BYTE (XINT (pos));
1257 if (!NILP (current_buffer->enable_multibyte_characters))
1259 DEC_POS (pos_byte);
1260 XSETFASTINT (val, FETCH_CHAR (pos_byte));
1262 else
1264 pos_byte--;
1265 XSETFASTINT (val, FETCH_BYTE (pos_byte));
1267 return val;
1270 DEFUN ("user-login-name", Fuser_login_name, Suser_login_name, 0, 1, 0,
1271 doc: /* Return the name under which the user logged in, as a string.
1272 This is based on the effective uid, not the real uid.
1273 Also, if the environment variables LOGNAME or USER are set,
1274 that determines the value of this function.
1276 If optional argument UID is an integer, return the login name of the user
1277 with that uid, or nil if there is no such user. */)
1278 (uid)
1279 Lisp_Object uid;
1281 struct passwd *pw;
1283 /* Set up the user name info if we didn't do it before.
1284 (That can happen if Emacs is dumpable
1285 but you decide to run `temacs -l loadup' and not dump. */
1286 if (INTEGERP (Vuser_login_name))
1287 init_editfns ();
1289 if (NILP (uid))
1290 return Vuser_login_name;
1292 CHECK_NUMBER (uid);
1293 BLOCK_INPUT;
1294 pw = (struct passwd *) getpwuid (XINT (uid));
1295 UNBLOCK_INPUT;
1296 return (pw ? build_string (pw->pw_name) : Qnil);
1299 DEFUN ("user-real-login-name", Fuser_real_login_name, Suser_real_login_name,
1300 0, 0, 0,
1301 doc: /* Return the name of the user's real uid, as a string.
1302 This ignores the environment variables LOGNAME and USER, so it differs from
1303 `user-login-name' when running under `su'. */)
1306 /* Set up the user name info if we didn't do it before.
1307 (That can happen if Emacs is dumpable
1308 but you decide to run `temacs -l loadup' and not dump. */
1309 if (INTEGERP (Vuser_login_name))
1310 init_editfns ();
1311 return Vuser_real_login_name;
1314 DEFUN ("user-uid", Fuser_uid, Suser_uid, 0, 0, 0,
1315 doc: /* Return the effective uid of Emacs.
1316 Value is an integer or float, depending on the value. */)
1319 /* Assignment to EMACS_INT stops GCC whining about limited range of
1320 data type. */
1321 EMACS_INT euid = geteuid ();
1322 return make_fixnum_or_float (euid);
1325 DEFUN ("user-real-uid", Fuser_real_uid, Suser_real_uid, 0, 0, 0,
1326 doc: /* Return the real uid of Emacs.
1327 Value is an integer or float, depending on the value. */)
1330 /* Assignment to EMACS_INT stops GCC whining about limited range of
1331 data type. */
1332 EMACS_INT uid = getuid ();
1333 return make_fixnum_or_float (uid);
1336 DEFUN ("user-full-name", Fuser_full_name, Suser_full_name, 0, 1, 0,
1337 doc: /* Return the full name of the user logged in, as a string.
1338 If the full name corresponding to Emacs's userid is not known,
1339 return "unknown".
1341 If optional argument UID is an integer or float, return the full name
1342 of the user with that uid, or nil if there is no such user.
1343 If UID is a string, return the full name of the user with that login
1344 name, or nil if there is no such user. */)
1345 (uid)
1346 Lisp_Object uid;
1348 struct passwd *pw;
1349 register unsigned char *p, *q;
1350 Lisp_Object full;
1352 if (NILP (uid))
1353 return Vuser_full_name;
1354 else if (NUMBERP (uid))
1356 BLOCK_INPUT;
1357 pw = (struct passwd *) getpwuid ((uid_t) XFLOATINT (uid));
1358 UNBLOCK_INPUT;
1360 else if (STRINGP (uid))
1362 BLOCK_INPUT;
1363 pw = (struct passwd *) getpwnam (SDATA (uid));
1364 UNBLOCK_INPUT;
1366 else
1367 error ("Invalid UID specification");
1369 if (!pw)
1370 return Qnil;
1372 p = (unsigned char *) USER_FULL_NAME;
1373 /* Chop off everything after the first comma. */
1374 q = (unsigned char *) index (p, ',');
1375 full = make_string (p, q ? q - p : strlen (p));
1377 #ifdef AMPERSAND_FULL_NAME
1378 p = SDATA (full);
1379 q = (unsigned char *) index (p, '&');
1380 /* Substitute the login name for the &, upcasing the first character. */
1381 if (q)
1383 register unsigned char *r;
1384 Lisp_Object login;
1386 login = Fuser_login_name (make_number (pw->pw_uid));
1387 r = (unsigned char *) alloca (strlen (p) + SCHARS (login) + 1);
1388 bcopy (p, r, q - p);
1389 r[q - p] = 0;
1390 strcat (r, SDATA (login));
1391 r[q - p] = UPCASE (r[q - p]);
1392 strcat (r, q + 1);
1393 full = build_string (r);
1395 #endif /* AMPERSAND_FULL_NAME */
1397 return full;
1400 DEFUN ("system-name", Fsystem_name, Ssystem_name, 0, 0, 0,
1401 doc: /* Return the host name of the machine you are running on, as a string. */)
1404 return Vsystem_name;
1407 /* For the benefit of callers who don't want to include lisp.h */
1409 char *
1410 get_system_name ()
1412 if (STRINGP (Vsystem_name))
1413 return (char *) SDATA (Vsystem_name);
1414 else
1415 return "";
1418 char *
1419 get_operating_system_release()
1421 if (STRINGP (Voperating_system_release))
1422 return (char *) SDATA (Voperating_system_release);
1423 else
1424 return "";
1427 DEFUN ("emacs-pid", Femacs_pid, Semacs_pid, 0, 0, 0,
1428 doc: /* Return the process ID of Emacs, as an integer. */)
1431 return make_number (getpid ());
1434 DEFUN ("current-time", Fcurrent_time, Scurrent_time, 0, 0, 0,
1435 doc: /* Return the current time, as the number of seconds since 1970-01-01 00:00:00.
1436 The time is returned as a list of three integers. The first has the
1437 most significant 16 bits of the seconds, while the second has the
1438 least significant 16 bits. The third integer gives the microsecond
1439 count.
1441 The microsecond count is zero on systems that do not provide
1442 resolution finer than a second. */)
1445 EMACS_TIME t;
1447 EMACS_GET_TIME (t);
1448 return list3 (make_number ((EMACS_SECS (t) >> 16) & 0xffff),
1449 make_number ((EMACS_SECS (t) >> 0) & 0xffff),
1450 make_number (EMACS_USECS (t)));
1453 DEFUN ("get-internal-run-time", Fget_internal_run_time, Sget_internal_run_time,
1454 0, 0, 0,
1455 doc: /* Return the current run time used by Emacs.
1456 The time is returned as a list of three integers. The first has the
1457 most significant 16 bits of the seconds, while the second has the
1458 least significant 16 bits. The third integer gives the microsecond
1459 count.
1461 On systems that can't determine the run time, `get-internal-run-time'
1462 does the same thing as `current-time'. The microsecond count is zero
1463 on systems that do not provide resolution finer than a second. */)
1466 #ifdef HAVE_GETRUSAGE
1467 struct rusage usage;
1468 int secs, usecs;
1470 if (getrusage (RUSAGE_SELF, &usage) < 0)
1471 /* This shouldn't happen. What action is appropriate? */
1472 xsignal0 (Qerror);
1474 /* Sum up user time and system time. */
1475 secs = usage.ru_utime.tv_sec + usage.ru_stime.tv_sec;
1476 usecs = usage.ru_utime.tv_usec + usage.ru_stime.tv_usec;
1477 if (usecs >= 1000000)
1479 usecs -= 1000000;
1480 secs++;
1483 return list3 (make_number ((secs >> 16) & 0xffff),
1484 make_number ((secs >> 0) & 0xffff),
1485 make_number (usecs));
1486 #else
1487 return Fcurrent_time ();
1488 #endif
1493 lisp_time_argument (specified_time, result, usec)
1494 Lisp_Object specified_time;
1495 time_t *result;
1496 int *usec;
1498 if (NILP (specified_time))
1500 if (usec)
1502 EMACS_TIME t;
1504 EMACS_GET_TIME (t);
1505 *usec = EMACS_USECS (t);
1506 *result = EMACS_SECS (t);
1507 return 1;
1509 else
1510 return time (result) != -1;
1512 else
1514 Lisp_Object high, low;
1515 high = Fcar (specified_time);
1516 CHECK_NUMBER (high);
1517 low = Fcdr (specified_time);
1518 if (CONSP (low))
1520 if (usec)
1522 Lisp_Object usec_l = Fcdr (low);
1523 if (CONSP (usec_l))
1524 usec_l = Fcar (usec_l);
1525 if (NILP (usec_l))
1526 *usec = 0;
1527 else
1529 CHECK_NUMBER (usec_l);
1530 *usec = XINT (usec_l);
1533 low = Fcar (low);
1535 else if (usec)
1536 *usec = 0;
1537 CHECK_NUMBER (low);
1538 *result = (XINT (high) << 16) + (XINT (low) & 0xffff);
1539 return *result >> 16 == XINT (high);
1543 DEFUN ("float-time", Ffloat_time, Sfloat_time, 0, 1, 0,
1544 doc: /* Return the current time, as a float number of seconds since the epoch.
1545 If SPECIFIED-TIME is given, it is the time to convert to float
1546 instead of the current time. The argument should have the form
1547 (HIGH LOW . IGNORED). Thus, you can use times obtained from
1548 `current-time' and from `file-attributes'. SPECIFIED-TIME can also
1549 have the form (HIGH . LOW), but this is considered obsolete.
1551 WARNING: Since the result is floating point, it may not be exact.
1552 Do not use this function if precise time stamps are required. */)
1553 (specified_time)
1554 Lisp_Object specified_time;
1556 time_t sec;
1557 int usec;
1559 if (! lisp_time_argument (specified_time, &sec, &usec))
1560 error ("Invalid time specification");
1562 return make_float ((sec * 1e6 + usec) / 1e6);
1565 /* Write information into buffer S of size MAXSIZE, according to the
1566 FORMAT of length FORMAT_LEN, using time information taken from *TP.
1567 Default to Universal Time if UT is nonzero, local time otherwise.
1568 Return the number of bytes written, not including the terminating
1569 '\0'. If S is NULL, nothing will be written anywhere; so to
1570 determine how many bytes would be written, use NULL for S and
1571 ((size_t) -1) for MAXSIZE.
1573 This function behaves like emacs_strftimeu, except it allows null
1574 bytes in FORMAT. */
1575 static size_t
1576 emacs_memftimeu (s, maxsize, format, format_len, tp, ut)
1577 char *s;
1578 size_t maxsize;
1579 const char *format;
1580 size_t format_len;
1581 const struct tm *tp;
1582 int ut;
1584 size_t total = 0;
1586 /* Loop through all the null-terminated strings in the format
1587 argument. Normally there's just one null-terminated string, but
1588 there can be arbitrarily many, concatenated together, if the
1589 format contains '\0' bytes. emacs_strftimeu stops at the first
1590 '\0' byte so we must invoke it separately for each such string. */
1591 for (;;)
1593 size_t len;
1594 size_t result;
1596 if (s)
1597 s[0] = '\1';
1599 result = emacs_strftimeu (s, maxsize, format, tp, ut);
1601 if (s)
1603 if (result == 0 && s[0] != '\0')
1604 return 0;
1605 s += result + 1;
1608 maxsize -= result + 1;
1609 total += result;
1610 len = strlen (format);
1611 if (len == format_len)
1612 return total;
1613 total++;
1614 format += len + 1;
1615 format_len -= len + 1;
1619 DEFUN ("format-time-string", Fformat_time_string, Sformat_time_string, 1, 3, 0,
1620 doc: /* Use FORMAT-STRING to format the time TIME, or now if omitted.
1621 TIME is specified as (HIGH LOW . IGNORED), as returned by
1622 `current-time' or `file-attributes'. The obsolete form (HIGH . LOW)
1623 is also still accepted.
1624 The third, optional, argument UNIVERSAL, if non-nil, means describe TIME
1625 as Universal Time; nil means describe TIME in the local time zone.
1626 The value is a copy of FORMAT-STRING, but with certain constructs replaced
1627 by text that describes the specified date and time in TIME:
1629 %Y is the year, %y within the century, %C the century.
1630 %G is the year corresponding to the ISO week, %g within the century.
1631 %m is the numeric month.
1632 %b and %h are the locale's abbreviated month name, %B the full name.
1633 %d is the day of the month, zero-padded, %e is blank-padded.
1634 %u is the numeric day of week from 1 (Monday) to 7, %w from 0 (Sunday) to 6.
1635 %a is the locale's abbreviated name of the day of week, %A the full name.
1636 %U is the week number starting on Sunday, %W starting on Monday,
1637 %V according to ISO 8601.
1638 %j is the day of the year.
1640 %H is the hour on a 24-hour clock, %I is on a 12-hour clock, %k is like %H
1641 only blank-padded, %l is like %I blank-padded.
1642 %p is the locale's equivalent of either AM or PM.
1643 %M is the minute.
1644 %S is the second.
1645 %Z is the time zone name, %z is the numeric form.
1646 %s is the number of seconds since 1970-01-01 00:00:00 +0000.
1648 %c is the locale's date and time format.
1649 %x is the locale's "preferred" date format.
1650 %D is like "%m/%d/%y".
1652 %R is like "%H:%M", %T is like "%H:%M:%S", %r is like "%I:%M:%S %p".
1653 %X is the locale's "preferred" time format.
1655 Finally, %n is a newline, %t is a tab, %% is a literal %.
1657 Certain flags and modifiers are available with some format controls.
1658 The flags are `_', `-', `^' and `#'. For certain characters X,
1659 %_X is like %X, but padded with blanks; %-X is like %X,
1660 but without padding. %^X is like %X, but with all textual
1661 characters up-cased; %#X is like %X, but with letter-case of
1662 all textual characters reversed.
1663 %NX (where N stands for an integer) is like %X,
1664 but takes up at least N (a number) positions.
1665 The modifiers are `E' and `O'. For certain characters X,
1666 %EX is a locale's alternative version of %X;
1667 %OX is like %X, but uses the locale's number symbols.
1669 For example, to produce full ISO 8601 format, use "%Y-%m-%dT%T%z". */)
1670 (format_string, time, universal)
1671 Lisp_Object format_string, time, universal;
1673 time_t value;
1674 int size;
1675 struct tm *tm;
1676 int ut = ! NILP (universal);
1678 CHECK_STRING (format_string);
1680 if (! lisp_time_argument (time, &value, NULL))
1681 error ("Invalid time specification");
1683 format_string = code_convert_string_norecord (format_string,
1684 Vlocale_coding_system, 1);
1686 /* This is probably enough. */
1687 size = SBYTES (format_string) * 6 + 50;
1689 BLOCK_INPUT;
1690 tm = ut ? gmtime (&value) : localtime (&value);
1691 UNBLOCK_INPUT;
1692 if (! tm)
1693 error ("Specified time is not representable");
1695 synchronize_system_time_locale ();
1697 while (1)
1699 char *buf = (char *) alloca (size + 1);
1700 int result;
1702 buf[0] = '\1';
1703 BLOCK_INPUT;
1704 result = emacs_memftimeu (buf, size, SDATA (format_string),
1705 SBYTES (format_string),
1706 tm, ut);
1707 UNBLOCK_INPUT;
1708 if ((result > 0 && result < size) || (result == 0 && buf[0] == '\0'))
1709 return code_convert_string_norecord (make_unibyte_string (buf, result),
1710 Vlocale_coding_system, 0);
1712 /* If buffer was too small, make it bigger and try again. */
1713 BLOCK_INPUT;
1714 result = emacs_memftimeu (NULL, (size_t) -1,
1715 SDATA (format_string),
1716 SBYTES (format_string),
1717 tm, ut);
1718 UNBLOCK_INPUT;
1719 size = result + 1;
1723 DEFUN ("decode-time", Fdecode_time, Sdecode_time, 0, 1, 0,
1724 doc: /* Decode a time value as (SEC MINUTE HOUR DAY MONTH YEAR DOW DST ZONE).
1725 The optional SPECIFIED-TIME should be a list of (HIGH LOW . IGNORED),
1726 as from `current-time' and `file-attributes', or nil to use the
1727 current time. The obsolete form (HIGH . LOW) is also still accepted.
1728 The list has the following nine members: SEC is an integer between 0
1729 and 60; SEC is 60 for a leap second, which only some operating systems
1730 support. MINUTE is an integer between 0 and 59. HOUR is an integer
1731 between 0 and 23. DAY is an integer between 1 and 31. MONTH is an
1732 integer between 1 and 12. YEAR is an integer indicating the
1733 four-digit year. DOW is the day of week, an integer between 0 and 6,
1734 where 0 is Sunday. DST is t if daylight saving time is in effect,
1735 otherwise nil. ZONE is an integer indicating the number of seconds
1736 east of Greenwich. (Note that Common Lisp has different meanings for
1737 DOW and ZONE.) */)
1738 (specified_time)
1739 Lisp_Object specified_time;
1741 time_t time_spec;
1742 struct tm save_tm;
1743 struct tm *decoded_time;
1744 Lisp_Object list_args[9];
1746 if (! lisp_time_argument (specified_time, &time_spec, NULL))
1747 error ("Invalid time specification");
1749 BLOCK_INPUT;
1750 decoded_time = localtime (&time_spec);
1751 UNBLOCK_INPUT;
1752 if (! decoded_time)
1753 error ("Specified time is not representable");
1754 XSETFASTINT (list_args[0], decoded_time->tm_sec);
1755 XSETFASTINT (list_args[1], decoded_time->tm_min);
1756 XSETFASTINT (list_args[2], decoded_time->tm_hour);
1757 XSETFASTINT (list_args[3], decoded_time->tm_mday);
1758 XSETFASTINT (list_args[4], decoded_time->tm_mon + 1);
1759 /* On 64-bit machines an int is narrower than EMACS_INT, thus the
1760 cast below avoids overflow in int arithmetics. */
1761 XSETINT (list_args[5], TM_YEAR_BASE + (EMACS_INT) decoded_time->tm_year);
1762 XSETFASTINT (list_args[6], decoded_time->tm_wday);
1763 list_args[7] = (decoded_time->tm_isdst)? Qt : Qnil;
1765 /* Make a copy, in case gmtime modifies the struct. */
1766 save_tm = *decoded_time;
1767 BLOCK_INPUT;
1768 decoded_time = gmtime (&time_spec);
1769 UNBLOCK_INPUT;
1770 if (decoded_time == 0)
1771 list_args[8] = Qnil;
1772 else
1773 XSETINT (list_args[8], tm_diff (&save_tm, decoded_time));
1774 return Flist (9, list_args);
1777 DEFUN ("encode-time", Fencode_time, Sencode_time, 6, MANY, 0,
1778 doc: /* Convert SECOND, MINUTE, HOUR, DAY, MONTH, YEAR and ZONE to internal time.
1779 This is the reverse operation of `decode-time', which see.
1780 ZONE defaults to the current time zone rule. This can
1781 be a string or t (as from `set-time-zone-rule'), or it can be a list
1782 \(as from `current-time-zone') or an integer (as from `decode-time')
1783 applied without consideration for daylight saving time.
1785 You can pass more than 7 arguments; then the first six arguments
1786 are used as SECOND through YEAR, and the *last* argument is used as ZONE.
1787 The intervening arguments are ignored.
1788 This feature lets (apply 'encode-time (decode-time ...)) work.
1790 Out-of-range values for SECOND, MINUTE, HOUR, DAY, or MONTH are allowed;
1791 for example, a DAY of 0 means the day preceding the given month.
1792 Year numbers less than 100 are treated just like other year numbers.
1793 If you want them to stand for years in this century, you must do that yourself.
1795 Years before 1970 are not guaranteed to work. On some systems,
1796 year values as low as 1901 do work.
1798 usage: (encode-time SECOND MINUTE HOUR DAY MONTH YEAR &optional ZONE) */)
1799 (nargs, args)
1800 int nargs;
1801 register Lisp_Object *args;
1803 time_t time;
1804 struct tm tm;
1805 Lisp_Object zone = (nargs > 6 ? args[nargs - 1] : Qnil);
1807 CHECK_NUMBER (args[0]); /* second */
1808 CHECK_NUMBER (args[1]); /* minute */
1809 CHECK_NUMBER (args[2]); /* hour */
1810 CHECK_NUMBER (args[3]); /* day */
1811 CHECK_NUMBER (args[4]); /* month */
1812 CHECK_NUMBER (args[5]); /* year */
1814 tm.tm_sec = XINT (args[0]);
1815 tm.tm_min = XINT (args[1]);
1816 tm.tm_hour = XINT (args[2]);
1817 tm.tm_mday = XINT (args[3]);
1818 tm.tm_mon = XINT (args[4]) - 1;
1819 tm.tm_year = XINT (args[5]) - TM_YEAR_BASE;
1820 tm.tm_isdst = -1;
1822 if (CONSP (zone))
1823 zone = Fcar (zone);
1824 if (NILP (zone))
1826 BLOCK_INPUT;
1827 time = mktime (&tm);
1828 UNBLOCK_INPUT;
1830 else
1832 char tzbuf[100];
1833 char *tzstring;
1834 char **oldenv = environ, **newenv;
1836 if (EQ (zone, Qt))
1837 tzstring = "UTC0";
1838 else if (STRINGP (zone))
1839 tzstring = (char *) SDATA (zone);
1840 else if (INTEGERP (zone))
1842 int abszone = abs (XINT (zone));
1843 sprintf (tzbuf, "XXX%s%d:%02d:%02d", "-" + (XINT (zone) < 0),
1844 abszone / (60*60), (abszone/60) % 60, abszone % 60);
1845 tzstring = tzbuf;
1847 else
1848 error ("Invalid time zone specification");
1850 /* Set TZ before calling mktime; merely adjusting mktime's returned
1851 value doesn't suffice, since that would mishandle leap seconds. */
1852 set_time_zone_rule (tzstring);
1854 BLOCK_INPUT;
1855 time = mktime (&tm);
1856 UNBLOCK_INPUT;
1858 /* Restore TZ to previous value. */
1859 newenv = environ;
1860 environ = oldenv;
1861 xfree (newenv);
1862 #ifdef LOCALTIME_CACHE
1863 tzset ();
1864 #endif
1867 if (time == (time_t) -1)
1868 error ("Specified time is not representable");
1870 return make_time (time);
1873 DEFUN ("current-time-string", Fcurrent_time_string, Scurrent_time_string, 0, 1, 0,
1874 doc: /* Return the current time, as a human-readable string.
1875 Programs can use this function to decode a time,
1876 since the number of columns in each field is fixed
1877 if the year is in the range 1000-9999.
1878 The format is `Sun Sep 16 01:03:52 1973'.
1879 However, see also the functions `decode-time' and `format-time-string'
1880 which provide a much more powerful and general facility.
1882 If SPECIFIED-TIME is given, it is a time to format instead of the
1883 current time. The argument should have the form (HIGH LOW . IGNORED).
1884 Thus, you can use times obtained from `current-time' and from
1885 `file-attributes'. SPECIFIED-TIME can also have the form (HIGH . LOW),
1886 but this is considered obsolete. */)
1887 (specified_time)
1888 Lisp_Object specified_time;
1890 time_t value;
1891 struct tm *tm;
1892 register char *tem;
1894 if (! lisp_time_argument (specified_time, &value, NULL))
1895 error ("Invalid time specification");
1897 /* Convert to a string, checking for out-of-range time stamps.
1898 Don't use 'ctime', as that might dump core if VALUE is out of
1899 range. */
1900 BLOCK_INPUT;
1901 tm = localtime (&value);
1902 UNBLOCK_INPUT;
1903 if (! (tm && TM_YEAR_IN_ASCTIME_RANGE (tm->tm_year) && (tem = asctime (tm))))
1904 error ("Specified time is not representable");
1906 /* Remove the trailing newline. */
1907 tem[strlen (tem) - 1] = '\0';
1909 return build_string (tem);
1912 /* Yield A - B, measured in seconds.
1913 This function is copied from the GNU C Library. */
1914 static int
1915 tm_diff (a, b)
1916 struct tm *a, *b;
1918 /* Compute intervening leap days correctly even if year is negative.
1919 Take care to avoid int overflow in leap day calculations,
1920 but it's OK to assume that A and B are close to each other. */
1921 int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
1922 int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
1923 int a100 = a4 / 25 - (a4 % 25 < 0);
1924 int b100 = b4 / 25 - (b4 % 25 < 0);
1925 int a400 = a100 >> 2;
1926 int b400 = b100 >> 2;
1927 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
1928 int years = a->tm_year - b->tm_year;
1929 int days = (365 * years + intervening_leap_days
1930 + (a->tm_yday - b->tm_yday));
1931 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
1932 + (a->tm_min - b->tm_min))
1933 + (a->tm_sec - b->tm_sec));
1936 DEFUN ("current-time-zone", Fcurrent_time_zone, Scurrent_time_zone, 0, 1, 0,
1937 doc: /* Return the offset and name for the local time zone.
1938 This returns a list of the form (OFFSET NAME).
1939 OFFSET is an integer number of seconds ahead of UTC (east of Greenwich).
1940 A negative value means west of Greenwich.
1941 NAME is a string giving the name of the time zone.
1942 If SPECIFIED-TIME is given, the time zone offset is determined from it
1943 instead of using the current time. The argument should have the form
1944 (HIGH LOW . IGNORED). Thus, you can use times obtained from
1945 `current-time' and from `file-attributes'. SPECIFIED-TIME can also
1946 have the form (HIGH . LOW), but this is considered obsolete.
1948 Some operating systems cannot provide all this information to Emacs;
1949 in this case, `current-time-zone' returns a list containing nil for
1950 the data it can't find. */)
1951 (specified_time)
1952 Lisp_Object specified_time;
1954 time_t value;
1955 struct tm *t;
1956 struct tm gmt;
1958 if (!lisp_time_argument (specified_time, &value, NULL))
1959 t = NULL;
1960 else
1962 BLOCK_INPUT;
1963 t = gmtime (&value);
1964 if (t)
1966 gmt = *t;
1967 t = localtime (&value);
1969 UNBLOCK_INPUT;
1972 if (t)
1974 int offset = tm_diff (t, &gmt);
1975 char *s = 0;
1976 char buf[6];
1977 #ifdef HAVE_TM_ZONE
1978 if (t->tm_zone)
1979 s = (char *)t->tm_zone;
1980 #else /* not HAVE_TM_ZONE */
1981 #ifdef HAVE_TZNAME
1982 if (t->tm_isdst == 0 || t->tm_isdst == 1)
1983 s = tzname[t->tm_isdst];
1984 #endif
1985 #endif /* not HAVE_TM_ZONE */
1987 #if defined HAVE_TM_ZONE || defined HAVE_TZNAME
1988 if (s)
1990 /* On Japanese w32, we can get a Japanese string as time
1991 zone name. Don't accept that. */
1992 char *p;
1993 for (p = s; *p && (isalnum ((unsigned char)*p) || *p == ' '); ++p)
1995 if (p == s || *p)
1996 s = NULL;
1998 #endif
2000 if (!s)
2002 /* No local time zone name is available; use "+-NNNN" instead. */
2003 int am = (offset < 0 ? -offset : offset) / 60;
2004 sprintf (buf, "%c%02d%02d", (offset < 0 ? '-' : '+'), am/60, am%60);
2005 s = buf;
2007 return Fcons (make_number (offset), Fcons (build_string (s), Qnil));
2009 else
2010 return Fmake_list (make_number (2), Qnil);
2013 /* This holds the value of `environ' produced by the previous
2014 call to Fset_time_zone_rule, or 0 if Fset_time_zone_rule
2015 has never been called. */
2016 static char **environbuf;
2018 DEFUN ("set-time-zone-rule", Fset_time_zone_rule, Sset_time_zone_rule, 1, 1, 0,
2019 doc: /* Set the local time zone using TZ, a string specifying a time zone rule.
2020 If TZ is nil, use implementation-defined default time zone information.
2021 If TZ is t, use Universal Time. */)
2022 (tz)
2023 Lisp_Object tz;
2025 char *tzstring;
2027 if (NILP (tz))
2028 tzstring = 0;
2029 else if (EQ (tz, Qt))
2030 tzstring = "UTC0";
2031 else
2033 CHECK_STRING (tz);
2034 tzstring = (char *) SDATA (tz);
2037 set_time_zone_rule (tzstring);
2038 if (environbuf)
2039 free (environbuf);
2040 environbuf = environ;
2042 return Qnil;
2045 #ifdef LOCALTIME_CACHE
2047 /* These two values are known to load tz files in buggy implementations,
2048 i.e. Solaris 1 executables running under either Solaris 1 or Solaris 2.
2049 Their values shouldn't matter in non-buggy implementations.
2050 We don't use string literals for these strings,
2051 since if a string in the environment is in readonly
2052 storage, it runs afoul of bugs in SVR4 and Solaris 2.3.
2053 See Sun bugs 1113095 and 1114114, ``Timezone routines
2054 improperly modify environment''. */
2056 static char set_time_zone_rule_tz1[] = "TZ=GMT+0";
2057 static char set_time_zone_rule_tz2[] = "TZ=GMT+1";
2059 #endif
2061 /* Set the local time zone rule to TZSTRING.
2062 This allocates memory into `environ', which it is the caller's
2063 responsibility to free. */
2065 void
2066 set_time_zone_rule (tzstring)
2067 char *tzstring;
2069 int envptrs;
2070 char **from, **to, **newenv;
2072 /* Make the ENVIRON vector longer with room for TZSTRING. */
2073 for (from = environ; *from; from++)
2074 continue;
2075 envptrs = from - environ + 2;
2076 newenv = to = (char **) xmalloc (envptrs * sizeof (char *)
2077 + (tzstring ? strlen (tzstring) + 4 : 0));
2079 /* Add TZSTRING to the end of environ, as a value for TZ. */
2080 if (tzstring)
2082 char *t = (char *) (to + envptrs);
2083 strcpy (t, "TZ=");
2084 strcat (t, tzstring);
2085 *to++ = t;
2088 /* Copy the old environ vector elements into NEWENV,
2089 but don't copy the TZ variable.
2090 So we have only one definition of TZ, which came from TZSTRING. */
2091 for (from = environ; *from; from++)
2092 if (strncmp (*from, "TZ=", 3) != 0)
2093 *to++ = *from;
2094 *to = 0;
2096 environ = newenv;
2098 /* If we do have a TZSTRING, NEWENV points to the vector slot where
2099 the TZ variable is stored. If we do not have a TZSTRING,
2100 TO points to the vector slot which has the terminating null. */
2102 #ifdef LOCALTIME_CACHE
2104 /* In SunOS 4.1.3_U1 and 4.1.4, if TZ has a value like
2105 "US/Pacific" that loads a tz file, then changes to a value like
2106 "XXX0" that does not load a tz file, and then changes back to
2107 its original value, the last change is (incorrectly) ignored.
2108 Also, if TZ changes twice in succession to values that do
2109 not load a tz file, tzset can dump core (see Sun bug#1225179).
2110 The following code works around these bugs. */
2112 if (tzstring)
2114 /* Temporarily set TZ to a value that loads a tz file
2115 and that differs from tzstring. */
2116 char *tz = *newenv;
2117 *newenv = (strcmp (tzstring, set_time_zone_rule_tz1 + 3) == 0
2118 ? set_time_zone_rule_tz2 : set_time_zone_rule_tz1);
2119 tzset ();
2120 *newenv = tz;
2122 else
2124 /* The implied tzstring is unknown, so temporarily set TZ to
2125 two different values that each load a tz file. */
2126 *to = set_time_zone_rule_tz1;
2127 to[1] = 0;
2128 tzset ();
2129 *to = set_time_zone_rule_tz2;
2130 tzset ();
2131 *to = 0;
2134 /* Now TZ has the desired value, and tzset can be invoked safely. */
2137 tzset ();
2138 #endif
2141 /* Insert NARGS Lisp objects in the array ARGS by calling INSERT_FUNC
2142 (if a type of object is Lisp_Int) or INSERT_FROM_STRING_FUNC (if a
2143 type of object is Lisp_String). INHERIT is passed to
2144 INSERT_FROM_STRING_FUNC as the last argument. */
2146 static void
2147 general_insert_function (insert_func, insert_from_string_func,
2148 inherit, nargs, args)
2149 void (*insert_func) P_ ((const unsigned char *, int));
2150 void (*insert_from_string_func) P_ ((Lisp_Object, int, int, int, int, int));
2151 int inherit, nargs;
2152 register Lisp_Object *args;
2154 register int argnum;
2155 register Lisp_Object val;
2157 for (argnum = 0; argnum < nargs; argnum++)
2159 val = args[argnum];
2160 if (INTEGERP (val))
2162 unsigned char str[MAX_MULTIBYTE_LENGTH];
2163 int len;
2165 if (!NILP (current_buffer->enable_multibyte_characters))
2166 len = CHAR_STRING (XFASTINT (val), str);
2167 else
2169 str[0] = (SINGLE_BYTE_CHAR_P (XINT (val))
2170 ? XINT (val)
2171 : multibyte_char_to_unibyte (XINT (val), Qnil));
2172 len = 1;
2174 (*insert_func) (str, len);
2176 else if (STRINGP (val))
2178 (*insert_from_string_func) (val, 0, 0,
2179 SCHARS (val),
2180 SBYTES (val),
2181 inherit);
2183 else
2184 wrong_type_argument (Qchar_or_string_p, val);
2188 void
2189 insert1 (arg)
2190 Lisp_Object arg;
2192 Finsert (1, &arg);
2196 /* Callers passing one argument to Finsert need not gcpro the
2197 argument "array", since the only element of the array will
2198 not be used after calling insert or insert_from_string, so
2199 we don't care if it gets trashed. */
2201 DEFUN ("insert", Finsert, Sinsert, 0, MANY, 0,
2202 doc: /* Insert the arguments, either strings or characters, at point.
2203 Point and before-insertion markers move forward to end up
2204 after the inserted text.
2205 Any other markers at the point of insertion remain before the text.
2207 If the current buffer is multibyte, unibyte strings are converted
2208 to multibyte for insertion (see `string-make-multibyte').
2209 If the current buffer is unibyte, multibyte strings are converted
2210 to unibyte for insertion (see `string-make-unibyte').
2212 When operating on binary data, it may be necessary to preserve the
2213 original bytes of a unibyte string when inserting it into a multibyte
2214 buffer; to accomplish this, apply `string-as-multibyte' to the string
2215 and insert the result.
2217 usage: (insert &rest ARGS) */)
2218 (nargs, args)
2219 int nargs;
2220 register Lisp_Object *args;
2222 general_insert_function (insert, insert_from_string, 0, nargs, args);
2223 return Qnil;
2226 DEFUN ("insert-and-inherit", Finsert_and_inherit, Sinsert_and_inherit,
2227 0, MANY, 0,
2228 doc: /* Insert the arguments at point, inheriting properties from adjoining text.
2229 Point and before-insertion markers move forward to end up
2230 after the inserted text.
2231 Any other markers at the point of insertion remain before the text.
2233 If the current buffer is multibyte, unibyte strings are converted
2234 to multibyte for insertion (see `unibyte-char-to-multibyte').
2235 If the current buffer is unibyte, multibyte strings are converted
2236 to unibyte for insertion.
2238 usage: (insert-and-inherit &rest ARGS) */)
2239 (nargs, args)
2240 int nargs;
2241 register Lisp_Object *args;
2243 general_insert_function (insert_and_inherit, insert_from_string, 1,
2244 nargs, args);
2245 return Qnil;
2248 DEFUN ("insert-before-markers", Finsert_before_markers, Sinsert_before_markers, 0, MANY, 0,
2249 doc: /* Insert strings or characters at point, relocating markers after the text.
2250 Point and markers move forward to end up after the inserted text.
2252 If the current buffer is multibyte, unibyte strings are converted
2253 to multibyte for insertion (see `unibyte-char-to-multibyte').
2254 If the current buffer is unibyte, multibyte strings are converted
2255 to unibyte for insertion.
2257 usage: (insert-before-markers &rest ARGS) */)
2258 (nargs, args)
2259 int nargs;
2260 register Lisp_Object *args;
2262 general_insert_function (insert_before_markers,
2263 insert_from_string_before_markers, 0,
2264 nargs, args);
2265 return Qnil;
2268 DEFUN ("insert-before-markers-and-inherit", Finsert_and_inherit_before_markers,
2269 Sinsert_and_inherit_before_markers, 0, MANY, 0,
2270 doc: /* Insert text at point, relocating markers and inheriting properties.
2271 Point and markers move forward to end up after the inserted text.
2273 If the current buffer is multibyte, unibyte strings are converted
2274 to multibyte for insertion (see `unibyte-char-to-multibyte').
2275 If the current buffer is unibyte, multibyte strings are converted
2276 to unibyte for insertion.
2278 usage: (insert-before-markers-and-inherit &rest ARGS) */)
2279 (nargs, args)
2280 int nargs;
2281 register Lisp_Object *args;
2283 general_insert_function (insert_before_markers_and_inherit,
2284 insert_from_string_before_markers, 1,
2285 nargs, args);
2286 return Qnil;
2289 DEFUN ("insert-char", Finsert_char, Sinsert_char, 2, 3, 0,
2290 doc: /* Insert COUNT copies of CHARACTER.
2291 Point, and before-insertion markers, are relocated as in the function `insert'.
2292 The optional third arg INHERIT, if non-nil, says to inherit text properties
2293 from adjoining text, if those properties are sticky. */)
2294 (character, count, inherit)
2295 Lisp_Object character, count, inherit;
2297 register unsigned char *string;
2298 register int strlen;
2299 register int i, n;
2300 int len;
2301 unsigned char str[MAX_MULTIBYTE_LENGTH];
2303 CHECK_NUMBER (character);
2304 CHECK_NUMBER (count);
2306 if (!NILP (current_buffer->enable_multibyte_characters))
2307 len = CHAR_STRING (XFASTINT (character), str);
2308 else
2309 str[0] = XFASTINT (character), len = 1;
2310 n = XINT (count) * len;
2311 if (n <= 0)
2312 return Qnil;
2313 strlen = min (n, 256 * len);
2314 string = (unsigned char *) alloca (strlen);
2315 for (i = 0; i < strlen; i++)
2316 string[i] = str[i % len];
2317 while (n >= strlen)
2319 QUIT;
2320 if (!NILP (inherit))
2321 insert_and_inherit (string, strlen);
2322 else
2323 insert (string, strlen);
2324 n -= strlen;
2326 if (n > 0)
2328 if (!NILP (inherit))
2329 insert_and_inherit (string, n);
2330 else
2331 insert (string, n);
2333 return Qnil;
2337 /* Making strings from buffer contents. */
2339 /* Return a Lisp_String containing the text of the current buffer from
2340 START to END. If text properties are in use and the current buffer
2341 has properties in the range specified, the resulting string will also
2342 have them, if PROPS is nonzero.
2344 We don't want to use plain old make_string here, because it calls
2345 make_uninit_string, which can cause the buffer arena to be
2346 compacted. make_string has no way of knowing that the data has
2347 been moved, and thus copies the wrong data into the string. This
2348 doesn't effect most of the other users of make_string, so it should
2349 be left as is. But we should use this function when conjuring
2350 buffer substrings. */
2352 Lisp_Object
2353 make_buffer_string (start, end, props)
2354 int start, end;
2355 int props;
2357 int start_byte = CHAR_TO_BYTE (start);
2358 int end_byte = CHAR_TO_BYTE (end);
2360 return make_buffer_string_both (start, start_byte, end, end_byte, props);
2363 /* Return a Lisp_String containing the text of the current buffer from
2364 START / START_BYTE to END / END_BYTE.
2366 If text properties are in use and the current buffer
2367 has properties in the range specified, the resulting string will also
2368 have them, if PROPS is nonzero.
2370 We don't want to use plain old make_string here, because it calls
2371 make_uninit_string, which can cause the buffer arena to be
2372 compacted. make_string has no way of knowing that the data has
2373 been moved, and thus copies the wrong data into the string. This
2374 doesn't effect most of the other users of make_string, so it should
2375 be left as is. But we should use this function when conjuring
2376 buffer substrings. */
2378 Lisp_Object
2379 make_buffer_string_both (start, start_byte, end, end_byte, props)
2380 int start, start_byte, end, end_byte;
2381 int props;
2383 Lisp_Object result, tem, tem1;
2385 if (start < GPT && GPT < end)
2386 move_gap (start);
2388 if (! NILP (current_buffer->enable_multibyte_characters))
2389 result = make_uninit_multibyte_string (end - start, end_byte - start_byte);
2390 else
2391 result = make_uninit_string (end - start);
2392 bcopy (BYTE_POS_ADDR (start_byte), SDATA (result),
2393 end_byte - start_byte);
2395 /* If desired, update and copy the text properties. */
2396 if (props)
2398 update_buffer_properties (start, end);
2400 tem = Fnext_property_change (make_number (start), Qnil, make_number (end));
2401 tem1 = Ftext_properties_at (make_number (start), Qnil);
2403 if (XINT (tem) != end || !NILP (tem1))
2404 copy_intervals_to_string (result, current_buffer, start,
2405 end - start);
2408 return result;
2411 /* Call Vbuffer_access_fontify_functions for the range START ... END
2412 in the current buffer, if necessary. */
2414 static void
2415 update_buffer_properties (start, end)
2416 int start, end;
2418 /* If this buffer has some access functions,
2419 call them, specifying the range of the buffer being accessed. */
2420 if (!NILP (Vbuffer_access_fontify_functions))
2422 Lisp_Object args[3];
2423 Lisp_Object tem;
2425 args[0] = Qbuffer_access_fontify_functions;
2426 XSETINT (args[1], start);
2427 XSETINT (args[2], end);
2429 /* But don't call them if we can tell that the work
2430 has already been done. */
2431 if (!NILP (Vbuffer_access_fontified_property))
2433 tem = Ftext_property_any (args[1], args[2],
2434 Vbuffer_access_fontified_property,
2435 Qnil, Qnil);
2436 if (! NILP (tem))
2437 Frun_hook_with_args (3, args);
2439 else
2440 Frun_hook_with_args (3, args);
2444 DEFUN ("buffer-substring", Fbuffer_substring, Sbuffer_substring, 2, 2, 0,
2445 doc: /* Return the contents of part of the current buffer as a string.
2446 The two arguments START and END are character positions;
2447 they can be in either order.
2448 The string returned is multibyte if the buffer is multibyte.
2450 This function copies the text properties of that part of the buffer
2451 into the result string; if you don't want the text properties,
2452 use `buffer-substring-no-properties' instead. */)
2453 (start, end)
2454 Lisp_Object start, end;
2456 register int b, e;
2458 validate_region (&start, &end);
2459 b = XINT (start);
2460 e = XINT (end);
2462 return make_buffer_string (b, e, 1);
2465 DEFUN ("buffer-substring-no-properties", Fbuffer_substring_no_properties,
2466 Sbuffer_substring_no_properties, 2, 2, 0,
2467 doc: /* Return the characters of part of the buffer, without the text properties.
2468 The two arguments START and END are character positions;
2469 they can be in either order. */)
2470 (start, end)
2471 Lisp_Object start, end;
2473 register int b, e;
2475 validate_region (&start, &end);
2476 b = XINT (start);
2477 e = XINT (end);
2479 return make_buffer_string (b, e, 0);
2482 DEFUN ("buffer-string", Fbuffer_string, Sbuffer_string, 0, 0, 0,
2483 doc: /* Return the contents of the current buffer as a string.
2484 If narrowing is in effect, this function returns only the visible part
2485 of the buffer. */)
2488 return make_buffer_string (BEGV, ZV, 1);
2491 DEFUN ("insert-buffer-substring", Finsert_buffer_substring, Sinsert_buffer_substring,
2492 1, 3, 0,
2493 doc: /* Insert before point a substring of the contents of BUFFER.
2494 BUFFER may be a buffer or a buffer name.
2495 Arguments START and END are character positions specifying the substring.
2496 They default to the values of (point-min) and (point-max) in BUFFER. */)
2497 (buffer, start, end)
2498 Lisp_Object buffer, start, end;
2500 register int b, e, temp;
2501 register struct buffer *bp, *obuf;
2502 Lisp_Object buf;
2504 buf = Fget_buffer (buffer);
2505 if (NILP (buf))
2506 nsberror (buffer);
2507 bp = XBUFFER (buf);
2508 if (NILP (bp->name))
2509 error ("Selecting deleted buffer");
2511 if (NILP (start))
2512 b = BUF_BEGV (bp);
2513 else
2515 CHECK_NUMBER_COERCE_MARKER (start);
2516 b = XINT (start);
2518 if (NILP (end))
2519 e = BUF_ZV (bp);
2520 else
2522 CHECK_NUMBER_COERCE_MARKER (end);
2523 e = XINT (end);
2526 if (b > e)
2527 temp = b, b = e, e = temp;
2529 if (!(BUF_BEGV (bp) <= b && e <= BUF_ZV (bp)))
2530 args_out_of_range (start, end);
2532 obuf = current_buffer;
2533 set_buffer_internal_1 (bp);
2534 update_buffer_properties (b, e);
2535 set_buffer_internal_1 (obuf);
2537 insert_from_buffer (bp, b, e - b, 0);
2538 return Qnil;
2541 DEFUN ("compare-buffer-substrings", Fcompare_buffer_substrings, Scompare_buffer_substrings,
2542 6, 6, 0,
2543 doc: /* Compare two substrings of two buffers; return result as number.
2544 the value is -N if first string is less after N-1 chars,
2545 +N if first string is greater after N-1 chars, or 0 if strings match.
2546 Each substring is represented as three arguments: BUFFER, START and END.
2547 That makes six args in all, three for each substring.
2549 The value of `case-fold-search' in the current buffer
2550 determines whether case is significant or ignored. */)
2551 (buffer1, start1, end1, buffer2, start2, end2)
2552 Lisp_Object buffer1, start1, end1, buffer2, start2, end2;
2554 register int begp1, endp1, begp2, endp2, temp;
2555 register struct buffer *bp1, *bp2;
2556 register Lisp_Object trt
2557 = (!NILP (current_buffer->case_fold_search)
2558 ? current_buffer->case_canon_table : Qnil);
2559 int chars = 0;
2560 int i1, i2, i1_byte, i2_byte;
2562 /* Find the first buffer and its substring. */
2564 if (NILP (buffer1))
2565 bp1 = current_buffer;
2566 else
2568 Lisp_Object buf1;
2569 buf1 = Fget_buffer (buffer1);
2570 if (NILP (buf1))
2571 nsberror (buffer1);
2572 bp1 = XBUFFER (buf1);
2573 if (NILP (bp1->name))
2574 error ("Selecting deleted buffer");
2577 if (NILP (start1))
2578 begp1 = BUF_BEGV (bp1);
2579 else
2581 CHECK_NUMBER_COERCE_MARKER (start1);
2582 begp1 = XINT (start1);
2584 if (NILP (end1))
2585 endp1 = BUF_ZV (bp1);
2586 else
2588 CHECK_NUMBER_COERCE_MARKER (end1);
2589 endp1 = XINT (end1);
2592 if (begp1 > endp1)
2593 temp = begp1, begp1 = endp1, endp1 = temp;
2595 if (!(BUF_BEGV (bp1) <= begp1
2596 && begp1 <= endp1
2597 && endp1 <= BUF_ZV (bp1)))
2598 args_out_of_range (start1, end1);
2600 /* Likewise for second substring. */
2602 if (NILP (buffer2))
2603 bp2 = current_buffer;
2604 else
2606 Lisp_Object buf2;
2607 buf2 = Fget_buffer (buffer2);
2608 if (NILP (buf2))
2609 nsberror (buffer2);
2610 bp2 = XBUFFER (buf2);
2611 if (NILP (bp2->name))
2612 error ("Selecting deleted buffer");
2615 if (NILP (start2))
2616 begp2 = BUF_BEGV (bp2);
2617 else
2619 CHECK_NUMBER_COERCE_MARKER (start2);
2620 begp2 = XINT (start2);
2622 if (NILP (end2))
2623 endp2 = BUF_ZV (bp2);
2624 else
2626 CHECK_NUMBER_COERCE_MARKER (end2);
2627 endp2 = XINT (end2);
2630 if (begp2 > endp2)
2631 temp = begp2, begp2 = endp2, endp2 = temp;
2633 if (!(BUF_BEGV (bp2) <= begp2
2634 && begp2 <= endp2
2635 && endp2 <= BUF_ZV (bp2)))
2636 args_out_of_range (start2, end2);
2638 i1 = begp1;
2639 i2 = begp2;
2640 i1_byte = buf_charpos_to_bytepos (bp1, i1);
2641 i2_byte = buf_charpos_to_bytepos (bp2, i2);
2643 while (i1 < endp1 && i2 < endp2)
2645 /* When we find a mismatch, we must compare the
2646 characters, not just the bytes. */
2647 int c1, c2;
2649 QUIT;
2651 if (! NILP (bp1->enable_multibyte_characters))
2653 c1 = BUF_FETCH_MULTIBYTE_CHAR (bp1, i1_byte);
2654 BUF_INC_POS (bp1, i1_byte);
2655 i1++;
2657 else
2659 c1 = BUF_FETCH_BYTE (bp1, i1);
2660 c1 = unibyte_char_to_multibyte (c1);
2661 i1++;
2664 if (! NILP (bp2->enable_multibyte_characters))
2666 c2 = BUF_FETCH_MULTIBYTE_CHAR (bp2, i2_byte);
2667 BUF_INC_POS (bp2, i2_byte);
2668 i2++;
2670 else
2672 c2 = BUF_FETCH_BYTE (bp2, i2);
2673 c2 = unibyte_char_to_multibyte (c2);
2674 i2++;
2677 if (!NILP (trt))
2679 c1 = CHAR_TABLE_TRANSLATE (trt, c1);
2680 c2 = CHAR_TABLE_TRANSLATE (trt, c2);
2682 if (c1 < c2)
2683 return make_number (- 1 - chars);
2684 if (c1 > c2)
2685 return make_number (chars + 1);
2687 chars++;
2690 /* The strings match as far as they go.
2691 If one is shorter, that one is less. */
2692 if (chars < endp1 - begp1)
2693 return make_number (chars + 1);
2694 else if (chars < endp2 - begp2)
2695 return make_number (- chars - 1);
2697 /* Same length too => they are equal. */
2698 return make_number (0);
2701 static Lisp_Object
2702 subst_char_in_region_unwind (arg)
2703 Lisp_Object arg;
2705 return current_buffer->undo_list = arg;
2708 static Lisp_Object
2709 subst_char_in_region_unwind_1 (arg)
2710 Lisp_Object arg;
2712 return current_buffer->filename = arg;
2715 DEFUN ("subst-char-in-region", Fsubst_char_in_region,
2716 Ssubst_char_in_region, 4, 5, 0,
2717 doc: /* From START to END, replace FROMCHAR with TOCHAR each time it occurs.
2718 If optional arg NOUNDO is non-nil, don't record this change for undo
2719 and don't mark the buffer as really changed.
2720 Both characters must have the same length of multi-byte form. */)
2721 (start, end, fromchar, tochar, noundo)
2722 Lisp_Object start, end, fromchar, tochar, noundo;
2724 register int pos, pos_byte, stop, i, len, end_byte;
2725 /* Keep track of the first change in the buffer:
2726 if 0 we haven't found it yet.
2727 if < 0 we've found it and we've run the before-change-function.
2728 if > 0 we've actually performed it and the value is its position. */
2729 int changed = 0;
2730 unsigned char fromstr[MAX_MULTIBYTE_LENGTH], tostr[MAX_MULTIBYTE_LENGTH];
2731 unsigned char *p;
2732 int count = SPECPDL_INDEX ();
2733 #define COMBINING_NO 0
2734 #define COMBINING_BEFORE 1
2735 #define COMBINING_AFTER 2
2736 #define COMBINING_BOTH (COMBINING_BEFORE | COMBINING_AFTER)
2737 int maybe_byte_combining = COMBINING_NO;
2738 int last_changed = 0;
2739 int multibyte_p = !NILP (current_buffer->enable_multibyte_characters);
2741 restart:
2743 validate_region (&start, &end);
2744 CHECK_NUMBER (fromchar);
2745 CHECK_NUMBER (tochar);
2747 if (multibyte_p)
2749 len = CHAR_STRING (XFASTINT (fromchar), fromstr);
2750 if (CHAR_STRING (XFASTINT (tochar), tostr) != len)
2751 error ("Characters in `subst-char-in-region' have different byte-lengths");
2752 if (!ASCII_BYTE_P (*tostr))
2754 /* If *TOSTR is in the range 0x80..0x9F and TOCHAR is not a
2755 complete multibyte character, it may be combined with the
2756 after bytes. If it is in the range 0xA0..0xFF, it may be
2757 combined with the before and after bytes. */
2758 if (!CHAR_HEAD_P (*tostr))
2759 maybe_byte_combining = COMBINING_BOTH;
2760 else if (BYTES_BY_CHAR_HEAD (*tostr) > len)
2761 maybe_byte_combining = COMBINING_AFTER;
2764 else
2766 len = 1;
2767 fromstr[0] = XFASTINT (fromchar);
2768 tostr[0] = XFASTINT (tochar);
2771 pos = XINT (start);
2772 pos_byte = CHAR_TO_BYTE (pos);
2773 stop = CHAR_TO_BYTE (XINT (end));
2774 end_byte = stop;
2776 /* If we don't want undo, turn off putting stuff on the list.
2777 That's faster than getting rid of things,
2778 and it prevents even the entry for a first change.
2779 Also inhibit locking the file. */
2780 if (!changed && !NILP (noundo))
2782 record_unwind_protect (subst_char_in_region_unwind,
2783 current_buffer->undo_list);
2784 current_buffer->undo_list = Qt;
2785 /* Don't do file-locking. */
2786 record_unwind_protect (subst_char_in_region_unwind_1,
2787 current_buffer->filename);
2788 current_buffer->filename = Qnil;
2791 if (pos_byte < GPT_BYTE)
2792 stop = min (stop, GPT_BYTE);
2793 while (1)
2795 int pos_byte_next = pos_byte;
2797 if (pos_byte >= stop)
2799 if (pos_byte >= end_byte) break;
2800 stop = end_byte;
2802 p = BYTE_POS_ADDR (pos_byte);
2803 if (multibyte_p)
2804 INC_POS (pos_byte_next);
2805 else
2806 ++pos_byte_next;
2807 if (pos_byte_next - pos_byte == len
2808 && p[0] == fromstr[0]
2809 && (len == 1
2810 || (p[1] == fromstr[1]
2811 && (len == 2 || (p[2] == fromstr[2]
2812 && (len == 3 || p[3] == fromstr[3]))))))
2814 if (changed < 0)
2815 /* We've already seen this and run the before-change-function;
2816 this time we only need to record the actual position. */
2817 changed = pos;
2818 else if (!changed)
2820 changed = -1;
2821 modify_region (current_buffer, pos, XINT (end), 0);
2823 if (! NILP (noundo))
2825 if (MODIFF - 1 == SAVE_MODIFF)
2826 SAVE_MODIFF++;
2827 if (MODIFF - 1 == current_buffer->auto_save_modified)
2828 current_buffer->auto_save_modified++;
2831 /* The before-change-function may have moved the gap
2832 or even modified the buffer so we should start over. */
2833 goto restart;
2836 /* Take care of the case where the new character
2837 combines with neighboring bytes. */
2838 if (maybe_byte_combining
2839 && (maybe_byte_combining == COMBINING_AFTER
2840 ? (pos_byte_next < Z_BYTE
2841 && ! CHAR_HEAD_P (FETCH_BYTE (pos_byte_next)))
2842 : ((pos_byte_next < Z_BYTE
2843 && ! CHAR_HEAD_P (FETCH_BYTE (pos_byte_next)))
2844 || (pos_byte > BEG_BYTE
2845 && ! ASCII_BYTE_P (FETCH_BYTE (pos_byte - 1))))))
2847 Lisp_Object tem, string;
2849 struct gcpro gcpro1;
2851 tem = current_buffer->undo_list;
2852 GCPRO1 (tem);
2854 /* Make a multibyte string containing this single character. */
2855 string = make_multibyte_string (tostr, 1, len);
2856 /* replace_range is less efficient, because it moves the gap,
2857 but it handles combining correctly. */
2858 replace_range (pos, pos + 1, string,
2859 0, 0, 1);
2860 pos_byte_next = CHAR_TO_BYTE (pos);
2861 if (pos_byte_next > pos_byte)
2862 /* Before combining happened. We should not increment
2863 POS. So, to cancel the later increment of POS,
2864 decrease it now. */
2865 pos--;
2866 else
2867 INC_POS (pos_byte_next);
2869 if (! NILP (noundo))
2870 current_buffer->undo_list = tem;
2872 UNGCPRO;
2874 else
2876 if (NILP (noundo))
2877 record_change (pos, 1);
2878 for (i = 0; i < len; i++) *p++ = tostr[i];
2880 last_changed = pos + 1;
2882 pos_byte = pos_byte_next;
2883 pos++;
2886 if (changed > 0)
2888 signal_after_change (changed,
2889 last_changed - changed, last_changed - changed);
2890 update_compositions (changed, last_changed, CHECK_ALL);
2893 unbind_to (count, Qnil);
2894 return Qnil;
2897 DEFUN ("translate-region-internal", Ftranslate_region_internal,
2898 Stranslate_region_internal, 3, 3, 0,
2899 doc: /* Internal use only.
2900 From START to END, translate characters according to TABLE.
2901 TABLE is a string; the Nth character in it is the mapping
2902 for the character with code N.
2903 It returns the number of characters changed. */)
2904 (start, end, table)
2905 Lisp_Object start;
2906 Lisp_Object end;
2907 register Lisp_Object table;
2909 register unsigned char *tt; /* Trans table. */
2910 register int nc; /* New character. */
2911 int cnt; /* Number of changes made. */
2912 int size; /* Size of translate table. */
2913 int pos, pos_byte, end_pos;
2914 int multibyte = !NILP (current_buffer->enable_multibyte_characters);
2915 int string_multibyte;
2917 validate_region (&start, &end);
2918 if (CHAR_TABLE_P (table))
2920 size = MAX_CHAR;
2921 tt = NULL;
2923 else
2925 CHECK_STRING (table);
2927 if (! multibyte && (SCHARS (table) < SBYTES (table)))
2928 table = string_make_unibyte (table);
2929 string_multibyte = SCHARS (table) < SBYTES (table);
2930 size = SCHARS (table);
2931 tt = SDATA (table);
2934 pos = XINT (start);
2935 pos_byte = CHAR_TO_BYTE (pos);
2936 end_pos = XINT (end);
2937 modify_region (current_buffer, pos, XINT (end), 0);
2939 cnt = 0;
2940 for (; pos < end_pos; )
2942 register unsigned char *p = BYTE_POS_ADDR (pos_byte);
2943 unsigned char *str, buf[MAX_MULTIBYTE_LENGTH];
2944 int len, str_len;
2945 int oc;
2947 if (multibyte)
2948 oc = STRING_CHAR_AND_LENGTH (p, MAX_MULTIBYTE_LENGTH, len);
2949 else
2950 oc = *p, len = 1;
2951 if (oc < size)
2953 if (tt)
2955 /* Reload as signal_after_change in last iteration may GC. */
2956 tt = SDATA (table);
2957 if (string_multibyte)
2959 str = tt + string_char_to_byte (table, oc);
2960 nc = STRING_CHAR_AND_LENGTH (str, MAX_MULTIBYTE_LENGTH,
2961 str_len);
2963 else
2965 nc = tt[oc];
2966 if (! ASCII_BYTE_P (nc) && multibyte)
2968 str_len = CHAR_STRING (nc, buf);
2969 str = buf;
2971 else
2973 str_len = 1;
2974 str = tt + oc;
2978 else
2980 Lisp_Object val;
2981 int c;
2983 nc = oc;
2984 val = CHAR_TABLE_REF (table, oc);
2985 if (INTEGERP (val)
2986 && (c = XINT (val), CHAR_VALID_P (c, 0)))
2988 nc = c;
2989 str_len = CHAR_STRING (nc, buf);
2990 str = buf;
2994 if (nc != oc)
2996 if (len != str_len)
2998 Lisp_Object string;
3000 /* This is less efficient, because it moves the gap,
3001 but it should multibyte characters correctly. */
3002 string = make_multibyte_string (str, 1, str_len);
3003 replace_range (pos, pos + 1, string, 1, 0, 1);
3004 len = str_len;
3006 else
3008 record_change (pos, 1);
3009 while (str_len-- > 0)
3010 *p++ = *str++;
3011 signal_after_change (pos, 1, 1);
3012 update_compositions (pos, pos + 1, CHECK_BORDER);
3014 ++cnt;
3017 pos_byte += len;
3018 pos++;
3021 return make_number (cnt);
3024 DEFUN ("delete-region", Fdelete_region, Sdelete_region, 2, 2, "r",
3025 doc: /* Delete the text between point and mark.
3027 When called from a program, expects two arguments,
3028 positions (integers or markers) specifying the stretch to be deleted. */)
3029 (start, end)
3030 Lisp_Object start, end;
3032 validate_region (&start, &end);
3033 del_range (XINT (start), XINT (end));
3034 return Qnil;
3037 DEFUN ("delete-and-extract-region", Fdelete_and_extract_region,
3038 Sdelete_and_extract_region, 2, 2, 0,
3039 doc: /* Delete the text between START and END and return it. */)
3040 (start, end)
3041 Lisp_Object start, end;
3043 validate_region (&start, &end);
3044 if (XINT (start) == XINT (end))
3045 return build_string ("");
3046 return del_range_1 (XINT (start), XINT (end), 1, 1);
3049 DEFUN ("widen", Fwiden, Swiden, 0, 0, "",
3050 doc: /* Remove restrictions (narrowing) from current buffer.
3051 This allows the buffer's full text to be seen and edited. */)
3054 if (BEG != BEGV || Z != ZV)
3055 current_buffer->clip_changed = 1;
3056 BEGV = BEG;
3057 BEGV_BYTE = BEG_BYTE;
3058 SET_BUF_ZV_BOTH (current_buffer, Z, Z_BYTE);
3059 /* Changing the buffer bounds invalidates any recorded current column. */
3060 invalidate_current_column ();
3061 return Qnil;
3064 DEFUN ("narrow-to-region", Fnarrow_to_region, Snarrow_to_region, 2, 2, "r",
3065 doc: /* Restrict editing in this buffer to the current region.
3066 The rest of the text becomes temporarily invisible and untouchable
3067 but is not deleted; if you save the buffer in a file, the invisible
3068 text is included in the file. \\[widen] makes all visible again.
3069 See also `save-restriction'.
3071 When calling from a program, pass two arguments; positions (integers
3072 or markers) bounding the text that should remain visible. */)
3073 (start, end)
3074 register Lisp_Object start, end;
3076 CHECK_NUMBER_COERCE_MARKER (start);
3077 CHECK_NUMBER_COERCE_MARKER (end);
3079 if (XINT (start) > XINT (end))
3081 Lisp_Object tem;
3082 tem = start; start = end; end = tem;
3085 if (!(BEG <= XINT (start) && XINT (start) <= XINT (end) && XINT (end) <= Z))
3086 args_out_of_range (start, end);
3088 if (BEGV != XFASTINT (start) || ZV != XFASTINT (end))
3089 current_buffer->clip_changed = 1;
3091 SET_BUF_BEGV (current_buffer, XFASTINT (start));
3092 SET_BUF_ZV (current_buffer, XFASTINT (end));
3093 if (PT < XFASTINT (start))
3094 SET_PT (XFASTINT (start));
3095 if (PT > XFASTINT (end))
3096 SET_PT (XFASTINT (end));
3097 /* Changing the buffer bounds invalidates any recorded current column. */
3098 invalidate_current_column ();
3099 return Qnil;
3102 Lisp_Object
3103 save_restriction_save ()
3105 if (BEGV == BEG && ZV == Z)
3106 /* The common case that the buffer isn't narrowed.
3107 We return just the buffer object, which save_restriction_restore
3108 recognizes as meaning `no restriction'. */
3109 return Fcurrent_buffer ();
3110 else
3111 /* We have to save a restriction, so return a pair of markers, one
3112 for the beginning and one for the end. */
3114 Lisp_Object beg, end;
3116 beg = buildmark (BEGV, BEGV_BYTE);
3117 end = buildmark (ZV, ZV_BYTE);
3119 /* END must move forward if text is inserted at its exact location. */
3120 XMARKER(end)->insertion_type = 1;
3122 return Fcons (beg, end);
3126 Lisp_Object
3127 save_restriction_restore (data)
3128 Lisp_Object data;
3130 if (CONSP (data))
3131 /* A pair of marks bounding a saved restriction. */
3133 struct Lisp_Marker *beg = XMARKER (XCAR (data));
3134 struct Lisp_Marker *end = XMARKER (XCDR (data));
3135 struct buffer *buf = beg->buffer; /* END should have the same buffer. */
3137 if (buf /* Verify marker still points to a buffer. */
3138 && (beg->charpos != BUF_BEGV (buf) || end->charpos != BUF_ZV (buf)))
3139 /* The restriction has changed from the saved one, so restore
3140 the saved restriction. */
3142 int pt = BUF_PT (buf);
3144 SET_BUF_BEGV_BOTH (buf, beg->charpos, beg->bytepos);
3145 SET_BUF_ZV_BOTH (buf, end->charpos, end->bytepos);
3147 if (pt < beg->charpos || pt > end->charpos)
3148 /* The point is outside the new visible range, move it inside. */
3149 SET_BUF_PT_BOTH (buf,
3150 clip_to_bounds (beg->charpos, pt, end->charpos),
3151 clip_to_bounds (beg->bytepos, BUF_PT_BYTE (buf),
3152 end->bytepos));
3154 buf->clip_changed = 1; /* Remember that the narrowing changed. */
3157 else
3158 /* A buffer, which means that there was no old restriction. */
3160 struct buffer *buf = XBUFFER (data);
3162 if (buf /* Verify marker still points to a buffer. */
3163 && (BUF_BEGV (buf) != BUF_BEG (buf) || BUF_ZV (buf) != BUF_Z (buf)))
3164 /* The buffer has been narrowed, get rid of the narrowing. */
3166 SET_BUF_BEGV_BOTH (buf, BUF_BEG (buf), BUF_BEG_BYTE (buf));
3167 SET_BUF_ZV_BOTH (buf, BUF_Z (buf), BUF_Z_BYTE (buf));
3169 buf->clip_changed = 1; /* Remember that the narrowing changed. */
3173 return Qnil;
3176 DEFUN ("save-restriction", Fsave_restriction, Ssave_restriction, 0, UNEVALLED, 0,
3177 doc: /* Execute BODY, saving and restoring current buffer's restrictions.
3178 The buffer's restrictions make parts of the beginning and end invisible.
3179 \(They are set up with `narrow-to-region' and eliminated with `widen'.)
3180 This special form, `save-restriction', saves the current buffer's restrictions
3181 when it is entered, and restores them when it is exited.
3182 So any `narrow-to-region' within BODY lasts only until the end of the form.
3183 The old restrictions settings are restored
3184 even in case of abnormal exit (throw or error).
3186 The value returned is the value of the last form in BODY.
3188 Note: if you are using both `save-excursion' and `save-restriction',
3189 use `save-excursion' outermost:
3190 (save-excursion (save-restriction ...))
3192 usage: (save-restriction &rest BODY) */)
3193 (body)
3194 Lisp_Object body;
3196 register Lisp_Object val;
3197 int count = SPECPDL_INDEX ();
3199 record_unwind_protect (save_restriction_restore, save_restriction_save ());
3200 val = Fprogn (body);
3201 return unbind_to (count, val);
3204 /* Buffer for the most recent text displayed by Fmessage_box. */
3205 static char *message_text;
3207 /* Allocated length of that buffer. */
3208 static int message_length;
3210 DEFUN ("message", Fmessage, Smessage, 1, MANY, 0,
3211 doc: /* Display a message at the bottom of the screen.
3212 The message also goes into the `*Messages*' buffer.
3213 \(In keyboard macros, that's all it does.)
3214 Return the message.
3216 The first argument is a format control string, and the rest are data
3217 to be formatted under control of the string. See `format' for details.
3219 Note: Use (message "%s" VALUE) to print the value of expressions and
3220 variables to avoid accidentally interpreting `%' as format specifiers.
3222 If the first argument is nil or the empty string, the function clears
3223 any existing message; this lets the minibuffer contents show. See
3224 also `current-message'.
3226 usage: (message FORMAT-STRING &rest ARGS) */)
3227 (nargs, args)
3228 int nargs;
3229 Lisp_Object *args;
3231 if (NILP (args[0])
3232 || (STRINGP (args[0])
3233 && SBYTES (args[0]) == 0))
3235 message (0);
3236 return args[0];
3238 else
3240 register Lisp_Object val;
3241 val = Fformat (nargs, args);
3242 message3 (val, SBYTES (val), STRING_MULTIBYTE (val));
3243 return val;
3247 DEFUN ("message-box", Fmessage_box, Smessage_box, 1, MANY, 0,
3248 doc: /* Display a message, in a dialog box if possible.
3249 If a dialog box is not available, use the echo area.
3250 The first argument is a format control string, and the rest are data
3251 to be formatted under control of the string. See `format' for details.
3253 If the first argument is nil or the empty string, clear any existing
3254 message; let the minibuffer contents show.
3256 usage: (message-box FORMAT-STRING &rest ARGS) */)
3257 (nargs, args)
3258 int nargs;
3259 Lisp_Object *args;
3261 if (NILP (args[0]))
3263 message (0);
3264 return Qnil;
3266 else
3268 register Lisp_Object val;
3269 val = Fformat (nargs, args);
3270 #ifdef HAVE_MENUS
3271 /* The MS-DOS frames support popup menus even though they are
3272 not FRAME_WINDOW_P. */
3273 if (FRAME_WINDOW_P (XFRAME (selected_frame))
3274 || FRAME_MSDOS_P (XFRAME (selected_frame)))
3276 Lisp_Object pane, menu, obj;
3277 struct gcpro gcpro1;
3278 pane = Fcons (Fcons (build_string ("OK"), Qt), Qnil);
3279 GCPRO1 (pane);
3280 menu = Fcons (val, pane);
3281 obj = Fx_popup_dialog (Qt, menu, Qt);
3282 UNGCPRO;
3283 return val;
3285 #endif /* HAVE_MENUS */
3286 /* Copy the data so that it won't move when we GC. */
3287 if (! message_text)
3289 message_text = (char *)xmalloc (80);
3290 message_length = 80;
3292 if (SBYTES (val) > message_length)
3294 message_length = SBYTES (val);
3295 message_text = (char *)xrealloc (message_text, message_length);
3297 bcopy (SDATA (val), message_text, SBYTES (val));
3298 message2 (message_text, SBYTES (val),
3299 STRING_MULTIBYTE (val));
3300 return val;
3303 #ifdef HAVE_MENUS
3304 extern Lisp_Object last_nonmenu_event;
3305 #endif
3307 DEFUN ("message-or-box", Fmessage_or_box, Smessage_or_box, 1, MANY, 0,
3308 doc: /* Display a message in a dialog box or in the echo area.
3309 If this command was invoked with the mouse, use a dialog box if
3310 `use-dialog-box' is non-nil.
3311 Otherwise, use the echo area.
3312 The first argument is a format control string, and the rest are data
3313 to be formatted under control of the string. See `format' for details.
3315 If the first argument is nil or the empty string, clear any existing
3316 message; let the minibuffer contents show.
3318 usage: (message-or-box FORMAT-STRING &rest ARGS) */)
3319 (nargs, args)
3320 int nargs;
3321 Lisp_Object *args;
3323 #ifdef HAVE_MENUS
3324 if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
3325 && use_dialog_box)
3326 return Fmessage_box (nargs, args);
3327 #endif
3328 return Fmessage (nargs, args);
3331 DEFUN ("current-message", Fcurrent_message, Scurrent_message, 0, 0, 0,
3332 doc: /* Return the string currently displayed in the echo area, or nil if none. */)
3335 return current_message ();
3339 DEFUN ("propertize", Fpropertize, Spropertize, 1, MANY, 0,
3340 doc: /* Return a copy of STRING with text properties added.
3341 First argument is the string to copy.
3342 Remaining arguments form a sequence of PROPERTY VALUE pairs for text
3343 properties to add to the result.
3344 usage: (propertize STRING &rest PROPERTIES) */)
3345 (nargs, args)
3346 int nargs;
3347 Lisp_Object *args;
3349 Lisp_Object properties, string;
3350 struct gcpro gcpro1, gcpro2;
3351 int i;
3353 /* Number of args must be odd. */
3354 if ((nargs & 1) == 0 || nargs < 1)
3355 error ("Wrong number of arguments");
3357 properties = string = Qnil;
3358 GCPRO2 (properties, string);
3360 /* First argument must be a string. */
3361 CHECK_STRING (args[0]);
3362 string = Fcopy_sequence (args[0]);
3364 for (i = 1; i < nargs; i += 2)
3365 properties = Fcons (args[i], Fcons (args[i + 1], properties));
3367 Fadd_text_properties (make_number (0),
3368 make_number (SCHARS (string)),
3369 properties, string);
3370 RETURN_UNGCPRO (string);
3374 /* Number of bytes that STRING will occupy when put into the result.
3375 MULTIBYTE is nonzero if the result should be multibyte. */
3377 #define CONVERTED_BYTE_SIZE(MULTIBYTE, STRING) \
3378 (((MULTIBYTE) && ! STRING_MULTIBYTE (STRING)) \
3379 ? count_size_as_multibyte (SDATA (STRING), SBYTES (STRING)) \
3380 : SBYTES (STRING))
3382 DEFUN ("format", Fformat, Sformat, 1, MANY, 0,
3383 doc: /* Format a string out of a format-string and arguments.
3384 The first argument is a format control string.
3385 The other arguments are substituted into it to make the result, a string.
3387 The format control string may contain %-sequences meaning to substitute
3388 the next available argument:
3390 %s means print a string argument. Actually, prints any object, with `princ'.
3391 %d means print as number in decimal (%o octal, %x hex).
3392 %X is like %x, but uses upper case.
3393 %e means print a number in exponential notation.
3394 %f means print a number in decimal-point notation.
3395 %g means print a number in exponential notation
3396 or decimal-point notation, whichever uses fewer characters.
3397 %c means print a number as a single character.
3398 %S means print any object as an s-expression (using `prin1').
3400 The argument used for %d, %o, %x, %e, %f, %g or %c must be a number.
3401 Use %% to put a single % into the output.
3403 A %-sequence may contain optional flag, width, and precision
3404 specifiers, as follows:
3406 %<flags><width><precision>character
3408 where flags is [+ #-0]+, width is [0-9]+, and precision is .[0-9]+
3410 The + flag character inserts a + before any positive number, while a
3411 space inserts a space before any positive number; these flags only
3412 affect %d, %e, %f, and %g sequences, and the + flag takes precedence.
3413 The # flag means to use an alternate display form for %o, %x, %X, %e,
3414 %f, and %g sequences. The - and 0 flags affect the width specifier,
3415 as described below.
3417 The width specifier supplies a lower limit for the length of the
3418 printed representation. The padding, if any, normally goes on the
3419 left, but it goes on the right if the - flag is present. The padding
3420 character is normally a space, but it is 0 if the 0 flag is present.
3421 The - flag takes precedence over the 0 flag.
3423 For %e, %f, and %g sequences, the number after the "." in the
3424 precision specifier says how many decimal places to show; if zero, the
3425 decimal point itself is omitted. For %s and %S, the precision
3426 specifier truncates the string to the given width.
3428 usage: (format STRING &rest OBJECTS) */)
3429 (nargs, args)
3430 int nargs;
3431 register Lisp_Object *args;
3433 register int n; /* The number of the next arg to substitute */
3434 register int total; /* An estimate of the final length */
3435 char *buf, *p;
3436 register unsigned char *format, *end, *format_start;
3437 int nchars;
3438 /* Nonzero if the output should be a multibyte string,
3439 which is true if any of the inputs is one. */
3440 int multibyte = 0;
3441 /* When we make a multibyte string, we must pay attention to the
3442 byte combining problem, i.e., a byte may be combined with a
3443 multibyte charcter of the previous string. This flag tells if we
3444 must consider such a situation or not. */
3445 int maybe_combine_byte;
3446 unsigned char *this_format;
3447 /* Precision for each spec, or -1, a flag value meaning no precision
3448 was given in that spec. Element 0, corresonding to the format
3449 string itself, will not be used. Element NARGS, corresponding to
3450 no argument, *will* be assigned to in the case that a `%' and `.'
3451 occur after the final format specifier. */
3452 int *precision = (int *) (alloca((nargs + 1) * sizeof (int)));
3453 int longest_format;
3454 Lisp_Object val;
3455 int arg_intervals = 0;
3456 USE_SAFE_ALLOCA;
3458 /* discarded[I] is 1 if byte I of the format
3459 string was not copied into the output.
3460 It is 2 if byte I was not the first byte of its character. */
3461 char *discarded = 0;
3463 /* Each element records, for one argument,
3464 the start and end bytepos in the output string,
3465 and whether the argument is a string with intervals.
3466 info[0] is unused. Unused elements have -1 for start. */
3467 struct info
3469 int start, end, intervals;
3470 } *info = 0;
3472 /* It should not be necessary to GCPRO ARGS, because
3473 the caller in the interpreter should take care of that. */
3475 /* Try to determine whether the result should be multibyte.
3476 This is not always right; sometimes the result needs to be multibyte
3477 because of an object that we will pass through prin1,
3478 and in that case, we won't know it here. */
3479 for (n = 0; n < nargs; n++)
3481 if (STRINGP (args[n]) && STRING_MULTIBYTE (args[n]))
3482 multibyte = 1;
3483 /* Piggyback on this loop to initialize precision[N]. */
3484 precision[n] = -1;
3486 precision[nargs] = -1;
3488 CHECK_STRING (args[0]);
3489 /* We may have to change "%S" to "%s". */
3490 args[0] = Fcopy_sequence (args[0]);
3492 /* GC should never happen here, so abort if it does. */
3493 abort_on_gc++;
3495 /* If we start out planning a unibyte result,
3496 then discover it has to be multibyte, we jump back to retry.
3497 That can only happen from the first large while loop below. */
3498 retry:
3500 format = SDATA (args[0]);
3501 format_start = format;
3502 end = format + SBYTES (args[0]);
3503 longest_format = 0;
3505 /* Make room in result for all the non-%-codes in the control string. */
3506 total = 5 + CONVERTED_BYTE_SIZE (multibyte, args[0]) + 1;
3508 /* Allocate the info and discarded tables. */
3510 int nbytes = (nargs+1) * sizeof *info;
3511 int i;
3512 if (!info)
3513 info = (struct info *) alloca (nbytes);
3514 bzero (info, nbytes);
3515 for (i = 0; i <= nargs; i++)
3516 info[i].start = -1;
3517 if (!discarded)
3518 SAFE_ALLOCA (discarded, char *, SBYTES (args[0]));
3519 bzero (discarded, SBYTES (args[0]));
3522 /* Add to TOTAL enough space to hold the converted arguments. */
3524 n = 0;
3525 while (format != end)
3526 if (*format++ == '%')
3528 int thissize = 0;
3529 int actual_width = 0;
3530 unsigned char *this_format_start = format - 1;
3531 int field_width = 0;
3533 /* General format specifications look like
3535 '%' [flags] [field-width] [precision] format
3537 where
3539 flags ::= [-+ #0]+
3540 field-width ::= [0-9]+
3541 precision ::= '.' [0-9]*
3543 If a field-width is specified, it specifies to which width
3544 the output should be padded with blanks, if the output
3545 string is shorter than field-width.
3547 If precision is specified, it specifies the number of
3548 digits to print after the '.' for floats, or the max.
3549 number of chars to print from a string. */
3551 while (format != end
3552 && (*format == '-' || *format == '0' || *format == '#'
3553 || * format == ' ' || *format == '+'))
3554 ++format;
3556 if (*format >= '0' && *format <= '9')
3558 for (field_width = 0; *format >= '0' && *format <= '9'; ++format)
3559 field_width = 10 * field_width + *format - '0';
3562 /* N is not incremented for another few lines below, so refer to
3563 element N+1 (which might be precision[NARGS]). */
3564 if (*format == '.')
3566 ++format;
3567 for (precision[n+1] = 0; *format >= '0' && *format <= '9'; ++format)
3568 precision[n+1] = 10 * precision[n+1] + *format - '0';
3571 /* Extra +1 for 'l' that we may need to insert into the
3572 format. */
3573 if (format - this_format_start + 2 > longest_format)
3574 longest_format = format - this_format_start + 2;
3576 if (format == end)
3577 error ("Format string ends in middle of format specifier");
3578 if (*format == '%')
3579 format++;
3580 else if (++n >= nargs)
3581 error ("Not enough arguments for format string");
3582 else if (*format == 'S')
3584 /* For `S', prin1 the argument and then treat like a string. */
3585 register Lisp_Object tem;
3586 tem = Fprin1_to_string (args[n], Qnil);
3587 if (STRING_MULTIBYTE (tem) && ! multibyte)
3589 multibyte = 1;
3590 goto retry;
3592 args[n] = tem;
3593 /* If we restart the loop, we should not come here again
3594 because args[n] is now a string and calling
3595 Fprin1_to_string on it produces superflous double
3596 quotes. So, change "%S" to "%s" now. */
3597 *format = 's';
3598 goto string;
3600 else if (SYMBOLP (args[n]))
3602 args[n] = SYMBOL_NAME (args[n]);
3603 if (STRING_MULTIBYTE (args[n]) && ! multibyte)
3605 multibyte = 1;
3606 goto retry;
3608 goto string;
3610 else if (STRINGP (args[n]))
3612 string:
3613 if (*format != 's' && *format != 'S')
3614 error ("Format specifier doesn't match argument type");
3615 /* In the case (PRECISION[N] > 0), THISSIZE may not need
3616 to be as large as is calculated here. Easy check for
3617 the case PRECISION = 0. */
3618 thissize = precision[n] ? CONVERTED_BYTE_SIZE (multibyte, args[n]) : 0;
3619 actual_width = lisp_string_width (args[n], -1, NULL, NULL);
3621 /* Would get MPV otherwise, since Lisp_Int's `point' to low memory. */
3622 else if (INTEGERP (args[n]) && *format != 's')
3624 /* The following loop assumes the Lisp type indicates
3625 the proper way to pass the argument.
3626 So make sure we have a flonum if the argument should
3627 be a double. */
3628 if (*format == 'e' || *format == 'f' || *format == 'g')
3629 args[n] = Ffloat (args[n]);
3630 else
3631 if (*format != 'd' && *format != 'o' && *format != 'x'
3632 && *format != 'i' && *format != 'X' && *format != 'c')
3633 error ("Invalid format operation %%%c", *format);
3635 thissize = 30 + (precision[n] > 0 ? precision[n] : 0);
3636 if (*format == 'c')
3638 if (! SINGLE_BYTE_CHAR_P (XINT (args[n]))
3639 /* Note: No one can remember why we have to treat
3640 the character 0 as a multibyte character here.
3641 But, until it causes a real problem, let's
3642 don't change it. */
3643 || XINT (args[n]) == 0)
3645 if (! multibyte)
3647 multibyte = 1;
3648 goto retry;
3650 args[n] = Fchar_to_string (args[n]);
3651 thissize = SBYTES (args[n]);
3653 else if (! ASCII_BYTE_P (XINT (args[n])) && multibyte)
3655 args[n]
3656 = Fchar_to_string (Funibyte_char_to_multibyte (args[n]));
3657 thissize = SBYTES (args[n]);
3661 else if (FLOATP (args[n]) && *format != 's')
3663 if (! (*format == 'e' || *format == 'f' || *format == 'g'))
3665 if (*format != 'd' && *format != 'o' && *format != 'x'
3666 && *format != 'i' && *format != 'X' && *format != 'c')
3667 error ("Invalid format operation %%%c", *format);
3668 /* This fails unnecessarily if args[n] is bigger than
3669 most-positive-fixnum but smaller than MAXINT.
3670 These cases are important because we sometimes use floats
3671 to represent such integer values (typically such values
3672 come from UIDs or PIDs). */
3673 /* args[n] = Ftruncate (args[n], Qnil); */
3676 /* Note that we're using sprintf to print floats,
3677 so we have to take into account what that function
3678 prints. */
3679 /* Filter out flag value of -1. */
3680 thissize = (MAX_10_EXP + 100
3681 + (precision[n] > 0 ? precision[n] : 0));
3683 else
3685 /* Anything but a string, convert to a string using princ. */
3686 register Lisp_Object tem;
3687 tem = Fprin1_to_string (args[n], Qt);
3688 if (STRING_MULTIBYTE (tem) && ! multibyte)
3690 multibyte = 1;
3691 goto retry;
3693 args[n] = tem;
3694 goto string;
3697 thissize += max (0, field_width - actual_width);
3698 total += thissize + 4;
3701 abort_on_gc--;
3703 /* Now we can no longer jump to retry.
3704 TOTAL and LONGEST_FORMAT are known for certain. */
3706 this_format = (unsigned char *) alloca (longest_format + 1);
3708 /* Allocate the space for the result.
3709 Note that TOTAL is an overestimate. */
3710 SAFE_ALLOCA (buf, char *, total);
3712 p = buf;
3713 nchars = 0;
3714 n = 0;
3716 /* Scan the format and store result in BUF. */
3717 format = SDATA (args[0]);
3718 format_start = format;
3719 end = format + SBYTES (args[0]);
3720 maybe_combine_byte = 0;
3721 while (format != end)
3723 if (*format == '%')
3725 int minlen;
3726 int negative = 0;
3727 unsigned char *this_format_start = format;
3729 discarded[format - format_start] = 1;
3730 format++;
3732 while (index("-+0# ", *format))
3734 if (*format == '-')
3736 negative = 1;
3738 discarded[format - format_start] = 1;
3739 ++format;
3742 minlen = atoi (format);
3744 while ((*format >= '0' && *format <= '9') || *format == '.')
3746 discarded[format - format_start] = 1;
3747 format++;
3750 if (*format++ == '%')
3752 *p++ = '%';
3753 nchars++;
3754 continue;
3757 ++n;
3759 discarded[format - format_start - 1] = 1;
3760 info[n].start = nchars;
3762 if (STRINGP (args[n]))
3764 /* handle case (precision[n] >= 0) */
3766 int width, padding;
3767 int nbytes, start, end;
3768 int nchars_string;
3770 /* lisp_string_width ignores a precision of 0, but GNU
3771 libc functions print 0 characters when the precision
3772 is 0. Imitate libc behavior here. Changing
3773 lisp_string_width is the right thing, and will be
3774 done, but meanwhile we work with it. */
3776 if (precision[n] == 0)
3777 width = nchars_string = nbytes = 0;
3778 else if (precision[n] > 0)
3779 width = lisp_string_width (args[n], precision[n], &nchars_string, &nbytes);
3780 else
3781 { /* no precision spec given for this argument */
3782 width = lisp_string_width (args[n], -1, NULL, NULL);
3783 nbytes = SBYTES (args[n]);
3784 nchars_string = SCHARS (args[n]);
3787 /* If spec requires it, pad on right with spaces. */
3788 padding = minlen - width;
3789 if (! negative)
3790 while (padding-- > 0)
3792 *p++ = ' ';
3793 ++nchars;
3796 info[n].start = start = nchars;
3797 nchars += nchars_string;
3798 end = nchars;
3800 if (p > buf
3801 && multibyte
3802 && !ASCII_BYTE_P (*((unsigned char *) p - 1))
3803 && STRING_MULTIBYTE (args[n])
3804 && !CHAR_HEAD_P (SREF (args[n], 0)))
3805 maybe_combine_byte = 1;
3807 p += copy_text (SDATA (args[n]), p,
3808 nbytes,
3809 STRING_MULTIBYTE (args[n]), multibyte);
3811 info[n].end = nchars;
3813 if (negative)
3814 while (padding-- > 0)
3816 *p++ = ' ';
3817 nchars++;
3820 /* If this argument has text properties, record where
3821 in the result string it appears. */
3822 if (STRING_INTERVALS (args[n]))
3823 info[n].intervals = arg_intervals = 1;
3825 else if (INTEGERP (args[n]) || FLOATP (args[n]))
3827 int this_nchars;
3829 bcopy (this_format_start, this_format,
3830 format - this_format_start);
3831 this_format[format - this_format_start] = 0;
3833 if (format[-1] == 'e' || format[-1] == 'f' || format[-1] == 'g')
3834 sprintf (p, this_format, XFLOAT_DATA (args[n]));
3835 else
3837 if (sizeof (EMACS_INT) > sizeof (int)
3838 && format[-1] != 'c')
3840 /* Insert 'l' before format spec. */
3841 this_format[format - this_format_start]
3842 = this_format[format - this_format_start - 1];
3843 this_format[format - this_format_start - 1] = 'l';
3844 this_format[format - this_format_start + 1] = 0;
3847 if (INTEGERP (args[n]))
3849 if (format[-1] == 'c')
3850 sprintf (p, this_format, (int) XINT (args[n]));
3851 else if (format[-1] == 'd')
3852 sprintf (p, this_format, XINT (args[n]));
3853 /* Don't sign-extend for octal or hex printing. */
3854 else
3855 sprintf (p, this_format, XUINT (args[n]));
3857 else if (format[-1] == 'c')
3858 sprintf (p, this_format, (int) XFLOAT_DATA (args[n]));
3859 else if (format[-1] == 'd')
3860 /* Maybe we should use "%1.0f" instead so it also works
3861 for values larger than MAXINT. */
3862 sprintf (p, this_format, (EMACS_INT) XFLOAT_DATA (args[n]));
3863 else
3864 /* Don't sign-extend for octal or hex printing. */
3865 sprintf (p, this_format, (EMACS_UINT) XFLOAT_DATA (args[n]));
3868 if (p > buf
3869 && multibyte
3870 && !ASCII_BYTE_P (*((unsigned char *) p - 1))
3871 && !CHAR_HEAD_P (*((unsigned char *) p)))
3872 maybe_combine_byte = 1;
3873 this_nchars = strlen (p);
3874 if (multibyte)
3875 p += str_to_multibyte (p, buf + total - 1 - p, this_nchars);
3876 else
3877 p += this_nchars;
3878 nchars += this_nchars;
3879 info[n].end = nchars;
3883 else if (STRING_MULTIBYTE (args[0]))
3885 /* Copy a whole multibyte character. */
3886 if (p > buf
3887 && multibyte
3888 && !ASCII_BYTE_P (*((unsigned char *) p - 1))
3889 && !CHAR_HEAD_P (*format))
3890 maybe_combine_byte = 1;
3891 *p++ = *format++;
3892 while (! CHAR_HEAD_P (*format))
3894 discarded[format - format_start] = 2;
3895 *p++ = *format++;
3897 nchars++;
3899 else if (multibyte)
3901 /* Convert a single-byte character to multibyte. */
3902 int len = copy_text (format, p, 1, 0, 1);
3904 p += len;
3905 format++;
3906 nchars++;
3908 else
3909 *p++ = *format++, nchars++;
3912 if (p > buf + total)
3913 abort ();
3915 if (maybe_combine_byte)
3916 nchars = multibyte_chars_in_text (buf, p - buf);
3917 val = make_specified_string (buf, nchars, p - buf, multibyte);
3919 /* If we allocated BUF with malloc, free it too. */
3920 SAFE_FREE ();
3922 /* If the format string has text properties, or any of the string
3923 arguments has text properties, set up text properties of the
3924 result string. */
3926 if (STRING_INTERVALS (args[0]) || arg_intervals)
3928 Lisp_Object len, new_len, props;
3929 struct gcpro gcpro1;
3931 /* Add text properties from the format string. */
3932 len = make_number (SCHARS (args[0]));
3933 props = text_property_list (args[0], make_number (0), len, Qnil);
3934 GCPRO1 (props);
3936 if (CONSP (props))
3938 int bytepos = 0, position = 0, translated = 0, argn = 1;
3939 Lisp_Object list;
3941 /* Adjust the bounds of each text property
3942 to the proper start and end in the output string. */
3944 /* Put the positions in PROPS in increasing order, so that
3945 we can do (effectively) one scan through the position
3946 space of the format string. */
3947 props = Fnreverse (props);
3949 /* BYTEPOS is the byte position in the format string,
3950 POSITION is the untranslated char position in it,
3951 TRANSLATED is the translated char position in BUF,
3952 and ARGN is the number of the next arg we will come to. */
3953 for (list = props; CONSP (list); list = XCDR (list))
3955 Lisp_Object item;
3956 int pos;
3958 item = XCAR (list);
3960 /* First adjust the property start position. */
3961 pos = XINT (XCAR (item));
3963 /* Advance BYTEPOS, POSITION, TRANSLATED and ARGN
3964 up to this position. */
3965 for (; position < pos; bytepos++)
3967 if (! discarded[bytepos])
3968 position++, translated++;
3969 else if (discarded[bytepos] == 1)
3971 position++;
3972 if (translated == info[argn].start)
3974 translated += info[argn].end - info[argn].start;
3975 argn++;
3980 XSETCAR (item, make_number (translated));
3982 /* Likewise adjust the property end position. */
3983 pos = XINT (XCAR (XCDR (item)));
3985 for (; position < pos; bytepos++)
3987 if (! discarded[bytepos])
3988 position++, translated++;
3989 else if (discarded[bytepos] == 1)
3991 position++;
3992 if (translated == info[argn].start)
3994 translated += info[argn].end - info[argn].start;
3995 argn++;
4000 XSETCAR (XCDR (item), make_number (translated));
4003 add_text_properties_from_list (val, props, make_number (0));
4006 /* Add text properties from arguments. */
4007 if (arg_intervals)
4008 for (n = 1; n < nargs; ++n)
4009 if (info[n].intervals)
4011 len = make_number (SCHARS (args[n]));
4012 new_len = make_number (info[n].end - info[n].start);
4013 props = text_property_list (args[n], make_number (0), len, Qnil);
4014 extend_property_ranges (props, len, new_len);
4015 /* If successive arguments have properites, be sure that
4016 the value of `composition' property be the copy. */
4017 if (n > 1 && info[n - 1].end)
4018 make_composition_value_copy (props);
4019 add_text_properties_from_list (val, props,
4020 make_number (info[n].start));
4023 UNGCPRO;
4026 return val;
4029 Lisp_Object
4030 format2 (string1, arg0, arg1)
4031 char *string1;
4032 Lisp_Object arg0, arg1;
4034 Lisp_Object args[3];
4035 args[0] = build_string (string1);
4036 args[1] = arg0;
4037 args[2] = arg1;
4038 return Fformat (3, args);
4041 DEFUN ("char-equal", Fchar_equal, Schar_equal, 2, 2, 0,
4042 doc: /* Return t if two characters match, optionally ignoring case.
4043 Both arguments must be characters (i.e. integers).
4044 Case is ignored if `case-fold-search' is non-nil in the current buffer. */)
4045 (c1, c2)
4046 register Lisp_Object c1, c2;
4048 int i1, i2;
4049 CHECK_NUMBER (c1);
4050 CHECK_NUMBER (c2);
4052 if (XINT (c1) == XINT (c2))
4053 return Qt;
4054 if (NILP (current_buffer->case_fold_search))
4055 return Qnil;
4057 /* Do these in separate statements,
4058 then compare the variables.
4059 because of the way DOWNCASE uses temp variables. */
4060 i1 = DOWNCASE (XFASTINT (c1));
4061 i2 = DOWNCASE (XFASTINT (c2));
4062 return (i1 == i2 ? Qt : Qnil);
4065 /* Transpose the markers in two regions of the current buffer, and
4066 adjust the ones between them if necessary (i.e.: if the regions
4067 differ in size).
4069 START1, END1 are the character positions of the first region.
4070 START1_BYTE, END1_BYTE are the byte positions.
4071 START2, END2 are the character positions of the second region.
4072 START2_BYTE, END2_BYTE are the byte positions.
4074 Traverses the entire marker list of the buffer to do so, adding an
4075 appropriate amount to some, subtracting from some, and leaving the
4076 rest untouched. Most of this is copied from adjust_markers in insdel.c.
4078 It's the caller's job to ensure that START1 <= END1 <= START2 <= END2. */
4080 static void
4081 transpose_markers (start1, end1, start2, end2,
4082 start1_byte, end1_byte, start2_byte, end2_byte)
4083 register int start1, end1, start2, end2;
4084 register int start1_byte, end1_byte, start2_byte, end2_byte;
4086 register int amt1, amt1_byte, amt2, amt2_byte, diff, diff_byte, mpos;
4087 register struct Lisp_Marker *marker;
4089 /* Update point as if it were a marker. */
4090 if (PT < start1)
4092 else if (PT < end1)
4093 TEMP_SET_PT_BOTH (PT + (end2 - end1),
4094 PT_BYTE + (end2_byte - end1_byte));
4095 else if (PT < start2)
4096 TEMP_SET_PT_BOTH (PT + (end2 - start2) - (end1 - start1),
4097 (PT_BYTE + (end2_byte - start2_byte)
4098 - (end1_byte - start1_byte)));
4099 else if (PT < end2)
4100 TEMP_SET_PT_BOTH (PT - (start2 - start1),
4101 PT_BYTE - (start2_byte - start1_byte));
4103 /* We used to adjust the endpoints here to account for the gap, but that
4104 isn't good enough. Even if we assume the caller has tried to move the
4105 gap out of our way, it might still be at start1 exactly, for example;
4106 and that places it `inside' the interval, for our purposes. The amount
4107 of adjustment is nontrivial if there's a `denormalized' marker whose
4108 position is between GPT and GPT + GAP_SIZE, so it's simpler to leave
4109 the dirty work to Fmarker_position, below. */
4111 /* The difference between the region's lengths */
4112 diff = (end2 - start2) - (end1 - start1);
4113 diff_byte = (end2_byte - start2_byte) - (end1_byte - start1_byte);
4115 /* For shifting each marker in a region by the length of the other
4116 region plus the distance between the regions. */
4117 amt1 = (end2 - start2) + (start2 - end1);
4118 amt2 = (end1 - start1) + (start2 - end1);
4119 amt1_byte = (end2_byte - start2_byte) + (start2_byte - end1_byte);
4120 amt2_byte = (end1_byte - start1_byte) + (start2_byte - end1_byte);
4122 for (marker = BUF_MARKERS (current_buffer); marker; marker = marker->next)
4124 mpos = marker->bytepos;
4125 if (mpos >= start1_byte && mpos < end2_byte)
4127 if (mpos < end1_byte)
4128 mpos += amt1_byte;
4129 else if (mpos < start2_byte)
4130 mpos += diff_byte;
4131 else
4132 mpos -= amt2_byte;
4133 marker->bytepos = mpos;
4135 mpos = marker->charpos;
4136 if (mpos >= start1 && mpos < end2)
4138 if (mpos < end1)
4139 mpos += amt1;
4140 else if (mpos < start2)
4141 mpos += diff;
4142 else
4143 mpos -= amt2;
4145 marker->charpos = mpos;
4149 DEFUN ("transpose-regions", Ftranspose_regions, Stranspose_regions, 4, 5, 0,
4150 doc: /* Transpose region STARTR1 to ENDR1 with STARTR2 to ENDR2.
4151 The regions may not be overlapping, because the size of the buffer is
4152 never changed in a transposition.
4154 Optional fifth arg LEAVE-MARKERS, if non-nil, means don't update
4155 any markers that happen to be located in the regions.
4157 Transposing beyond buffer boundaries is an error. */)
4158 (startr1, endr1, startr2, endr2, leave_markers)
4159 Lisp_Object startr1, endr1, startr2, endr2, leave_markers;
4161 register int start1, end1, start2, end2;
4162 int start1_byte, start2_byte, len1_byte, len2_byte;
4163 int gap, len1, len_mid, len2;
4164 unsigned char *start1_addr, *start2_addr, *temp;
4166 INTERVAL cur_intv, tmp_interval1, tmp_interval_mid, tmp_interval2, tmp_interval3;
4167 Lisp_Object buf;
4169 XSETBUFFER (buf, current_buffer);
4170 cur_intv = BUF_INTERVALS (current_buffer);
4172 validate_region (&startr1, &endr1);
4173 validate_region (&startr2, &endr2);
4175 start1 = XFASTINT (startr1);
4176 end1 = XFASTINT (endr1);
4177 start2 = XFASTINT (startr2);
4178 end2 = XFASTINT (endr2);
4179 gap = GPT;
4181 /* Swap the regions if they're reversed. */
4182 if (start2 < end1)
4184 register int glumph = start1;
4185 start1 = start2;
4186 start2 = glumph;
4187 glumph = end1;
4188 end1 = end2;
4189 end2 = glumph;
4192 len1 = end1 - start1;
4193 len2 = end2 - start2;
4195 if (start2 < end1)
4196 error ("Transposed regions overlap");
4197 else if (start1 == end1 || start2 == end2)
4198 error ("Transposed region has length 0");
4200 /* The possibilities are:
4201 1. Adjacent (contiguous) regions, or separate but equal regions
4202 (no, really equal, in this case!), or
4203 2. Separate regions of unequal size.
4205 The worst case is usually No. 2. It means that (aside from
4206 potential need for getting the gap out of the way), there also
4207 needs to be a shifting of the text between the two regions. So
4208 if they are spread far apart, we are that much slower... sigh. */
4210 /* It must be pointed out that the really studly thing to do would
4211 be not to move the gap at all, but to leave it in place and work
4212 around it if necessary. This would be extremely efficient,
4213 especially considering that people are likely to do
4214 transpositions near where they are working interactively, which
4215 is exactly where the gap would be found. However, such code
4216 would be much harder to write and to read. So, if you are
4217 reading this comment and are feeling squirrely, by all means have
4218 a go! I just didn't feel like doing it, so I will simply move
4219 the gap the minimum distance to get it out of the way, and then
4220 deal with an unbroken array. */
4222 /* Make sure the gap won't interfere, by moving it out of the text
4223 we will operate on. */
4224 if (start1 < gap && gap < end2)
4226 if (gap - start1 < end2 - gap)
4227 move_gap (start1);
4228 else
4229 move_gap (end2);
4232 start1_byte = CHAR_TO_BYTE (start1);
4233 start2_byte = CHAR_TO_BYTE (start2);
4234 len1_byte = CHAR_TO_BYTE (end1) - start1_byte;
4235 len2_byte = CHAR_TO_BYTE (end2) - start2_byte;
4237 #ifdef BYTE_COMBINING_DEBUG
4238 if (end1 == start2)
4240 if (count_combining_before (BYTE_POS_ADDR (start2_byte),
4241 len2_byte, start1, start1_byte)
4242 || count_combining_before (BYTE_POS_ADDR (start1_byte),
4243 len1_byte, end2, start2_byte + len2_byte)
4244 || count_combining_after (BYTE_POS_ADDR (start1_byte),
4245 len1_byte, end2, start2_byte + len2_byte))
4246 abort ();
4248 else
4250 if (count_combining_before (BYTE_POS_ADDR (start2_byte),
4251 len2_byte, start1, start1_byte)
4252 || count_combining_before (BYTE_POS_ADDR (start1_byte),
4253 len1_byte, start2, start2_byte)
4254 || count_combining_after (BYTE_POS_ADDR (start2_byte),
4255 len2_byte, end1, start1_byte + len1_byte)
4256 || count_combining_after (BYTE_POS_ADDR (start1_byte),
4257 len1_byte, end2, start2_byte + len2_byte))
4258 abort ();
4260 #endif
4262 /* Hmmm... how about checking to see if the gap is large
4263 enough to use as the temporary storage? That would avoid an
4264 allocation... interesting. Later, don't fool with it now. */
4266 /* Working without memmove, for portability (sigh), so must be
4267 careful of overlapping subsections of the array... */
4269 if (end1 == start2) /* adjacent regions */
4271 modify_region (current_buffer, start1, end2, 0);
4272 record_change (start1, len1 + len2);
4274 tmp_interval1 = copy_intervals (cur_intv, start1, len1);
4275 tmp_interval2 = copy_intervals (cur_intv, start2, len2);
4276 /* Don't use Fset_text_properties: that can cause GC, which can
4277 clobber objects stored in the tmp_intervals. */
4278 tmp_interval3 = validate_interval_range (buf, &startr1, &endr2, 0);
4279 if (!NULL_INTERVAL_P (tmp_interval3))
4280 set_text_properties_1 (startr1, endr2, Qnil, buf, tmp_interval3);
4282 /* First region smaller than second. */
4283 if (len1_byte < len2_byte)
4285 USE_SAFE_ALLOCA;
4287 SAFE_ALLOCA (temp, unsigned char *, len2_byte);
4289 /* Don't precompute these addresses. We have to compute them
4290 at the last minute, because the relocating allocator might
4291 have moved the buffer around during the xmalloc. */
4292 start1_addr = BYTE_POS_ADDR (start1_byte);
4293 start2_addr = BYTE_POS_ADDR (start2_byte);
4295 bcopy (start2_addr, temp, len2_byte);
4296 bcopy (start1_addr, start1_addr + len2_byte, len1_byte);
4297 bcopy (temp, start1_addr, len2_byte);
4298 SAFE_FREE ();
4300 else
4301 /* First region not smaller than second. */
4303 USE_SAFE_ALLOCA;
4305 SAFE_ALLOCA (temp, unsigned char *, len1_byte);
4306 start1_addr = BYTE_POS_ADDR (start1_byte);
4307 start2_addr = BYTE_POS_ADDR (start2_byte);
4308 bcopy (start1_addr, temp, len1_byte);
4309 bcopy (start2_addr, start1_addr, len2_byte);
4310 bcopy (temp, start1_addr + len2_byte, len1_byte);
4311 SAFE_FREE ();
4313 graft_intervals_into_buffer (tmp_interval1, start1 + len2,
4314 len1, current_buffer, 0);
4315 graft_intervals_into_buffer (tmp_interval2, start1,
4316 len2, current_buffer, 0);
4317 update_compositions (start1, start1 + len2, CHECK_BORDER);
4318 update_compositions (start1 + len2, end2, CHECK_TAIL);
4320 /* Non-adjacent regions, because end1 != start2, bleagh... */
4321 else
4323 len_mid = start2_byte - (start1_byte + len1_byte);
4325 if (len1_byte == len2_byte)
4326 /* Regions are same size, though, how nice. */
4328 USE_SAFE_ALLOCA;
4330 modify_region (current_buffer, start1, end1, 0);
4331 modify_region (current_buffer, start2, end2, 0);
4332 record_change (start1, len1);
4333 record_change (start2, len2);
4334 tmp_interval1 = copy_intervals (cur_intv, start1, len1);
4335 tmp_interval2 = copy_intervals (cur_intv, start2, len2);
4337 tmp_interval3 = validate_interval_range (buf, &startr1, &endr1, 0);
4338 if (!NULL_INTERVAL_P (tmp_interval3))
4339 set_text_properties_1 (startr1, endr1, Qnil, buf, tmp_interval3);
4341 tmp_interval3 = validate_interval_range (buf, &startr2, &endr2, 0);
4342 if (!NULL_INTERVAL_P (tmp_interval3))
4343 set_text_properties_1 (startr2, endr2, Qnil, buf, tmp_interval3);
4345 SAFE_ALLOCA (temp, unsigned char *, len1_byte);
4346 start1_addr = BYTE_POS_ADDR (start1_byte);
4347 start2_addr = BYTE_POS_ADDR (start2_byte);
4348 bcopy (start1_addr, temp, len1_byte);
4349 bcopy (start2_addr, start1_addr, len2_byte);
4350 bcopy (temp, start2_addr, len1_byte);
4351 SAFE_FREE ();
4353 graft_intervals_into_buffer (tmp_interval1, start2,
4354 len1, current_buffer, 0);
4355 graft_intervals_into_buffer (tmp_interval2, start1,
4356 len2, current_buffer, 0);
4359 else if (len1_byte < len2_byte) /* Second region larger than first */
4360 /* Non-adjacent & unequal size, area between must also be shifted. */
4362 USE_SAFE_ALLOCA;
4364 modify_region (current_buffer, start1, end2, 0);
4365 record_change (start1, (end2 - start1));
4366 tmp_interval1 = copy_intervals (cur_intv, start1, len1);
4367 tmp_interval_mid = copy_intervals (cur_intv, end1, len_mid);
4368 tmp_interval2 = copy_intervals (cur_intv, start2, len2);
4370 tmp_interval3 = validate_interval_range (buf, &startr1, &endr2, 0);
4371 if (!NULL_INTERVAL_P (tmp_interval3))
4372 set_text_properties_1 (startr1, endr2, Qnil, buf, tmp_interval3);
4374 /* holds region 2 */
4375 SAFE_ALLOCA (temp, unsigned char *, len2_byte);
4376 start1_addr = BYTE_POS_ADDR (start1_byte);
4377 start2_addr = BYTE_POS_ADDR (start2_byte);
4378 bcopy (start2_addr, temp, len2_byte);
4379 bcopy (start1_addr, start1_addr + len_mid + len2_byte, len1_byte);
4380 safe_bcopy (start1_addr + len1_byte, start1_addr + len2_byte, len_mid);
4381 bcopy (temp, start1_addr, len2_byte);
4382 SAFE_FREE ();
4384 graft_intervals_into_buffer (tmp_interval1, end2 - len1,
4385 len1, current_buffer, 0);
4386 graft_intervals_into_buffer (tmp_interval_mid, start1 + len2,
4387 len_mid, current_buffer, 0);
4388 graft_intervals_into_buffer (tmp_interval2, start1,
4389 len2, current_buffer, 0);
4391 else
4392 /* Second region smaller than first. */
4394 USE_SAFE_ALLOCA;
4396 record_change (start1, (end2 - start1));
4397 modify_region (current_buffer, start1, end2, 0);
4399 tmp_interval1 = copy_intervals (cur_intv, start1, len1);
4400 tmp_interval_mid = copy_intervals (cur_intv, end1, len_mid);
4401 tmp_interval2 = copy_intervals (cur_intv, start2, len2);
4403 tmp_interval3 = validate_interval_range (buf, &startr1, &endr2, 0);
4404 if (!NULL_INTERVAL_P (tmp_interval3))
4405 set_text_properties_1 (startr1, endr2, Qnil, buf, tmp_interval3);
4407 /* holds region 1 */
4408 SAFE_ALLOCA (temp, unsigned char *, len1_byte);
4409 start1_addr = BYTE_POS_ADDR (start1_byte);
4410 start2_addr = BYTE_POS_ADDR (start2_byte);
4411 bcopy (start1_addr, temp, len1_byte);
4412 bcopy (start2_addr, start1_addr, len2_byte);
4413 bcopy (start1_addr + len1_byte, start1_addr + len2_byte, len_mid);
4414 bcopy (temp, start1_addr + len2_byte + len_mid, len1_byte);
4415 SAFE_FREE ();
4417 graft_intervals_into_buffer (tmp_interval1, end2 - len1,
4418 len1, current_buffer, 0);
4419 graft_intervals_into_buffer (tmp_interval_mid, start1 + len2,
4420 len_mid, current_buffer, 0);
4421 graft_intervals_into_buffer (tmp_interval2, start1,
4422 len2, current_buffer, 0);
4425 update_compositions (start1, start1 + len2, CHECK_BORDER);
4426 update_compositions (end2 - len1, end2, CHECK_BORDER);
4429 /* When doing multiple transpositions, it might be nice
4430 to optimize this. Perhaps the markers in any one buffer
4431 should be organized in some sorted data tree. */
4432 if (NILP (leave_markers))
4434 transpose_markers (start1, end1, start2, end2,
4435 start1_byte, start1_byte + len1_byte,
4436 start2_byte, start2_byte + len2_byte);
4437 fix_start_end_in_overlays (start1, end2);
4440 signal_after_change (start1, end2 - start1, end2 - start1);
4441 return Qnil;
4445 void
4446 syms_of_editfns ()
4448 environbuf = 0;
4450 Qbuffer_access_fontify_functions
4451 = intern ("buffer-access-fontify-functions");
4452 staticpro (&Qbuffer_access_fontify_functions);
4454 DEFVAR_LISP ("inhibit-field-text-motion", &Vinhibit_field_text_motion,
4455 doc: /* Non-nil means text motion commands don't notice fields. */);
4456 Vinhibit_field_text_motion = Qnil;
4458 DEFVAR_LISP ("buffer-access-fontify-functions",
4459 &Vbuffer_access_fontify_functions,
4460 doc: /* List of functions called by `buffer-substring' to fontify if necessary.
4461 Each function is called with two arguments which specify the range
4462 of the buffer being accessed. */);
4463 Vbuffer_access_fontify_functions = Qnil;
4466 Lisp_Object obuf;
4467 extern Lisp_Object Vprin1_to_string_buffer;
4468 obuf = Fcurrent_buffer ();
4469 /* Do this here, because init_buffer_once is too early--it won't work. */
4470 Fset_buffer (Vprin1_to_string_buffer);
4471 /* Make sure buffer-access-fontify-functions is nil in this buffer. */
4472 Fset (Fmake_local_variable (intern ("buffer-access-fontify-functions")),
4473 Qnil);
4474 Fset_buffer (obuf);
4477 DEFVAR_LISP ("buffer-access-fontified-property",
4478 &Vbuffer_access_fontified_property,
4479 doc: /* Property which (if non-nil) indicates text has been fontified.
4480 `buffer-substring' need not call the `buffer-access-fontify-functions'
4481 functions if all the text being accessed has this property. */);
4482 Vbuffer_access_fontified_property = Qnil;
4484 DEFVAR_LISP ("system-name", &Vsystem_name,
4485 doc: /* The host name of the machine Emacs is running on. */);
4487 DEFVAR_LISP ("user-full-name", &Vuser_full_name,
4488 doc: /* The full name of the user logged in. */);
4490 DEFVAR_LISP ("user-login-name", &Vuser_login_name,
4491 doc: /* The user's name, taken from environment variables if possible. */);
4493 DEFVAR_LISP ("user-real-login-name", &Vuser_real_login_name,
4494 doc: /* The user's name, based upon the real uid only. */);
4496 DEFVAR_LISP ("operating-system-release", &Voperating_system_release,
4497 doc: /* The release of the operating system Emacs is running on. */);
4499 defsubr (&Spropertize);
4500 defsubr (&Schar_equal);
4501 defsubr (&Sgoto_char);
4502 defsubr (&Sstring_to_char);
4503 defsubr (&Schar_to_string);
4504 defsubr (&Sbuffer_substring);
4505 defsubr (&Sbuffer_substring_no_properties);
4506 defsubr (&Sbuffer_string);
4508 defsubr (&Spoint_marker);
4509 defsubr (&Smark_marker);
4510 defsubr (&Spoint);
4511 defsubr (&Sregion_beginning);
4512 defsubr (&Sregion_end);
4514 staticpro (&Qfield);
4515 Qfield = intern ("field");
4516 staticpro (&Qboundary);
4517 Qboundary = intern ("boundary");
4518 defsubr (&Sfield_beginning);
4519 defsubr (&Sfield_end);
4520 defsubr (&Sfield_string);
4521 defsubr (&Sfield_string_no_properties);
4522 defsubr (&Sdelete_field);
4523 defsubr (&Sconstrain_to_field);
4525 defsubr (&Sline_beginning_position);
4526 defsubr (&Sline_end_position);
4528 /* defsubr (&Smark); */
4529 /* defsubr (&Sset_mark); */
4530 defsubr (&Ssave_excursion);
4531 defsubr (&Ssave_current_buffer);
4533 defsubr (&Sbufsize);
4534 defsubr (&Spoint_max);
4535 defsubr (&Spoint_min);
4536 defsubr (&Spoint_min_marker);
4537 defsubr (&Spoint_max_marker);
4538 defsubr (&Sgap_position);
4539 defsubr (&Sgap_size);
4540 defsubr (&Sposition_bytes);
4541 defsubr (&Sbyte_to_position);
4543 defsubr (&Sbobp);
4544 defsubr (&Seobp);
4545 defsubr (&Sbolp);
4546 defsubr (&Seolp);
4547 defsubr (&Sfollowing_char);
4548 defsubr (&Sprevious_char);
4549 defsubr (&Schar_after);
4550 defsubr (&Schar_before);
4551 defsubr (&Sinsert);
4552 defsubr (&Sinsert_before_markers);
4553 defsubr (&Sinsert_and_inherit);
4554 defsubr (&Sinsert_and_inherit_before_markers);
4555 defsubr (&Sinsert_char);
4557 defsubr (&Suser_login_name);
4558 defsubr (&Suser_real_login_name);
4559 defsubr (&Suser_uid);
4560 defsubr (&Suser_real_uid);
4561 defsubr (&Suser_full_name);
4562 defsubr (&Semacs_pid);
4563 defsubr (&Scurrent_time);
4564 defsubr (&Sget_internal_run_time);
4565 defsubr (&Sformat_time_string);
4566 defsubr (&Sfloat_time);
4567 defsubr (&Sdecode_time);
4568 defsubr (&Sencode_time);
4569 defsubr (&Scurrent_time_string);
4570 defsubr (&Scurrent_time_zone);
4571 defsubr (&Sset_time_zone_rule);
4572 defsubr (&Ssystem_name);
4573 defsubr (&Smessage);
4574 defsubr (&Smessage_box);
4575 defsubr (&Smessage_or_box);
4576 defsubr (&Scurrent_message);
4577 defsubr (&Sformat);
4579 defsubr (&Sinsert_buffer_substring);
4580 defsubr (&Scompare_buffer_substrings);
4581 defsubr (&Ssubst_char_in_region);
4582 defsubr (&Stranslate_region_internal);
4583 defsubr (&Sdelete_region);
4584 defsubr (&Sdelete_and_extract_region);
4585 defsubr (&Swiden);
4586 defsubr (&Snarrow_to_region);
4587 defsubr (&Ssave_restriction);
4588 defsubr (&Stranspose_regions);
4591 /* arch-tag: fc3827d8-6f60-4067-b11e-c3218031b018
4592 (do not change this comment) */