xemacs-beta: src/editfns.c comparison

comparison src/editfns.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	9ee227acff29
children	e04119814345

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 if (p)
 Vuser_full_name = build_string ((char *) p);
 #endif /* 0 */
 }
-DEFUN ("char-to-string", Fchar_to_string, Schar_to_string, 1, 1, 0 /*
+DEFUN ("char-to-string", Fchar_to_string, 1, 1, 0, /*
 Convert arg CH to a one-character string containing that character.
-*/ )
+*/
-(ch)
+(ch))
-Lisp_Object ch;
 {
 Bytecount len;
 Bufbyte str[MAX_EMCHAR_LEN];
 if (EVENTP (ch))
 len = set_charptr_emchar (str, XCHAR (ch));
 return make_string (str, len);
 }
-DEFUN ("string-to-char", Fstring_to_char, Sstring_to_char, 1, 1, 0 /*
+DEFUN ("string-to-char", Fstring_to_char, 1, 1, 0, /*
 Convert arg STRING to a character, the first character of that string.
-*/ )
+*/
-(str)
+(str))
-Lisp_Object str;
 {
 struct Lisp_String *p;
 CHECK_STRING (str);
 p = XSTRING (str);
 mark = Fmake_marker ();
 Fset_marker (mark, make_int (val), buffer);
 return mark;
 }
-DEFUN ("point", Fpoint, Spoint, 0, 1, 0 /*
+DEFUN ("point", Fpoint, 0, 1, 0, /*
 Return value of point, as an integer.
 Beginning of buffer is position (point-min).
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 return (make_int (BUF_PT (b)));
 }
-DEFUN ("point-marker", Fpoint_marker, Spoint_marker, 0, 2, 0 /*
+DEFUN ("point-marker", Fpoint_marker, 0, 2, 0, /*
 Return value of point, as a marker object.
 This marker is a copy; you may modify it with reckless abandon.
 If optional argument DONT-COPY-P is non-nil, then it returns the real
 point-marker; modifying the position of this marker will move point.
 It is illegal to change the buffer of it, or make it point nowhere.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(dont_copy_p, buffer)
+(dont_copy_p, buffer))
-Lisp_Object dont_copy_p, buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 if (NILP (dont_copy_p))
 return Fcopy_marker (b->point_marker, Qnil);
 return b->point_marker;
 *
 * Jamie thinks he's wrong, but we'll leave this in for now.
 */
 int atomic_extent_goto_char_p;
-DEFUN ("goto-char", Fgoto_char, Sgoto_char, 1, 2, "NGoto char: " /*
+DEFUN ("goto-char", Fgoto_char, 1, 2, "NGoto char: ", /*
 Set point to POSITION, a number or marker.
 Beginning of buffer is position (point-min), end is (point-max).
 If BUFFER is nil, the current buffer is assumed.
 Return value of POSITION, as an integer.
-*/ )
+*/
-(position, buffer)
+(position, buffer))
-Lisp_Object position, buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 Bufpos n = get_buffer_pos_char (b, position, GB_COERCE_RANGE);
 BUF_SET_PT (b, n);
 atomic_extent_goto_char_p = 1;
 return (make_int (BUF_PT (b)));
 else
 return (m);
 }
-DEFUN ("region-beginning", Fregion_beginning, Sregion_beginning, 0, 1, 0 /*
+DEFUN ("region-beginning", Fregion_beginning, 0, 1, 0, /*
 Return position of beginning of region, as an integer.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 return (region_limit (1, decode_buffer (buffer, 1)));
 }
-DEFUN ("region-end", Fregion_end, Sregion_end, 0, 1, 0 /*
+DEFUN ("region-end", Fregion_end, 0, 1, 0, /*
 Return position of end of region, as an integer.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 return (region_limit (0, decode_buffer (buffer, 1)));
 }
 /* Whether to use lispm-style active-regions */
 return call0 (Qzmacs_region_buffer);
 else
 return Qnil;
 }
