Mercurial > hg > xemacs-beta
annotate src/cmds.c @ 5402:308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
| author | Mats Lidell <matsl@xemacs.org> |
|---|---|
| date | Thu, 14 Oct 2010 17:15:20 +0200 |
| parents | 91950589598c |
| children | 8d29f1c4bb98 |
| 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 { | |
| 444 | 68 CHECK_INT (count); |
| 69 n = XINT (count); | |
| 428 | 70 } |
| 71 | |
| 444 | 72 /* This used to just set point to point + XINT (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)) |
| 112 count = make_int (-1); | |
| 428 | 113 else |
| 114 { | |
| 444 | 115 CHECK_INT (count); |
| 116 count = make_int (- XINT (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 { | |
| 444 | 148 CHECK_INT (count); |
| 149 n = XINT (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); | |
| 161 return make_int (negp ? - shortage : shortage); | |
| 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)) |
| 177 count = make_int (0); | |
| 428 | 178 else |
| 179 { | |
| 444 | 180 CHECK_INT (count); |
| 181 count = make_int (XINT (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 | |
| 189 return make_int (end); | |
| 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 | |
| 444 | 207 BUF_SET_PT (b, XINT (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 { | |
| 444 | 226 CHECK_INT (count); |
| 227 n = XINT (count); | |
| 428 | 228 } |
| 229 | |
| 230 return make_int (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 | |
| 444 | 249 BUF_SET_PT (b, XINT (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 { | |
| 270 CHECK_INT (count); | |
| 271 n = XINT (count); | |
| 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 { | |
| 314 CHECK_INT (count); | |
| 315 n = XINT (count); | |
| 316 } | |
| 317 | |
| 318 return Fdelete_char (make_int (- 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 |
| 444 | 335 CHECK_NATNUM (count); |
| 336 n = XINT (count); | |
| 428 | 337 |
| 338 if (CHAR_OR_CHAR_INTP (Vlast_command_char)) | |
| 339 c = Vlast_command_char; | |
| 340 else | |
| 2862 | 341 c = Fevent_to_character (Vlast_command_event, Qnil, Qnil, Qnil); |
| 428 | 342 |
| 343 if (NILP (c)) | |
| 2828 | 344 invalid_operation ( |
| 345 "Last typed key has no character equivalent (that we know of)", | |
| 346 Fcopy_event (Vlast_command_event, Qnil)); | |
| 428 | 347 |
| 348 CHECK_CHAR_COERCE_INT (c); | |
| 349 | |
| 350 ch = XCHAR (c); | |
| 351 | |
| 444 | 352 while (n--) |
| 353 internal_self_insert (ch, (n != 0)); | |
| 428 | 354 |
| 355 return Qnil; | |
| 356 } | |
| 357 | |
| 358 /* Insert character C1. If NOAUTOFILL is nonzero, don't do autofill | |
| 359 even if it is enabled. | |
| 360 | |
| 361 FSF: | |
| 362 | |
| 363 If this insertion is suitable for direct output (completely simple), | |
| 364 return 0. A value of 1 indicates this *might* not have been simple. | |
| 365 A value of 2 means this did things that call for an undo boundary. */ | |
| 366 | |
| 367 static void | |
| 867 | 368 internal_self_insert (Ichar c1, int noautofill) |
| 428 | 369 { |
| 370 /* This function can GC */ | |
| 371 /* int hairy = 0; -- unused */ | |
| 372 REGISTER enum syntaxcode synt; | |
| 867 | 373 REGISTER Ichar c2; |
| 428 | 374 Lisp_Object overwrite; |
| 826 | 375 Lisp_Object syntax_table; |
| 428 | 376 struct buffer *buf = current_buffer; |
| 377 int tab_width; | |
| 378 | |
| 379 overwrite = buf->overwrite_mode; | |
| 826 | 380 syntax_table = buf->mirror_syntax_table; |
| 428 | 381 |
| 382 #if 0 | |
| 383 /* No, this is very bad, it makes undo *always* undo a character at a time | |
| 384 instead of grouping consecutive self-inserts together. Nasty nasty. | |
| 385 */ | |
| 386 if (!NILP (Vbefore_change_functions) || !NILP (Vafter_change_functions) | |
| 387 || !NILP (Vbefore_change_function) || !NILP (Vafter_change_function)) | |
| 388 hairy = 1; | |
| 389 #endif | |
| 390 | |
| 391 if (!NILP (overwrite) | |
| 392 && BUF_PT (buf) < BUF_ZV (buf) | |
| 393 && (EQ (overwrite, Qoverwrite_mode_binary) | |
| 394 || (c1 != '\n' && BUF_FETCH_CHAR (buf, BUF_PT (buf)) != '\n')) | |
| 395 && (EQ (overwrite, Qoverwrite_mode_binary) | |
| 396 || BUF_FETCH_CHAR (buf, BUF_PT (buf)) != '\t' | |
| 397 || ((tab_width = XINT (buf->tab_width), tab_width <= 0) | |
| 398 || tab_width > 20 | |
| 399 || !((current_column (buf) + 1) % tab_width)))) | |
| 400 { | |
| 401 buffer_delete_range (buf, BUF_PT (buf), BUF_PT (buf) + 1, 0); | |
| 402 /* hairy = 2; */ | |
| 403 } | |
| 404 | |
| 405 if (!NILP (buf->abbrev_mode) | |
| 406 && !WORD_SYNTAX_P (syntax_table, c1) | |
| 407 && NILP (buf->read_only) | |
| 408 && BUF_PT (buf) > BUF_BEGV (buf)) | |
| 409 { | |
| 410 c2 = BUF_FETCH_CHAR (buf, BUF_PT (buf) - 1); | |
| 411 | |
| 412 if (WORD_SYNTAX_P (syntax_table, c2)) | |
| 413 { | |
| 414 #if 1 | |
| 415 Fexpand_abbrev (); | |
| 416 #else /* FSFmacs */ | |
| 417 Lisp_Object sym = Fexpand_abbrev (); | |
| 418 | |
| 419 /* I think this is too bogus to add. The function should | |
| 420 have a way of examining the character to be inserted, so | |
| 421 it can decide whether to insert it or not. We should | |
| 422 design it better than that. */ | |
| 423 | |
| 424 /* Here FSFmacs remembers MODIFF, compares it after | |
| 425 Fexpand_abbrev() finishes, and updates HAIRY. */ | |
| 426 | |
| 427 /* NOTE: we cannot simply check for Vlast_abbrev, because | |
| 428 Fexpand_abbrev() can bail out before setting it to | |
| 429 anything meaningful, leaving us stuck with an old value. | |
| 430 Thus Fexpand_abbrev() was extended to return the actual | |
| 431 abbrev symbol. */ | |
| 432 if (!NILP (sym) | |
| 433 && !NILP (symbol_function (XSYMBOL (sym))) | |
| 434 && SYMBOLP (symbol_function (XSYMBOL (sym)))) | |
| 435 { | |
| 436 Lisp_Object prop = Fget (symbol_function (XSYMBOL (sym)), | |
| 437 Qno_self_insert, Qnil); | |
| 438 if (!NILP (prop)) | |
| 439 return; | |
| 440 } | |
| 441 #endif /* FSFmacs */ | |
| 442 } | |
| 443 } | |
| 442 | 444 if ((CHAR_TABLEP (Vauto_fill_chars) |
| 826 | 445 ? !NILP (get_char_table (c1, Vauto_fill_chars)) |
| 442 | 446 : (c1 == ' ' || c1 == '\n')) |
| 428 | 447 && !noautofill |
| 448 && !NILP (buf->auto_fill_function)) | |
| 449 { | |
| 450 buffer_insert_emacs_char (buf, c1); | |
| 451 if (c1 == '\n') | |
| 452 /* After inserting a newline, move to previous line and fill */ | |
| 453 /* that. Must have the newline in place already so filling and */ | |
| 454 /* justification, if any, know where the end is going to be. */ | |
| 455 BUF_SET_PT (buf, BUF_PT (buf) - 1); | |
| 456 call0 (buf->auto_fill_function); | |
| 457 if (c1 == '\n') | |
| 458 BUF_SET_PT (buf, BUF_PT (buf) + 1); | |
| 459 /* hairy = 2; */ | |
| 460 } | |
| 461 else | |
| 462 buffer_insert_emacs_char (buf, c1); | |
| 463 | |
| 464 /* If previous command specified a face to use, use it. */ | |
| 465 if (!NILP (Vself_insert_face) | |
| 466 && EQ (Vlast_command, Vself_insert_face_command)) | |
| 467 { | |
| 468 Lisp_Object before = make_int (BUF_PT (buf) - 1); | |
| 469 Lisp_Object after = make_int (BUF_PT (buf)); | |
| 470 Fput_text_property (before, after, Qface, Vself_insert_face, Qnil); | |
| 471 Fput_text_property (before, after, Qstart_open, Qt, Qnil); | |
| 472 Fput_text_property (before, after, Qend_open, Qnil, Qnil); | |
| 473 /* #### FSFmacs properties are normally closed ("sticky") on the | |
| 474 end but not the beginning. It's the opposite for us. */ | |
| 475 Vself_insert_face = Qnil; | |
| 476 } | |
| 477 synt = SYNTAX (syntax_table, c1); | |
| 478 if ((synt == Sclose || synt == Smath) | |
| 479 && !NILP (Vblink_paren_function) && INTERACTIVE | |
| 480 && !noautofill) | |
| 481 { | |
| 482 call0 (Vblink_paren_function); | |
| 483 /* hairy = 2; */ | |
| 484 } | |
| 485 | |
| 486 /* return hairy; */ | |
| 487 } | |
| 488 | |
| 489 /* (this comes from Mule but is a generally good idea) */ | |
| 490 | |
| 491 DEFUN ("self-insert-internal", Fself_insert_internal, 1, 1, 0, /* | |
| 444 | 492 Invoke `self-insert-command' as if CHARACTER is entered from keyboard. |
| 428 | 493 */ |
| 444 | 494 (character)) |
| 428 | 495 { |
| 496 /* This function can GC */ | |
| 444 | 497 CHECK_CHAR_COERCE_INT (character); |
| 498 internal_self_insert (XCHAR (character), 0); | |
| 428 | 499 return Qnil; |
| 500 } | |
| 501 | |
| 502 /* module initialization */ | |
| 503 | |
| 504 void | |
| 505 syms_of_cmds (void) | |
| 506 { | |
| 563 | 507 DEFSYMBOL (Qkill_forward_chars); |
| 508 DEFSYMBOL (Qself_insert_command); | |
| 509 DEFSYMBOL (Qoverwrite_mode_binary); | |
| 510 DEFSYMBOL (Qno_self_insert); | |
| 428 | 511 |
| 512 DEFSUBR (Fforward_char); | |
| 513 DEFSUBR (Fbackward_char); | |
| 514 DEFSUBR (Fforward_line); | |
| 515 DEFSUBR (Fbeginning_of_line); | |
| 516 DEFSUBR (Fend_of_line); | |
| 517 | |
| 518 DEFSUBR (Fpoint_at_bol); | |
| 519 DEFSUBR (Fpoint_at_eol); | |
| 520 | |
| 521 DEFSUBR (Fdelete_char); | |
| 522 DEFSUBR (Fdelete_backward_char); | |
| 523 | |
| 524 DEFSUBR (Fself_insert_command); | |
| 525 DEFSUBR (Fself_insert_internal); | |
| 526 } | |
| 527 | |
| 528 void | |
| 529 vars_of_cmds (void) | |
| 530 { | |
| 531 DEFVAR_LISP ("self-insert-face", &Vself_insert_face /* | |
| 532 If non-nil, set the face of the next self-inserting character to this. | |
| 533 See also `self-insert-face-command'. | |
| 534 */ ); | |
| 535 Vself_insert_face = Qnil; | |
| 536 | |
| 537 DEFVAR_LISP ("self-insert-face-command", &Vself_insert_face_command /* | |
| 538 This is the command that set up `self-insert-face'. | |
| 539 If `last-command' does not equal this value, we ignore `self-insert-face'. | |
| 540 */ ); | |
| 541 Vself_insert_face_command = Qnil; | |
| 542 | |
| 543 DEFVAR_LISP ("blink-paren-function", &Vblink_paren_function /* | |
| 544 Function called, if non-nil, whenever a close parenthesis is inserted. | |
| 545 More precisely, a char with closeparen syntax is self-inserted. | |
| 546 */ ); | |
| 547 Vblink_paren_function = Qnil; | |
| 442 | 548 |
| 549 DEFVAR_LISP ("auto-fill-chars", &Vauto_fill_chars /* | |
| 550 A char-table for characters which invoke auto-filling. | |
| 444 | 551 Such characters have value t in this table. |
| 442 | 552 */); |
| 553 Vauto_fill_chars = Fmake_char_table (Qgeneric); | |
| 554 XCHAR_TABLE (Vauto_fill_chars)->ascii[' '] = Qt; | |
| 555 XCHAR_TABLE (Vauto_fill_chars)->ascii['\n'] = Qt; | |
| 428 | 556 } |