![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmds.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src|
Return to cmds.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src |
1.1 root 1: /* Simple built-in editing commands.
2: Copyright (C) 1985 Free Software Foundation, Inc.
3:
4: This file is part of GNU Emacs.
5:
6: GNU Emacs is distributed in the hope that it will be useful,
7: but WITHOUT ANY WARRANTY. No author or distributor
8: accepts responsibility to anyone for the consequences of using it
9: or for whether it serves any particular purpose or works at all,
10: unless he says so in writing. Refer to the GNU Emacs General Public
11: License for full details.
12:
13: Everyone is granted permission to copy, modify and redistribute
14: GNU Emacs, but only under the conditions described in the
15: GNU Emacs General Public License. A copy of this license is
16: supposed to have been given to you along with GNU Emacs so you
17: can know your rights and responsibilities. It should be in a
18: file named COPYING. Among other things, the copyright notice
19: and this notice must be preserved on all copies. */
20:
21:
22: #include "config.h"
23: #include "lisp.h"
24: #include "commands.h"
25: #include "buffer.h"
26: #include "syntax.h"
27:
28: Lisp_Object Qkill_forward_chars, Qkill_backward_chars, Vblink_paren_hook;
29:
30:
31: DEFUN ("forward-char", Fforward_char, Sforward_char, 0, 1, "p",
32: "Move point right ARG characters (left if ARG negative).\n\
33: On reaching end of buffer, stop and signal error.")
34: (n)
35: Lisp_Object n;
36: {
37: if (NULL (n))
38: XFASTINT (n) = 1;
39: else
40: CHECK_NUMBER (n, 0);
41:
42: SetPoint (point + XINT (n));
43: if (point < FirstCharacter)
44: {
45: SetPoint (FirstCharacter);
46: Fsignal (Qbeginning_of_buffer, Qnil);
47: }
48: if (point > NumCharacters + 1)
49: {
50: SetPoint (NumCharacters + 1);
51: Fsignal (Qend_of_buffer, Qnil);
52: }
53: return Qnil;
54: }
55:
56: DEFUN ("backward-char", Fbackward_char, Sbackward_char, 0, 1, "p",
57: "Move point left ARG characters (right if ARG negative).\n\
58: On attempt to pass beginning or end of buffer, stop and signal error.")
59: (n)
60: Lisp_Object n;
61: {
62: if (NULL (n))
63: XFASTINT (n) = 1;
64: else
65: CHECK_NUMBER (n, 0);
66:
67: XSETINT (n, - XINT (n));
68: return Fforward_char (n);
69: }
70:
71: DEFUN ("forward-line", Fforward_line, Sforward_line, 0, 1, "p",
72: "If point is on line i, move to the start of line i + ARG.\n\
73: If there isn't room, go as far as possible (no error).\n\
74: Returns the count of lines left to move.\n\
75: With positive ARG, a non-empty line at the end counts as one line\n\
76: successfully moved (for the return value).")
77: (n)
78: Lisp_Object n;
79: {
80: int pos2 = point;
81: int pos;
82: int count, shortage, negp;
83:
84: if (NULL (n))
85: count = 1;
86: else
87: {
88: CHECK_NUMBER (n, 0);
89: count = XINT (n);
90: }
91:
92: negp = count <= 0;
93: pos = scan_buffer ('\n', pos2, count - negp, &shortage);
94: if (shortage > 0
95: && (negp
96: || (NumCharacters >= FirstCharacter
97: && CharAt (pos - 1) != '\n')))
98: shortage--;
99: SetPoint (pos);
100: return make_number (negp ? - shortage : shortage);
101: }
102:
103: DEFUN ("beginning-of-line", Fbeginning_of_line, Sbeginning_of_line,
104: 0, 1, "p",
105: "Move point to beginning of current line.\n\
106: With argument ARG not nil or 1, move forward ARG - 1 lines first.\n\
107: If scan reaches end of buffer, stop there without error.")
108: (n)
109: Lisp_Object n;
110: {
111: if (NULL (n))
112: XFASTINT (n) = 1;
113: else
114: CHECK_NUMBER (n, 0);
115:
116: Fforward_line (make_number (XINT (n) - 1));
117: return Qnil;
118: }
119:
120: DEFUN ("end-of-line", Fend_of_line, Send_of_line,
121: 0, 1, "p",
122: "Move point to end of current line.\n\
123: With argument ARG not nil or 1, move forward ARG - 1 lines first.\n\
124: If scan reaches end of buffer, stop there without error.")
125: (n)
126: Lisp_Object n;
127: {
128: register int pos;
129: register int stop;
130:
131: if (NULL (n))
132: XFASTINT (n) = 1;
133: else
134: CHECK_NUMBER (n, 0);
135:
136: if (XINT (n) != 1)
137: Fforward_line (make_number (XINT (n) - 1));
138:
139: pos = point;
140: stop = NumCharacters + 1;
141: while (pos < stop && CharAt (pos) != '\n') pos++;
142: SetPoint (pos);
143:
144: return Qnil;
145: }
146:
147: DEFUN ("delete-char", Fdelete_char, Sdelete_char, 1, 2, "p\nP",
148: "Delete the following ARG characters (previous, with negative arg).\n\
149: Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).\n\
150: Interactively, ARG is the prefix arg, and KILLFLAG is set if\n\
151: ARG was explicitly specified.")
152: (n, killflag)
153: Lisp_Object n, killflag;
154: {
155: CHECK_NUMBER (n, 0);
156:
157: if (NULL (killflag))
158: {
159: if (XINT (n) < 0)
160: {
161: if (point + XINT (n) < FirstCharacter)
162: Fsignal (Qbeginning_of_buffer, Qnil);
163: else
164: del_range (point + XINT (n), point);
165: }
166: else
167: {
168: if (point + XINT (n) > NumCharacters + 1)
169: Fsignal (Qend_of_buffer, Qnil);
170: else
171: del_range (point, point + XINT (n));
172: }
173: }
174: else
175: {
176: call1 (Qkill_forward_chars, n);
177: }
178: return Qnil;
179: }
180:
181: DEFUN ("delete-backward-char", Fdelete_backward_char, Sdelete_backward_char,
182: 1, 2, "p\nP",
183: "Delete the previous ARG characters (following, with negative ARG).\n\
184: Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).\n\
185: Interactively, ARG is the prefix arg, and KILLFLAG is set if\n\
186: ARG was explicitly specified.")
187: (n, killflag)
188: Lisp_Object n, killflag;
189: {
190: CHECK_NUMBER (n, 0);
191: return Fdelete_char (make_number (-XINT (n)), killflag);
192: }
193:
194: DEFUN ("self-insert-command", Fself_insert_command, Sself_insert_command, 1, 1, "p",
195: "Insert this character. Prefix arg is repeat-count.")
196: (arg)
197: Lisp_Object arg;
198: {
199: CHECK_NUMBER (arg, 0);
200:
201: while (XINT (arg) > 0)
202: {
203: XFASTINT (arg)--; /* Ok since old and new vals both nonneg */
204: SelfInsert (last_command_char, XFASTINT (arg) != 0);
205: }
206: return Qnil;
207: }
208:
209: DEFUN ("newline", Fnewline, Snewline, 0, 1, "P",
210: "Insert a newline. With arg, insert that many newlines.\n\
211: In Auto Fill mode, can break the preceding line if no numeric arg.")
212: (arg1)
213: Lisp_Object arg1;
214: {
215: int flag;
216: Lisp_Object arg;
217: char c1 = '\n';
218:
219: arg = Fprefix_numeric_value (arg1);
220:
221: if (!NULL (bf_cur->read_only))
222: Fsignal (Qbuffer_read_only, Qnil);
223:
224: /* Inserting a newline at the end of a line
225: produces better redisplay in try_window_id
226: than inserting at the ebginning fo a line,
227: And the textual result is the same.
228: So if at beginning, pretend to be at the end.
229: Must avoid SelfInsert in that case since point is wrong.
230: Luckily SelfInsert's special features all do nothing in that case. */
231:
232: flag = point > FirstCharacter && CharAt (point - 1) == '\n';
233: if (flag) PointLeft (1);
234:
235: while (XINT (arg) > 0)
236: {
237: if (flag)
238: InsCStr (&c1, 1);
239: else
240: SelfInsert ('\n', !NULL (arg1));
241: XFASTINT (arg)--; /* Ok since old and new vals both nonneg */
242: }
243:
244: if (flag) PointRight (1);
245:
246: return Qnil;
247: }
248:
249: SelfInsert (c1, noautofill)
250: char c1;
251: int noautofill;
252: {
253: extern Lisp_Object Fexpand_abbrev ();
254: int hairy = 0;
255: Lisp_Object tem;
256: register enum syntaxcode synt;
257: register int c = c1;
258:
259: if (!NULL (bf_cur->overwrite_mode)
260: && point <= NumCharacters
261: && c != '\n' && CharAt (point) != '\n'
262: && (CharAt (point) != '\t'
263: || XINT (bf_cur->tab_width) <= 0
264: || !((current_column () + 1) % XFASTINT (bf_cur->tab_width))))
265: {
266: del_range (point, point + 1);
267: hairy = 1;
268: }
269: if (!NULL (bf_cur->abbrev_mode)
270: && SYNTAX (c) != Sword
271: && NULL (bf_cur->read_only)
272: && point > FirstCharacter && SYNTAX (CharAt (point - 1)) == Sword)
273: {
274: tem = Fexpand_abbrev ();
275: if (!NULL (tem))
276: hairy = 1;
277: }
278: if ((c == ' ' || c == '\n')
279: && !noautofill
280: && !NULL (bf_cur->auto_fill_hook)
281: && current_column () > XFASTINT (bf_cur->fill_column))
282: {
283: if (c1 != '\n')
284: InsCStr (&c1, 1);
285: call0 (bf_cur->auto_fill_hook);
286: if (c1 == '\n')
287: InsCStr (&c1, 1);
288: hairy = 1;
289: }
290: else
291: InsCStr (&c1, 1);
292: synt = SYNTAX (c);
293: if ((synt == Sclose || synt == Smath)
294: && !NULL (Vblink_paren_hook) && INTERACTIVE)
295: {
296: call0 (Vblink_paren_hook);
297: hairy = 1;
298: }
299: return hairy;
300: }
301:
302: /* module initialization */
303:
304: syms_of_cmds ()
305: {
306: Qkill_backward_chars = intern ("kill-backward-chars");
307: staticpro (&Qkill_backward_chars);
308:
309: Qkill_forward_chars = intern ("kill-forward-chars");
310: staticpro (&Qkill_forward_chars);
311:
312: DEFVAR_LISP ("blink-paren-hook", &Vblink_paren_hook,
313: "Function called, if non-nil, whenever a char with closeparen syntax is self-inserted.");
314: Vblink_paren_hook = Qnil;
315:
316: defsubr (&Sforward_char);
317: defsubr (&Sbackward_char);
318: defsubr (&Sforward_line);
319: defsubr (&Sbeginning_of_line);
320: defsubr (&Send_of_line);
321:
322: defsubr (&Sdelete_char);
323: defsubr (&Sdelete_backward_char);
324:
325: defsubr (&Sself_insert_command);
326: defsubr (&Snewline);
327: }
328:
329: keys_of_cmds ()
330: {
331: int n;
332:
333: defkey (GlobalMap, Ctl('M'), "newline");
334: defkey (GlobalMap, Ctl('I'), "self-insert-command");
335: for (n = 040; n < 0177; n++)
336: defkey (GlobalMap, n, "self-insert-command");
337:
338: defkey (GlobalMap, Ctl ('A'), "beginning-of-line");
339: defkey (GlobalMap, Ctl ('B'), "backward-char");
340: defkey (GlobalMap, Ctl ('D'), "delete-char");
341: defkey (GlobalMap, Ctl ('E'), "end-of-line");
342: defkey (GlobalMap, Ctl ('F'), "forward-char");
343: defkey (GlobalMap, 0177, "delete-backward-char");
344: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.