-DEFUN ("mark-marker", Fmark_marker, Smark_marker, 0, 2, 0 /*
+DEFUN ("mark-marker", Fmark_marker, 0, 2, 0, /*
 Return this buffer's mark, as a marker object.
 If `zmacs-regions' is true, then this returns nil unless the region is
 currently in the active (highlighted) state.  If optional argument FORCE
 is t, this returns the mark (if there is one) regardless of the zmacs-region
 state.  You should *generally* not use the mark unless the region is active,
 if the user has expressed a preference for the zmacs-region model.
 Watch out!  Moving this marker changes the mark position.
 If you set the marker not to point anywhere, the buffer will have no mark.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(force, buffer)
+(force, buffer))
-Lisp_Object force, buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 if (! zmacs_regions || zmacs_region_active_p || !NILP (force))
 return b->mark;
 return Qnil;
 free_cons (XCONS (XCDR (info)));
 free_cons (XCONS (info));
 return Qnil;
 }
-DEFUN ("save-excursion", Fsave_excursion, Ssave_excursion, 0, UNEVALLED, 0 /*
+DEFUN ("save-excursion", Fsave_excursion, 0, UNEVALLED, 0, /*
 Save point, mark, and current buffer; execute BODY; restore those things.
 Executes BODY just like `progn'.
 The values of point, mark and the current buffer are restored
 even in case of abnormal exit (throw or error).
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 int speccount = specpdl_depth ();
 record_unwind_protect (save_excursion_restore, save_excursion_save ());
 return unbind_to (speccount, Fprogn (args));
 }
-DEFUN ("buffer-size", Fbufsize, Sbufsize, 0, 1, 0 /*
+DEFUN ("buffer-size", Fbufsize, 0, 1, 0, /*
 Return the number of characters in BUFFER.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 return (make_int (BUF_SIZE (b)));
 }
-DEFUN ("point-min", Fpoint_min, Spoint_min, 0, 1, 0 /*
+DEFUN ("point-min", Fpoint_min, 0, 1, 0, /*
 Return the minimum permissible value of point in BUFFER.
 This is 1, unless narrowing (a buffer restriction) is in effect.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 return (make_int (BUF_BEGV (b)));
 }
-DEFUN ("point-min-marker", Fpoint_min_marker, Spoint_min_marker, 0, 1, 0 /*
+DEFUN ("point-min-marker", Fpoint_min_marker, 0, 1, 0, /*
 Return a marker to the minimum permissible value of point in BUFFER.
 This is the beginning, unless narrowing (a buffer restriction) is in effect.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 return buildmark (BUF_BEGV (b), make_buffer (b));
 }
-DEFUN ("point-max", Fpoint_max, Spoint_max, 0, 1, 0 /*
+DEFUN ("point-max", Fpoint_max, 0, 1, 0, /*
 Return the maximum permissible value of point in BUFFER.
 This is (1+ (buffer-size)), unless narrowing (a buffer restriction)
 is in effect, in which case it is less.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 return (make_int (BUF_ZV (b)));
 }
-DEFUN ("point-max-marker", Fpoint_max_marker, Spoint_max_marker, 0, 1, 0 /*
+DEFUN ("point-max-marker", Fpoint_max_marker, 0, 1, 0, /*
 Return a marker to the maximum permissible value of point BUFFER.
 This is (1+ (buffer-size)), unless narrowing (a buffer restriction)
 is in effect, in which case it is less.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 return buildmark (BUF_ZV (b), make_buffer (b));
 }
-DEFUN ("following-char", Ffollowing_char, Sfollowing_char, 0, 1, 0 /*
+DEFUN ("following-char", Ffollowing_char, 0, 1, 0, /*
 Return the character following point, as a number.
 At the end of the buffer or accessible region, return 0.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 if (BUF_PT (b) >= BUF_ZV (b))
 return (Qzero);             /* #### Gag me! */
 else
 return (make_char (BUF_FETCH_CHAR (b, BUF_PT (b))));
 }
-DEFUN ("preceding-char", Fpreceding_char, Spreceding_char, 0, 1, 0 /*
+DEFUN ("preceding-char", Fpreceding_char, 0, 1, 0, /*
 Return the character preceding point, as a number.
 At the beginning of the buffer or accessible region, return 0.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 if (BUF_PT (b) <= BUF_BEGV (b))
 return (Qzero);             /* #### Gag me! */
 else
 return (make_char (BUF_FETCH_CHAR (b, BUF_PT (b) - 1)));
 }
-DEFUN ("bobp", Fbobp, Sbobp, 0, 1, 0 /*
+DEFUN ("bobp", Fbobp, 0, 1, 0, /*
 Return T if point is at the beginning of the buffer.
 If the buffer is narrowed, this means the beginning of the narrowed part.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 return BUF_PT (b) == BUF_BEGV (b) ? Qt : Qnil;
 }
-DEFUN ("eobp", Feobp, Seobp, 0, 1, 0 /*
+DEFUN ("eobp", Feobp, 0, 1, 0, /*
 Return T if point is at the end of the buffer.
 If the buffer is narrowed, this means the end of the narrowed part.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 return BUF_PT (b) == BUF_ZV (b) ? Qt : Qnil;
 }
 return 1;
 return BUF_FETCH_CHAR (b, pt - 1) == '\n';
 }
-DEFUN ("bolp", Fbolp, Sbolp, 0, 1, 0 /*
+DEFUN ("bolp", Fbolp, 0, 1, 0, /*
 Return T if point is at the beginning of a line.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 return beginning_of_line_p (b, BUF_PT (b)) ? Qt : Qnil;
 }
-DEFUN ("eolp", Feolp, Seolp, 0, 1, 0 /*
+DEFUN ("eolp", Feolp, 0, 1, 0, /*
 Return T if point is at the end of a line.
 `End of a line' includes point being at the end of the buffer.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 if (BUF_PT (b) == BUF_ZV (b) || BUF_FETCH_CHAR (b, BUF_PT (b)) == '\n')
 return Qt;
 return Qnil;
 }
-DEFUN ("char-after", Fchar_after, Schar_after, 1, 2, 0 /*
+DEFUN ("char-after", Fchar_after, 1, 2, 0, /*
 Return character in BUFFER at position POS.
 POS is an integer or a buffer pointer.
 If POS is out of range, the value is nil.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(pos, buffer)
+(pos, buffer))
-Lisp_Object pos, buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 Bufpos n = get_buffer_pos_char (b, pos, GB_NO_ERROR_IF_BAD);
 if (n < 0 || n == BUF_ZV (b))
 return Qnil;
 return (make_char (BUF_FETCH_CHAR (b, n)));
 }
-DEFUN ("user-login-name", Fuser_login_name, Suser_login_name, 0, 1, 0 /*
+DEFUN ("user-login-name", Fuser_login_name, 0, 1, 0, /*
 Return the name under which the user logged in, as a string.
 This is based on the effective uid, not the real uid.
 Also, if the environment variable LOGNAME or USER is set,
 that determines the value of this function.
 If the optional argument UID is present, then environment variables are
 ignored and this function returns the login name for that UID, or nil.
-*/ )
+*/
-(uid)
+(uid))
-Lisp_Object uid;
 {
 struct passwd *pw = NULL;
 if (!NILP (uid))
 {
 }
 /* #### - I believe this should return nil instead of "unknown" when pw==0 */
 return (pw ? build_string (pw->pw_name) : Qnil);
 }
