readline/readline/undo.c

   1 /* undo.c - manage list of changes to lines, offering opportunity to undo them */
   2
   3 /* Copyright (C) 1987-2017 Free Software Foundation, Inc.
   4
   5    This file is part of the GNU Readline Library (Readline), a library
   6    for reading lines of text with interactive input and history editing.
   7
   8    Readline is free software: you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation, either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    Readline is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with Readline.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #define READLINE_LIBRARY
  23
  24 #if defined (HAVE_CONFIG_H)
  25 #  include <config.h>
  26 #endif
  27
  28 #include <sys/types.h>
  29
  30 #if defined (HAVE_UNISTD_H)
  31 #  include <unistd.h>           /* for _POSIX_VERSION */
  32 #endif /* HAVE_UNISTD_H */
  33
  34 #if defined (HAVE_STDLIB_H)
  35 #  include <stdlib.h>
  36 #else
  37 #  include "ansi_stdlib.h"
  38 #endif /* HAVE_STDLIB_H */
  39
  40 #include <stdio.h>
  41
  42 /* System-specific feature definitions and include files. */
  43 #include "rldefs.h"
  44
  45 /* Some standard library routines. */
  46 #include "readline.h"
  47 #include "history.h"
  48
  49 #include "rlprivate.h"
  50 #include "xmalloc.h"
  51
  52 extern void _hs_replace_history_data PARAMS((int, histdata_t *, histdata_t *));
  53
  54 extern HIST_ENTRY *_rl_saved_line_for_history;
  55
  56 /* Non-zero tells rl_delete_text and rl_insert_text to not add to
  57    the undo list. */
  58 int _rl_doing_an_undo = 0;
  59
  60 /* How many unclosed undo groups we currently have. */
  61 int _rl_undo_group_level = 0;
  62
  63 /* The current undo list for THE_LINE. */
  64 UNDO_LIST *rl_undo_list = (UNDO_LIST *)NULL;
  65
  66 /* **************************************************************** */
  67 /*                                                                  */
  68 /*                      Undo, and Undoing                           */
  69 /*                                                                  */
  70 /* **************************************************************** */
  71
  72 static UNDO_LIST *
  73 alloc_undo_entry (enum undo_code what, int start, int end, char *text)
  74 {
  75   UNDO_LIST *temp;
  76
  77   temp = (UNDO_LIST *)xmalloc (sizeof (UNDO_LIST));
  78   temp->what = what;
  79   temp->start = start;
  80   temp->end = end;
  81   temp->text = text;
  82
  83   temp->next = (UNDO_LIST *)NULL;
  84   return temp;
  85 }
  86
  87 /* Remember how to undo something.  Concatenate some undos if that
  88    seems right. */
  89 void
  90 rl_add_undo (enum undo_code what, int start, int end, char *text)
  91 {
  92   UNDO_LIST *temp;
  93
  94   temp = alloc_undo_entry (what, start, end, text);
  95   temp->next = rl_undo_list;
  96   rl_undo_list = temp;
  97 }
  98
  99 /* Free an UNDO_LIST */
 100 void
 101 _rl_free_undo_list (UNDO_LIST *ul)
 102 {
 103   UNDO_LIST *release;
 104
 105   while (ul)
 106     {
 107       release = ul;
 108       ul = ul->next;
 109
 110       if (release->what == UNDO_DELETE)
 111         xfree (release->text);
 112
 113       xfree (release);
 114     }
 115 }
 116
 117 /* Free the existing undo list. */
 118 void
 119 rl_free_undo_list (void)
 120 {
 121   UNDO_LIST *release, *orig_list;
 122
 123   orig_list = rl_undo_list;
 124   _rl_free_undo_list (rl_undo_list);
 125   rl_undo_list = (UNDO_LIST *)NULL;
 126   _hs_replace_history_data (-1, (histdata_t *)orig_list, (histdata_t *)NULL);
 127 }
 128
 129 UNDO_LIST *
 130 _rl_copy_undo_entry (UNDO_LIST *entry)
 131 {
 132   UNDO_LIST *new;
 133
 134   new = alloc_undo_entry (entry->what, entry->start, entry->end, (char *)NULL);
 135   new->text = entry->text ? savestring (entry->text) : 0;
 136   return new;
 137 }
 138
 139 UNDO_LIST *
 140 _rl_copy_undo_list (UNDO_LIST *head)
 141 {
 142   UNDO_LIST *list, *new, *roving, *c;
 143
 144   if (head == 0)
 145     return head;
 146
 147   list = head;
 148   new = 0;
 149   while (list)
 150     {
 151       c = _rl_copy_undo_entry (list);
 152       if (new == 0)
 153         roving = new = c;
 154       else
 155         {
 156           roving->next = c;
 157           roving = roving->next;
 158         }
 159       list = list->next;
 160     }
 161
 162   roving->next = 0;
 163   return new;
 164 }
 165
 166 /* Undo the next thing in the list.  Return 0 if there
 167    is nothing to undo, or non-zero if there was. */
 168 int
 169 rl_do_undo (void)
 170 {
 171   UNDO_LIST *release, *search;
 172   int waiting_for_begin, start, end;
 173   HIST_ENTRY *cur, *temp;
 174
 175 #define TRANS(i) ((i) == -1 ? rl_point : ((i) == -2 ? rl_end : (i)))
 176
 177   start = end = waiting_for_begin = 0;
 178   do
 179     {
 180       if (rl_undo_list == 0)
 181         return (0);
 182
 183       _rl_doing_an_undo = 1;
 184       RL_SETSTATE(RL_STATE_UNDOING);
 185
 186       /* To better support vi-mode, a start or end value of -1 means
 187          rl_point, and a value of -2 means rl_end. */
 188       if (rl_undo_list->what == UNDO_DELETE || rl_undo_list->what == UNDO_INSERT)
 189         {
 190           start = TRANS (rl_undo_list->start);
 191           end = TRANS (rl_undo_list->end);
 192         }
 193
 194       switch (rl_undo_list->what)
 195         {
 196         /* Undoing deletes means inserting some text. */
 197         case UNDO_DELETE:
 198           rl_point = start;
 199           rl_insert_text (rl_undo_list->text);
 200           xfree (rl_undo_list->text);
 201           break;
 202
 203         /* Undoing inserts means deleting some text. */
 204         case UNDO_INSERT:
 205           rl_delete_text (start, end);
 206           rl_point = start;
 207           break;
 208
 209         /* Undoing an END means undoing everything 'til we get to a BEGIN. */
 210         case UNDO_END:
 211           waiting_for_begin++;
 212           break;
 213
 214         /* Undoing a BEGIN means that we are done with this group. */
 215         case UNDO_BEGIN:
 216           if (waiting_for_begin)
 217             waiting_for_begin--;
 218           else
 219             rl_ding ();
 220           break;
 221         }
 222
 223       _rl_doing_an_undo = 0;
 224       RL_UNSETSTATE(RL_STATE_UNDOING);
 225
 226       release = rl_undo_list;
 227       rl_undo_list = rl_undo_list->next;
 228       release->next = 0;        /* XXX */
 229
 230       /* If we are editing a history entry, make sure the change is replicated
 231          in the history entry's line */
 232       cur = current_history ();
 233       if (cur && cur->data && (UNDO_LIST *)cur->data == release)
 234         {
 235           temp = replace_history_entry (where_history (), rl_line_buffer, (histdata_t)rl_undo_list);
 236           xfree (temp->line);
 237           FREE (temp->timestamp);
 238           xfree (temp);
 239         }
 240
 241       /* Make sure there aren't any history entries with that undo list */
 242       _hs_replace_history_data (-1, (histdata_t *)release, (histdata_t *)rl_undo_list);
 243
 244       /* And make sure this list isn't anywhere in the saved line for history */
 245       if (_rl_saved_line_for_history && _rl_saved_line_for_history->data)
 246         {
 247           /* Brute force; no finesse here */
 248           search = (UNDO_LIST *)_rl_saved_line_for_history->data;
 249           if (search == release)
 250             _rl_saved_line_for_history->data = rl_undo_list;
 251           else
 252             {
 253               while (search->next)
 254                 {
 255                   if (search->next == release)
 256                     {
 257                       search->next = rl_undo_list;
 258                       break;
 259                     }
 260                   search = search->next;
 261                 }
 262             }
 263         }
 264
 265       xfree (release);
 266     }
 267   while (waiting_for_begin);
 268
 269   return (1);
 270 }
 271 #undef TRANS
 272
 273 int
 274 _rl_fix_last_undo_of_type (int type, int start, int end)
 275 {
 276   UNDO_LIST *rl;
 277
 278   for (rl = rl_undo_list; rl; rl = rl->next)
 279     {
 280       if (rl->what == type)
 281         {
 282           rl->start = start;
 283           rl->end = end;
 284           return 0;
 285         }
 286     }
 287   return 1;
 288 }
 289
 290 /* Begin a group.  Subsequent undos are undone as an atomic operation. */
 291 int
 292 rl_begin_undo_group (void)
 293 {
 294   rl_add_undo (UNDO_BEGIN, 0, 0, 0);
 295   _rl_undo_group_level++;
 296   return 0;
 297 }
 298
 299 /* End an undo group started with rl_begin_undo_group (). */
 300 int
 301 rl_end_undo_group (void)
 302 {
 303   rl_add_undo (UNDO_END, 0, 0, 0);
 304   _rl_undo_group_level--;
 305   return 0;
 306 }
 307
 308 /* Save an undo entry for the text from START to END. */
 309 int
 310 rl_modifying (int start, int end)
 311 {
 312   if (start > end)
 313     {
 314       SWAP (start, end);
 315     }
 316
 317   if (start != end)
 318     {
 319       char *temp = rl_copy_text (start, end);
 320       rl_begin_undo_group ();
 321       rl_add_undo (UNDO_DELETE, start, end, temp);
 322       rl_add_undo (UNDO_INSERT, start, end, (char *)NULL);
 323       rl_end_undo_group ();
 324     }
 325   return 0;
 326 }
 327
 328 /* Revert the current line to its previous state. */
 329 int
 330 rl_revert_line (int count, int key)
 331 {
 332   if (rl_undo_list == 0)
 333     rl_ding ();
 334   else
 335     {
 336       while (rl_undo_list)
 337         rl_do_undo ();
 338 #if defined (VI_MODE)
 339       if (rl_editing_mode == vi_mode)
 340         rl_point = rl_mark = 0;         /* rl_end should be set correctly */
 341 #endif
 342     }
 343
 344   return 0;
 345 }
 346
 347 /* Do some undoing of things that were done. */
 348 int
 349 rl_undo_command (int count, int key)
 350 {
 351   if (count < 0)
 352     return 0;   /* Nothing to do. */
 353
 354   while (count)
 355     {
 356       if (rl_do_undo ())
 357         count--;
 358       else
 359         {
 360           rl_ding ();
 361           break;
 362         }
 363     }
 364   return 0;
 365 }