File: | src/gnu/lib/libreadline/misc.c |
Warning: | line 90, column 4 Value stored to 'sawdigits' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* misc.c -- miscellaneous bindable readline functions. */ |
2 | |
3 | /* Copyright (C) 1987-2002 Free Software Foundation, Inc. |
4 | |
5 | This file is part of the GNU Readline Library, a library for |
6 | reading lines of text with interactive input and history editing. |
7 | |
8 | The GNU Readline Library is free software; you can redistribute it |
9 | and/or modify it under the terms of the GNU General Public License |
10 | as published by the Free Software Foundation; either version 2, or |
11 | (at your option) any later version. |
12 | |
13 | The GNU Readline Library is distributed in the hope that it will be |
14 | useful, but WITHOUT ANY WARRANTY; without even the implied warranty |
15 | of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
16 | GNU General Public License for more details. |
17 | |
18 | The GNU General Public License is often shipped with GNU software, and |
19 | is generally kept in a file called COPYING or LICENSE. If you do not |
20 | have a copy of the license, write to the Free Software Foundation, |
21 | 59 Temple Place, Suite 330, Boston, MA 02111 USA. */ |
22 | #define READLINE_LIBRARY |
23 | |
24 | #if defined (HAVE_CONFIG_H1) |
25 | # include <config.h> |
26 | #endif |
27 | |
28 | #if defined (HAVE_UNISTD_H1) |
29 | # include <unistd.h> |
30 | #endif /* HAVE_UNISTD_H */ |
31 | |
32 | #if defined (HAVE_STDLIB_H1) |
33 | # include <stdlib.h> |
34 | #else |
35 | # include "ansi_stdlib.h" |
36 | #endif /* HAVE_STDLIB_H */ |
37 | |
38 | #if defined (HAVE_LOCALE_H1) |
39 | # include <locale.h> |
40 | #endif |
41 | |
42 | #include <stdio.h> |
43 | |
44 | /* System-specific feature definitions and include files. */ |
45 | #include "rldefs.h" |
46 | #include "rlmbutil.h" |
47 | |
48 | /* Some standard library routines. */ |
49 | #include "readline.h" |
50 | #include "history.h" |
51 | |
52 | #include "rlprivate.h" |
53 | #include "rlshell.h" |
54 | #include "xmalloc.h" |
55 | |
56 | static int rl_digit_loop PARAMS((void))(void); |
57 | static void _rl_history_set_point PARAMS((void))(void); |
58 | |
59 | /* Forward declarations used in this file */ |
60 | void _rl_free_history_entry PARAMS((HIST_ENTRY *))(HIST_ENTRY *); |
61 | |
62 | /* If non-zero, rl_get_previous_history and rl_get_next_history attempt |
63 | to preserve the value of rl_point from line to line. */ |
64 | int _rl_history_preserve_point = 0; |
65 | |
66 | /* Saved target point for when _rl_history_preserve_point is set. Special |
67 | value of -1 means that point is at the end of the line. */ |
68 | int _rl_history_saved_point = -1; |
69 | |
70 | /* **************************************************************** */ |
71 | /* */ |
72 | /* Numeric Arguments */ |
73 | /* */ |
74 | /* **************************************************************** */ |
75 | |
76 | /* Handle C-u style numeric args, as well as M--, and M-digits. */ |
77 | static int |
78 | rl_digit_loop () |
79 | { |
80 | int key, c, sawminus, sawdigits; |
81 | |
82 | rl_save_prompt (); |
83 | |
84 | RL_SETSTATE(RL_STATE_NUMERICARG)(rl_readline_state |= (0x00400)); |
85 | sawminus = sawdigits = 0; |
86 | while (1) |
87 | { |
88 | if (rl_numeric_arg > 1000000) |
89 | { |
90 | sawdigits = rl_explicit_arg = rl_numeric_arg = 0; |
Value stored to 'sawdigits' is never read | |
91 | rl_ding (); |
92 | rl_restore_prompt (); |
93 | rl_clear_message (); |
94 | RL_UNSETSTATE(RL_STATE_NUMERICARG)(rl_readline_state &= ~(0x00400)); |
95 | return 1; |
96 | } |
97 | rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg); |
98 | RL_SETSTATE(RL_STATE_MOREINPUT)(rl_readline_state |= (0x00040)); |
99 | key = c = rl_read_key (); |
100 | RL_UNSETSTATE(RL_STATE_MOREINPUT)(rl_readline_state &= ~(0x00040)); |
101 | |
102 | if (c < 0) |
103 | { |
104 | _rl_abort_internal (); |
105 | return -1; |
106 | } |
107 | |
108 | /* If we see a key bound to `universal-argument' after seeing digits, |
109 | it ends the argument but is otherwise ignored. */ |
110 | if (_rl_keymap[c].type == ISFUNC0 && |
111 | _rl_keymap[c].function == rl_universal_argument) |
112 | { |
113 | if (sawdigits == 0) |
114 | { |
115 | rl_numeric_arg *= 4; |
116 | continue; |
117 | } |
118 | else |
119 | { |
120 | RL_SETSTATE(RL_STATE_MOREINPUT)(rl_readline_state |= (0x00040)); |
121 | key = rl_read_key (); |
122 | RL_UNSETSTATE(RL_STATE_MOREINPUT)(rl_readline_state &= ~(0x00040)); |
123 | rl_restore_prompt (); |
124 | rl_clear_message (); |
125 | RL_UNSETSTATE(RL_STATE_NUMERICARG)(rl_readline_state &= ~(0x00400)); |
126 | return (_rl_dispatch (key, _rl_keymap)); |
127 | } |
128 | } |
129 | |
130 | c = UNMETA (c)((c) & (~0x080)); |
131 | |
132 | if (_rl_digit_p (c)((c) >= '0' && (c) <= '9')) |
133 | { |
134 | rl_numeric_arg = rl_explicit_arg ? (rl_numeric_arg * 10) + c - '0' : c - '0'; |
135 | sawdigits = rl_explicit_arg = 1; |
136 | } |
137 | else if (c == '-' && rl_explicit_arg == 0) |
138 | { |
139 | rl_numeric_arg = sawminus = 1; |
140 | rl_arg_sign = -1; |
141 | } |
142 | else |
143 | { |
144 | /* Make M-- command equivalent to M--1 command. */ |
145 | if (sawminus && rl_numeric_arg == 1 && rl_explicit_arg == 0) |
146 | rl_explicit_arg = 1; |
147 | rl_restore_prompt (); |
148 | rl_clear_message (); |
149 | RL_UNSETSTATE(RL_STATE_NUMERICARG)(rl_readline_state &= ~(0x00400)); |
150 | return (_rl_dispatch (key, _rl_keymap)); |
151 | } |
152 | } |
153 | |
154 | /*NOTREACHED*/ |
155 | } |
156 | |
157 | /* Add the current digit to the argument in progress. */ |
158 | int |
159 | rl_digit_argument (ignore, key) |
160 | int ignore, key; |
161 | { |
162 | rl_execute_next (key); |
163 | return (rl_digit_loop ()); |
164 | } |
165 | |
166 | /* What to do when you abort reading an argument. */ |
167 | int |
168 | rl_discard_argument () |
169 | { |
170 | rl_ding (); |
171 | rl_clear_message (); |
172 | _rl_init_argument (); |
173 | return 0; |
174 | } |
175 | |
176 | /* Create a default argument. */ |
177 | int |
178 | _rl_init_argument () |
179 | { |
180 | rl_numeric_arg = rl_arg_sign = 1; |
181 | rl_explicit_arg = 0; |
182 | return 0; |
183 | } |
184 | |
185 | /* C-u, universal argument. Multiply the current argument by 4. |
186 | Read a key. If the key has nothing to do with arguments, then |
187 | dispatch on it. If the key is the abort character then abort. */ |
188 | int |
189 | rl_universal_argument (count, key) |
190 | int count, key; |
191 | { |
192 | rl_numeric_arg *= 4; |
193 | return (rl_digit_loop ()); |
194 | } |
195 | |
196 | /* **************************************************************** */ |
197 | /* */ |
198 | /* History Utilities */ |
199 | /* */ |
200 | /* **************************************************************** */ |
201 | |
202 | /* We already have a history library, and that is what we use to control |
203 | the history features of readline. This is our local interface to |
204 | the history mechanism. */ |
205 | |
206 | /* While we are editing the history, this is the saved |
207 | version of the original line. */ |
208 | HIST_ENTRY *_rl_saved_line_for_history = (HIST_ENTRY *)NULL((void *)0); |
209 | |
210 | /* Set the history pointer back to the last entry in the history. */ |
211 | void |
212 | _rl_start_using_history () |
213 | { |
214 | using_history (); |
215 | if (_rl_saved_line_for_history) |
216 | _rl_free_history_entry (_rl_saved_line_for_history); |
217 | |
218 | _rl_saved_line_for_history = (HIST_ENTRY *)NULL((void *)0); |
219 | } |
220 | |
221 | /* Free the contents (and containing structure) of a HIST_ENTRY. */ |
222 | void |
223 | _rl_free_history_entry (entry) |
224 | HIST_ENTRY *entry; |
225 | { |
226 | if (entry == 0) |
227 | return; |
228 | if (entry->line) |
229 | free (entry->line); |
230 | free (entry); |
231 | } |
232 | |
233 | /* Perhaps put back the current line if it has changed. */ |
234 | int |
235 | rl_maybe_replace_line () |
236 | { |
237 | HIST_ENTRY *temp; |
238 | |
239 | temp = current_history (); |
240 | /* If the current line has changed, save the changes. */ |
241 | if (temp && ((UNDO_LIST *)(temp->data) != rl_undo_list)) |
242 | { |
243 | temp = replace_history_entry (where_history (), rl_line_buffer, (histdata_t)rl_undo_list); |
244 | free (temp->line); |
245 | free (temp); |
246 | } |
247 | return 0; |
248 | } |
249 | |
250 | /* Restore the _rl_saved_line_for_history if there is one. */ |
251 | int |
252 | rl_maybe_unsave_line () |
253 | { |
254 | if (_rl_saved_line_for_history) |
255 | { |
256 | rl_replace_line (_rl_saved_line_for_history->line, 0); |
257 | rl_undo_list = (UNDO_LIST *)_rl_saved_line_for_history->data; |
258 | _rl_free_history_entry (_rl_saved_line_for_history); |
259 | _rl_saved_line_for_history = (HIST_ENTRY *)NULL((void *)0); |
260 | rl_point = rl_end; /* rl_replace_line sets rl_end */ |
261 | } |
262 | else |
263 | rl_ding (); |
264 | return 0; |
265 | } |
266 | |
267 | /* Save the current line in _rl_saved_line_for_history. */ |
268 | int |
269 | rl_maybe_save_line () |
270 | { |
271 | if (_rl_saved_line_for_history == 0) |
272 | { |
273 | _rl_saved_line_for_history = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY)); |
274 | _rl_saved_line_for_history->line = savestring (rl_line_buffer)xstrdup(rl_line_buffer); |
275 | _rl_saved_line_for_history->data = (char *)rl_undo_list; |
276 | } |
277 | return 0; |
278 | } |
279 | |
280 | int |
281 | _rl_free_saved_history_line () |
282 | { |
283 | if (_rl_saved_line_for_history) |
284 | { |
285 | _rl_free_history_entry (_rl_saved_line_for_history); |
286 | _rl_saved_line_for_history = (HIST_ENTRY *)NULL((void *)0); |
287 | } |
288 | return 0; |
289 | } |
290 | |
291 | static void |
292 | _rl_history_set_point () |
293 | { |
294 | rl_point = (_rl_history_preserve_point && _rl_history_saved_point != -1) |
295 | ? _rl_history_saved_point |
296 | : rl_end; |
297 | if (rl_point > rl_end) |
298 | rl_point = rl_end; |
299 | |
300 | #if defined (VI_MODE) |
301 | if (rl_editing_mode == vi_mode0) |
302 | rl_point = 0; |
303 | #endif /* VI_MODE */ |
304 | |
305 | if (rl_editing_mode == emacs_mode1) |
306 | rl_mark = (rl_point == rl_end ? 0 : rl_end); |
307 | } |
308 | |
309 | void |
310 | rl_replace_from_history (entry, flags) |
311 | HIST_ENTRY *entry; |
312 | int flags; /* currently unused */ |
313 | { |
314 | rl_replace_line (entry->line, 0); |
315 | rl_undo_list = (UNDO_LIST *)entry->data; |
316 | rl_point = rl_end; |
317 | rl_mark = 0; |
318 | |
319 | #if defined (VI_MODE) |
320 | if (rl_editing_mode == vi_mode0) |
321 | { |
322 | rl_point = 0; |
323 | rl_mark = rl_end; |
324 | } |
325 | #endif |
326 | } |
327 | |
328 | /* **************************************************************** */ |
329 | /* */ |
330 | /* History Commands */ |
331 | /* */ |
332 | /* **************************************************************** */ |
333 | |
334 | /* Meta-< goes to the start of the history. */ |
335 | int |
336 | rl_beginning_of_history (count, key) |
337 | int count, key; |
338 | { |
339 | return (rl_get_previous_history (1 + where_history (), key)); |
340 | } |
341 | |
342 | /* Meta-> goes to the end of the history. (The current line). */ |
343 | int |
344 | rl_end_of_history (count, key) |
345 | int count, key; |
346 | { |
347 | rl_maybe_replace_line (); |
348 | using_history (); |
349 | rl_maybe_unsave_line (); |
350 | return 0; |
351 | } |
352 | |
353 | /* Move down to the next history line. */ |
354 | int |
355 | rl_get_next_history (count, key) |
356 | int count, key; |
357 | { |
358 | HIST_ENTRY *temp; |
359 | |
360 | if (count < 0) |
361 | return (rl_get_previous_history (-count, key)); |
362 | |
363 | if (count == 0) |
364 | return 0; |
365 | |
366 | rl_maybe_replace_line (); |
367 | |
368 | /* either not saved by rl_newline or at end of line, so set appropriately. */ |
369 | if (_rl_history_saved_point == -1 && (rl_point || rl_end)) |
370 | _rl_history_saved_point = (rl_point == rl_end) ? -1 : rl_point; |
371 | |
372 | temp = (HIST_ENTRY *)NULL((void *)0); |
373 | while (count) |
374 | { |
375 | temp = next_history (); |
376 | if (!temp) |
377 | break; |
378 | --count; |
379 | } |
380 | |
381 | if (temp == 0) |
382 | rl_maybe_unsave_line (); |
383 | else |
384 | { |
385 | rl_replace_from_history (temp, 0); |
386 | _rl_history_set_point (); |
387 | } |
388 | return 0; |
389 | } |
390 | |
391 | /* Get the previous item out of our interactive history, making it the current |
392 | line. If there is no previous history, just ding. */ |
393 | int |
394 | rl_get_previous_history (count, key) |
395 | int count, key; |
396 | { |
397 | HIST_ENTRY *old_temp, *temp; |
398 | |
399 | if (count < 0) |
400 | return (rl_get_next_history (-count, key)); |
401 | |
402 | if (count == 0) |
403 | return 0; |
404 | |
405 | /* either not saved by rl_newline or at end of line, so set appropriately. */ |
406 | if (_rl_history_saved_point == -1 && (rl_point || rl_end)) |
407 | _rl_history_saved_point = (rl_point == rl_end) ? -1 : rl_point; |
408 | |
409 | /* If we don't have a line saved, then save this one. */ |
410 | rl_maybe_save_line (); |
411 | |
412 | /* If the current line has changed, save the changes. */ |
413 | rl_maybe_replace_line (); |
414 | |
415 | temp = old_temp = (HIST_ENTRY *)NULL((void *)0); |
416 | while (count) |
417 | { |
418 | temp = previous_history (); |
419 | if (temp == 0) |
420 | break; |
421 | |
422 | old_temp = temp; |
423 | --count; |
424 | } |
425 | |
426 | /* If there was a large argument, and we moved back to the start of the |
427 | history, that is not an error. So use the last value found. */ |
428 | if (!temp && old_temp) |
429 | temp = old_temp; |
430 | |
431 | if (temp == 0) |
432 | rl_ding (); |
433 | else |
434 | { |
435 | rl_replace_from_history (temp, 0); |
436 | _rl_history_set_point (); |
437 | } |
438 | return 0; |
439 | } |
440 | |
441 | /* **************************************************************** */ |
442 | /* */ |
443 | /* Editing Modes */ |
444 | /* */ |
445 | /* **************************************************************** */ |
446 | /* How to toggle back and forth between editing modes. */ |
447 | int |
448 | rl_vi_editing_mode (count, key) |
449 | int count, key; |
450 | { |
451 | #if defined (VI_MODE) |
452 | _rl_set_insert_mode (RL_IM_INSERT1, 1); /* vi mode ignores insert mode */ |
453 | rl_editing_mode = vi_mode0; |
454 | rl_vi_insertion_mode (1, key); |
455 | #endif /* VI_MODE */ |
456 | |
457 | return 0; |
458 | } |
459 | |
460 | int |
461 | rl_emacs_editing_mode (count, key) |
462 | int count, key; |
463 | { |
464 | rl_editing_mode = emacs_mode1; |
465 | _rl_set_insert_mode (RL_IM_INSERT1, 1); /* emacs mode default is insert mode */ |
466 | _rl_keymap = emacs_standard_keymap; |
467 | return 0; |
468 | } |
469 | |
470 | /* Function for the rest of the library to use to set insert/overwrite mode. */ |
471 | void |
472 | _rl_set_insert_mode (im, force) |
473 | int im, force; |
474 | { |
475 | #ifdef CURSOR_MODE |
476 | _rl_set_cursor (im, force); |
477 | #endif |
478 | |
479 | rl_insert_mode = im; |
480 | } |
481 | |
482 | /* Toggle overwrite mode. A positive explicit argument selects overwrite |
483 | mode. A negative or zero explicit argument selects insert mode. */ |
484 | int |
485 | rl_overwrite_mode (count, key) |
486 | int count, key; |
487 | { |
488 | if (rl_explicit_arg == 0) |
489 | _rl_set_insert_mode (rl_insert_mode ^ 1, 0); |
490 | else if (count > 0) |
491 | _rl_set_insert_mode (RL_IM_OVERWRITE0, 0); |
492 | else |
493 | _rl_set_insert_mode (RL_IM_INSERT1, 0); |
494 | |
495 | return 0; |
496 | } |