-DEFUN ("user-real-login-name", Fuser_real_login_name, Suser_real_login_name,
+DEFUN ("user-real-login-name", Fuser_real_login_name, 0, 0, 0, /*
-0, 0, 0 /*
 Return the name of the user's real uid, as a string.
 This ignores the environment variables LOGNAME and USER, so it differs from
 `user-login-name' when running under `su'.
-*/ )
+*/
-()
+())
 {
 struct passwd *pw = (struct passwd *) getpwuid (getuid ());
 /* #### - I believe this should return nil instead of "unknown" when pw==0 */
 #ifdef MSDOS
 Lisp_Object tem = build_string (pw ? pw->pw_name : "unknown");/* no gettext */
 #endif
 return (tem);
 }
-DEFUN ("user-uid", Fuser_uid, Suser_uid, 0, 0, 0 /*
+DEFUN ("user-uid", Fuser_uid, 0, 0, 0, /*
 Return the effective uid of Emacs, as an integer.
-*/ )
+*/
-()
+())
 {
 return make_int (geteuid ());
 }
-DEFUN ("user-real-uid", Fuser_real_uid, Suser_real_uid, 0, 0, 0 /*
+DEFUN ("user-real-uid", Fuser_real_uid, 0, 0, 0, /*
 Return the real uid of Emacs, as an integer.
-*/ )
+*/
-()
+())
 {
 return make_int (getuid ());
 }
-DEFUN ("user-full-name", Fuser_full_name, Suser_full_name, 0, 1, 0 /*
+DEFUN ("user-full-name", Fuser_full_name, 0, 1, 0, /*
 Return the full name of the user logged in, as a string.
 If the optional argument USER is given, then the full name for that
 user is returned, or nil.  USER may be either a login name or a uid.
-*/ )
+*/
-(user)
+(user))
-Lisp_Object user;
 {
 Lisp_Object uname = (STRINGP (user) ? user : Fuser_login_name (user));
 struct passwd *pw = NULL;
 Lisp_Object tem;
 char *p, *q;
 if (p)
 tem = build_string (p);
 return (tem);
 }
-DEFUN ("system-name", Fsystem_name, Ssystem_name, 0, 0, 0 /*
+DEFUN ("system-name", Fsystem_name, 0, 0, 0, /*
 Return the name of the machine you are running on, as a string.
-*/ )
+*/
-()
+())
 {
 return (Fcopy_sequence (Vsystem_name));
 }
 /* For the benefit of callers who don't want to include lisp.h.
 get_system_name (void)
 {
 return xstrdup ((char *) XSTRING_DATA (Vsystem_name));
 }
-DEFUN ("emacs-pid", Femacs_pid, Semacs_pid, 0, 0, 0 /*
+DEFUN ("emacs-pid", Femacs_pid, 0, 0, 0, /*
 Return the process ID of Emacs, as an integer.
-*/ )
+*/
-()
+())
 {
 return make_int (getpid ());
 }
-DEFUN ("current-time", Fcurrent_time, Scurrent_time, 0, 0, 0 /*
+DEFUN ("current-time", Fcurrent_time, 0, 0, 0, /*
 Return the current time, as the number of seconds since 1970-01-01 00:00:00.
 The time is returned as a list of three integers.  The first has the
 most significant 16 bits of the seconds, while the second has the
 least significant 16 bits.  The third integer gives the microsecond
 count.
 The microsecond count is zero on systems that do not provide
 resolution finer than a second.
-*/ )
+*/
-()
+())
 {
 EMACS_TIME t;
 Lisp_Object result[3];
 EMACS_GET_TIME (t);
 XSETINT (result[2], EMACS_USECS (t));
 return Flist (3, result);
 }
