Mercurial > hg > xemacs-beta
annotate src/cmds.c @ 5602:c9e5612f5424
Support the MP library on recent FreeBSD, have it pass relevant tests.
src/ChangeLog addition:
2011-11-26 Aidan Kehoe <kehoea@parhasard.net>
* number-mp.c (bignum_to_string):
Don't overwrite the accumulator we've just set up for this
function.
* number-mp.c (BIGNUM_TO_TYPE):
mp_itom() doesn't necessarily do what this code used to think with
negative numbers, it can treat them as unsigned ints. Subtract
numbers from bignum_zero instead of multiplying them by -1 to
convert them to their negative equivalents.
* number-mp.c (bignum_to_int):
* number-mp.c (bignum_to_uint):
* number-mp.c (bignum_to_long):
* number-mp.c (bignum_to_ulong):
* number-mp.c (bignum_to_double):
Use the changed BIGNUM_TO_TYPE() in these functions.
* number-mp.c (bignum_ceil):
* number-mp.c (bignum_floor):
In these functions, be more careful about rounding to positive and
negative infinity, respectively. Don't use the sign of QUOTIENT
when working out out whether to add or subtract one, rather use
the sign QUOTIENT would have if arbitrary-precision division were
done.
* number-mp.h:
* number-mp.h (MP_GCD):
Wrap #include <mp.h> in BEGIN_C_DECLS/END_C_DECLS.
* number.c (Fbigfloat_get_precision):
* number.c (Fbigfloat_set_precision):
Don't attempt to call XBIGFLOAT_GET_PREC if this build doesn't
support big floats.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Sat, 26 Nov 2011 17:59:14 +0000 |
| parents | 56144c8593a8 |
| children | ad35a0cd95f5 |
| rev | line source |
|---|---|
| 428 | 1 /* Simple built-in editing commands. |
| 2 Copyright (C) 1985, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. | |
| 826 | 3 Copyright (C) 2002 Ben Wing. |
| 428 | 4 |
| 5 This file is part of XEmacs. | |
| 6 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
3577
diff
changeset
|
7 XEmacs is free software: you can redistribute it and/or modify it |
| 428 | 8 under the terms of the GNU General Public License as published by the |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
3577
diff
changeset
|
9 Free Software Foundation, either version 3 of the License, or (at your |
|
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
3577
diff
changeset
|
10 option) any later version. |
| 428 | 11 |
| 12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
3577
diff
changeset
|
18 along with XEmacs. If not, see <http://www.gnu.org/licenses/>. */ |
| 428 | 19 |
| 20 /* Synched up with: Mule 2.0, FSF 19.30. */ | |
| 21 | |
| 22 #include <config.h> | |
| 23 #include "lisp.h" | |
| 24 #include "commands.h" | |
| 25 #include "buffer.h" | |
| 872 | 26 #include "extents.h" |
| 428 | 27 #include "syntax.h" |
| 28 #include "insdel.h" | |
| 29 | |
| 30 Lisp_Object Qkill_forward_chars; | |
| 31 Lisp_Object Qself_insert_command; | |
| 32 Lisp_Object Qno_self_insert; | |
| 33 | |
| 34 Lisp_Object Vblink_paren_function; | |
| 35 | |
| 36 /* A possible value for a buffer's overwrite-mode variable. */ | |
| 37 Lisp_Object Qoverwrite_mode_binary; | |
| 38 | |
| 39 /* Non-nil means put this face on the next self-inserting character. */ | |
| 40 Lisp_Object Vself_insert_face; | |
| 41 | |
| 42 /* This is the command that set up Vself_insert_face. */ | |
| 43 Lisp_Object Vself_insert_face_command; | |
| 442 | 44 |
| 45 /* A char-table for characters which may invoke auto-filling. */ | |
| 46 Lisp_Object Vauto_fill_chars; | |
| 428 | 47 |
| 48 DEFUN ("forward-char", Fforward_char, 0, 2, "_p", /* | |
| 444 | 49 Move point right COUNT characters (left if COUNT is negative). |
| 428 | 50 On attempt to pass end of buffer, stop and signal `end-of-buffer'. |
| 51 On attempt to pass beginning of buffer, stop and signal `beginning-of-buffer'. | |
| 52 On reaching end of buffer, stop and signal error. | |
| 462 | 53 |
| 54 The characters that are moved over may be added to the current selection | |
| 55 \(i.e. active region) if the Shift key is held down, a motion key is used | |
| 56 to invoke this command, and `shifted-motion-keys-select-region' is t; see | |
| 57 the documentation for this variable for more details. | |
| 428 | 58 */ |
| 444 | 59 (count, buffer)) |
| 428 | 60 { |
| 61 struct buffer *buf = decode_buffer (buffer, 1); | |
| 444 | 62 EMACS_INT n; |
| 428 | 63 |
| 444 | 64 if (NILP (count)) |
| 65 n = 1; | |
| 428 | 66 else |
| 67 { | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
68 CHECK_FIXNUM (count); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
69 n = XFIXNUM (count); |
| 428 | 70 } |
| 71 | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
72 /* This used to just set point to point + XFIXNUM (count), and then check |
| 428 | 73 to see if it was within boundaries. But now that SET_PT can |
| 74 potentially do a lot of stuff (calling entering and exiting | |
| 75 hooks, etcetera), that's not a good approach. So we validate the | |
| 76 proposed position, then set point. */ | |
| 77 { | |
| 665 | 78 Charbpos new_point = BUF_PT (buf) + n; |
| 428 | 79 |
| 80 if (new_point < BUF_BEGV (buf)) | |
| 81 { | |
| 82 BUF_SET_PT (buf, BUF_BEGV (buf)); | |
| 83 Fsignal (Qbeginning_of_buffer, Qnil); | |
| 84 return Qnil; | |
| 85 } | |
| 86 if (new_point > BUF_ZV (buf)) | |
| 87 { | |
| 88 BUF_SET_PT (buf, BUF_ZV (buf)); | |
| 89 Fsignal (Qend_of_buffer, Qnil); | |
| 90 return Qnil; | |
| 91 } | |
| 92 | |
| 93 BUF_SET_PT (buf, new_point); | |
| 94 } | |
| 95 | |
| 96 return Qnil; | |
| 97 } | |
| 98 | |
| 99 DEFUN ("backward-char", Fbackward_char, 0, 2, "_p", /* | |
| 444 | 100 Move point left COUNT characters (right if COUNT is negative). |
| 428 | 101 On attempt to pass end of buffer, stop and signal `end-of-buffer'. |
| 102 On attempt to pass beginning of buffer, stop and signal `beginning-of-buffer'. | |
| 462 | 103 |
| 104 The characters that are moved over may be added to the current selection | |
| 105 \(i.e. active region) if the Shift key is held down, a motion key is used | |
| 106 to invoke this command, and `shifted-motion-keys-select-region' is t; see | |
| 107 the documentation for this variable for more details. | |
| 428 | 108 */ |
| 444 | 109 (count, buffer)) |
| 428 | 110 { |
| 444 | 111 if (NILP (count)) |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
112 count = make_fixnum (-1); |
| 428 | 113 else |
| 114 { | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
115 CHECK_FIXNUM (count); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
116 count = make_fixnum (- XFIXNUM (count)); |
| 428 | 117 } |
| 444 | 118 return Fforward_char (count, buffer); |
| 428 | 119 } |
| 120 | |
| 121 DEFUN ("forward-line", Fforward_line, 0, 2, "_p", /* | |
| 444 | 122 Move COUNT lines forward (backward if COUNT is negative). |
| 123 Precisely, if point is on line I, move to the start of line I + COUNT. | |
| 428 | 124 If there isn't room, go as far as possible (no error). |
| 125 Returns the count of lines left to move. If moving forward, | |
| 444 | 126 that is COUNT - number of lines moved; if backward, COUNT + number moved. |
| 3577 | 127 \(Note that if COUNT is negative, the return will be non-positive.) |
| 444 | 128 With positive COUNT, a non-empty line at the end counts as one line |
| 428 | 129 successfully moved (for the return value). |
| 130 If BUFFER is nil, the current buffer is assumed. | |
| 462 | 131 |
| 132 The characters that are moved over may be added to the current selection | |
| 133 \(i.e. active region) if the Shift key is held down, a motion key is used | |
| 134 to invoke this command, and `shifted-motion-keys-select-region' is t; see | |
| 135 the documentation for this variable for more details. | |
| 428 | 136 */ |
| 444 | 137 (count, buffer)) |
| 428 | 138 { |
| 139 struct buffer *buf = decode_buffer (buffer, 1); | |
| 665 | 140 Charbpos pos2 = BUF_PT (buf); |
| 141 Charbpos pos; | |
| 444 | 142 EMACS_INT n, shortage, negp; |
| 428 | 143 |
| 444 | 144 if (NILP (count)) |
| 145 n = 1; | |
| 428 | 146 else |
| 147 { | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
148 CHECK_FIXNUM (count); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
149 n = XFIXNUM (count); |
| 428 | 150 } |
| 151 | |
| 444 | 152 negp = n <= 0; |
| 153 pos = scan_buffer (buf, '\n', pos2, 0, n - negp, &shortage, 1); | |
| 428 | 154 if (shortage > 0 |
| 155 && (negp | |
| 156 || (BUF_ZV (buf) > BUF_BEGV (buf) | |
| 157 && pos != pos2 | |
| 158 && BUF_FETCH_CHAR (buf, pos - 1) != '\n'))) | |
| 159 shortage--; | |
| 160 BUF_SET_PT (buf, pos); | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
161 return make_fixnum (negp ? - shortage : shortage); |
| 428 | 162 } |
| 163 | |
| 164 DEFUN ("point-at-bol", Fpoint_at_bol, 0, 2, 0, /* | |
| 165 Return the character position of the first character on the current line. | |
| 444 | 166 With argument COUNT not nil or 1, move forward COUNT - 1 lines first. |
| 428 | 167 If scan reaches end of buffer, return that position. |
| 168 This function does not move point. | |
| 169 */ | |
| 444 | 170 (count, buffer)) |
| 428 | 171 { |
| 172 struct buffer *b = decode_buffer (buffer, 1); | |
| 173 REGISTER int orig, end; | |
| 174 | |
| 793 | 175 buffer = wrap_buffer (b); |
| 444 | 176 if (NILP (count)) |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
177 count = make_fixnum (0); |
| 428 | 178 else |
| 179 { | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
180 CHECK_FIXNUM (count); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
181 count = make_fixnum (XFIXNUM (count) - 1); |
| 428 | 182 } |
| 183 | |
| 184 orig = BUF_PT (b); | |
| 444 | 185 Fforward_line (count, buffer); |
| 428 | 186 end = BUF_PT (b); |
| 187 BUF_SET_PT (b, orig); | |
| 188 | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
189 return make_fixnum (end); |
| 428 | 190 } |
| 191 | |
| 192 DEFUN ("beginning-of-line", Fbeginning_of_line, 0, 2, "_p", /* | |
| 193 Move point to beginning of current line. | |
| 444 | 194 With argument COUNT not nil or 1, move forward COUNT - 1 lines first. |
| 428 | 195 If scan reaches end of buffer, stop there without error. |
| 196 If BUFFER is nil, the current buffer is assumed. | |
| 462 | 197 |
| 198 The characters that are moved over may be added to the current selection | |
| 199 \(i.e. active region) if the Shift key is held down, a motion key is used | |
| 200 to invoke this command, and `shifted-motion-keys-select-region' is t; see | |
| 201 the documentation for this variable for more details. | |
| 428 | 202 */ |
| 444 | 203 (count, buffer)) |
| 428 | 204 { |
| 205 struct buffer *b = decode_buffer (buffer, 1); | |
| 206 | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
207 BUF_SET_PT (b, XFIXNUM (Fpoint_at_bol (count, buffer))); |
| 428 | 208 return Qnil; |
| 209 } | |
| 210 | |
| 211 DEFUN ("point-at-eol", Fpoint_at_eol, 0, 2, 0, /* | |
| 212 Return the character position of the last character on the current line. | |
| 444 | 213 With argument COUNT not nil or 1, move forward COUNT - 1 lines first. |
| 428 | 214 If scan reaches end of buffer, return that position. |
| 215 This function does not move point. | |
| 216 */ | |
| 444 | 217 (count, buffer)) |
| 428 | 218 { |
| 219 struct buffer *buf = decode_buffer (buffer, 1); | |
| 446 | 220 EMACS_INT n; |
| 428 | 221 |
| 444 | 222 if (NILP (count)) |
| 223 n = 1; | |
| 428 | 224 else |
| 225 { | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
226 CHECK_FIXNUM (count); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
227 n = XFIXNUM (count); |
| 428 | 228 } |
| 229 | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
230 return make_fixnum (find_before_next_newline (buf, BUF_PT (buf), 0, |
| 444 | 231 n - (n <= 0))); |
| 428 | 232 } |
| 233 | |
| 234 DEFUN ("end-of-line", Fend_of_line, 0, 2, "_p", /* | |
| 235 Move point to end of current line. | |
| 444 | 236 With argument COUNT not nil or 1, move forward COUNT - 1 lines first. |
| 428 | 237 If scan reaches end of buffer, stop there without error. |
| 238 If BUFFER is nil, the current buffer is assumed. | |
| 462 | 239 |
| 240 The characters that are moved over may be added to the current selection | |
| 241 \(i.e. active region) if the Shift key is held down, a motion key is used | |
| 242 to invoke this command, and `shifted-motion-keys-select-region' is t; see | |
| 243 the documentation for this variable for more details. | |
| 428 | 244 */ |
| 444 | 245 (count, buffer)) |
| 428 | 246 { |
| 247 struct buffer *b = decode_buffer (buffer, 1); | |
| 248 | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
249 BUF_SET_PT (b, XFIXNUM (Fpoint_at_eol (count, buffer))); |
| 428 | 250 return Qnil; |
| 251 } | |
| 252 | |
| 446 | 253 DEFUN ("delete-char", Fdelete_char, 0, 2, "*p\nP", /* |
| 444 | 254 Delete the following COUNT characters (previous, with negative COUNT). |
| 255 Optional second arg KILLP non-nil means kill instead (save in kill ring). | |
| 256 Interactively, COUNT is the prefix arg, and KILLP is set if | |
| 257 COUNT was explicitly specified. | |
| 428 | 258 */ |
| 444 | 259 (count, killp)) |
| 428 | 260 { |
| 261 /* This function can GC */ | |
| 665 | 262 Charbpos pos; |
| 428 | 263 struct buffer *buf = current_buffer; |
| 446 | 264 EMACS_INT n; |
| 428 | 265 |
| 446 | 266 if (NILP (count)) |
| 267 n = 1; | |
| 268 else | |
| 269 { | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
270 CHECK_FIXNUM (count); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
271 n = XFIXNUM (count); |
| 446 | 272 } |
| 428 | 273 |
| 444 | 274 pos = BUF_PT (buf) + n; |
| 275 if (NILP (killp)) | |
| 428 | 276 { |
| 444 | 277 if (n < 0) |
| 428 | 278 { |
| 279 if (pos < BUF_BEGV (buf)) | |
| 563 | 280 signal_error (Qbeginning_of_buffer, 0, Qunbound); |
| 428 | 281 else |
| 282 buffer_delete_range (buf, pos, BUF_PT (buf), 0); | |
| 283 } | |
| 284 else | |
| 285 { | |
| 286 if (pos > BUF_ZV (buf)) | |
| 563 | 287 signal_error (Qend_of_buffer, 0, Qunbound); |
| 428 | 288 else |
| 289 buffer_delete_range (buf, BUF_PT (buf), pos, 0); | |
| 290 } | |
| 291 } | |
| 292 else | |
| 293 { | |
| 444 | 294 call1 (Qkill_forward_chars, count); |
| 428 | 295 } |
| 296 return Qnil; | |
| 297 } | |
| 298 | |
| 446 | 299 DEFUN ("delete-backward-char", Fdelete_backward_char, 0, 2, "*p\nP", /* |
| 444 | 300 Delete the previous COUNT characters (following, with negative COUNT). |
| 301 Optional second arg KILLP non-nil means kill instead (save in kill ring). | |
| 302 Interactively, COUNT is the prefix arg, and KILLP is set if | |
| 303 COUNT was explicitly specified. | |
| 428 | 304 */ |
| 444 | 305 (count, killp)) |
| 428 | 306 { |
| 307 /* This function can GC */ | |
| 446 | 308 EMACS_INT n; |
| 309 | |
| 310 if (NILP (count)) | |
| 311 n = 1; | |
| 312 else | |
| 313 { | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
314 CHECK_FIXNUM (count); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
315 n = XFIXNUM (count); |
| 446 | 316 } |
| 317 | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
318 return Fdelete_char (make_fixnum (- n), killp); |
| 428 | 319 } |
| 320 | |
| 867 | 321 static void internal_self_insert (Ichar ch, int noautofill); |
| 428 | 322 |
| 323 DEFUN ("self-insert-command", Fself_insert_command, 1, 1, "*p", /* | |
| 324 Insert the character you type. | |
| 325 Whichever character you type to run this command is inserted. | |
| 444 | 326 If a prefix arg COUNT is specified, the character is inserted COUNT times. |
| 428 | 327 */ |
| 444 | 328 (count)) |
| 428 | 329 { |
| 330 /* This function can GC */ | |
| 867 | 331 Ichar ch; |
| 428 | 332 Lisp_Object c; |
| 446 | 333 EMACS_INT n; |
| 428 | 334 |
|
5307
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3577
diff
changeset
|
335 /* Can't insert more than most-positive-fixnum characters, the buffer |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3577
diff
changeset
|
336 won't hold that many. */ |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
337 check_integer_range (count, Qzero, make_fixnum (MOST_POSITIVE_FIXNUM)); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
338 n = XFIXNUM (count); |
| 428 | 339 |
| 340 if (CHAR_OR_CHAR_INTP (Vlast_command_char)) | |
| 341 c = Vlast_command_char; | |
| 342 else | |
| 2862 | 343 c = Fevent_to_character (Vlast_command_event, Qnil, Qnil, Qnil); |
| 428 | 344 |
| 345 if (NILP (c)) | |
| 2828 | 346 invalid_operation ( |
| 347 "Last typed key has no character equivalent (that we know of)", | |
| 348 Fcopy_event (Vlast_command_event, Qnil)); | |
| 428 | 349 |
| 350 CHECK_CHAR_COERCE_INT (c); | |
| 351 | |
| 352 ch = XCHAR (c); | |
| 353 | |
| 444 | 354 while (n--) |
| 355 internal_self_insert (ch, (n != 0)); | |
| 428 | 356 |
| 357 return Qnil; | |
| 358 } | |
| 359 | |
| 360 /* Insert character C1. If NOAUTOFILL is nonzero, don't do autofill | |
| 361 even if it is enabled. | |
| 362 | |
| 363 FSF: | |
| 364 | |
| 365 If this insertion is suitable for direct output (completely simple), | |
| 366 return 0. A value of 1 indicates this *might* not have been simple. | |
| 367 A value of 2 means this did things that call for an undo boundary. */ | |
| 368 | |
| 369 static void | |
| 867 | 370 internal_self_insert (Ichar c1, int noautofill) |
| 428 | 371 { |
| 372 /* This function can GC */ | |
| 373 /* int hairy = 0; -- unused */ | |
| 374 REGISTER enum syntaxcode synt; | |
| 867 | 375 REGISTER Ichar c2; |
| 428 | 376 Lisp_Object overwrite; |
| 826 | 377 Lisp_Object syntax_table; |
| 428 | 378 struct buffer *buf = current_buffer; |
| 379 int tab_width; | |
| 380 | |
| 381 overwrite = buf->overwrite_mode; | |
| 826 | 382 syntax_table = buf->mirror_syntax_table; |
| 428 | 383 |
| 384 #if 0 | |
| 385 /* No, this is very bad, it makes undo *always* undo a character at a time | |
| 386 instead of grouping consecutive self-inserts together. Nasty nasty. | |
| 387 */ | |
| 388 if (!NILP (Vbefore_change_functions) || !NILP (Vafter_change_functions) | |
| 389 || !NILP (Vbefore_change_function) || !NILP (Vafter_change_function)) | |
| 390 hairy = 1; | |
| 391 #endif | |
| 392 | |
| 393 if (!NILP (overwrite) | |
| 394 && BUF_PT (buf) < BUF_ZV (buf) | |
| 395 && (EQ (overwrite, Qoverwrite_mode_binary) | |
| 396 || (c1 != '\n' && BUF_FETCH_CHAR (buf, BUF_PT (buf)) != '\n')) | |
| 397 && (EQ (overwrite, Qoverwrite_mode_binary) | |
| 398 || BUF_FETCH_CHAR (buf, BUF_PT (buf)) != '\t' | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
399 || ((tab_width = XFIXNUM (buf->tab_width), tab_width <= 0) |
| 428 | 400 || tab_width > 20 |
| 401 || !((current_column (buf) + 1) % tab_width)))) | |
| 402 { | |
| 403 buffer_delete_range (buf, BUF_PT (buf), BUF_PT (buf) + 1, 0); | |
| 404 /* hairy = 2; */ | |
| 405 } | |
| 406 | |
| 407 if (!NILP (buf->abbrev_mode) | |
| 408 && !WORD_SYNTAX_P (syntax_table, c1) | |
| 409 && NILP (buf->read_only) | |
| 410 && BUF_PT (buf) > BUF_BEGV (buf)) | |
| 411 { | |
| 412 c2 = BUF_FETCH_CHAR (buf, BUF_PT (buf) - 1); | |
| 413 | |
| 414 if (WORD_SYNTAX_P (syntax_table, c2)) | |
| 415 { | |
| 416 #if 1 | |
| 417 Fexpand_abbrev (); | |
| 418 #else /* FSFmacs */ | |
| 419 Lisp_Object sym = Fexpand_abbrev (); | |
| 420 | |
| 421 /* I think this is too bogus to add. The function should | |
| 422 have a way of examining the character to be inserted, so | |
| 423 it can decide whether to insert it or not. We should | |
| 424 design it better than that. */ | |
| 425 | |
| 426 /* Here FSFmacs remembers MODIFF, compares it after | |
| 427 Fexpand_abbrev() finishes, and updates HAIRY. */ | |
| 428 | |
| 429 /* NOTE: we cannot simply check for Vlast_abbrev, because | |
| 430 Fexpand_abbrev() can bail out before setting it to | |
| 431 anything meaningful, leaving us stuck with an old value. | |
| 432 Thus Fexpand_abbrev() was extended to return the actual | |
| 433 abbrev symbol. */ | |
| 434 if (!NILP (sym) | |
| 435 && !NILP (symbol_function (XSYMBOL (sym))) | |
| 436 && SYMBOLP (symbol_function (XSYMBOL (sym)))) | |
| 437 { | |
| 438 Lisp_Object prop = Fget (symbol_function (XSYMBOL (sym)), | |
| 439 Qno_self_insert, Qnil); | |
| 440 if (!NILP (prop)) | |
| 441 return; | |
| 442 } | |
| 443 #endif /* FSFmacs */ | |
| 444 } | |
| 445 } | |
| 442 | 446 if ((CHAR_TABLEP (Vauto_fill_chars) |
| 826 | 447 ? !NILP (get_char_table (c1, Vauto_fill_chars)) |
| 442 | 448 : (c1 == ' ' || c1 == '\n')) |
| 428 | 449 && !noautofill |
| 450 && !NILP (buf->auto_fill_function)) | |
| 451 { | |
| 452 buffer_insert_emacs_char (buf, c1); | |
| 453 if (c1 == '\n') | |
| 454 /* After inserting a newline, move to previous line and fill */ | |
| 455 /* that. Must have the newline in place already so filling and */ | |
| 456 /* justification, if any, know where the end is going to be. */ | |
| 457 BUF_SET_PT (buf, BUF_PT (buf) - 1); | |
| 458 call0 (buf->auto_fill_function); | |
| 459 if (c1 == '\n') | |
| 460 BUF_SET_PT (buf, BUF_PT (buf) + 1); | |
| 461 /* hairy = 2; */ | |
| 462 } | |
| 463 else | |
| 464 buffer_insert_emacs_char (buf, c1); | |
| 465 | |
| 466 /* If previous command specified a face to use, use it. */ | |
| 467 if (!NILP (Vself_insert_face) | |
| 468 && EQ (Vlast_command, Vself_insert_face_command)) | |
| 469 { | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
470 Lisp_Object before = make_fixnum (BUF_PT (buf) - 1); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5438
diff
changeset
|
471 Lisp_Object after = make_fixnum (BUF_PT (buf)); |
| 428 | 472 Fput_text_property (before, after, Qface, Vself_insert_face, Qnil); |
| 473 Fput_text_property (before, after, Qstart_open, Qt, Qnil); | |
| 474 Fput_text_property (before, after, Qend_open, Qnil, Qnil); | |
| 475 /* #### FSFmacs properties are normally closed ("sticky") on the | |
| 476 end but not the beginning. It's the opposite for us. */ | |
| 477 Vself_insert_face = Qnil; | |
| 478 } | |
| 479 synt = SYNTAX (syntax_table, c1); | |
| 480 if ((synt == Sclose || synt == Smath) | |
| 481 && !NILP (Vblink_paren_function) && INTERACTIVE | |
| 482 && !noautofill) | |
| 483 { | |
| 484 call0 (Vblink_paren_function); | |
| 485 /* hairy = 2; */ | |
| 486 } | |
| 487 | |
| 488 /* return hairy; */ | |
| 489 } | |
| 490 | |
| 491 /* (this comes from Mule but is a generally good idea) */ | |
| 492 | |
| 493 DEFUN ("self-insert-internal", Fself_insert_internal, 1, 1, 0, /* | |
| 444 | 494 Invoke `self-insert-command' as if CHARACTER is entered from keyboard. |
| 428 | 495 */ |
| 444 | 496 (character)) |
| 428 | 497 { |
| 498 /* This function can GC */ | |
| 444 | 499 CHECK_CHAR_COERCE_INT (character); |
| 500 internal_self_insert (XCHAR (character), 0); | |
| 428 | 501 return Qnil; |
| 502 } | |
| 503 | |
| 504 /* module initialization */ | |
| 505 | |
| 506 void | |
| 507 syms_of_cmds (void) | |
| 508 { | |
| 563 | 509 DEFSYMBOL (Qkill_forward_chars); |
| 510 DEFSYMBOL (Qself_insert_command); | |
| 511 DEFSYMBOL (Qoverwrite_mode_binary); | |
| 512 DEFSYMBOL (Qno_self_insert); | |
| 428 | 513 |
| 514 DEFSUBR (Fforward_char); | |
| 515 DEFSUBR (Fbackward_char); | |
| 516 DEFSUBR (Fforward_line); | |
| 517 DEFSUBR (Fbeginning_of_line); | |
| 518 DEFSUBR (Fend_of_line); | |
| 519 | |
| 520 DEFSUBR (Fpoint_at_bol); | |
| 521 DEFSUBR (Fpoint_at_eol); | |
| 522 | |
| 523 DEFSUBR (Fdelete_char); | |
| 524 DEFSUBR (Fdelete_backward_char); | |
| 525 | |
| 526 DEFSUBR (Fself_insert_command); | |
| 527 DEFSUBR (Fself_insert_internal); | |
| 528 } | |
| 529 | |
| 530 void | |
| 531 vars_of_cmds (void) | |
| 532 { | |
| 533 DEFVAR_LISP ("self-insert-face", &Vself_insert_face /* | |
| 534 If non-nil, set the face of the next self-inserting character to this. | |
| 535 See also `self-insert-face-command'. | |
| 536 */ ); | |
| 537 Vself_insert_face = Qnil; | |
| 538 | |
| 539 DEFVAR_LISP ("self-insert-face-command", &Vself_insert_face_command /* | |
| 540 This is the command that set up `self-insert-face'. | |
| 541 If `last-command' does not equal this value, we ignore `self-insert-face'. | |
| 542 */ ); | |
| 543 Vself_insert_face_command = Qnil; | |
| 544 | |
| 545 DEFVAR_LISP ("blink-paren-function", &Vblink_paren_function /* | |
| 546 Function called, if non-nil, whenever a close parenthesis is inserted. | |
| 547 More precisely, a char with closeparen syntax is self-inserted. | |
| 548 */ ); | |
| 549 Vblink_paren_function = Qnil; | |
| 442 | 550 |
| 551 DEFVAR_LISP ("auto-fill-chars", &Vauto_fill_chars /* | |
| 552 A char-table for characters which invoke auto-filling. | |
| 444 | 553 Such characters have value t in this table. |
| 442 | 554 */); |
| 555 Vauto_fill_chars = Fmake_char_table (Qgeneric); | |
| 556 XCHAR_TABLE (Vauto_fill_chars)->ascii[' '] = Qt; | |
| 557 XCHAR_TABLE (Vauto_fill_chars)->ascii['\n'] = Qt; | |
| 428 | 558 } |