Mercurial > hg > xemacs-beta
annotate src/cmds.c @ 5588:2dbefd79b3d3
Prevent SIGPIPEs in deactivate_process().
* process.c (deactivate_process):
Use Lstream_close_noflush on output pipe instead of Lstream_close.
* lstream.c (Lstream_close_noflush):
New. Factored out of Lstream_close.
(Lstream_close): Use Lstream_close_noflush.
* lstream.h (Lstream_close_noflush): Declare it.
| author | Stephen J. Turnbull <stephen@xemacs.org> |
|---|---|
| date | Sat, 29 Oct 2011 01:10:32 +0900 |
| 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 } |