-DEFUN ("current-process-time", Fcurrent_process_time, Scurrent_process_time,
+DEFUN ("current-process-time", Fcurrent_process_time, 0, 0, 0, /*
-0, 0, 0 /*
 Return the amount of time used by this XEmacs process so far.
 The return value is a list of three floating-point numbers, expressing
 the user, system, and real times used by the process.  The user time
 measures the time actually spent by the CPU executing the code in this
 process.  The system time measures time spent by the CPU executing kernel
 the process, and the system time will be 0.
 Some systems do not allow the real and processor times to be distinguished.
 In this case, the user and real times will be the same and the system
 time will be 0.
-*/ )
+*/
-()
+())
 {
 double user, sys, real;
 get_process_times (&user, &sys, &real);
 return list3 (make_float (user), make_float (sys), make_float (real));
 size_t emacs_strftime (char *string, size_t max, CONST char *format,
 		       CONST struct tm *tm);
 static long difftm (CONST struct tm *a, CONST struct tm *b);
-DEFUN ("format-time-string", Fformat_time_string, Sformat_time_string,
+DEFUN ("format-time-string", Fformat_time_string, 2, 2, 0, /*
-2, 2, 0 /*
 Use FORMAT-STRING to format the time TIME.
 TIME is specified as (HIGH LOW . IGNORED) or (HIGH . LOW), as from
 `current-time' and `file-attributes'.
 FORMAT-STRING may contain %-sequences to substitute parts of the time.
 %a is replaced by the abbreviated name of the day of week.
 The number of options reflects the `strftime' function.
 BUG: If the charset used by the current locale is not ISO 8859-1, the
 characters appearing in the day and month names may be incorrect.
-*/ )
+*/
-(format_string, _time)
+(format_string, _time))
-Lisp_Object format_string, _time;
 {
 time_t value;
 int size;
 CHECK_STRING (format_string);
 /* If buffer was too small, make it bigger.  */
 size *= 2;
 }
 }
-DEFUN ("decode-time", Fdecode_time, Sdecode_time, 0, 1, 0 /*
+DEFUN ("decode-time", Fdecode_time, 0, 1, 0, /*
 Decode a time value as (SEC MINUTE HOUR DAY MONTH YEAR DOW DST ZONE).
 The optional SPECIFIED-TIME should be a list of (HIGH LOW . IGNORED)
 or (HIGH . LOW), as from `current-time' and `file-attributes', or `nil'
 to use the current time.  The list has the following nine members:
 SEC is an integer between 0 and 60; SEC is 60 for a leap second, which
 MONTH is an integer between 1 and 12.  YEAR is an integer indicating the
 four-digit year.  DOW is the day of week, an integer between 0 and 6, where
 0 is Sunday.  DST is t if daylight savings time is effect, otherwise nil.
 ZONE is an integer indicating the number of seconds east of Greenwich.
 \(Note that Common Lisp has different meanings for DOW and ZONE.)
-*/ )
+*/
-(specified_time)
+(specified_time))
-Lisp_Object specified_time;
 {
 time_t time_spec;
 struct tm save_tm;
 struct tm *decoded_time;
 Lisp_Object list_args[9];
 return Flist (9, list_args);
 }
 static void set_time_zone_rule (char *tzstring);
-DEFUN ("encode-time", Fencode_time, Sencode_time, 6, MANY, 0 /*
+DEFUN ("encode-time", Fencode_time, 6, MANY, 0, /*
 Convert SECOND, MINUTE, HOUR, DAY, MONTH, YEAR and ZONE to internal time.
 This is the reverse operation of `decode-time', which see.
 ZONE defaults to the current time zone rule.  This can
 be a string (as from `set-time-zone-rule'), or it can be a list
 (as from `current-time-zone') or an integer (as from `decode-time')
 Out-of-range values for SEC, MINUTE, HOUR, DAY, or MONTH are allowed;
 for example, a DAY of 0 means the day preceding the given month.
 Year numbers less than 100 are treated just like other year numbers.
 If you want them to stand for years in this century, you must do that yourself
-*/ )
+*/
-(nargs, args)
+(int nargs, Lisp_Object *args))
-int nargs;
-Lisp_Object *args;
 {
 time_t _time;
 struct tm tm;
 Lisp_Object zone = (nargs > 6) ? args[nargs - 1] : Qnil;
 error ("Specified time is not representable");
 return wasteful_word_to_lisp (_time);
 }
-DEFUN ("current-time-string", Fcurrent_time_string, Scurrent_time_string,
+DEFUN ("current-time-string", Fcurrent_time_string, 0, 1, 0, /*
-0, 1, 0 /*
 Return the current time, as a human-readable string.
 Programs can use this function to decode a time,
 since the number of columns in each field is fixed.
 The format is `Sun Sep 16 01:03:52 1973'.
 If an argument is given, it specifies a time to format
 (HIGH . LOW)
 or the form:
 (HIGH LOW . IGNORED).
 Thus, you can use times obtained from `current-time'
 and from `file-attributes'.
-*/ )
+*/
-(specified_time)
+(specified_time))
-Lisp_Object specified_time;
 {
 time_t value;
 char buf[30];
 char *tem;
 return (60*(60*(24*days + (a->tm_hour - b->tm_hour))
 	      + (a->tm_min - b->tm_min))
 	  + (a->tm_sec - b->tm_sec));
 }
-DEFUN ("current-time-zone", Fcurrent_time_zone, Scurrent_time_zone, 0, 1, 0 /*
+DEFUN ("current-time-zone", Fcurrent_time_zone, 0, 1, 0, /*
 Return the offset and name for the local time zone.
 This returns a list of the form (OFFSET NAME).
 OFFSET is an integer number of seconds ahead of UTC (east of Greenwich).
 A negative value means west of Greenwich.
 NAME is a string giving the name of the time zone.
 and from `file-attributes'.
 Some operating systems cannot provide all this information to Emacs;
 in this case, `current-time-zone' returns a list containing nil for
 the data it can't find.
-*/ )
+*/
-(specified_time)
+(specified_time))
-Lisp_Object specified_time;
 {
 time_t value;
 struct tm *t;
 if (lisp_to_time (specified_time, &value)
 #ifdef LOCALTIME_CACHE
 tzset ();
 #endif
 }
-DEFUN ("set-time-zone-rule", Fset_time_zone_rule, Sset_time_zone_rule,
+DEFUN ("set-time-zone-rule", Fset_time_zone_rule, 1, 1, 0, /*
-1, 1, 0 /*
 Set the local time zone using TZ, a string specifying a time zone rule.
 If TZ is nil, use implementation-defined default time zone information.
-*/ )
+*/
-(tz)
+(tz))
-Lisp_Object tz;
 {
 char *tzstring;
 if (NILP (tz))
 tzstring = 0;
 /* Callers passing one argument to Finsert need not gcpro the
 argument "array", since the only element of the array will
 not be used after calling insert_emacs_char or insert_lisp_string,
 so we don't care if it gets trashed.  */
-DEFUN ("insert", Finsert, Sinsert, 0, MANY, 0 /*
+DEFUN ("insert", Finsert, 0, MANY, 0, /*
 Insert the arguments, either strings or characters, at point.
 Point moves forward so that it ends up after the inserted text.
 Any other markers at the point of insertion remain before the text.
 If a string has non-null string-extent-data, new extents will be created.
-*/ )
+*/
-(nargs, args)
+(int nargs, Lisp_Object *args))
-int nargs;
-Lisp_Object *args;
 {
 /* This function can GC */
 REGISTER int argnum;
 for (argnum = 0; argnum < nargs; argnum++)
 }
 return Qnil;
 }
-DEFUN ("insert-before-markers", Finsert_before_markers, Sinsert_before_markers, 0, MANY, 0 /*
+DEFUN ("insert-before-markers", Finsert_before_markers, 0, MANY, 0, /*
 Insert strings or characters at point, relocating markers after the text.
 Point moves forward so that it ends up after the inserted text.
 Any other markers at the point of insertion also end up after the text.
-*/ )
+*/
-(nargs, args)
+(int nargs, Lisp_Object *args))
-int nargs;
-Lisp_Object *args;
 {
 /* This function can GC */
 REGISTER int argnum;
 REGISTER Lisp_Object tem;
 }
 zmacs_region_stays = 0;
 return Qnil;
 }
-DEFUN ("insert-string", Finsert_string, Sinsert_string, 1, 2, 0 /*
+DEFUN ("insert-string", Finsert_string, 1, 2, 0, /*
 Insert STRING into BUFFER at BUFFER's point.
 Point moves forward so that it ends up after the inserted text.
 Any other markers at the point of insertion remain before the text.
 If a string has non-null string-extent-data, new extents will be created.
 BUFFER defaults to the current buffer.
-*/ )
+*/
-(string, buffer)
+(string, buffer))
-Lisp_Object string, buffer;
 {
 struct buffer *buf = decode_buffer (buffer, 1);
 CHECK_STRING (string);
 buffer_insert_lisp_string (buf, string);
 zmacs_region_stays = 0;
 from adjoining text, if those properties are sticky."
 Jamie thinks this is bogus. */
-DEFUN ("insert-char", Finsert_char, Sinsert_char, 1, 4, 0 /*
+DEFUN ("insert-char", Finsert_char, 1, 4, 0, /*
 Insert COUNT (second arg) copies of CHR (first arg).
 Point and all markers are affected as in the function `insert'.
 COUNT defaults to 1 if omitted.
 The optional third arg IGNORED is INHERIT under FSF Emacs.
 This is highly bogus, however, and XEmacs always behaves as if
 `t' were passed to INHERIT.
 The optional fourth arg BUFFER specifies the buffer to insert the
 text into.  If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(chr, count, ignored, buffer)
+(chr, count, ignored, buffer))
-Lisp_Object chr, count, ignored, buffer;
 {
 /* This function can GC */
 REGISTER Bufbyte *string;
 REGISTER int slen;
 REGISTER int i, j;
 }
 /* Making strings from buffer contents.  */
-DEFUN ("buffer-substring", Fbuffer_substring, Sbuffer_substring, 0, 3, 0 /*
+DEFUN ("buffer-substring", Fbuffer_substring, 0, 3, 0, /*
 Return the contents of part of BUFFER as a string.
 The two arguments START and END are character positions;
 they can be in either order.  If omitted, they default to the beginning
 and end of BUFFER, respectively.
 If there are duplicable extents in the region, the string remembers
 them in its extent data.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(start, end, buffer)
+(start, end, buffer))
-Lisp_Object start, end, buffer;
 {
 /* This function can GC */
 Bufpos begv, zv;
 struct buffer *b = decode_buffer (buffer, 1);
 get_buffer_range_char (b, start, end, &begv, &zv, GB_ALLOW_NIL);
 return make_string_from_buffer (b, begv, zv - begv);
 }
-DEFUN ("insert-buffer-substring", Finsert_buffer_substring, Sinsert_buffer_substring,
+DEFUN ("insert-buffer-substring", Finsert_buffer_substring, 1, 3, 0, /*
-1, 3, 0 /*
 Insert before point a substring of the contents of buffer BUFFER.
 BUFFER may be a buffer or a buffer name.
 Arguments START and END are character numbers specifying the substring.
 They default to the beginning and the end of BUFFER.
-*/ )
+*/
-(buffer, start, end)
+(buffer, start, end))
-Lisp_Object buffer, start, end;
 {
 /* This function can GC */
 Bufpos b, e;
 struct buffer *bp;
 buffer_insert_from_buffer (current_buffer, bp, b, e - b);
 return Qnil;
 }
-DEFUN ("compare-buffer-substrings", Fcompare_buffer_substrings, Scompare_buffer_substrings,
+DEFUN ("compare-buffer-substrings", Fcompare_buffer_substrings, 6, 6, 0, /*
-6, 6, 0 /*
 Compare two substrings of two buffers; return result as number.
 the value is -N if first string is less after N-1 chars,
 +N if first string is greater after N-1 chars, or 0 if strings match.
 Each substring is represented as three arguments: BUFFER, START and END.
 That makes six args in all, three for each substring.
 The value of `case-fold-search' in the current buffer
 determines whether case is significant or ignored.
-*/ )
+*/
-(buffer1, start1, end1, buffer2, start2, end2)
+(buffer1, start1, end1, buffer2, start2, end2))
-Lisp_Object buffer1, start1, end1, buffer2, start2, end2;
 {
 Bufpos begp1, endp1, begp2, endp2;
 REGISTER Charcount len1, len2, length, i;
 struct buffer *bp1, *bp2;
 Lisp_Object trt = ((!NILP (current_buffer->case_fold_search)) ?
 {
 XBUFFER (XCAR (arg))->filename = XCDR (arg);
 return Qnil;
 }
-DEFUN ("subst-char-in-region", Fsubst_char_in_region,
+DEFUN ("subst-char-in-region", Fsubst_char_in_region, 4, 5, 0, /*
-Ssubst_char_in_region, 4, 5, 0 /*
 From START to END, replace FROMCHAR with TOCHAR each time it occurs.
 If optional arg NOUNDO is non-nil, don't record this change for undo
 and don't mark the buffer as really changed.
-*/ )
+*/
-(start, end, fromchar, tochar, noundo)
+(start, end, fromchar, tochar, noundo))
-Lisp_Object start, end, fromchar, tochar, noundo;
 {
 /* This function can GC */
 Bufpos pos, stop;
 Emchar fromc, toc;
 int mc_count;
 unbind_to (count, Qnil);
 return Qnil;
 }
-DEFUN ("translate-region", Ftranslate_region, Stranslate_region, 3, 3, 0 /*
+DEFUN ("translate-region", Ftranslate_region, 3, 3, 0, /*
 From START to END, translate characters according to TABLE.
 TABLE is a string; the Nth character in it is the mapping
 for the character with code N.  Returns the number of characters changed.
-*/ )
+*/
-(start, end, table)
+(start, end, table))
-Lisp_Object start;
-Lisp_Object end;
-Lisp_Object table;
 {
 /* This function can GC */
 Bufpos pos, stop;	/* Limits of the region. */
 REGISTER Emchar oc;		/* Old character. */
 REGISTER Emchar nc;		/* New character. */
 end_multiple_change (buf, mc_count);
 return make_int (cnt);
 }
-DEFUN ("delete-region", Fdelete_region, Sdelete_region, 2, 3, "r" /*
+DEFUN ("delete-region", Fdelete_region, 2, 3, "r", /*
 Delete the text between point and mark.
 When called from a program, expects two arguments,
 positions (integers or markers) specifying the stretch to be deleted.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(b, e, buffer)
+(b, e, buffer))
-Lisp_Object b, e, buffer;
 {
 /* This function can GC */
 Bufpos start, end;
 struct buffer *buf = decode_buffer (buffer, 1);
 column.  */
 invalidate_current_column ();
 }
 }
-DEFUN ("widen", Fwiden, Swiden, 0, 1, "" /*
+DEFUN ("widen", Fwiden, 0, 1, "", /*
 Remove restrictions (narrowing) from BUFFER.
 This allows the buffer's full text to be seen and edited.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 widen_buffer (b, 0);
 zmacs_region_stays = 0;
 return Qnil;
 }
-DEFUN ("narrow-to-region", Fnarrow_to_region, Snarrow_to_region, 2, 3, "r" /*
+DEFUN ("narrow-to-region", Fnarrow_to_region, 2, 3, "r", /*
 Restrict editing in BUFFER to the current region.
 The rest of the text becomes temporarily invisible and untouchable
 but is not deleted; if you save the buffer in a file, the invisible
 text is included in the file.  \\[widen] makes all visible again.
 If BUFFER is nil, the current buffer is assumed.
 See also `save-restriction'.
 When calling from a program, pass two arguments; positions (integers
 or markers) bounding the text that should remain visible.
-*/ )
+*/
-(b, e, buffer)
+(b, e, buffer))
-Lisp_Object b, e, buffer;
 {
 Bufpos start, end;
 struct buffer *buf = decode_buffer (buffer, 1);
 Bytind bi_start, bi_end;
 				     BUF_ZV (buf)));
 return Qnil;
 }
-DEFUN ("save-restriction", Fsave_restriction, Ssave_restriction, 0, UNEVALLED, 0 /*
+DEFUN ("save-restriction", Fsave_restriction, 0, UNEVALLED, 0, /*
 Execute BODY, saving and restoring current buffer's restrictions.
 The buffer's restrictions make parts of the beginning and end invisible.
 \(They are set up with `narrow-to-region' and eliminated with `widen'.)
 This special form, `save-restriction', saves the current buffer's restrictions
 when it is entered, and restores them when it is exited.
 and then make changes outside the area within the saved restrictions.
 Note: if you are using both `save-excursion' and `save-restriction',
 use `save-excursion' outermost:
 (save-excursion (save-restriction ...))
-*/ )
+*/
-(body)
+(body))
-Lisp_Object body;
 {
 /* This function can GC */
 int speccount = specpdl_depth ();
 record_unwind_protect (save_restriction_restore, save_restriction_save ());
 return unbind_to (speccount, Fprogn (body));
 }
-DEFUN ("format", Fformat, Sformat, 1, MANY, 0 /*
+DEFUN ("format", Fformat, 1, MANY, 0, /*
 Format a string out of a control-string and arguments.
 The first argument is a control string.
 The other arguments are substituted into it to make the result, a string.
 It may contain %-sequences meaning to substitute the next argument.
 %s means print all objects as-is, using `princ'.
 a decimal point is printed in %f, %e, and %E conversions even if no
 numbers are printed after it; and trailing zeroes are not omitted in
 %g and %G conversions.
 Use %% to put a single % into the output.
-*/ )
+*/
-(nargs, args)
+(int nargs, Lisp_Object *args))
-int nargs;
-Lisp_Object *args;
 {
 /* It should not be necessary to GCPRO ARGS, because
 the caller in the interpreter should take care of that.  */
 CHECK_STRING (args[0]);
 return emacs_doprnt_string_lisp (0, args[0], 0, nargs - 1, args + 1);
 }
-DEFUN ("char-equal", Fchar_equal, Schar_equal, 2, 3, 0 /*
+DEFUN ("char-equal", Fchar_equal, 2, 3, 0, /*
 Return t if two characters match, optionally ignoring case.
 Both arguments must be characters (i.e. integers).
 Case is ignored if `case-fold-search' is non-nil in BUFFER.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(c1, c2, buffer)
+(c1, c2, buffer))
-Lisp_Object c1, c2, buffer;
 {
 Emchar x1, x2;
 struct buffer *buf = decode_buffer (buffer, 1);
 CHECK_CHAR_COERCE_INT (c1);
 }
 }
 #endif
-DEFUN ("transpose-regions", Ftranspose_regions, Stranspose_regions, 4, 5, 0 /*
+DEFUN ("transpose-regions", Ftranspose_regions, 4, 5, 0, /*
 Transpose region START1 to END1 with START2 to END2.
 The regions may not be overlapping, because the size of the buffer is
 never changed in a transposition.
 Optional fifth arg LEAVE_MARKERS, if non-nil, means don't transpose
 any markers that happen to be located in the regions. (#### BUG: currently
 this function always acts as if LEAVE_MARKERS is non-nil.)
 Transposing beyond buffer boundaries is an error.
-*/ )
+*/
-(startr1, endr1, startr2, endr2, leave_markers)
+(startr1, endr1, startr2, endr2, leave_markers))
-Lisp_Object startr1, endr1, startr2, endr2, leave_markers;
 {
 Bufpos start1, end1, start2, end2;
 Charcount len1, len2;
 Lisp_Object string1, string2;
 struct buffer *buf = current_buffer;
 defsymbol (&Qmark, "mark");
 defsymbol (&Qregion_beginning, "region-beginning");
 defsymbol (&Qregion_end, "region-end");
 defsymbol (&Qformat, "format");
-defsubr (&Schar_equal);
+DEFSUBR (Fchar_equal);
-defsubr (&Sgoto_char);
+DEFSUBR (Fgoto_char);
-defsubr (&Sstring_to_char);
+DEFSUBR (Fstring_to_char);
-defsubr (&Schar_to_string);
+DEFSUBR (Fchar_to_string);
-defsubr (&Sbuffer_substring);
+DEFSUBR (Fbuffer_substring);
-defsubr (&Spoint_marker);
+DEFSUBR (Fpoint_marker);
-defsubr (&Smark_marker);
+DEFSUBR (Fmark_marker);
-defsubr (&Spoint);
+DEFSUBR (Fpoint);
-defsubr (&Sregion_beginning);
+DEFSUBR (Fregion_beginning);
-defsubr (&Sregion_end);
+DEFSUBR (Fregion_end);
-defsubr (&Ssave_excursion);
+DEFSUBR (Fsave_excursion);
-defsubr (&Sbufsize);
+DEFSUBR (Fbufsize);
-defsubr (&Spoint_max);
+DEFSUBR (Fpoint_max);
-defsubr (&Spoint_min);
+DEFSUBR (Fpoint_min);
-defsubr (&Spoint_min_marker);
+DEFSUBR (Fpoint_min_marker);
-defsubr (&Spoint_max_marker);
+DEFSUBR (Fpoint_max_marker);
-defsubr (&Sbobp);
+DEFSUBR (Fbobp);
-defsubr (&Seobp);
+DEFSUBR (Feobp);
-defsubr (&Sbolp);
+DEFSUBR (Fbolp);
-defsubr (&Seolp);
+DEFSUBR (Feolp);
-defsubr (&Sfollowing_char);
+DEFSUBR (Ffollowing_char);
-defsubr (&Spreceding_char);
+DEFSUBR (Fpreceding_char);
-defsubr (&Schar_after);
+DEFSUBR (Fchar_after);
-defsubr (&Sinsert);
+DEFSUBR (Finsert);
-defsubr (&Sinsert_string);
+DEFSUBR (Finsert_string);
-defsubr (&Sinsert_before_markers);
+DEFSUBR (Finsert_before_markers);
-defsubr (&Sinsert_char);
+DEFSUBR (Finsert_char);
-defsubr (&Suser_login_name);
+DEFSUBR (Fuser_login_name);
-defsubr (&Suser_real_login_name);
+DEFSUBR (Fuser_real_login_name);
-defsubr (&Suser_uid);
+DEFSUBR (Fuser_uid);
-defsubr (&Suser_real_uid);
+DEFSUBR (Fuser_real_uid);
-defsubr (&Suser_full_name);
+DEFSUBR (Fuser_full_name);
-defsubr (&Semacs_pid);
+DEFSUBR (Femacs_pid);
-defsubr (&Scurrent_time);
+DEFSUBR (Fcurrent_time);
-defsubr (&Scurrent_process_time);
+DEFSUBR (Fcurrent_process_time);
-defsubr (&Sformat_time_string);
+DEFSUBR (Fformat_time_string);
-defsubr (&Sdecode_time);
+DEFSUBR (Fdecode_time);
-defsubr (&Sencode_time);
+DEFSUBR (Fencode_time);
-defsubr (&Scurrent_time_string);
+DEFSUBR (Fcurrent_time_string);
-defsubr (&Scurrent_time_zone);
+DEFSUBR (Fcurrent_time_zone);
-defsubr (&Sset_time_zone_rule);
+DEFSUBR (Fset_time_zone_rule);
-defsubr (&Ssystem_name);
+DEFSUBR (Fsystem_name);
-defsubr (&Sformat);
+DEFSUBR (Fformat);
-defsubr (&Sinsert_buffer_substring);
+DEFSUBR (Finsert_buffer_substring);
-defsubr (&Scompare_buffer_substrings);
+DEFSUBR (Fcompare_buffer_substrings);
-defsubr (&Ssubst_char_in_region);
+DEFSUBR (Fsubst_char_in_region);
-defsubr (&Stranslate_region);
+DEFSUBR (Ftranslate_region);
-defsubr (&Sdelete_region);
+DEFSUBR (Fdelete_region);
-defsubr (&Swiden);
+DEFSUBR (Fwiden);
-defsubr (&Snarrow_to_region);
+DEFSUBR (Fnarrow_to_region);
-defsubr (&Ssave_restriction);
+DEFSUBR (Fsave_restriction);
-defsubr (&Stranspose_regions);
+DEFSUBR (Ftranspose_regions);
 defsymbol (&Qzmacs_update_region, "zmacs-update-region");
 defsymbol (&Qzmacs_deactivate_region, "zmacs-deactivate-region");
 defsymbol (&Qzmacs_region_buffer, "zmacs-region-buffer");
 }

Mercurial > hg > xemacs-beta

comparison src/editfns.c @ 20:859a2309aef8 r19-15b93