src/editor/edit.c

   1 /*
   2    Editor low level data handling and cursor fundamentals.
   3
   4    Copyright (C) 1996, 1997, 1998, 2001, 2002, 2003, 2004, 2005, 2006,
   5    2007, 2008, 2009, 2010, 2011, 2012
   6    The Free Software Foundation, Inc.
   7
   8    Written by:
   9    Paul Sheer 1996, 1997
  10    Ilia Maslakov <il.smind@gmail.com> 2009, 2010, 2011
  11    Andrew Borodin <aborodin@vmail.ru> 2012.
  12
  13    This file is part of the Midnight Commander.
  14
  15    The Midnight Commander is free software: you can redistribute it
  16    and/or modify it under the terms of the GNU General Public License as
  17    published by the Free Software Foundation, either version 3 of the License,
  18    or (at your option) any later version.
  19
  20    The Midnight Commander is distributed in the hope that it will be useful,
  21    but WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23    GNU General Public License for more details.
  24
  25    You should have received a copy of the GNU General Public License
  26    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  27  */
  28
  29 /** \file
  30  *  \brief Source: editor low level data handling and cursor fundamentals
  31  *  \author Paul Sheer
  32  *  \date 1996, 1997
  33  */
  34
  35 #include <config.h>
  36 #include <stdio.h>
  37 #include <stdarg.h>
  38 #include <sys/types.h>
  39 #include <unistd.h>
  40 #include <string.h>
  41 #include <ctype.h>
  42 #include <errno.h>
  43 #include <sys/stat.h>
  44 #include <stdlib.h>
  45 #include <fcntl.h>
  46
  47 #include "lib/global.h"
  48
  49 #include "lib/tty/color.h"
  50 #include "lib/tty/tty.h"        /* attrset() */
  51 #include "lib/tty/key.h"        /* is_idle() */
  52 #include "lib/skin.h"           /* EDITOR_NORMAL_COLOR */
  53 #include "lib/vfs/vfs.h"
  54 #include "lib/strutil.h"        /* utf string functions */
  55 #include "lib/util.h"           /* load_file_position(), save_file_position() */
  56 #include "lib/timefmt.h"        /* time formatting */
  57 #include "lib/lock.h"
  58 #include "lib/widget.h"
  59
  60 #ifdef HAVE_CHARSET
  61 #include "lib/charsets.h"       /* get_codepage_id */
  62 #endif
  63
  64 #include "src/filemanager/usermenu.h"   /* user_menu_cmd() */
  65
  66 #include "src/setup.h"          /* option_tab_spacing */
  67 #include "src/main.h"           /* macro_index */
  68 #include "src/learn.h"          /* learn_keys */
  69 #include "src/keybind-defaults.h"
  70
  71 #include "edit-impl.h"
  72 #include "editwidget.h"
  73 #ifdef HAVE_ASPELL
  74 #include "spell.h"
  75 #endif
  76
  77 /*** global variables ****************************************************************************/
  78
  79 int option_word_wrap_line_length = DEFAULT_WRAP_LINE_LENGTH;
  80 int option_typewriter_wrap = 0;
  81 int option_auto_para_formatting = 0;
  82 int option_fill_tabs_with_spaces = 0;
  83 int option_return_does_auto_indent = 1;
  84 int option_backspace_through_tabs = 0;
  85 int option_fake_half_tabs = 1;
  86 int option_save_mode = EDIT_QUICK_SAVE;
  87 int option_save_position = 1;
  88 int option_max_undo = 32768;
  89 int option_persistent_selections = 1;
  90 int option_cursor_beyond_eol = 0;
  91 int option_line_state = 0;
  92 int option_line_state_width = 0;
  93
  94 int option_edit_right_extreme = 0;
  95 int option_edit_left_extreme = 0;
  96 int option_edit_top_extreme = 0;
  97 int option_edit_bottom_extreme = 0;
  98 int enable_show_tabs_tws = 1;
  99 int option_check_nl_at_eof = 0;
 100 int option_group_undo = 0;
 101 int show_right_margin = 0;
 102
 103 const char *option_whole_chars_search = "0123456789abcdefghijklmnopqrstuvwxyz_";
 104 char *option_backup_ext = NULL;
 105
 106 int edit_stack_iterator = 0;
 107 edit_stack_type edit_history_moveto[MAX_HISTORY_MOVETO];
 108 /* magic sequense for say than block is vertical */
 109 const char VERTICAL_MAGIC[] = { '\1', '\1', '\1', '\1', '\n' };
 110
 111 /*** file scope macro definitions ****************************************************************/
 112
 113 #define TEMP_BUF_LEN 1024
 114
 115 #define space_width 1
 116
 117 /*** file scope type declarations ****************************************************************/
 118
 119 /*** file scope variables ************************************************************************/
 120
 121 /* detecting an error on save is easy: just check if every byte has been written. */
 122 /* detecting an error on read, is not so easy 'cos there is not way to tell
 123    whether you read everything or not. */
 124 /* FIXME: add proper `triple_pipe_open' to read, write and check errors. */
 125 static const struct edit_filters
 126 {
 127     const char *read, *write, *extension;
 128 } all_filters[] =
 129 {
 130     /* *INDENT-OFF* */
 131     { "xz -cd %s 2>&1", "xz > %s", ".xz"},
 132     { "lzma -cd %s 2>&1", "lzma > %s", ".lzma" },
 133     { "bzip2 -cd %s 2>&1", "bzip2 > %s", ".bz2" },
 134     { "gzip -cd %s 2>&1", "gzip > %s", ".gz" },
 135     { "gzip -cd %s 2>&1", "gzip > %s", ".Z" }
 136     /* *INDENT-ON* */
 137 };
 138
 139 static long last_bracket = -1;
 140
 141 /*** file scope functions ************************************************************************/
 142 /* --------------------------------------------------------------------------------------------- */
 143
 144 /*-
 145  *
 146  * here's a quick sketch of the layout: (don't run this through indent.)
 147  *
 148  * (b1 is buffers1 and b2 is buffers2)
 149  *
 150  *                                       |
 151  * \0\0\0\0\0m e _ f i l e . \nf i n . \n|T h i s _ i s _ s o\0\0\0\0\0\0\0\0\0
 152  * ______________________________________|______________________________________
 153  *                                       |
 154  * ...  |  b2[2]   |  b2[1]   |  b2[0]   |  b1[0]   |  b1[1]   |  b1[2]   | ...
 155  *      |->        |->        |->        |->        |->        |->        |
 156  *                                       |
 157  *           _<------------------------->|<----------------->_
 158  *                   WEdit->curs2        |   WEdit->curs1
 159  *           ^                           |                   ^
 160  *           |                          ^|^                  |
 161  *         cursor                       |||                cursor
 162  *                                      |||
 163  *                              file end|||file beginning
 164  *                                       |
 165  *                                       |
 166  *
 167  *           _
 168  * This_is_some_file
 169  * fin.
 170  */
 171
 172 /* --------------------------------------------------------------------------------------------- */
 173
 174 static int left_of_four_spaces (WEdit * edit);
 175
 176 /* --------------------------------------------------------------------------------------------- */
 177 /**
 178  * Initialize the buffers for an empty files.
 179  */
 180
 181 static void
 182 edit_init_buffers (WEdit * edit)
 183 {
 184     int j;
 185
 186     for (j = 0; j <= MAXBUFF; j++)
 187     {
 188         edit->buffers1[j] = NULL;
 189         edit->buffers2[j] = NULL;
 190     }
 191
 192     edit->curs1 = 0;
 193     edit->curs2 = 0;
 194     edit->buffers2[0] = g_malloc0 (EDIT_BUF_SIZE);
 195 }
 196
 197 /* --------------------------------------------------------------------------------------------- */
 198
 199 /**
 200  * Load file OR text into buffers.  Set cursor to the beginning of file.
 201  *
 202  * @returns FALSE on error.
 203  */
 204
 205 static gboolean
 206 edit_load_file_fast (WEdit * edit, const vfs_path_t * filename_vpath)
 207 {
 208     long buf, buf2;
 209     int file = -1;
 210     gboolean ret = FALSE;
 211
 212     edit->curs2 = edit->last_byte;
 213     buf2 = edit->curs2 >> S_EDIT_BUF_SIZE;
 214
 215     file = mc_open (filename_vpath, O_RDONLY | O_BINARY);
 216     if (file == -1)
 217     {
 218         gchar *errmsg, *filename;
 219
 220         filename = vfs_path_to_str (filename_vpath);
 221         errmsg = g_strdup_printf (_("Cannot open %s for reading"), filename);
 222         g_free (filename);
 223         edit_error_dialog (_("Error"), errmsg);
 224         g_free (errmsg);
 225         return FALSE;
 226     }
 227
 228     if (!edit->buffers2[buf2])
 229         edit->buffers2[buf2] = g_malloc0 (EDIT_BUF_SIZE);
 230
 231     do
 232     {
 233         if (mc_read (file,
 234                      (char *) edit->buffers2[buf2] + EDIT_BUF_SIZE -
 235                      (edit->curs2 & M_EDIT_BUF_SIZE), edit->curs2 & M_EDIT_BUF_SIZE) < 0)
 236             break;
 237
 238         for (buf = buf2 - 1; buf >= 0; buf--)
 239         {
 240             /* edit->buffers2[0] is already allocated */
 241             if (!edit->buffers2[buf])
 242                 edit->buffers2[buf] = g_malloc0 (EDIT_BUF_SIZE);
 243             if (mc_read (file, (char *) edit->buffers2[buf], EDIT_BUF_SIZE) < 0)
 244                 break;
 245         }
 246         ret = TRUE;
 247     }
 248     while (FALSE);
 249
 250     if (!ret)
 251     {
 252         gchar *errmsg, *filename;
 253
 254         filename = vfs_path_to_str (filename_vpath);
 255         errmsg = g_strdup_printf (_("Error reading %s"), filename);
 256         g_free (filename);
 257         edit_error_dialog (_("Error"), errmsg);
 258         g_free (errmsg);
 259     }
 260     mc_close (file);
 261     return ret;
 262 }
 263
 264 /* --------------------------------------------------------------------------------------------- */
 265 /** Return index of the filter or -1 is there is no appropriate filter */
 266
 267 static int
 268 edit_find_filter (const vfs_path_t * filename_vpath)
 269 {
 270     size_t i, l, e;
 271     char *filename;
 272
 273     if (filename_vpath == NULL)
 274         return -1;
 275
 276     filename = vfs_path_to_str (filename_vpath);
 277     l = strlen (filename);
 278     for (i = 0; i < sizeof (all_filters) / sizeof (all_filters[0]); i++)
 279     {
 280         e = strlen (all_filters[i].extension);
 281         if (l > e)
 282             if (!strcmp (all_filters[i].extension, filename + l - e))
 283             {
 284                 g_free (filename);
 285                 return i;
 286             }
 287     }
 288     g_free (filename);
 289     return -1;
 290 }
 291
 292 /* --------------------------------------------------------------------------------------------- */
 293
 294 static char *
 295 edit_get_filter (const vfs_path_t * filename_vpath)
 296 {
 297     int i;
 298     char *p, *quoted_name, *filename;
 299
 300     i = edit_find_filter (filename_vpath);
 301     if (i < 0)
 302         return NULL;
 303
 304     filename = vfs_path_to_str (filename_vpath);
 305     quoted_name = name_quote (filename, 0);
 306     g_free (filename);
 307     p = g_strdup_printf (all_filters[i].read, quoted_name);
 308     g_free (quoted_name);
 309     return p;
 310 }
 311
 312 /* --------------------------------------------------------------------------------------------- */
 313
 314 static long
 315 edit_insert_stream (WEdit * edit, FILE * f)
 316 {
 317     int c;
 318     long i = 0;
 319     while ((c = fgetc (f)) >= 0)
 320     {
 321         edit_insert (edit, c);
 322         i++;
 323     }
 324     return i;
 325 }
 326
 327 /* --------------------------------------------------------------------------------------------- */
 328 /**
 329   * Open file and create it if necessary.
 330   *
 331   * @param edit           editor object
 332   * @param filename_vpath file name
 333   * @param st             buffer for store stat info
 334   * @returns TRUE for success, FALSE for error.
 335   */
 336
 337 static gboolean
 338 check_file_access (WEdit * edit, const vfs_path_t * filename_vpath, struct stat *st)
 339 {
 340     int file;
 341     gchar *errmsg = NULL;
 342
 343     /* Try opening an existing file */
 344     file = mc_open (filename_vpath, O_NONBLOCK | O_RDONLY | O_BINARY, 0666);
 345     if (file < 0)
 346     {
 347         /*
 348          * Try creating the file. O_EXCL prevents following broken links
 349          * and opening existing files.
 350          */
 351         file = mc_open (filename_vpath, O_NONBLOCK | O_RDONLY | O_BINARY | O_CREAT | O_EXCL, 0666);
 352         if (file < 0)
 353         {
 354             char *filename;
 355
 356             filename = vfs_path_to_str (filename_vpath);
 357             errmsg = g_strdup_printf (_("Cannot open %s for reading"), filename);
 358             g_free (filename);
 359             goto cleanup;
 360         }
 361
 362         /* New file, delete it if it's not modified or saved */
 363         edit->delete_file = 1;
 364     }
 365
 366     /* Check what we have opened */
 367     if (mc_fstat (file, st) < 0)
 368     {
 369         char *filename;
 370
 371         filename = vfs_path_to_str (filename_vpath);
 372         errmsg = g_strdup_printf (_("Cannot get size/permissions for %s"), filename);
 373         g_free (filename);
 374         goto cleanup;
 375     }
 376
 377     /* We want to open regular files only */
 378     if (!S_ISREG (st->st_mode))
 379     {
 380         char *filename;
 381
 382         filename = vfs_path_to_str (filename_vpath);
 383         errmsg = g_strdup_printf (_("\"%s\" is not a regular file"), filename);
 384         g_free (filename);
 385         goto cleanup;
 386     }
 387
 388     /*
 389      * Don't delete non-empty files.
 390      * O_EXCL should prevent it, but let's be on the safe side.
 391      */
 392     if (st->st_size > 0)
 393         edit->delete_file = 0;
 394
 395     if (st->st_size >= SIZE_LIMIT)
 396     {
 397         char *filename;
 398
 399         filename = vfs_path_to_str (filename_vpath);
 400         errmsg = g_strdup_printf (_("File \"%s\" is too large"), filename);
 401         g_free (filename);
 402     }
 403
 404   cleanup:
 405     (void) mc_close (file);
 406
 407     if (errmsg != NULL)
 408     {
 409         edit_error_dialog (_("Error"), errmsg);
 410         g_free (errmsg);
 411         return FALSE;
 412     }
 413     return TRUE;
 414 }
 415
 416 /* --------------------------------------------------------------------------------------------- */
 417
 418 /**
 419  * Open the file and load it into the buffers, either directly or using
 420  * a filter.  Return TRUE on success, FALSE on error.
 421  *
 422  * Fast loading (edit_load_file_fast) is used when the file size is
 423  * known.  In this case the data is read into the buffers by blocks.
 424  * If the file size is not known, the data is loaded byte by byte in
 425  * edit_insert_file.
 426  *
 427  * @param edit editor object
 428  * @return TRUE if file was successfully opened and loaded to buffers, FALSE otherwise
 429  */
 430 static gboolean
 431 edit_load_file (WEdit * edit)
 432 {
 433     gboolean fast_load = TRUE;
 434
 435     /* Cannot do fast load if a filter is used */
 436     if (edit_find_filter (edit->filename_vpath) >= 0)
 437         fast_load = FALSE;
 438
 439     /*
 440      * FIXME: line end translation should disable fast loading as well
 441      * Consider doing fseek() to the end and ftell() for the real size.
 442      */
 443     if (edit->filename_vpath != NULL)
 444     {
 445         /*
 446          * VFS may report file size incorrectly, and slow load is not a big
 447          * deal considering overhead in VFS.
 448          */
 449         if (!vfs_file_is_local (edit->filename_vpath))
 450             fast_load = FALSE;
 451
 452         /* If we are dealing with a real file, check that it exists */
 453         if (!check_file_access (edit, edit->filename_vpath, &edit->stat1))
 454         {
 455             edit_clean (edit);
 456             return FALSE;
 457         }
 458     }
 459     else
 460     {
 461         /* nothing to load */
 462         fast_load = FALSE;
 463     }
 464
 465     edit_init_buffers (edit);
 466
 467     if (fast_load)
 468     {
 469         edit->last_byte = edit->stat1.st_size;
 470         edit_load_file_fast (edit, edit->filename_vpath);
 471         /* If fast load was used, the number of lines wasn't calculated */
 472         edit->total_lines = edit_count_lines (edit, 0, edit->last_byte);
 473     }
 474     else
 475     {
 476         edit->last_byte = 0;
 477         if (edit->filename_vpath != NULL
 478             && *(vfs_path_get_by_index (edit->filename_vpath, 0)->path) != '\0')
 479         {
 480             edit->undo_stack_disable = 1;
 481             if (edit_insert_file (edit, edit->filename_vpath) < 0)
 482             {
 483                 edit_clean (edit);
 484                 return FALSE;
 485             }
 486             edit->undo_stack_disable = 0;
 487         }
 488     }
 489     edit->lb = LB_ASIS;
 490     return TRUE;
 491 }
 492
 493 /* --------------------------------------------------------------------------------------------- */
 494 /** Restore saved cursor position in the file */
 495
 496 static void
 497 edit_load_position (WEdit * edit)
 498 {
 499     long line, column;
 500     off_t offset;
 501
 502     if (edit->filename_vpath == NULL
 503         || *(vfs_path_get_by_index (edit->filename_vpath, 0)->path) == '\0')
 504         return;
 505
 506     load_file_position (edit->filename_vpath, &line, &column, &offset, &edit->serialized_bookmarks);
 507
 508     if (line > 0)
 509     {
 510         edit_move_to_line (edit, line - 1);
 511         edit->prev_col = column;
 512     }
 513     else if (offset > 0)
 514     {
 515         edit_cursor_move (edit, offset);
 516         line = edit->curs_line;
 517         edit->search_start = edit->curs1;
 518     }
 519
 520     book_mark_restore (edit, BOOK_MARK_COLOR);
 521
 522     edit_move_to_prev_col (edit, edit_bol (edit, edit->curs1));
 523     edit_move_display (edit, line - (edit->widget.lines / 2));
 524 }
 525
 526 /* --------------------------------------------------------------------------------------------- */
 527 /** Save cursor position in the file */
 528
 529 static void
 530 edit_save_position (WEdit * edit)
 531 {
 532     if (edit->filename_vpath == NULL
 533         || *(vfs_path_get_by_index (edit->filename_vpath, 0)->path) == '\0')
 534         return;
 535
 536     book_mark_serialize (edit, BOOK_MARK_COLOR);
 537     save_file_position (edit->filename_vpath, edit->curs_line + 1, edit->curs_col, edit->curs1,
 538                         edit->serialized_bookmarks);
 539     edit->serialized_bookmarks = NULL;
 540 }
 541
 542 /* --------------------------------------------------------------------------------------------- */
 543 /** Clean the WEdit stricture except the widget part */
 544
 545 static void
 546 edit_purge_widget (WEdit * edit)
 547 {
 548     size_t len = sizeof (WEdit) - sizeof (Widget);
 549     char *start = (char *) edit + sizeof (Widget);
 550     memset (start, 0, len);
 551 }
 552
 553 /* --------------------------------------------------------------------------------------------- */
 554
 555 /*
 556    TODO: if the user undos until the stack bottom, and the stack has not wrapped,
 557    then the file should be as it was when he loaded up. Then set edit->modified to 0.
 558  */
 559
 560 static long
 561 edit_pop_undo_action (WEdit * edit)
 562 {
 563     long c;
 564     unsigned long sp = edit->undo_stack_pointer;
 565
 566     if (sp == edit->undo_stack_bottom)
 567         return STACK_BOTTOM;
 568
 569     sp = (sp - 1) & edit->undo_stack_size_mask;
 570     c = edit->undo_stack[sp];
 571     if (c >= 0)
 572     {
 573         /*      edit->undo_stack[sp] = '@'; */
 574         edit->undo_stack_pointer = (edit->undo_stack_pointer - 1) & edit->undo_stack_size_mask;
 575         return c;
 576     }
 577
 578     if (sp == edit->undo_stack_bottom)
 579         return STACK_BOTTOM;
 580
 581     c = edit->undo_stack[(sp - 1) & edit->undo_stack_size_mask];
 582     if (edit->undo_stack[sp] == -2)
 583     {
 584         /*      edit->undo_stack[sp] = '@'; */
 585         edit->undo_stack_pointer = sp;
 586     }
 587     else
 588         edit->undo_stack[sp]++;
 589
 590     return c;
 591 }
 592
 593 static long
 594 edit_pop_redo_action (WEdit * edit)
 595 {
 596     long c;
 597     unsigned long sp = edit->redo_stack_pointer;
 598
 599     if (sp == edit->redo_stack_bottom)
 600         return STACK_BOTTOM;
 601
 602     sp = (sp - 1) & edit->redo_stack_size_mask;
 603     c = edit->redo_stack[sp];
 604     if (c >= 0)
 605     {
 606         edit->redo_stack_pointer = (edit->redo_stack_pointer - 1) & edit->redo_stack_size_mask;
 607         return c;
 608     }
 609
 610     if (sp == edit->redo_stack_bottom)
 611         return STACK_BOTTOM;
 612
 613     c = edit->redo_stack[(sp - 1) & edit->redo_stack_size_mask];
 614     if (edit->redo_stack[sp] == -2)
 615         edit->redo_stack_pointer = sp;
 616     else
 617         edit->redo_stack[sp]++;
 618
 619     return c;
 620 }
 621
 622 static long
 623 get_prev_undo_action (WEdit * edit)
 624 {
 625     long c;
 626     unsigned long sp = edit->undo_stack_pointer;
 627
 628     if (sp == edit->undo_stack_bottom)
 629         return STACK_BOTTOM;
 630
 631     sp = (sp - 1) & edit->undo_stack_size_mask;
 632     c = edit->undo_stack[sp];
 633     if (c >= 0)
 634         return c;
 635
 636     if (sp == edit->undo_stack_bottom)
 637         return STACK_BOTTOM;
 638
 639     c = edit->undo_stack[(sp - 1) & edit->undo_stack_size_mask];
 640     return c;
 641 }
 642
 643 /* --------------------------------------------------------------------------------------------- */
 644 /** is called whenever a modification is made by one of the four routines below */
 645
 646 static void
 647 edit_modification (WEdit * edit)
 648 {
 649     edit->caches_valid = 0;
 650
 651     /* raise lock when file modified */
 652     if (!edit->modified && !edit->delete_file)
 653         edit->locked = lock_file (edit->filename_vpath);
 654     edit->modified = 1;
 655 }
 656
 657 /* --------------------------------------------------------------------------------------------- */
 658
 659 static char *
 660 edit_get_byte_ptr (WEdit * edit, long byte_index)
 661 {
 662     if (byte_index >= (edit->curs1 + edit->curs2) || byte_index < 0)
 663         return NULL;
 664
 665     if (byte_index >= edit->curs1)
 666     {
 667         unsigned long p;
 668
 669         p = edit->curs1 + edit->curs2 - byte_index - 1;
 670         return (char *) (edit->buffers2[p >> S_EDIT_BUF_SIZE] +
 671                          (EDIT_BUF_SIZE - (p & M_EDIT_BUF_SIZE) - 1));
 672     }
 673
 674     return (char *) (edit->buffers1[byte_index >> S_EDIT_BUF_SIZE] +
 675                      (byte_index & M_EDIT_BUF_SIZE));
 676 }
 677
 678 /* --------------------------------------------------------------------------------------------- */
 679
 680 static int
 681 edit_get_prev_utf (WEdit * edit, long byte_index, int *char_width)
 682 {
 683     int i, res;
 684     gchar utf8_buf[3 * UTF8_CHAR_LEN + 1];
 685     gchar *str;
 686     gchar *cursor_buf_ptr;
 687
 688     if (byte_index > (edit->curs1 + edit->curs2) || byte_index <= 0)
 689     {
 690         *char_width = 0;
 691         return 0;
 692     }
 693
 694     for (i = 0; i < (3 * UTF8_CHAR_LEN); i++)
 695         utf8_buf[i] = edit_get_byte (edit, byte_index + i - (2 * UTF8_CHAR_LEN));
 696     utf8_buf[3 * UTF8_CHAR_LEN] = '\0';
 697
 698     cursor_buf_ptr = utf8_buf + (2 * UTF8_CHAR_LEN);
 699     str = g_utf8_find_prev_char (utf8_buf, cursor_buf_ptr);
 700
 701     if (str == NULL || g_utf8_next_char (str) != cursor_buf_ptr)
 702     {
 703         *char_width = 1;
 704         return *(cursor_buf_ptr - 1);
 705     }
 706     else
 707     {
 708         res = g_utf8_get_char_validated (str, -1);
 709
 710         if (res < 0)
 711         {
 712             *char_width = 1;
 713             return *(cursor_buf_ptr - 1);
 714         }
 715         else
 716         {
 717             *char_width = cursor_buf_ptr - str;
 718             return res;
 719         }
 720     }
 721 }
 722
 723 /* --------------------------------------------------------------------------------------------- */
 724 /* high level cursor movement commands */
 725 /* --------------------------------------------------------------------------------------------- */
 726
 727 static int
 728 is_in_indent (WEdit * edit)
 729 {
 730     long p = edit_bol (edit, edit->curs1);
 731     while (p < edit->curs1)
 732         if (!strchr (" \t", edit_get_byte (edit, p++)))
 733             return 0;
 734     return 1;
 735 }
 736
 737 /* --------------------------------------------------------------------------------------------- */
 738
 739 static int
 740 is_blank (WEdit * edit, long offset)
 741 {
 742     long s, f;
 743     int c;
 744     s = edit_bol (edit, offset);
 745     f = edit_eol (edit, offset) - 1;
 746     while (s <= f)
 747     {
 748         c = edit_get_byte (edit, s++);
 749         if (!isspace (c))
 750             return 0;
 751     }
 752     return 1;
 753 }
 754
 755
 756 /* --------------------------------------------------------------------------------------------- */
 757 /** returns the offset of line i */
 758
 759 static long
 760 edit_find_line (WEdit * edit, int line)
 761 {
 762     int i, j = 0;
 763     int m = 2000000000;
 764     if (!edit->caches_valid)
 765     {
 766         for (i = 0; i < N_LINE_CACHES; i++)
 767             edit->line_numbers[i] = edit->line_offsets[i] = 0;
 768         /* three offsets that we *know* are line 0 at 0 and these two: */
 769         edit->line_numbers[1] = edit->curs_line;
 770         edit->line_offsets[1] = edit_bol (edit, edit->curs1);
 771         edit->line_numbers[2] = edit->total_lines;
 772         edit->line_offsets[2] = edit_bol (edit, edit->last_byte);
 773         edit->caches_valid = 1;
 774     }
 775     if (line >= edit->total_lines)
 776         return edit->line_offsets[2];
 777     if (line <= 0)
 778         return 0;
 779     /* find the closest known point */
 780     for (i = 0; i < N_LINE_CACHES; i++)
 781     {
 782         int n;
 783         n = abs (edit->line_numbers[i] - line);
 784         if (n < m)
 785         {
 786             m = n;
 787             j = i;
 788         }
 789     }
 790     if (m == 0)
 791         return edit->line_offsets[j];   /* know the offset exactly */
 792     if (m == 1 && j >= 3)
 793         i = j;                  /* one line different - caller might be looping, so stay in this cache */
 794     else
 795         i = 3 + (rand () % (N_LINE_CACHES - 3));
 796     if (line > edit->line_numbers[j])
 797         edit->line_offsets[i] =
 798             edit_move_forward (edit, edit->line_offsets[j], line - edit->line_numbers[j], 0);
 799     else
 800         edit->line_offsets[i] =
 801             edit_move_backward (edit, edit->line_offsets[j], edit->line_numbers[j] - line);
 802     edit->line_numbers[i] = line;
 803     return edit->line_offsets[i];
 804 }
 805
 806 /* --------------------------------------------------------------------------------------------- */
 807 /** moves up until a blank line is reached, or until just
 808    before a non-blank line is reached */
 809
 810 static void
 811 edit_move_up_paragraph (WEdit * edit, int do_scroll)
 812 {
 813     int i = 0;
 814     if (edit->curs_line > 1)
 815     {
 816         if (line_is_blank (edit, edit->curs_line))
 817         {
 818             if (line_is_blank (edit, edit->curs_line - 1))
 819             {
 820                 for (i = edit->curs_line - 1; i; i--)
 821                     if (!line_is_blank (edit, i))
 822                     {
 823                         i++;
 824                         break;
 825                     }
 826             }
 827             else
 828             {
 829                 for (i = edit->curs_line - 1; i; i--)
 830                     if (line_is_blank (edit, i))
 831                         break;
 832             }
 833         }
 834         else
 835         {
 836             for (i = edit->curs_line - 1; i; i--)
 837                 if (line_is_blank (edit, i))
 838                     break;
 839         }
 840     }
 841     edit_move_up (edit, edit->curs_line - i, do_scroll);
 842 }
 843
 844 /* --------------------------------------------------------------------------------------------- */
 845 /** moves down until a blank line is reached, or until just
 846    before a non-blank line is reached */
 847
 848 static void
 849 edit_move_down_paragraph (WEdit * edit, int do_scroll)
 850 {
 851     int i;
 852     if (edit->curs_line >= edit->total_lines - 1)
 853     {
 854         i = edit->total_lines;
 855     }
 856     else
 857     {
 858         if (line_is_blank (edit, edit->curs_line))
 859         {
 860             if (line_is_blank (edit, edit->curs_line + 1))
 861             {
 862                 for (i = edit->curs_line + 1; i; i++)
 863                     if (!line_is_blank (edit, i) || i > edit->total_lines)
 864                     {
 865                         i--;
 866                         break;
 867                     }
 868             }
 869             else
 870             {
 871                 for (i = edit->curs_line + 1; i; i++)
 872                     if (line_is_blank (edit, i) || i >= edit->total_lines)
 873                         break;
 874             }
 875         }
 876         else
 877         {
 878             for (i = edit->curs_line + 1; i; i++)
 879                 if (line_is_blank (edit, i) || i >= edit->total_lines)
 880                     break;
 881         }
 882     }
 883     edit_move_down (edit, i - edit->curs_line, do_scroll);
 884 }
 885
 886 /* --------------------------------------------------------------------------------------------- */
 887
 888 static void
 889 edit_begin_page (WEdit * edit)
 890 {
 891     edit_update_curs_row (edit);
 892     edit_move_up (edit, edit->curs_row, 0);
 893 }
 894
 895 /* --------------------------------------------------------------------------------------------- */
 896
 897 static void
 898 edit_end_page (WEdit * edit)
 899 {
 900     edit_update_curs_row (edit);
 901     edit_move_down (edit, edit->widget.lines - edit->curs_row - 1, 0);
 902 }
 903
 904
 905 /* --------------------------------------------------------------------------------------------- */
 906 /** goto beginning of text */
 907
 908 static void
 909 edit_move_to_top (WEdit * edit)
 910 {
 911     if (edit->curs_line)
 912     {
 913         edit_cursor_move (edit, -edit->curs1);
 914         edit_move_to_prev_col (edit, 0);
 915         edit->force |= REDRAW_PAGE;
 916         edit->search_start = 0;
 917         edit_update_curs_row (edit);
 918     }
 919 }
 920
 921
 922 /* --------------------------------------------------------------------------------------------- */
 923 /** goto end of text */
 924
 925 static void
 926 edit_move_to_bottom (WEdit * edit)
 927 {
 928     if (edit->curs_line < edit->total_lines)
 929     {
 930         edit_move_down (edit, edit->total_lines - edit->curs_row, 0);
 931         edit->start_display = edit->last_byte;
 932         edit->start_line = edit->total_lines;
 933         edit_scroll_upward (edit, edit->widget.lines - 1);
 934         edit->force |= REDRAW_PAGE;
 935     }
 936 }
 937
 938 /* --------------------------------------------------------------------------------------------- */
 939 /** goto beginning of line */
 940
 941 static void
 942 edit_cursor_to_bol (WEdit * edit)
 943 {
 944     edit_cursor_move (edit, edit_bol (edit, edit->curs1) - edit->curs1);
 945     edit->search_start = edit->curs1;
 946     edit->prev_col = edit_get_col (edit);
 947     edit->over_col = 0;
 948 }
 949
 950 /* --------------------------------------------------------------------------------------------- */
 951 /** goto end of line */
 952
 953 static void
 954 edit_cursor_to_eol (WEdit * edit)
 955 {
 956     edit_cursor_move (edit, edit_eol (edit, edit->curs1) - edit->curs1);
 957     edit->search_start = edit->curs1;
 958     edit->prev_col = edit_get_col (edit);
 959     edit->over_col = 0;
 960 }
 961
 962 /* --------------------------------------------------------------------------------------------- */
 963
 964 static unsigned long
 965 my_type_of (int c)
 966 {
 967     int x, r = 0;
 968     const char *p, *q;
 969     const char option_chars_move_whole_word[] =
 970         "!=&|<>^~ !:;, !'!`!.?!\"!( !) !{ !} !Aa0 !+-*/= |<> ![ !] !\\#! ";
 971
 972     if (!c)
 973         return 0;
 974     if (c == '!')
 975     {
 976         if (*option_chars_move_whole_word == '!')
 977             return 2;
 978         return 0x80000000UL;
 979     }
 980     if (g_ascii_isupper ((gchar) c))
 981         c = 'A';
 982     else if (g_ascii_islower ((gchar) c))
 983         c = 'a';
 984     else if (g_ascii_isalpha (c))
 985         c = 'a';
 986     else if (isdigit (c))
 987         c = '0';
 988     else if (isspace (c))
 989         c = ' ';
 990     q = strchr (option_chars_move_whole_word, c);
 991     if (!q)
 992         return 0xFFFFFFFFUL;
 993     do
 994     {
 995         for (x = 1, p = option_chars_move_whole_word; p < q; p++)
 996             if (*p == '!')
 997                 x <<= 1;
 998         r |= x;
 999     }
1000     while ((q = strchr (q + 1, c)));
1001     return r;
1002 }
1003
1004 /* --------------------------------------------------------------------------------------------- */
1005
1006 static void
1007 edit_left_word_move (WEdit * edit, int s)
1008 {
1009     for (;;)
1010     {
1011         int c1, c2;
1012         if (edit->column_highlight
1013             && edit->mark1 != edit->mark2
1014             && edit->over_col == 0 && edit->curs1 == edit_bol (edit, edit->curs1))
1015             break;
1016         edit_cursor_move (edit, -1);
1017         if (!edit->curs1)
1018             break;
1019         c1 = edit_get_byte (edit, edit->curs1 - 1);
1020         c2 = edit_get_byte (edit, edit->curs1);
1021         if (c1 == '\n' || c2 == '\n')
1022             break;
1023         if (!(my_type_of (c1) & my_type_of (c2)))
1024             break;
1025         if (isspace (c1) && !isspace (c2))
1026             break;
1027         if (s)
1028             if (!isspace (c1) && isspace (c2))
1029                 break;
1030     }
1031 }
1032
1033 /* --------------------------------------------------------------------------------------------- */
1034
1035 static void
1036 edit_left_word_move_cmd (WEdit * edit)
1037 {
1038     edit_left_word_move (edit, 0);
1039     edit->force |= REDRAW_PAGE;
1040 }
1041
1042 /* --------------------------------------------------------------------------------------------- */
1043
1044 static void
1045 edit_right_word_move (WEdit * edit, int s)
1046 {
1047     for (;;)
1048     {
1049         int c1, c2;
1050         if (edit->column_highlight
1051             && edit->mark1 != edit->mark2
1052             && edit->over_col == 0 && edit->curs1 == edit_eol (edit, edit->curs1))
1053             break;
1054         edit_cursor_move (edit, 1);
1055         if (edit->curs1 >= edit->last_byte)
1056             break;
1057         c1 = edit_get_byte (edit, edit->curs1 - 1);
1058         c2 = edit_get_byte (edit, edit->curs1);
1059         if (c1 == '\n' || c2 == '\n')
1060             break;
1061         if (!(my_type_of (c1) & my_type_of (c2)))
1062             break;
1063         if (isspace (c1) && !isspace (c2))
1064             break;
1065         if (s)
1066             if (!isspace (c1) && isspace (c2))
1067                 break;
1068     }
1069 }
1070
1071 /* --------------------------------------------------------------------------------------------- */
1072
1073 static void
1074 edit_right_word_move_cmd (WEdit * edit)
1075 {
1076     edit_right_word_move (edit, 0);
1077     edit->force |= REDRAW_PAGE;
1078 }
1079
1080 /* --------------------------------------------------------------------------------------------- */
1081
1082 static void
1083 edit_right_char_move_cmd (WEdit * edit)
1084 {
1085     int cw = 1;
1086     int c = 0;
1087     if (edit->utf8)
1088     {
1089         c = edit_get_utf (edit, edit->curs1, &cw);
1090         if (cw < 1)
1091             cw = 1;
1092     }
1093     else
1094     {
1095         c = edit_get_byte (edit, edit->curs1);
1096     }
1097     if (option_cursor_beyond_eol && c == '\n')
1098     {
1099         edit->over_col++;
1100     }
1101     else
1102     {
1103         edit_cursor_move (edit, cw);
1104     }
1105 }
1106
1107 /* --------------------------------------------------------------------------------------------- */
1108
1109 static void
1110 edit_left_char_move_cmd (WEdit * edit)
1111 {
1112     int cw = 1;
1113     if (edit->column_highlight
1114         && option_cursor_beyond_eol
1115         && edit->mark1 != edit->mark2
1116         && edit->over_col == 0 && edit->curs1 == edit_bol (edit, edit->curs1))
1117         return;
1118     if (edit->utf8)
1119     {
1120         edit_get_prev_utf (edit, edit->curs1, &cw);
1121         if (cw < 1)
1122             cw = 1;
1123     }
1124     if (option_cursor_beyond_eol && edit->over_col > 0)
1125     {
1126         edit->over_col--;
1127     }
1128     else
1129     {
1130         edit_cursor_move (edit, -cw);
1131     }
1132 }
1133
1134 /* --------------------------------------------------------------------------------------------- */
1135 /** Up or down cursor moving.
1136  direction = TRUE - move up
1137            = FALSE - move down
1138 */
1139
1140 static void
1141 edit_move_updown (WEdit * edit, unsigned long i, int do_scroll, gboolean direction)
1142 {
1143     unsigned long p;
1144     unsigned long l = (direction) ? edit->curs_line : edit->total_lines - edit->curs_line;
1145
1146     if (i > l)
1147         i = l;
1148
1149     if (i == 0)
1150         return;
1151
1152     if (i > 1)
1153         edit->force |= REDRAW_PAGE;
1154     if (do_scroll)
1155     {
1156         if (direction)
1157             edit_scroll_upward (edit, i);
1158         else
1159             edit_scroll_downward (edit, i);
1160     }
1161     p = edit_bol (edit, edit->curs1);
1162
1163     p = (direction) ? edit_move_backward (edit, p, i) : edit_move_forward (edit, p, i, 0);
1164
1165     edit_cursor_move (edit, p - edit->curs1);
1166
1167     edit_move_to_prev_col (edit, p);
1168
1169     /* search start of current multibyte char (like CJK) */
1170     if (edit->curs1 + 1 < edit->last_byte)
1171     {
1172         edit_right_char_move_cmd (edit);
1173         edit_left_char_move_cmd (edit);
1174     }
1175
1176     edit->search_start = edit->curs1;
1177     edit->found_len = 0;
1178 }
1179
1180 /* --------------------------------------------------------------------------------------------- */
1181
1182 static void
1183 edit_right_delete_word (WEdit * edit)
1184 {
1185     int c1, c2;
1186     for (;;)
1187     {
1188         if (edit->curs1 >= edit->last_byte)
1189             break;
1190         c1 = edit_delete (edit, 1);
1191         c2 = edit_get_byte (edit, edit->curs1);
1192         if (c1 == '\n' || c2 == '\n')
1193             break;
1194         if ((isspace (c1) == 0) != (isspace (c2) == 0))
1195             break;
1196         if (!(my_type_of (c1) & my_type_of (c2)))
1197             break;
1198     }
1199 }
1200
1201 /* --------------------------------------------------------------------------------------------- */
1202
1203 static void
1204 edit_left_delete_word (WEdit * edit)
1205 {
1206     int c1, c2;
1207     for (;;)
1208     {
1209         if (edit->curs1 <= 0)
1210             break;
1211         c1 = edit_backspace (edit, 1);
1212         c2 = edit_get_byte (edit, edit->curs1 - 1);
1213         if (c1 == '\n' || c2 == '\n')
1214             break;
1215         if ((isspace (c1) == 0) != (isspace (c2) == 0))
1216             break;
1217         if (!(my_type_of (c1) & my_type_of (c2)))
1218             break;
1219     }
1220 }
1221
1222 /* --------------------------------------------------------------------------------------------- */
1223 /**
1224    the start column position is not recorded, and hence does not
1225    undo as it happed. But who would notice.
1226  */
1227
1228 static void
1229 edit_do_undo (WEdit * edit)
1230 {
1231     long ac;
1232     long count = 0;
1233
1234     edit->undo_stack_disable = 1;       /* don't record undo's onto undo stack! */
1235     edit->over_col = 0;
1236     while ((ac = edit_pop_undo_action (edit)) < KEY_PRESS)
1237     {
1238         switch ((int) ac)
1239         {
1240         case STACK_BOTTOM:
1241             goto done_undo;
1242         case CURS_RIGHT:
1243             edit_cursor_move (edit, 1);
1244             break;
1245         case CURS_LEFT:
1246             edit_cursor_move (edit, -1);
1247             break;
1248         case BACKSPACE:
1249         case BACKSPACE_BR:
1250             edit_backspace (edit, 1);
1251             break;
1252         case DELCHAR:
1253         case DELCHAR_BR:
1254             edit_delete (edit, 1);
1255             break;
1256         case COLUMN_ON:
1257             edit->column_highlight = 1;
1258             break;
1259         case COLUMN_OFF:
1260             edit->column_highlight = 0;
1261             break;
1262         }
1263         if (ac >= 256 && ac < 512)
1264             edit_insert_ahead (edit, ac - 256);
1265         if (ac >= 0 && ac < 256)
1266             edit_insert (edit, ac);
1267
1268         if (ac >= MARK_1 - 2 && ac < MARK_2 - 2)
1269         {
1270             edit->mark1 = ac - MARK_1;
1271             edit->column1 = edit_move_forward3 (edit, edit_bol (edit, edit->mark1), 0, edit->mark1);
1272         }
1273         if (ac >= MARK_2 - 2 && ac < MARK_CURS - 2)
1274         {
1275             edit->mark2 = ac - MARK_2;
1276             edit->column2 = edit_move_forward3 (edit, edit_bol (edit, edit->mark2), 0, edit->mark2);
1277         }
1278         else if (ac >= MARK_CURS - 2 && ac < KEY_PRESS)
1279         {
1280             edit->end_mark_curs = ac - MARK_CURS;
1281         }
1282         if (count++)
1283             edit->force |= REDRAW_PAGE; /* more than one pop usually means something big */
1284     }
1285
1286     if (edit->start_display > ac - KEY_PRESS)
1287     {
1288         edit->start_line -= edit_count_lines (edit, ac - KEY_PRESS, edit->start_display);
1289         edit->force |= REDRAW_PAGE;
1290     }
1291     else if (edit->start_display < ac - KEY_PRESS)
1292     {
1293         edit->start_line += edit_count_lines (edit, edit->start_display, ac - KEY_PRESS);
1294         edit->force |= REDRAW_PAGE;
1295     }
1296     edit->start_display = ac - KEY_PRESS;       /* see push and pop above */
1297     edit_update_curs_row (edit);
1298
1299   done_undo:;
1300     edit->undo_stack_disable = 0;
1301 }
1302
1303 static void
1304 edit_do_redo (WEdit * edit)
1305 {
1306     long ac;
1307     long count = 0;
1308
1309     if (edit->redo_stack_reset)
1310         return;
1311
1312     edit->over_col = 0;
1313     while ((ac = edit_pop_redo_action (edit)) < KEY_PRESS)
1314     {
1315         switch ((int) ac)
1316         {
1317         case STACK_BOTTOM:
1318             goto done_redo;
1319         case CURS_RIGHT:
1320             edit_cursor_move (edit, 1);
1321             break;
1322         case CURS_LEFT:
1323             edit_cursor_move (edit, -1);
1324             break;
1325         case BACKSPACE:
1326             edit_backspace (edit, 1);
1327             break;
1328         case DELCHAR:
1329             edit_delete (edit, 1);
1330             break;
1331         case COLUMN_ON:
1332             edit->column_highlight = 1;
1333             break;
1334         case COLUMN_OFF:
1335             edit->column_highlight = 0;
1336             break;
1337         }
1338         if (ac >= 256 && ac < 512)
1339             edit_insert_ahead (edit, ac - 256);
1340         if (ac >= 0 && ac < 256)
1341             edit_insert (edit, ac);
1342
1343         if (ac >= MARK_1 - 2 && ac < MARK_2 - 2)
1344         {
1345             edit->mark1 = ac - MARK_1;
1346             edit->column1 = edit_move_forward3 (edit, edit_bol (edit, edit->mark1), 0, edit->mark1);
1347         }
1348         else if (ac >= MARK_2 - 2 && ac < KEY_PRESS)
1349         {
1350             edit->mark2 = ac - MARK_2;
1351             edit->column2 = edit_move_forward3 (edit, edit_bol (edit, edit->mark2), 0, edit->mark2);
1352         }
1353         /* more than one pop usually means something big */
1354         if (count++)
1355             edit->force |= REDRAW_PAGE;
1356     }
1357
1358     if (edit->start_display > ac - KEY_PRESS)
1359     {
1360         edit->start_line -= edit_count_lines (edit, ac - KEY_PRESS, edit->start_display);
1361         edit->force |= REDRAW_PAGE;
1362     }
1363     else if (edit->start_display < ac - KEY_PRESS)
1364     {
1365         edit->start_line += edit_count_lines (edit, edit->start_display, ac - KEY_PRESS);
1366         edit->force |= REDRAW_PAGE;
1367     }
1368     edit->start_display = ac - KEY_PRESS;       /* see push and pop above */
1369     edit_update_curs_row (edit);
1370
1371   done_redo:;
1372 }
1373
1374 static void
1375 edit_group_undo (WEdit * edit)
1376 {
1377     long ac = KEY_PRESS;
1378     long cur_ac = KEY_PRESS;
1379     while (ac != STACK_BOTTOM && ac == cur_ac)
1380     {
1381         cur_ac = get_prev_undo_action (edit);
1382         edit_do_undo (edit);
1383         ac = get_prev_undo_action (edit);
1384         /* exit from cycle if option_group_undo is not set,
1385          * and make single UNDO operation
1386          */
1387         if (!option_group_undo)
1388             ac = STACK_BOTTOM;
1389     }
1390 }
1391
1392 /* --------------------------------------------------------------------------------------------- */
1393
1394 static void
1395 edit_delete_to_line_end (WEdit * edit)
1396 {
1397     while (edit_get_byte (edit, edit->curs1) != '\n')
1398     {
1399         if (!edit->curs2)
1400             break;
1401         edit_delete (edit, 1);
1402     }
1403 }
1404
1405 /* --------------------------------------------------------------------------------------------- */
1406
1407 static void
1408 edit_delete_to_line_begin (WEdit * edit)
1409 {
1410     while (edit_get_byte (edit, edit->curs1 - 1) != '\n')
1411     {
1412         if (!edit->curs1)
1413             break;
1414         edit_backspace (edit, 1);
1415     }
1416 }
1417
1418 /* --------------------------------------------------------------------------------------------- */
1419
1420 static int
1421 is_aligned_on_a_tab (WEdit * edit)
1422 {
1423     edit_update_curs_col (edit);
1424     return !((edit->curs_col % (TAB_SIZE * space_width))
1425              && edit->curs_col % (TAB_SIZE * space_width) != (HALF_TAB_SIZE * space_width));
1426 }
1427
1428 /* --------------------------------------------------------------------------------------------- */
1429
1430 static int
1431 right_of_four_spaces (WEdit * edit)
1432 {
1433     int i, ch = 0;
1434     for (i = 1; i <= HALF_TAB_SIZE; i++)
1435         ch |= edit_get_byte (edit, edit->curs1 - i);
1436     if (ch == ' ')
1437         return is_aligned_on_a_tab (edit);
1438     return 0;
1439 }
1440
1441 /* --------------------------------------------------------------------------------------------- */
1442
1443 static int
1444 left_of_four_spaces (WEdit * edit)
1445 {
1446     int i, ch = 0;
1447     for (i = 0; i < HALF_TAB_SIZE; i++)
1448         ch |= edit_get_byte (edit, edit->curs1 + i);
1449     if (ch == ' ')
1450         return is_aligned_on_a_tab (edit);
1451     return 0;
1452 }
1453
1454 /* --------------------------------------------------------------------------------------------- */
1455
1456 static void
1457 edit_auto_indent (WEdit * edit)
1458 {
1459     long p;
1460     char c;
1461     p = edit->curs1;
1462     /* use the previous line as a template */
1463     p = edit_move_backward (edit, p, 1);
1464     /* copy the leading whitespace of the line */
1465     for (;;)
1466     {                           /* no range check - the line _is_ \n-terminated */
1467         c = edit_get_byte (edit, p++);
1468         if (c != ' ' && c != '\t')
1469             break;
1470         edit_insert (edit, c);
1471     }
1472 }
1473
1474 /* --------------------------------------------------------------------------------------------- */
1475
1476 static inline void
1477 edit_double_newline (WEdit * edit)
1478 {
1479     edit_insert (edit, '\n');
1480     if (edit_get_byte (edit, edit->curs1) == '\n')
1481         return;
1482     if (edit_get_byte (edit, edit->curs1 - 2) == '\n')
1483         return;
1484     edit->force |= REDRAW_PAGE;
1485     edit_insert (edit, '\n');
1486 }
1487
1488
1489 /* --------------------------------------------------------------------------------------------- */
1490
1491 static void
1492 insert_spaces_tab (WEdit * edit, gboolean half)
1493 {
1494     int i;
1495
1496     edit_update_curs_col (edit);
1497     i = option_tab_spacing * space_width;
1498     if (half)
1499         i /= 2;
1500     i = ((edit->curs_col / i) + 1) * i - edit->curs_col;
1501     while (i > 0)
1502     {
1503         edit_insert (edit, ' ');
1504         i -= space_width;
1505     }
1506 }
1507
1508 /* --------------------------------------------------------------------------------------------- */
1509
1510 static inline void
1511 edit_tab_cmd (WEdit * edit)
1512 {
1513     int i;
1514
1515     if (option_fake_half_tabs)
1516     {
1517         if (is_in_indent (edit))
1518         {
1519             /*insert a half tab (usually four spaces) unless there is a
1520                half tab already behind, then delete it and insert a
1521                full tab. */
1522             if (option_fill_tabs_with_spaces || !right_of_four_spaces (edit))
1523                 insert_spaces_tab (edit, TRUE);
1524             else
1525             {
1526                 for (i = 1; i <= HALF_TAB_SIZE; i++)
1527                     edit_backspace (edit, 1);
1528                 edit_insert (edit, '\t');
1529             }
1530             return;
1531         }
1532     }
1533     if (option_fill_tabs_with_spaces)
1534         insert_spaces_tab (edit, FALSE);
1535     else
1536         edit_insert (edit, '\t');
1537 }
1538
1539 /* --------------------------------------------------------------------------------------------- */
1540
1541 static void
1542 check_and_wrap_line (WEdit * edit)
1543 {
1544     int curs, c;
1545     if (!option_typewriter_wrap)
1546         return;
1547     edit_update_curs_col (edit);
1548     if (edit->curs_col < option_word_wrap_line_length)
1549         return;
1550     curs = edit->curs1;
1551     for (;;)
1552     {
1553         curs--;
1554         c = edit_get_byte (edit, curs);
1555         if (c == '\n' || curs <= 0)
1556         {
1557             edit_insert (edit, '\n');
1558             return;
1559         }
1560         if (c == ' ' || c == '\t')
1561         {
1562             int current = edit->curs1;
1563             edit_cursor_move (edit, curs - edit->curs1 + 1);
1564             edit_insert (edit, '\n');
1565             edit_cursor_move (edit, current - edit->curs1 + 1);
1566             return;
1567         }
1568     }
1569 }
1570
1571 /* --------------------------------------------------------------------------------------------- */
1572 /** this find the matching bracket in either direction, and sets edit->bracket */
1573
1574 static long
1575 edit_get_bracket (WEdit * edit, int in_screen, unsigned long furthest_bracket_search)
1576 {
1577     const char *const b = "{}{[][()(", *p;
1578     int i = 1, a, inc = -1, c, d, n = 0;
1579     unsigned long j = 0;
1580     long q;
1581     edit_update_curs_row (edit);
1582     c = edit_get_byte (edit, edit->curs1);
1583     p = strchr (b, c);
1584     /* no limit */
1585     if (!furthest_bracket_search)
1586         furthest_bracket_search--;
1587     /* not on a bracket at all */
1588     if (!p)
1589         return -1;
1590     /* the matching bracket */
1591     d = p[1];
1592     /* going left or right? */
1593     if (strchr ("{[(", c))
1594         inc = 1;
1595     for (q = edit->curs1 + inc;; q += inc)
1596     {
1597         /* out of buffer? */
1598         if (q >= edit->last_byte || q < 0)
1599             break;
1600         a = edit_get_byte (edit, q);
1601         /* don't want to eat CPU */
1602         if (j++ > furthest_bracket_search)
1603             break;
1604         /* out of screen? */
1605         if (in_screen)
1606         {
1607             if (q < edit->start_display)
1608                 break;
1609             /* count lines if searching downward */
1610             if (inc > 0 && a == '\n')
1611                 if (n++ >= edit->widget.lines - edit->curs_row) /* out of screen */
1612                     break;
1613         }
1614         /* count bracket depth */
1615         i += (a == c) - (a == d);
1616         /* return if bracket depth is zero */
1617         if (!i)
1618             return q;
1619     }
1620     /* no match */
1621     return -1;
1622 }
1623
1624 /* --------------------------------------------------------------------------------------------- */
1625
1626 static inline void
1627 edit_goto_matching_bracket (WEdit * edit)
1628 {
1629     long q;
1630
1631     q = edit_get_bracket (edit, 0, 0);
1632     if (q >= 0)
1633     {
1634         edit->bracket = edit->curs1;
1635         edit->force |= REDRAW_PAGE;
1636         edit_cursor_move (edit, q - edit->curs1);
1637     }
1638 }
1639
1640 /* --------------------------------------------------------------------------------------------- */
1641
1642 static void
1643 edit_move_block_to_right (WEdit * edit)
1644 {
1645     long start_mark, end_mark;
1646     long cur_bol, start_bol;
1647
1648     if (eval_marks (edit, &start_mark, &end_mark))
1649         return;
1650
1651     start_bol = edit_bol (edit, start_mark);
1652     cur_bol = edit_bol (edit, end_mark - 1);
1653
1654     do
1655     {
1656         edit_cursor_move (edit, cur_bol - edit->curs1);
1657         if (option_fill_tabs_with_spaces)
1658             insert_spaces_tab (edit, option_fake_half_tabs);
1659         else
1660             edit_insert (edit, '\t');
1661         edit_cursor_move (edit, edit_bol (edit, cur_bol) - edit->curs1);
1662
1663         if (cur_bol == 0)
1664             break;
1665
1666         cur_bol = edit_bol (edit, cur_bol - 1);
1667     }
1668     while (cur_bol >= start_bol);
1669
1670     edit->force |= REDRAW_PAGE;
1671 }
1672
1673 /* --------------------------------------------------------------------------------------------- */
1674
1675 static void
1676 edit_move_block_to_left (WEdit * edit)
1677 {
1678     long start_mark, end_mark;
1679     long cur_bol, start_bol;
1680     int i;
1681
1682     if (eval_marks (edit, &start_mark, &end_mark))
1683         return;
1684
1685     start_bol = edit_bol (edit, start_mark);
1686     cur_bol = edit_bol (edit, end_mark - 1);
1687
1688     do
1689     {
1690         int del_tab_width;
1691         int next_char;
1692
1693         edit_cursor_move (edit, cur_bol - edit->curs1);
1694
1695         if (option_fake_half_tabs)
1696             del_tab_width = HALF_TAB_SIZE;
1697         else
1698             del_tab_width = option_tab_spacing;
1699
1700         next_char = edit_get_byte (edit, edit->curs1);
1701         if (next_char == '\t')
1702             edit_delete (edit, 1);
1703         else if (next_char == ' ')
1704             for (i = 1; i <= del_tab_width; i++)
1705             {
1706                 if (next_char == ' ')
1707                     edit_delete (edit, 1);
1708                 next_char = edit_get_byte (edit, edit->curs1);
1709             }
1710
1711         if (cur_bol == 0)
1712             break;
1713
1714         cur_bol = edit_bol (edit, cur_bol - 1);
1715     }
1716     while (cur_bol >= start_bol);
1717
1718     edit->force |= REDRAW_PAGE;
1719 }
1720
1721 /* --------------------------------------------------------------------------------------------- */
1722 /**
1723  * prints at the cursor
1724  * @returns the number of chars printed
1725  */
1726
1727 static size_t
1728 edit_print_string (WEdit * e, const char *s)
1729 {
1730     size_t i = 0;
1731
1732     while (s[i] != '\0')
1733         edit_execute_cmd (e, CK_InsertChar, (unsigned char) s[i++]);
1734     e->force |= REDRAW_COMPLETELY;
1735     edit_update_screen (e);
1736     return i;
1737 }
1738
1739 /* --------------------------------------------------------------------------------------------- */
1740 /*** public functions ****************************************************************************/
1741 /* --------------------------------------------------------------------------------------------- */
1742
1743 /** User edit menu, like user menu (F2) but only in editor. */
1744
1745 void
1746 user_menu (WEdit * edit, const char *menu_file, int selected_entry)
1747 {
1748     char *block_file;
1749     int nomark;
1750     long curs;
1751     long start_mark, end_mark;
1752     struct stat status;
1753     vfs_path_t *block_file_vpath;
1754
1755     block_file = mc_config_get_full_path (EDIT_BLOCK_FILE);
1756     block_file_vpath = vfs_path_from_str (block_file);
1757     curs = edit->curs1;
1758     nomark = eval_marks (edit, &start_mark, &end_mark);
1759     if (nomark == 0)
1760         edit_save_block (edit, block_file, start_mark, end_mark);
1761
1762     /* run shell scripts from menu */
1763     if (user_menu_cmd (edit, menu_file, selected_entry)
1764         && (mc_stat (block_file_vpath, &status) == 0) && (status.st_size != 0))
1765     {
1766         int rc = 0;
1767         FILE *fd;
1768
1769         /* i.e. we have marked block */
1770         if (nomark == 0)
1771             rc = edit_block_delete_cmd (edit);
1772
1773         if (rc == 0)
1774         {
1775             long ins_len;
1776
1777             ins_len = edit_insert_file (edit, block_file_vpath);
1778             if (nomark == 0 && ins_len > 0)
1779                 edit_set_markers (edit, start_mark, start_mark + ins_len, 0, 0);
1780         }
1781         /* truncate block file */
1782         fd = fopen (block_file, "w");
1783         if (fd != NULL)
1784             fclose (fd);
1785     }
1786     g_free (block_file);
1787     vfs_path_free (block_file_vpath);
1788
1789     edit_cursor_move (edit, curs - edit->curs1);
1790     edit->force |= REDRAW_PAGE;
1791     send_message ((Widget *) edit, WIDGET_DRAW, 0);
1792 }
1793
1794 /* --------------------------------------------------------------------------------------------- */
1795
1796 int
1797 edit_get_byte (WEdit * edit, long byte_index)
1798 {
1799     unsigned long p;
1800     if (byte_index >= (edit->curs1 + edit->curs2) || byte_index < 0)
1801         return '\n';
1802
1803     if (byte_index >= edit->curs1)
1804     {
1805         p = edit->curs1 + edit->curs2 - byte_index - 1;
1806         return edit->buffers2[p >> S_EDIT_BUF_SIZE][EDIT_BUF_SIZE - (p & M_EDIT_BUF_SIZE) - 1];
1807     }
1808     else
1809     {
1810         return edit->buffers1[byte_index >> S_EDIT_BUF_SIZE][byte_index & M_EDIT_BUF_SIZE];
1811     }
1812 }
1813
1814 /* --------------------------------------------------------------------------------------------- */
1815
1816 int
1817 edit_get_utf (WEdit * edit, long byte_index, int *char_width)
1818 {
1819     gchar *str = NULL;
1820     int res = -1;
1821     gunichar ch;
1822     gchar *next_ch = NULL;
1823     int width = 0;
1824     gchar utf8_buf[UTF8_CHAR_LEN + 1];
1825
1826     if (byte_index >= (edit->curs1 + edit->curs2) || byte_index < 0)
1827     {
1828         *char_width = 0;
1829         return '\n';
1830     }
1831
1832     str = edit_get_byte_ptr (edit, byte_index);
1833
1834     if (str == NULL)
1835     {
1836         *char_width = 0;
1837         return 0;
1838     }
1839
1840     res = g_utf8_get_char_validated (str, -1);
1841
1842     if (res < 0)
1843     {
1844         /* Retry with explicit bytes to make sure it's not a buffer boundary */
1845         int i;
1846         for (i = 0; i < UTF8_CHAR_LEN; i++)
1847             utf8_buf[i] = edit_get_byte (edit, byte_index + i);
1848         utf8_buf[UTF8_CHAR_LEN] = '\0';
1849         str = utf8_buf;
1850         res = g_utf8_get_char_validated (str, -1);
1851     }
1852
1853     if (res < 0)
1854     {
1855         ch = *str;
1856         width = 0;
1857     }
1858     else
1859     {
1860         ch = res;
1861         /* Calculate UTF-8 char width */
1862         next_ch = g_utf8_next_char (str);
1863         if (next_ch)
1864         {
1865             width = next_ch - str;
1866         }
1867         else
1868         {
1869             ch = 0;
1870             width = 0;
1871         }
1872     }
1873     *char_width = width;
1874     return ch;
1875 }
1876
1877 /* --------------------------------------------------------------------------------------------- */
1878
1879 char *
1880 edit_get_write_filter (const vfs_path_t * write_name_vpath, const vfs_path_t * filename_vpath)
1881 {
1882     int i;
1883     char *p, *writename;
1884     const vfs_path_element_t *path_element;
1885
1886     i = edit_find_filter (filename_vpath);
1887     if (i < 0)
1888         return NULL;
1889
1890     path_element = vfs_path_get_by_index (write_name_vpath, -1);
1891     writename = name_quote (path_element->path, 0);
1892     p = g_strdup_printf (all_filters[i].write, writename);
1893     g_free (writename);
1894     return p;
1895 }
1896
1897 /* --------------------------------------------------------------------------------------------- */
1898
1899 long
1900 edit_write_stream (WEdit * edit, FILE * f)
1901 {
1902     long i;
1903
1904     if (edit->lb == LB_ASIS)
1905     {
1906         for (i = 0; i < edit->last_byte; i++)
1907             if (fputc (edit_get_byte (edit, i), f) < 0)
1908                 break;
1909         return i;
1910     }
1911
1912     /* change line breaks */
1913     for (i = 0; i < edit->last_byte; i++)
1914     {
1915         unsigned char c = edit_get_byte (edit, i);
1916
1917         if (!(c == '\n' || c == '\r'))
1918         {
1919             /* not line break */
1920             if (fputc (c, f) < 0)
1921                 return i;
1922         }
1923         else
1924         {                       /* (c == '\n' || c == '\r') */
1925             unsigned char c1 = edit_get_byte (edit, i + 1);     /* next char */
1926
1927             switch (edit->lb)
1928             {
1929             case LB_UNIX:      /* replace "\r\n" or '\r' to '\n' */
1930                 /* put one line break unconditionally */
1931                 if (fputc ('\n', f) < 0)
1932                     return i;
1933
1934                 i++;            /* 2 chars are processed */
1935
1936                 if (c == '\r' && c1 == '\n')
1937                     /* Windows line break; go to the next char */
1938                     break;
1939
1940                 if (c == '\r' && c1 == '\r')
1941                 {
1942                     /* two Macintosh line breaks; put second line break */
1943                     if (fputc ('\n', f) < 0)
1944                         return i;
1945                     break;
1946                 }
1947
1948                 if (fputc (c1, f) < 0)
1949                     return i;
1950                 break;
1951
1952             case LB_WIN:       /* replace '\n' or '\r' to "\r\n" */
1953                 /* put one line break unconditionally */
1954                 if (fputc ('\r', f) < 0 || fputc ('\n', f) < 0)
1955                     return i;
1956
1957                 if (c == '\r' && c1 == '\n')
1958                     /* Windows line break; go to the next char */
1959                     i++;
1960                 break;
1961
1962             case LB_MAC:       /* replace "\r\n" or '\n' to '\r' */
1963                 /* put one line break unconditionally */
1964                 if (fputc ('\r', f) < 0)
1965                     return i;
1966
1967                 i++;            /* 2 chars are processed */
1968
1969                 if (c == '\r' && c1 == '\n')
1970                     /* Windows line break; go to the next char */
1971                     break;
1972
1973                 if (c == '\n' && c1 == '\n')
1974                 {
1975                     /* two Windows line breaks; put second line break */
1976                     if (fputc ('\r', f) < 0)
1977                         return i;
1978                     break;
1979                 }
1980
1981                 if (fputc (c1, f) < 0)
1982                     return i;
1983                 break;
1984             case LB_ASIS:      /* default without changes */
1985                 break;
1986             }
1987         }
1988     }
1989
1990     return edit->last_byte;
1991 }
1992
1993 /* --------------------------------------------------------------------------------------------- */
1994
1995 gboolean
1996 is_break_char (char c)
1997 {
1998     return (isspace (c) || strchr ("{}[]()<>=|/\\!?~-+`'\",.;:#$%^&*", c));
1999 }
2000
2001 /* --------------------------------------------------------------------------------------------- */
2002
2003 char *
2004 edit_get_word_from_pos (WEdit * edit, long start_pos, long *start, gsize * len, gsize * cut)
2005 {
2006     long word_start;
2007     long cut_len = 0;
2008     GString *match_expr;
2009     unsigned char *bufpos;
2010     int c1, c2;
2011
2012     for (word_start = start_pos; word_start != 0; word_start--, cut_len++)
2013     {
2014         c1 = edit_get_byte (edit, word_start);
2015         c2 = edit_get_byte (edit, word_start - 1);
2016
2017         if (is_break_char (c1) != is_break_char (c2) || c1 == '\n' || c2 == '\n')
2018             break;
2019     }
2020
2021     bufpos = &edit->buffers1[word_start >> S_EDIT_BUF_SIZE][word_start & M_EDIT_BUF_SIZE];
2022     match_expr = g_string_sized_new (16);
2023
2024     do
2025     {
2026         c1 = edit_get_byte (edit, word_start + match_expr->len);
2027         c2 = edit_get_byte (edit, word_start + match_expr->len + 1);
2028         g_string_append_c (match_expr, c1);
2029     }
2030     while (!(is_break_char (c1) != is_break_char (c2) || c1 == '\n' || c2 == '\n'));
2031
2032     *len = match_expr->len;
2033     *start = word_start;
2034     *cut = cut_len;
2035
2036     return g_string_free (match_expr, FALSE);
2037 }
2038
2039 /* --------------------------------------------------------------------------------------------- */
2040 /** inserts a file at the cursor, returns count of inserted bytes on success */
2041
2042 long
2043 edit_insert_file (WEdit * edit, const vfs_path_t * filename_vpath)
2044 {
2045     char *p;
2046     long ins_len = 0;
2047
2048     p = edit_get_filter (filename_vpath);
2049     if (p != NULL)
2050     {
2051         FILE *f;
2052         long current = edit->curs1;
2053
2054         f = (FILE *) popen (p, "r");
2055         if (f != NULL)
2056         {
2057             edit_insert_stream (edit, f);
2058             ins_len = edit->curs1 - current;
2059             edit_cursor_move (edit, -ins_len);
2060             if (pclose (f) > 0)
2061             {
2062                 char *errmsg;
2063
2064                 errmsg = g_strdup_printf (_("Error reading from pipe: %s"), p);
2065                 edit_error_dialog (_("Error"), errmsg);
2066                 g_free (errmsg);
2067                 ins_len = -1;
2068             }
2069         }
2070         else
2071         {
2072             char *errmsg;
2073
2074             errmsg = g_strdup_printf (_("Cannot open pipe for reading: %s"), p);
2075             edit_error_dialog (_("Error"), errmsg);
2076             g_free (errmsg);
2077             ins_len = -1;
2078         }
2079         g_free (p);
2080     }
2081     else
2082     {
2083         int i, file, blocklen;
2084         long current = edit->curs1;
2085         int vertical_insertion = 0;
2086         char *buf;
2087
2088         file = mc_open (filename_vpath, O_RDONLY | O_BINARY);
2089         if (file == -1)
2090             return -1;
2091
2092         buf = g_malloc0 (TEMP_BUF_LEN);
2093         blocklen = mc_read (file, buf, sizeof (VERTICAL_MAGIC));
2094         if (blocklen > 0)
2095         {
2096             /* if contain signature VERTICAL_MAGIC then it vertical block */
2097             if (memcmp (buf, VERTICAL_MAGIC, sizeof (VERTICAL_MAGIC)) == 0)
2098                 vertical_insertion = 1;
2099             else
2100                 mc_lseek (file, 0, SEEK_SET);
2101         }
2102
2103         if (vertical_insertion)
2104         {
2105             long mark1, mark2;
2106             int c1, c2;
2107
2108             blocklen = edit_insert_column_of_text_from_file (edit, file, &mark1, &mark2, &c1, &c2);
2109             edit_set_markers (edit, edit->curs1, mark2, c1, c2);
2110             /* highlight inserted text then not persistent blocks */
2111             if (!option_persistent_selections)
2112             {
2113                 if (!edit->column_highlight)
2114                     edit_push_undo_action (edit, COLUMN_OFF);
2115                 edit->column_highlight = 1;
2116             }
2117         }
2118         else
2119         {
2120             while ((blocklen = mc_read (file, (char *) buf, TEMP_BUF_LEN)) > 0)
2121             {
2122                 for (i = 0; i < blocklen; i++)
2123                     edit_insert (edit, buf[i]);
2124             }
2125             /* highlight inserted text then not persistent blocks */
2126             if (!option_persistent_selections && edit->modified)
2127             {
2128                 edit_set_markers (edit, edit->curs1, current, 0, 0);
2129                 if (edit->column_highlight)
2130                     edit_push_undo_action (edit, COLUMN_ON);
2131                 edit->column_highlight = 0;
2132             }
2133         }
2134
2135         edit->force |= REDRAW_PAGE;
2136         ins_len = edit->curs1 - current;
2137         edit_cursor_move (edit, -ins_len);
2138         g_free (buf);
2139         mc_close (file);
2140         if (blocklen != 0)
2141             ins_len = 0;
2142     }
2143
2144     return ins_len;
2145 }
2146
2147 /* --------------------------------------------------------------------------------------------- */
2148 /**
2149  * Fill in the edit structure.  Return NULL on failure.  Pass edit as
2150  * NULL to allocate a new structure.
2151  *
2152  * If line is 0, try to restore saved position.  Otherwise put the
2153  * cursor on that line and show it in the middle of the screen.
2154  */
2155
2156 WEdit *
2157 edit_init (WEdit * edit, int y, int x, int lines, int cols, const vfs_path_t * filename_vpath,
2158            long line)
2159 {
2160     gboolean to_free = FALSE;
2161
2162     option_auto_syntax = 1;     /* Resetting to auto on every invokation */
2163     option_line_state_width = option_line_state ? LINE_STATE_WIDTH : 0;
2164
2165     if (edit != NULL)
2166         edit_purge_widget (edit);
2167     else
2168     {
2169 #ifdef ENABLE_NLS
2170         /*
2171          * Expand option_whole_chars_search by national letters using
2172          * current locale
2173          */
2174
2175         static char option_whole_chars_search_buf[256];
2176
2177         if (option_whole_chars_search_buf != option_whole_chars_search)
2178         {
2179             size_t i;
2180             size_t len = str_term_width1 (option_whole_chars_search);
2181
2182             strcpy (option_whole_chars_search_buf, option_whole_chars_search);
2183
2184             for (i = 1; i <= sizeof (option_whole_chars_search_buf); i++)
2185             {
2186                 if (g_ascii_islower ((gchar) i) && !strchr (option_whole_chars_search, i))
2187                 {
2188                     option_whole_chars_search_buf[len++] = i;
2189                 }
2190             }
2191
2192             option_whole_chars_search_buf[len] = 0;
2193             option_whole_chars_search = option_whole_chars_search_buf;
2194         }
2195 #endif /* ENABLE_NLS */
2196         edit = g_malloc0 (sizeof (WEdit));
2197         to_free = TRUE;
2198     }
2199
2200     edit->drag_state = MCEDIT_DRAG_NORMAL;
2201     edit->widget.y = y;
2202     edit->widget.x = x;
2203     edit->widget.lines = lines;
2204     edit->widget.cols = cols;
2205     edit_save_size (edit);
2206     edit->fullscreen = TRUE;
2207
2208     edit->stat1.st_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
2209     edit->stat1.st_uid = getuid ();
2210     edit->stat1.st_gid = getgid ();
2211     edit->stat1.st_mtime = 0;
2212
2213     edit->over_col = 0;
2214     edit->bracket = -1;
2215     edit->force |= REDRAW_PAGE;
2216
2217     /* set file name before load file */
2218     edit_set_filename (edit, filename_vpath);
2219
2220     edit->undo_stack_size = START_STACK_SIZE;
2221     edit->undo_stack_size_mask = START_STACK_SIZE - 1;
2222     edit->undo_stack = g_malloc0 ((edit->undo_stack_size + 10) * sizeof (long));
2223
2224     edit->redo_stack_size = START_STACK_SIZE;
2225     edit->redo_stack_size_mask = START_STACK_SIZE - 1;
2226     edit->redo_stack = g_malloc0 ((edit->redo_stack_size + 10) * sizeof (long));
2227
2228     edit->utf8 = 0;
2229     edit->converter = str_cnv_from_term;
2230     edit_set_codeset (edit);
2231
2232     if (!edit_load_file (edit))
2233     {
2234         /* edit_load_file already gives an error message */
2235         if (to_free)
2236             g_free (edit);
2237         return NULL;
2238     }
2239
2240     edit->loading_done = 1;
2241     edit->modified = 0;
2242     edit->locked = 0;
2243     edit_load_syntax (edit, NULL, NULL);
2244     {
2245         int color;
2246         edit_get_syntax_color (edit, -1, &color);
2247     }
2248
2249     /* load saved cursor position */
2250     if ((line == 0) && option_save_position)
2251         edit_load_position (edit);
2252     else
2253     {
2254         if (line <= 0)
2255             line = 1;
2256         edit_move_display (edit, line - 1);
2257         edit_move_to_line (edit, line - 1);
2258     }
2259
2260     edit_load_macro_cmd (edit);
2261
2262     return edit;
2263 }
2264
2265 /* --------------------------------------------------------------------------------------------- */
2266
2267 /** Clear the edit struct, freeing everything in it.  Return TRUE on success */
2268 gboolean
2269 edit_clean (WEdit * edit)
2270 {
2271     int j = 0;
2272
2273     if (edit == NULL)
2274         return FALSE;
2275
2276     /* a stale lock, remove it */
2277     if (edit->locked)
2278         edit->locked = unlock_file (edit->filename_vpath);
2279
2280     /* save cursor position */
2281     if (option_save_position)
2282         edit_save_position (edit);
2283     else if (edit->serialized_bookmarks != NULL)
2284         edit->serialized_bookmarks = (GArray *) g_array_free (edit->serialized_bookmarks, TRUE);
2285
2286     /* File specified on the mcedit command line and never saved */
2287     if (edit->delete_file)
2288         unlink (vfs_path_get_last_path_str (edit->filename_vpath));
2289
2290     edit_free_syntax_rules (edit);
2291     book_mark_flush (edit, -1);
2292     for (; j <= MAXBUFF; j++)
2293     {
2294         g_free (edit->buffers1[j]);
2295         g_free (edit->buffers2[j]);
2296     }
2297
2298     g_free (edit->undo_stack);
2299     g_free (edit->redo_stack);
2300     vfs_path_free (edit->filename_vpath);
2301     vfs_path_free (edit->dir_vpath);
2302     mc_search_free (edit->search);
2303     edit->search = NULL;
2304
2305     if (edit->converter != str_cnv_from_term)
2306         str_close_conv (edit->converter);
2307
2308     edit_purge_widget (edit);
2309
2310     return TRUE;
2311 }
2312
2313 /* --------------------------------------------------------------------------------------------- */
2314
2315 /**
2316  * Load a new file into the editor and set line.  If it fails, preserve the old file.
2317  * To do it, allocate a new widget, initialize it and, if the new file
2318  * was loaded, copy the data to the old widget.
2319  *
2320  * @returns TRUE on success, FALSE on failure.
2321  */
2322 gboolean
2323 edit_reload_line (WEdit * edit, const vfs_path_t * filename_vpath, long line)
2324 {
2325     WEdit *e;
2326     int y = edit->widget.y;
2327     int x = edit->widget.x;
2328     int lines = edit->widget.lines;
2329     int columns = edit->widget.cols;
2330
2331     e = g_malloc0 (sizeof (WEdit));
2332     e->widget = edit->widget;
2333
2334     if (edit_init (e, y, x, lines, columns, filename_vpath, line) == NULL)
2335     {
2336         g_free (e);
2337         return FALSE;
2338     }
2339
2340     edit_clean (edit);
2341     memcpy (edit, e, sizeof (WEdit));
2342     g_free (e);
2343
2344     return TRUE;
2345 }
2346
2347 /* --------------------------------------------------------------------------------------------- */
2348
2349 void
2350 edit_set_codeset (WEdit * edit)
2351 {
2352 #ifdef HAVE_CHARSET
2353     const char *cp_id;
2354
2355     cp_id =
2356         get_codepage_id (mc_global.source_codepage >=
2357                          0 ? mc_global.source_codepage : mc_global.display_codepage);
2358
2359     if (cp_id != NULL)
2360     {
2361         GIConv conv;
2362         conv = str_crt_conv_from (cp_id);
2363         if (conv != INVALID_CONV)
2364         {
2365             if (edit->converter != str_cnv_from_term)
2366                 str_close_conv (edit->converter);
2367             edit->converter = conv;
2368         }
2369     }
2370
2371     if (cp_id != NULL)
2372         edit->utf8 = str_isutf8 (cp_id);
2373 #else
2374     (void) edit;
2375 #endif
2376 }
2377
2378
2379 /* --------------------------------------------------------------------------------------------- */
2380 /**
2381    Recording stack for undo:
2382    The following is an implementation of a compressed stack. Identical
2383    pushes are recorded by a negative prefix indicating the number of times the
2384    same char was pushed. This saves space for repeated curs-left or curs-right
2385    delete etc.
2386
2387    eg:
2388
2389    pushed:       stored:
2390
2391    a
2392    b             a
2393    b            -3
2394    b             b
2395    c  -->       -4
2396    c             c
2397    c             d
2398    c
2399    d
2400
2401    If the stack long int is 0-255 it represents a normal insert (from a backspace),
2402    256-512 is an insert ahead (from a delete), If it is betwen 600 and 700 it is one
2403    of the cursor functions #define'd in edit-impl.h. 1000 through 700'000'000 is to
2404    set edit->mark1 position. 700'000'000 through 1400'000'000 is to set edit->mark2
2405    position.
2406
2407    The only way the cursor moves or the buffer is changed is through the routines:
2408    insert, backspace, insert_ahead, delete, and cursor_move.
2409    These record the reverse undo movements onto the stack each time they are
2410    called.
2411
2412    Each key press results in a set of actions (insert; delete ...). So each time
2413    a key is pressed the current position of start_display is pushed as
2414    KEY_PRESS + start_display. Then for undoing, we pop until we get to a number
2415    over KEY_PRESS. We then assign this number less KEY_PRESS to start_display. So undo
2416    tracks scrolling and key actions exactly. (KEY_PRESS is about (2^31) * (2/3) = 1400'000'000)
2417
2418  */
2419
2420 void
2421 edit_push_undo_action (WEdit * edit, long c, ...)
2422 {
2423     unsigned long sp = edit->undo_stack_pointer;
2424     unsigned long spm1;
2425     long *t;
2426
2427     /* first enlarge the stack if necessary */
2428     if (sp > edit->undo_stack_size - 10)
2429     {                           /* say */
2430         if (option_max_undo < 256)
2431             option_max_undo = 256;
2432         if (edit->undo_stack_size < (unsigned long) option_max_undo)
2433         {
2434             t = g_realloc (edit->undo_stack, (edit->undo_stack_size * 2 + 10) * sizeof (long));
2435             if (t)
2436             {
2437                 edit->undo_stack = t;
2438                 edit->undo_stack_size <<= 1;
2439                 edit->undo_stack_size_mask = edit->undo_stack_size - 1;
2440             }
2441         }
2442     }
2443     spm1 = (edit->undo_stack_pointer - 1) & edit->undo_stack_size_mask;
2444     if (edit->undo_stack_disable)
2445     {
2446         edit_push_redo_action (edit, KEY_PRESS);
2447         edit_push_redo_action (edit, c);
2448         return;
2449     }
2450     else if (edit->redo_stack_reset)
2451     {
2452         edit->redo_stack_bottom = edit->redo_stack_pointer = 0;
2453     }
2454
2455     if (edit->undo_stack_bottom != sp
2456         && spm1 != edit->undo_stack_bottom
2457         && ((sp - 2) & edit->undo_stack_size_mask) != edit->undo_stack_bottom)
2458     {
2459         int d;
2460         if (edit->undo_stack[spm1] < 0)
2461         {
2462             d = edit->undo_stack[(sp - 2) & edit->undo_stack_size_mask];
2463             if (d == c)
2464             {
2465                 if (edit->undo_stack[spm1] > -1000000000)
2466                 {
2467                     if (c < KEY_PRESS)  /* --> no need to push multiple do-nothings */
2468                     {
2469                         edit->undo_stack[spm1]--;
2470                     }
2471                     return;
2472                 }
2473             }
2474         }
2475         else
2476         {
2477             d = edit->undo_stack[spm1];
2478             if (d == c)
2479             {
2480                 if (c >= KEY_PRESS)
2481                     return;     /* --> no need to push multiple do-nothings */
2482                 edit->undo_stack[sp] = -2;
2483                 goto check_bottom;
2484             }
2485         }
2486     }
2487     edit->undo_stack[sp] = c;
2488
2489   check_bottom:
2490     edit->undo_stack_pointer = (edit->undo_stack_pointer + 1) & edit->undo_stack_size_mask;
2491
2492     /* if the sp wraps round and catches the undo_stack_bottom then erase
2493      * the first set of actions on the stack to make space - by moving
2494      * undo_stack_bottom forward one "key press" */
2495     c = (edit->undo_stack_pointer + 2) & edit->undo_stack_size_mask;
2496     if ((unsigned long) c == edit->undo_stack_bottom ||
2497         (((unsigned long) c + 1) & edit->undo_stack_size_mask) == edit->undo_stack_bottom)
2498         do
2499         {
2500             edit->undo_stack_bottom = (edit->undo_stack_bottom + 1) & edit->undo_stack_size_mask;
2501         }
2502         while (edit->undo_stack[edit->undo_stack_bottom] < KEY_PRESS
2503                && edit->undo_stack_bottom != edit->undo_stack_pointer);
2504
2505     /*If a single key produced enough pushes to wrap all the way round then we would notice that the [undo_stack_bottom] does not contain KEY_PRESS. The stack is then initialised: */
2506     if (edit->undo_stack_pointer != edit->undo_stack_bottom
2507         && edit->undo_stack[edit->undo_stack_bottom] < KEY_PRESS)
2508     {
2509         edit->undo_stack_bottom = edit->undo_stack_pointer = 0;
2510     }
2511 }
2512
2513 void
2514 edit_push_redo_action (WEdit * edit, long c, ...)
2515 {
2516     unsigned long sp = edit->redo_stack_pointer;
2517     unsigned long spm1;
2518     long *t;
2519     /* first enlarge the stack if necessary */
2520     if (sp > edit->redo_stack_size - 10)
2521     {                           /* say */
2522         if (option_max_undo < 256)
2523             option_max_undo = 256;
2524         if (edit->redo_stack_size < (unsigned long) option_max_undo)
2525         {
2526             t = g_realloc (edit->redo_stack, (edit->redo_stack_size * 2 + 10) * sizeof (long));
2527             if (t)
2528             {
2529                 edit->redo_stack = t;
2530                 edit->redo_stack_size <<= 1;
2531                 edit->redo_stack_size_mask = edit->redo_stack_size - 1;
2532             }
2533         }
2534     }
2535     spm1 = (edit->redo_stack_pointer - 1) & edit->redo_stack_size_mask;
2536
2537     if (edit->redo_stack_bottom != sp
2538         && spm1 != edit->redo_stack_bottom
2539         && ((sp - 2) & edit->redo_stack_size_mask) != edit->redo_stack_bottom)
2540     {
2541         int d;
2542         if (edit->redo_stack[spm1] < 0)
2543         {
2544             d = edit->redo_stack[(sp - 2) & edit->redo_stack_size_mask];
2545             if (d == c)
2546             {
2547                 if (edit->redo_stack[spm1] > -1000000000)
2548                 {
2549                     if (c < KEY_PRESS)  /* --> no need to push multiple do-nothings */
2550                         edit->redo_stack[spm1]--;
2551                     return;
2552                 }
2553             }
2554         }
2555         else
2556         {
2557             d = edit->redo_stack[spm1];
2558             if (d == c)
2559             {
2560                 if (c >= KEY_PRESS)
2561                     return;     /* --> no need to push multiple do-nothings */
2562                 edit->redo_stack[sp] = -2;
2563                 goto redo_check_bottom;
2564             }
2565         }
2566     }
2567     edit->redo_stack[sp] = c;
2568
2569   redo_check_bottom:
2570     edit->redo_stack_pointer = (edit->redo_stack_pointer + 1) & edit->redo_stack_size_mask;
2571
2572     /* if the sp wraps round and catches the redo_stack_bottom then erase
2573      * the first set of actions on the stack to make space - by moving
2574      * redo_stack_bottom forward one "key press" */
2575     c = (edit->redo_stack_pointer + 2) & edit->redo_stack_size_mask;
2576     if ((unsigned long) c == edit->redo_stack_bottom ||
2577         (((unsigned long) c + 1) & edit->redo_stack_size_mask) == edit->redo_stack_bottom)
2578         do
2579         {
2580             edit->redo_stack_bottom = (edit->redo_stack_bottom + 1) & edit->redo_stack_size_mask;
2581         }
2582         while (edit->redo_stack[edit->redo_stack_bottom] < KEY_PRESS
2583                && edit->redo_stack_bottom != edit->redo_stack_pointer);
2584
2585     /*
2586      * If a single key produced enough pushes to wrap all the way round then
2587      * we would notice that the [redo_stack_bottom] does not contain KEY_PRESS.
2588      * The stack is then initialised:
2589      */
2590
2591     if (edit->redo_stack_pointer != edit->redo_stack_bottom
2592         && edit->redo_stack[edit->redo_stack_bottom] < KEY_PRESS)
2593         edit->redo_stack_bottom = edit->redo_stack_pointer = 0;
2594
2595 }
2596
2597 /* --------------------------------------------------------------------------------------------- */
2598 /**
2599    Basic low level single character buffer alterations and movements at the cursor.
2600    Returns char passed over, inserted or removed.
2601  */
2602
2603 void
2604 edit_insert (WEdit * edit, int c)
2605 {
2606     /* check if file has grown to large */
2607     if (edit->last_byte >= SIZE_LIMIT)
2608         return;
2609
2610     /* first we must update the position of the display window */
2611     if (edit->curs1 < edit->start_display)
2612     {
2613         edit->start_display++;
2614         if (c == '\n')
2615             edit->start_line++;
2616     }
2617
2618     /* Mark file as modified, unless the file hasn't been fully loaded */
2619     if (edit->loading_done)
2620     {
2621         edit_modification (edit);
2622     }
2623
2624     /* now we must update some info on the file and check if a redraw is required */
2625     if (c == '\n')
2626     {
2627         if (edit->book_mark)
2628             book_mark_inc (edit, edit->curs_line);
2629         edit->curs_line++;
2630         edit->total_lines++;
2631         edit->force |= REDRAW_LINE_ABOVE | REDRAW_AFTER_CURSOR;
2632     }
2633
2634     /* save the reverse command onto the undo stack */
2635     /* ordinary char and not space */
2636     if (c > 32)
2637         edit_push_undo_action (edit, BACKSPACE);
2638     else
2639         edit_push_undo_action (edit, BACKSPACE_BR);
2640     /* update markers */
2641     edit->mark1 += (edit->mark1 > edit->curs1);
2642     edit->mark2 += (edit->mark2 > edit->curs1);
2643     edit->last_get_rule += (edit->last_get_rule > edit->curs1);
2644
2645     /* add a new buffer if we've reached the end of the last one */
2646     if (!(edit->curs1 & M_EDIT_BUF_SIZE))
2647         edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] = g_malloc0 (EDIT_BUF_SIZE);
2648
2649     /* perform the insertion */
2650     edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE][edit->curs1 & M_EDIT_BUF_SIZE]
2651         = (unsigned char) c;
2652
2653     /* update file length */
2654     edit->last_byte++;
2655
2656     /* update cursor position */
2657     edit->curs1++;
2658 }
2659
2660 /* --------------------------------------------------------------------------------------------- */
2661 /** same as edit_insert and move left */
2662
2663 void
2664 edit_insert_ahead (WEdit * edit, int c)
2665 {
2666     if (edit->last_byte >= SIZE_LIMIT)
2667         return;
2668
2669     if (edit->curs1 < edit->start_display)
2670     {
2671         edit->start_display++;
2672         if (c == '\n')
2673             edit->start_line++;
2674     }
2675     edit_modification (edit);
2676     if (c == '\n')
2677     {
2678         if (edit->book_mark)
2679             book_mark_inc (edit, edit->curs_line);
2680         edit->total_lines++;
2681         edit->force |= REDRAW_AFTER_CURSOR;
2682     }
2683     /* ordinary char and not space */
2684     if (c > 32)
2685         edit_push_undo_action (edit, DELCHAR);
2686     else
2687         edit_push_undo_action (edit, DELCHAR_BR);
2688
2689     edit->mark1 += (edit->mark1 >= edit->curs1);
2690     edit->mark2 += (edit->mark2 >= edit->curs1);
2691     edit->last_get_rule += (edit->last_get_rule >= edit->curs1);
2692
2693     if (!((edit->curs2 + 1) & M_EDIT_BUF_SIZE))
2694         edit->buffers2[(edit->curs2 + 1) >> S_EDIT_BUF_SIZE] = g_malloc0 (EDIT_BUF_SIZE);
2695     edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE]
2696         [EDIT_BUF_SIZE - (edit->curs2 & M_EDIT_BUF_SIZE) - 1] = c;
2697
2698     edit->last_byte++;
2699     edit->curs2++;
2700 }
2701
2702
2703 /* --------------------------------------------------------------------------------------------- */
2704
2705 int
2706 edit_delete (WEdit * edit, const int byte_delete)
2707 {
2708     int p = 0;
2709     int cw = 1;
2710     int i;
2711
2712     if (!edit->curs2)
2713         return 0;
2714
2715     cw = 1;
2716     /* if byte_delete = 1 then delete only one byte not multibyte char */
2717     if (edit->utf8 && byte_delete == 0)
2718     {
2719         edit_get_utf (edit, edit->curs1, &cw);
2720         if (cw < 1)
2721             cw = 1;
2722     }
2723
2724     if (edit->mark2 != edit->mark1)
2725         edit_push_markers (edit);
2726
2727     for (i = 1; i <= cw; i++)
2728     {
2729         if (edit->mark1 > edit->curs1)
2730         {
2731             edit->mark1--;
2732             edit->end_mark_curs--;
2733         }
2734         if (edit->mark2 > edit->curs1)
2735             edit->mark2--;
2736         if (edit->last_get_rule > edit->curs1)
2737             edit->last_get_rule--;
2738
2739         p = edit->buffers2[(edit->curs2 - 1) >> S_EDIT_BUF_SIZE][EDIT_BUF_SIZE -
2740                                                                  ((edit->curs2 -
2741                                                                    1) & M_EDIT_BUF_SIZE) - 1];
2742
2743         if (!(edit->curs2 & M_EDIT_BUF_SIZE))
2744         {
2745             g_free (edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE]);
2746             edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE] = NULL;
2747         }
2748         edit->last_byte--;
2749         edit->curs2--;
2750         edit_push_undo_action (edit, p + 256);
2751     }
2752
2753     edit_modification (edit);
2754     if (p == '\n')
2755     {
2756         if (edit->book_mark)
2757             book_mark_dec (edit, edit->curs_line);
2758         edit->total_lines--;
2759         edit->force |= REDRAW_AFTER_CURSOR;
2760     }
2761     if (edit->curs1 < edit->start_display)
2762     {
2763         edit->start_display--;
2764         if (p == '\n')
2765             edit->start_line--;
2766     }
2767
2768     return p;
2769 }
2770
2771 /* --------------------------------------------------------------------------------------------- */
2772
2773 int
2774 edit_backspace (WEdit * edit, const int byte_delete)
2775 {
2776     int p = 0;
2777     int cw = 1;
2778     int i;
2779
2780     if (edit->curs1 == 0)
2781         return 0;
2782
2783     cw = 1;
2784
2785     if (edit->mark2 != edit->mark1)
2786         edit_push_markers (edit);
2787
2788     if (edit->utf8 && byte_delete == 0)
2789     {
2790         edit_get_prev_utf (edit, edit->curs1, &cw);
2791         if (cw < 1)
2792             cw = 1;
2793     }
2794     for (i = 1; i <= cw; i++)
2795     {
2796         if (edit->mark1 >= edit->curs1)
2797         {
2798             edit->mark1--;
2799             edit->end_mark_curs--;
2800         }
2801         if (edit->mark2 >= edit->curs1)
2802             edit->mark2--;
2803         if (edit->last_get_rule >= edit->curs1)
2804             edit->last_get_rule--;
2805
2806         p = *(edit->buffers1[(edit->curs1 - 1) >> S_EDIT_BUF_SIZE] +
2807               ((edit->curs1 - 1) & M_EDIT_BUF_SIZE));
2808         if (!((edit->curs1 - 1) & M_EDIT_BUF_SIZE))
2809         {
2810             g_free (edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE]);
2811             edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] = NULL;
2812         }
2813         edit->last_byte--;
2814         edit->curs1--;
2815         edit_push_undo_action (edit, p);
2816     }
2817     edit_modification (edit);
2818     if (p == '\n')
2819     {
2820         if (edit->book_mark)
2821             book_mark_dec (edit, edit->curs_line);
2822         edit->curs_line--;
2823         edit->total_lines--;
2824         edit->force |= REDRAW_AFTER_CURSOR;
2825     }
2826
2827     if (edit->curs1 < edit->start_display)
2828     {
2829         edit->start_display--;
2830         if (p == '\n')
2831             edit->start_line--;
2832     }
2833
2834     return p;
2835 }
2836
2837 /* --------------------------------------------------------------------------------------------- */
2838 /** moves the cursor right or left: increment positive or negative respectively */
2839
2840 void
2841 edit_cursor_move (WEdit * edit, long increment)
2842 {
2843     /* this is the same as a combination of two of the above routines, with only one push onto the undo stack */
2844     int c;
2845
2846     if (increment < 0)
2847     {
2848         for (; increment < 0; increment++)
2849         {
2850             if (!edit->curs1)
2851                 return;
2852
2853             edit_push_undo_action (edit, CURS_RIGHT);
2854
2855             c = edit_get_byte (edit, edit->curs1 - 1);
2856             if (!((edit->curs2 + 1) & M_EDIT_BUF_SIZE))
2857                 edit->buffers2[(edit->curs2 + 1) >> S_EDIT_BUF_SIZE] = g_malloc0 (EDIT_BUF_SIZE);
2858             edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE][EDIT_BUF_SIZE -
2859                                                            (edit->curs2 & M_EDIT_BUF_SIZE) - 1] = c;
2860             edit->curs2++;
2861             c = edit->buffers1[(edit->curs1 - 1) >> S_EDIT_BUF_SIZE][(edit->curs1 -
2862                                                                       1) & M_EDIT_BUF_SIZE];
2863             if (!((edit->curs1 - 1) & M_EDIT_BUF_SIZE))
2864             {
2865                 g_free (edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE]);
2866                 edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] = NULL;
2867             }
2868             edit->curs1--;
2869             if (c == '\n')
2870             {
2871                 edit->curs_line--;
2872                 edit->force |= REDRAW_LINE_BELOW;
2873             }
2874         }
2875
2876     }
2877     else if (increment > 0)
2878     {
2879         for (; increment > 0; increment--)
2880         {
2881             if (!edit->curs2)
2882                 return;
2883
2884             edit_push_undo_action (edit, CURS_LEFT);
2885
2886             c = edit_get_byte (edit, edit->curs1);
2887             if (!(edit->curs1 & M_EDIT_BUF_SIZE))
2888                 edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE] = g_malloc0 (EDIT_BUF_SIZE);
2889             edit->buffers1[edit->curs1 >> S_EDIT_BUF_SIZE][edit->curs1 & M_EDIT_BUF_SIZE] = c;
2890             edit->curs1++;
2891             c = edit->buffers2[(edit->curs2 - 1) >> S_EDIT_BUF_SIZE][EDIT_BUF_SIZE -
2892                                                                      ((edit->curs2 -
2893                                                                        1) & M_EDIT_BUF_SIZE) - 1];
2894             if (!(edit->curs2 & M_EDIT_BUF_SIZE))
2895             {
2896                 g_free (edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE]);
2897                 edit->buffers2[edit->curs2 >> S_EDIT_BUF_SIZE] = 0;
2898             }
2899             edit->curs2--;
2900             if (c == '\n')
2901             {
2902                 edit->curs_line++;
2903                 edit->force |= REDRAW_LINE_ABOVE;
2904             }
2905         }
2906     }
2907 }
2908
2909 /* These functions return positions relative to lines */
2910
2911 /* --------------------------------------------------------------------------------------------- */
2912 /** returns index of last char on line + 1 */
2913
2914 long
2915 edit_eol (WEdit * edit, long current)
2916 {
2917     if (current >= edit->last_byte)
2918         return edit->last_byte;
2919
2920     for (;; current++)
2921         if (edit_get_byte (edit, current) == '\n')
2922             break;
2923     return current;
2924 }
2925
2926 /* --------------------------------------------------------------------------------------------- */
2927 /** returns index of first char on line */
2928
2929 long
2930 edit_bol (WEdit * edit, long current)
2931 {
2932     if (current <= 0)
2933         return 0;
2934
2935     for (;; current--)
2936         if (edit_get_byte (edit, current - 1) == '\n')
2937             break;
2938     return current;
2939 }
2940
2941 /* --------------------------------------------------------------------------------------------- */
2942
2943 long
2944 edit_count_lines (WEdit * edit, long current, long upto)
2945 {
2946     long lines = 0;
2947     if (upto > edit->last_byte)
2948         upto = edit->last_byte;
2949     if (current < 0)
2950         current = 0;
2951     while (current < upto)
2952         if (edit_get_byte (edit, current++) == '\n')
2953             lines++;
2954     return lines;
2955 }
2956
2957 /* --------------------------------------------------------------------------------------------- */
2958 /* If lines is zero this returns the count of lines from current to upto. */
2959 /* If upto is zero returns index of lines forward current. */
2960
2961 long
2962 edit_move_forward (WEdit * edit, long current, long lines, long upto)
2963 {
2964     if (upto)
2965     {
2966         return edit_count_lines (edit, current, upto);
2967     }
2968     else
2969     {
2970         long next;
2971         if (lines < 0)
2972             lines = 0;
2973         while (lines--)
2974         {
2975             next = edit_eol (edit, current) + 1;
2976             if (next > edit->last_byte)
2977                 break;
2978             else
2979                 current = next;
2980         }
2981         return current;
2982     }
2983 }
2984
2985 /* --------------------------------------------------------------------------------------------- */
2986 /** Returns offset of 'lines' lines up from current */
2987
2988 long
2989 edit_move_backward (WEdit * edit, long current, long lines)
2990 {
2991     if (lines < 0)
2992         lines = 0;
2993     current = edit_bol (edit, current);
2994     while ((lines--) && current != 0)
2995         current = edit_bol (edit, current - 1);
2996     return current;
2997 }
2998
2999 /* --------------------------------------------------------------------------------------------- */
3000 /* If cols is zero this returns the count of columns from current to upto. */
3001 /* If upto is zero returns index of cols across from current. */
3002
3003 long
3004 edit_move_forward3 (WEdit * edit, long current, int cols, long upto)
3005 {
3006     long p, q;
3007     int col;
3008
3009     if (upto)
3010     {
3011         q = upto;
3012         cols = -10;
3013     }
3014     else
3015         q = edit->last_byte + 2;
3016
3017     for (col = 0, p = current; p < q; p++)
3018     {
3019         int c, orig_c;
3020
3021         if (cols != -10)
3022         {
3023             if (col == cols)
3024                 return p;
3025             if (col > cols)
3026                 return p - 1;
3027         }
3028
3029         orig_c = c = edit_get_byte (edit, p);
3030
3031 #ifdef HAVE_CHARSET
3032         if (edit->utf8)
3033         {
3034             int utf_ch;
3035             int cw = 1;
3036
3037             utf_ch = edit_get_utf (edit, p, &cw);
3038             if (mc_global.utf8_display)
3039             {
3040                 if (cw > 1)
3041                     col -= cw - 1;
3042                 if (g_unichar_iswide (utf_ch))
3043                     col++;
3044             }
3045             else if (cw > 1 && g_unichar_isprint (utf_ch))
3046                 col -= cw - 1;
3047         }
3048
3049         c = convert_to_display_c (c);
3050 #endif
3051
3052         if (c == '\t')
3053             col += TAB_SIZE - col % TAB_SIZE;
3054         else if (c == '\n')
3055         {
3056             if (upto)
3057                 return col;
3058             else
3059                 return p;
3060         }
3061         else if ((c < 32 || c == 127) && (orig_c == c || (!mc_global.utf8_display && !edit->utf8)))
3062             /* '\r' is shown as ^M, so we must advance 2 characters */
3063             /* Caret notation for control characters */
3064             col += 2;
3065         else
3066             col++;
3067     }
3068     return col;
3069 }
3070
3071 /* --------------------------------------------------------------------------------------------- */
3072 /** returns the current column position of the cursor */
3073
3074 int
3075 edit_get_col (WEdit * edit)
3076 {
3077     return edit_move_forward3 (edit, edit_bol (edit, edit->curs1), 0, edit->curs1);
3078 }
3079
3080 /* --------------------------------------------------------------------------------------------- */
3081 /* Scrolling functions */
3082 /* --------------------------------------------------------------------------------------------- */
3083
3084 void
3085 edit_update_curs_row (WEdit * edit)
3086 {
3087     edit->curs_row = edit->curs_line - edit->start_line;
3088 }
3089
3090 /* --------------------------------------------------------------------------------------------- */
3091
3092 void
3093 edit_update_curs_col (WEdit * edit)
3094 {
3095     edit->curs_col = edit_move_forward3 (edit, edit_bol (edit, edit->curs1), 0, edit->curs1);
3096 }
3097
3098 /* --------------------------------------------------------------------------------------------- */
3099
3100 int
3101 edit_get_curs_col (const WEdit * edit)
3102 {
3103     return edit->curs_col;
3104 }
3105
3106 /* --------------------------------------------------------------------------------------------- */
3107 /** moves the display start position up by i lines */
3108
3109 void
3110 edit_scroll_upward (WEdit * edit, unsigned long i)
3111 {
3112     unsigned long lines_above = edit->start_line;
3113     if (i > lines_above)
3114         i = lines_above;
3115     if (i)
3116     {
3117         edit->start_line -= i;
3118         edit->start_display = edit_move_backward (edit, edit->start_display, i);
3119         edit->force |= REDRAW_PAGE;
3120         edit->force &= (0xfff - REDRAW_CHAR_ONLY);
3121     }
3122     edit_update_curs_row (edit);
3123 }
3124
3125
3126 /* --------------------------------------------------------------------------------------------- */
3127 /** returns 1 if could scroll, 0 otherwise */
3128
3129 void
3130 edit_scroll_downward (WEdit * edit, int i)
3131 {
3132     int lines_below;
3133     lines_below = edit->total_lines - edit->start_line - (edit->widget.lines - 1);
3134     if (lines_below > 0)
3135     {
3136         if (i > lines_below)
3137             i = lines_below;
3138         edit->start_line += i;
3139         edit->start_display = edit_move_forward (edit, edit->start_display, i, 0);
3140         edit->force |= REDRAW_PAGE;
3141         edit->force &= (0xfff - REDRAW_CHAR_ONLY);
3142     }
3143     edit_update_curs_row (edit);
3144 }
3145
3146 /* --------------------------------------------------------------------------------------------- */
3147
3148 void
3149 edit_scroll_right (WEdit * edit, int i)
3150 {
3151     edit->force |= REDRAW_PAGE;
3152     edit->force &= (0xfff - REDRAW_CHAR_ONLY);
3153     edit->start_col -= i;
3154 }
3155
3156 /* --------------------------------------------------------------------------------------------- */
3157
3158 void
3159 edit_scroll_left (WEdit * edit, int i)
3160 {
3161     if (edit->start_col)
3162     {
3163         edit->start_col += i;
3164         if (edit->start_col > 0)
3165             edit->start_col = 0;
3166         edit->force |= REDRAW_PAGE;
3167         edit->force &= (0xfff - REDRAW_CHAR_ONLY);
3168     }
3169 }
3170
3171 /* --------------------------------------------------------------------------------------------- */
3172 /* high level cursor movement commands */
3173 /* --------------------------------------------------------------------------------------------- */
3174
3175 void
3176 edit_move_to_prev_col (WEdit * edit, long p)
3177 {
3178     int prev = edit->prev_col;
3179     int over = edit->over_col;
3180     edit_cursor_move (edit, edit_move_forward3 (edit, p, prev + edit->over_col, 0) - edit->curs1);
3181
3182     if (option_cursor_beyond_eol)
3183     {
3184         long line_len = edit_move_forward3 (edit, edit_bol (edit, edit->curs1), 0,
3185                                             edit_eol (edit, edit->curs1));
3186
3187         if (line_len < prev + edit->over_col)
3188         {
3189             edit->over_col = prev + over - line_len;
3190             edit->prev_col = line_len;
3191             edit->curs_col = line_len;
3192         }
3193         else
3194         {
3195             edit->curs_col = prev + over;
3196             edit->prev_col = edit->curs_col;
3197             edit->over_col = 0;
3198         }
3199     }
3200     else
3201     {
3202         edit->over_col = 0;
3203         if (is_in_indent (edit) && option_fake_half_tabs)
3204         {
3205             edit_update_curs_col (edit);
3206             if (space_width)
3207                 if (edit->curs_col % (HALF_TAB_SIZE * space_width))
3208                 {
3209                     int q = edit->curs_col;
3210                     edit->curs_col -= (edit->curs_col % (HALF_TAB_SIZE * space_width));
3211                     p = edit_bol (edit, edit->curs1);
3212                     edit_cursor_move (edit,
3213                                       edit_move_forward3 (edit, p, edit->curs_col,
3214                                                           0) - edit->curs1);
3215                     if (!left_of_four_spaces (edit))
3216                         edit_cursor_move (edit, edit_move_forward3 (edit, p, q, 0) - edit->curs1);
3217                 }
3218         }
3219     }
3220 }
3221
3222 /* --------------------------------------------------------------------------------------------- */
3223
3224 int
3225 line_is_blank (WEdit * edit, long line)
3226 {
3227     return is_blank (edit, edit_find_line (edit, line));
3228 }
3229
3230 /* --------------------------------------------------------------------------------------------- */
3231 /** move cursor to line 'line' */
3232
3233 void
3234 edit_move_to_line (WEdit * e, long line)
3235 {
3236     if (line < e->curs_line)
3237         edit_move_up (e, e->curs_line - line, 0);
3238     else
3239         edit_move_down (e, line - e->curs_line, 0);
3240     edit_scroll_screen_over_cursor (e);
3241 }
3242
3243 /* --------------------------------------------------------------------------------------------- */
3244 /** scroll window so that first visible line is 'line' */
3245
3246 void
3247 edit_move_display (WEdit * e, long line)
3248 {
3249     if (line < e->start_line)
3250         edit_scroll_upward (e, e->start_line - line);
3251     else
3252         edit_scroll_downward (e, line - e->start_line);
3253 }
3254
3255 /* --------------------------------------------------------------------------------------------- */
3256 /** save markers onto undo stack */
3257
3258 void
3259 edit_push_markers (WEdit * edit)
3260 {
3261     edit_push_undo_action (edit, MARK_1 + edit->mark1);
3262     edit_push_undo_action (edit, MARK_2 + edit->mark2);
3263     edit_push_undo_action (edit, MARK_CURS + edit->end_mark_curs);
3264 }
3265
3266 /* --------------------------------------------------------------------------------------------- */
3267
3268 void
3269 edit_set_markers (WEdit * edit, long m1, long m2, int c1, int c2)
3270 {
3271     edit->mark1 = m1;
3272     edit->mark2 = m2;
3273     edit->column1 = c1;
3274     edit->column2 = c2;
3275 }
3276
3277
3278 /* --------------------------------------------------------------------------------------------- */
3279 /** highlight marker toggle */
3280
3281 void
3282 edit_mark_cmd (WEdit * edit, int unmark)
3283 {
3284     edit_push_markers (edit);
3285     if (unmark)
3286     {
3287         edit_set_markers (edit, 0, 0, 0, 0);
3288         edit->force |= REDRAW_PAGE;
3289     }
3290     else
3291     {
3292         if (edit->mark2 >= 0)
3293         {
3294             edit->end_mark_curs = -1;
3295             edit_set_markers (edit, edit->curs1, -1, edit->curs_col + edit->over_col,
3296                               edit->curs_col + edit->over_col);
3297             edit->force |= REDRAW_PAGE;
3298         }
3299         else
3300         {
3301             edit->end_mark_curs = edit->curs1;
3302             edit_set_markers (edit, edit->mark1, edit->curs1, edit->column1,
3303                               edit->curs_col + edit->over_col);
3304         }
3305     }
3306 }
3307
3308 /* --------------------------------------------------------------------------------------------- */
3309 /** highlight the word under cursor */
3310
3311 void
3312 edit_mark_current_word_cmd (WEdit * edit)
3313 {
3314     long pos;
3315
3316     for (pos = edit->curs1; pos != 0; pos--)
3317     {
3318         int c1, c2;
3319
3320         c1 = edit_get_byte (edit, pos);
3321         c2 = edit_get_byte (edit, pos - 1);
3322         if (!isspace (c1) && isspace (c2))
3323             break;
3324         if ((my_type_of (c1) & my_type_of (c2)) == 0)
3325             break;
3326     }
3327     edit->mark1 = pos;
3328
3329     for (; pos < edit->last_byte; pos++)
3330     {
3331         int c1, c2;
3332
3333         c1 = edit_get_byte (edit, pos);
3334         c2 = edit_get_byte (edit, pos + 1);
3335         if (!isspace (c1) && isspace (c2))
3336             break;
3337         if ((my_type_of (c1) & my_type_of (c2)) == 0)
3338             break;
3339     }
3340     edit->mark2 = min (pos + 1, edit->last_byte);
3341
3342     edit->force |= REDRAW_LINE_ABOVE | REDRAW_AFTER_CURSOR;
3343 }
3344
3345 /* --------------------------------------------------------------------------------------------- */
3346
3347 void
3348 edit_mark_current_line_cmd (WEdit * edit)
3349 {
3350     long pos = edit->curs1;
3351
3352     edit->mark1 = edit_bol (edit, pos);
3353     edit->mark2 = edit_eol (edit, pos);
3354
3355     edit->force |= REDRAW_LINE_ABOVE | REDRAW_AFTER_CURSOR;
3356 }
3357
3358 /* --------------------------------------------------------------------------------------------- */
3359
3360 void
3361 edit_delete_line (WEdit * edit)
3362 {
3363     /*
3364      * Delete right part of the line.
3365      * Note that edit_get_byte() returns '\n' when byte position is
3366      *   beyond EOF.
3367      */
3368     while (edit_get_byte (edit, edit->curs1) != '\n')
3369     {
3370         (void) edit_delete (edit, 1);
3371     }
3372
3373     /*
3374      * Delete '\n' char.
3375      * Note that edit_delete() will not corrupt anything if called while
3376      *   cursor position is EOF.
3377      */
3378     (void) edit_delete (edit, 1);
3379
3380     /*
3381      * Delete left part of the line.
3382      * Note, that edit_get_byte() returns '\n' when byte position is < 0.
3383      */
3384     while (edit_get_byte (edit, edit->curs1 - 1) != '\n')
3385     {
3386         (void) edit_backspace (edit, 1);
3387     }
3388 }
3389
3390 /* --------------------------------------------------------------------------------------------- */
3391
3392 int
3393 edit_indent_width (WEdit * edit, long p)
3394 {
3395     long q = p;
3396     while (strchr ("\t ", edit_get_byte (edit, q)) && q < edit->last_byte - 1)  /* move to the end of the leading whitespace of the line */
3397         q++;
3398     return edit_move_forward3 (edit, p, 0, q);  /* count the number of columns of indentation */
3399 }
3400
3401 /* --------------------------------------------------------------------------------------------- */
3402
3403 void
3404 edit_insert_indent (WEdit * edit, int indent)
3405 {
3406     if (!option_fill_tabs_with_spaces)
3407     {
3408         while (indent >= TAB_SIZE)
3409         {
3410             edit_insert (edit, '\t');
3411             indent -= TAB_SIZE;
3412         }
3413     }
3414     while (indent-- > 0)
3415         edit_insert (edit, ' ');
3416 }
3417
3418 /* --------------------------------------------------------------------------------------------- */
3419
3420 void
3421 edit_push_key_press (WEdit * edit)
3422 {
3423     edit_push_undo_action (edit, KEY_PRESS + edit->start_display);
3424     if (edit->mark2 == -1)
3425     {
3426         edit_push_undo_action (edit, MARK_1 + edit->mark1);
3427         edit_push_undo_action (edit, MARK_CURS + edit->end_mark_curs);
3428     }
3429 }
3430
3431 /* --------------------------------------------------------------------------------------------- */
3432
3433 void
3434 edit_find_bracket (WEdit * edit)
3435 {
3436     edit->bracket = edit_get_bracket (edit, 1, 10000);
3437     if (last_bracket != edit->bracket)
3438         edit->force |= REDRAW_PAGE;
3439     last_bracket = edit->bracket;
3440 }
3441
3442 /* --------------------------------------------------------------------------------------------- */
3443 /**
3444  * This executes a command as though the user initiated it through a key
3445  * press.  Callback with WIDGET_KEY as a message calls this after
3446  * translating the key press.  This function can be used to pass any
3447  * command to the editor.  Note that the screen wouldn't update
3448  * automatically.  Either of command or char_for_insertion must be
3449  * passed as -1.  Commands are executed, and char_for_insertion is
3450  * inserted at the cursor.
3451  */
3452
3453 void
3454 edit_execute_key_command (WEdit * edit, unsigned long command, int char_for_insertion)
3455 {
3456     if (command == CK_MacroStartRecord || command == CK_RepeatStartRecord
3457         || (macro_index < 0
3458             && (command == CK_MacroStartStopRecord || command == CK_RepeatStartStopRecord)))
3459     {
3460         macro_index = 0;
3461         edit->force |= REDRAW_CHAR_ONLY | REDRAW_LINE;
3462         return;
3463     }
3464     if (macro_index != -1)
3465     {
3466         edit->force |= REDRAW_COMPLETELY;
3467         if (command == CK_MacroStopRecord || command == CK_MacroStartStopRecord)
3468         {
3469             edit_store_macro_cmd (edit);
3470             macro_index = -1;
3471             return;
3472         }
3473         else if (command == CK_RepeatStopRecord || command == CK_RepeatStartStopRecord)
3474         {
3475             edit_repeat_macro_cmd (edit);
3476             macro_index = -1;
3477             return;
3478         }
3479     }
3480
3481     if (macro_index >= 0 && macro_index < MAX_MACRO_LENGTH - 1)
3482     {
3483         record_macro_buf[macro_index].action = command;
3484         record_macro_buf[macro_index++].ch = char_for_insertion;
3485     }
3486     /* record the beginning of a set of editing actions initiated by a key press */
3487     if (command != CK_Undo && command != CK_ExtendedKeyMap)
3488         edit_push_key_press (edit);
3489
3490     edit_execute_cmd (edit, command, char_for_insertion);
3491     if (edit->column_highlight)
3492         edit->force |= REDRAW_PAGE;
3493 }
3494
3495 /* --------------------------------------------------------------------------------------------- */
3496 /**
3497    This executes a command at a lower level than macro recording.
3498    It also does not push a key_press onto the undo stack. This means
3499    that if it is called many times, a single undo command will undo
3500    all of them. It also does not check for the Undo command.
3501  */
3502 void
3503 edit_execute_cmd (WEdit * edit, unsigned long command, int char_for_insertion)
3504 {
3505     if (command == CK_WindowFullscreen)
3506     {
3507         edit_toggle_fullscreen (edit);
3508         return;
3509     }
3510
3511     /* handle window state */
3512     if (edit_handle_move_resize (edit, command))
3513         return;
3514
3515     edit->force |= REDRAW_LINE;
3516
3517     /* The next key press will unhighlight the found string, so update
3518      * the whole page */
3519     if (edit->found_len || edit->column_highlight)
3520         edit->force |= REDRAW_PAGE;
3521
3522     switch (command)
3523     {
3524         /* a mark command with shift-arrow */
3525     case CK_MarkLeft:
3526     case CK_MarkRight:
3527     case CK_MarkToWordBegin:
3528     case CK_MarkToWordEnd:
3529     case CK_MarkToHome:
3530     case CK_MarkToEnd:
3531     case CK_MarkUp:
3532     case CK_MarkDown:
3533     case CK_MarkPageUp:
3534     case CK_MarkPageDown:
3535     case CK_MarkToFileBegin:
3536     case CK_MarkToFileEnd:
3537     case CK_MarkToPageBegin:
3538     case CK_MarkToPageEnd:
3539     case CK_MarkScrollUp:
3540     case CK_MarkScrollDown:
3541     case CK_MarkParagraphUp:
3542     case CK_MarkParagraphDown:
3543         /* a mark command with alt-arrow */
3544     case CK_MarkColumnPageUp:
3545     case CK_MarkColumnPageDown:
3546     case CK_MarkColumnLeft:
3547     case CK_MarkColumnRight:
3548     case CK_MarkColumnUp:
3549     case CK_MarkColumnDown:
3550     case CK_MarkColumnScrollUp:
3551     case CK_MarkColumnScrollDown:
3552     case CK_MarkColumnParagraphUp:
3553     case CK_MarkColumnParagraphDown:
3554         edit->column_highlight = 0;
3555         if (edit->highlight == 0 || (edit->mark2 != -1 && edit->mark1 != edit->mark2))
3556         {
3557             edit_mark_cmd (edit, 1);    /* clear */
3558             edit_mark_cmd (edit, 0);    /* marking on */
3559         }
3560         edit->highlight = 1;
3561         break;
3562
3563         /* any other command */
3564     default:
3565         if (edit->highlight)
3566             edit_mark_cmd (edit, 0);    /* clear */
3567         edit->highlight = 0;
3568     }
3569
3570     /* first check for undo */
3571     if (command == CK_Undo)
3572     {
3573         edit->redo_stack_reset = 0;
3574         edit_group_undo (edit);
3575         edit->found_len = 0;
3576         edit->prev_col = edit_get_col (edit);
3577         edit->search_start = edit->curs1;
3578         return;
3579     }
3580     /*  check for redo */
3581     if (command == CK_Redo)
3582     {
3583         edit->redo_stack_reset = 0;
3584         edit_do_redo (edit);
3585         edit->found_len = 0;
3586         edit->prev_col = edit_get_col (edit);
3587         edit->search_start = edit->curs1;
3588         return;
3589     }
3590
3591     edit->redo_stack_reset = 1;
3592
3593     /* An ordinary key press */
3594     if (char_for_insertion >= 0)
3595     {
3596         /* if non persistent selection and text selected */
3597         if (!option_persistent_selections)
3598         {
3599             if (edit->mark1 != edit->mark2)
3600                 edit_block_delete_cmd (edit);
3601         }
3602         if (edit->overwrite)
3603         {
3604             /* remove char only one time, after input first byte, multibyte chars */
3605             if ((!mc_global.utf8_display || edit->charpoint == 0)
3606                 && edit_get_byte (edit, edit->curs1) != '\n')
3607                 edit_delete (edit, 0);
3608         }
3609         if (option_cursor_beyond_eol && edit->over_col > 0)
3610             edit_insert_over (edit);
3611 #ifdef HAVE_CHARSET
3612         if (char_for_insertion > 255 && !mc_global.utf8_display)
3613         {
3614             unsigned char str[6 + 1];
3615             size_t i = 0;
3616             int res;
3617
3618             res = g_unichar_to_utf8 (char_for_insertion, (char *) str);
3619             if (res == 0)
3620             {
3621                 str[0] = '.';
3622                 str[1] = '\0';
3623             }
3624             else
3625             {
3626                 str[res] = '\0';
3627             }
3628             while (str[i] != 0 && i <= 6)
3629             {
3630                 char_for_insertion = str[i];
3631                 edit_insert (edit, char_for_insertion);
3632                 i++;
3633             }
3634         }
3635         else
3636 #endif
3637             edit_insert (edit, char_for_insertion);
3638
3639         if (option_auto_para_formatting)
3640         {
3641             format_paragraph (edit, 0);
3642             edit->force |= REDRAW_PAGE;
3643         }
3644         else
3645             check_and_wrap_line (edit);
3646         edit->found_len = 0;
3647         edit->prev_col = edit_get_col (edit);
3648         edit->search_start = edit->curs1;
3649         edit_find_bracket (edit);
3650         return;
3651     }
3652
3653     switch (command)
3654     {
3655     case CK_TopOnScreen:
3656     case CK_BottomOnScreen:
3657     case CK_Top:
3658     case CK_Bottom:
3659     case CK_PageUp:
3660     case CK_PageDown:
3661     case CK_Home:
3662     case CK_End:
3663     case CK_Up:
3664     case CK_Down:
3665     case CK_Left:
3666     case CK_Right:
3667     case CK_WordLeft:
3668     case CK_WordRight:
3669         if (edit->mark2 >= 0)
3670         {
3671             if (!option_persistent_selections)
3672             {
3673                 if (edit->column_highlight)
3674                     edit_push_undo_action (edit, COLUMN_ON);
3675                 edit->column_highlight = 0;
3676                 edit_mark_cmd (edit, 1);
3677             }
3678         }
3679     }
3680
3681     switch (command)
3682     {
3683     case CK_TopOnScreen:
3684     case CK_BottomOnScreen:
3685     case CK_MarkToPageBegin:
3686     case CK_MarkToPageEnd:
3687     case CK_Up:
3688     case CK_Down:
3689     case CK_WordLeft:
3690     case CK_WordRight:
3691     case CK_MarkToWordBegin:
3692     case CK_MarkToWordEnd:
3693     case CK_MarkUp:
3694     case CK_MarkDown:
3695     case CK_MarkColumnUp:
3696     case CK_MarkColumnDown:
3697         if (edit->mark2 == -1)
3698             break;              /*marking is following the cursor: may need to highlight a whole line */
3699     case CK_Left:
3700     case CK_Right:
3701     case CK_MarkLeft:
3702     case CK_MarkRight:
3703         edit->force |= REDRAW_CHAR_ONLY;
3704     }
3705
3706     /* basic cursor key commands */
3707     switch (command)
3708     {
3709     case CK_BackSpace:
3710         /* if non persistent selection and text selected */
3711         if (!option_persistent_selections)
3712         {
3713             if (edit->mark1 != edit->mark2)
3714             {
3715                 edit_block_delete_cmd (edit);
3716                 break;
3717             }
3718         }
3719         if (option_cursor_beyond_eol && edit->over_col > 0)
3720         {
3721             edit->over_col--;
3722             break;
3723         }
3724         if (option_backspace_through_tabs && is_in_indent (edit))
3725         {
3726             while (edit_get_byte (edit, edit->curs1 - 1) != '\n' && edit->curs1 > 0)
3727                 edit_backspace (edit, 1);
3728             break;
3729         }
3730         else
3731         {
3732             if (option_fake_half_tabs)
3733             {
3734                 int i;
3735                 if (is_in_indent (edit) && right_of_four_spaces (edit))
3736                 {
3737                     for (i = 0; i < HALF_TAB_SIZE; i++)
3738                         edit_backspace (edit, 1);
3739                     break;
3740                 }
3741             }
3742         }
3743         edit_backspace (edit, 0);
3744         break;
3745     case CK_Delete:
3746         /* if non persistent selection and text selected */
3747         if (!option_persistent_selections)
3748         {
3749             if (edit->mark1 != edit->mark2)
3750             {
3751                 edit_block_delete_cmd (edit);
3752                 break;
3753             }
3754         }
3755
3756         if (option_cursor_beyond_eol && edit->over_col > 0)
3757             edit_insert_over (edit);
3758
3759         if (option_fake_half_tabs)
3760         {
3761             int i;
3762             if (is_in_indent (edit) && left_of_four_spaces (edit))
3763             {
3764                 for (i = 1; i <= HALF_TAB_SIZE; i++)
3765                     edit_delete (edit, 1);
3766                 break;
3767             }
3768         }
3769         edit_delete (edit, 0);
3770         break;
3771     case CK_DeleteToWordBegin:
3772         edit->over_col = 0;
3773         edit_left_delete_word (edit);
3774         break;
3775     case CK_DeleteToWordEnd:
3776         if (option_cursor_beyond_eol && edit->over_col > 0)
3777             edit_insert_over (edit);
3778
3779         edit_right_delete_word (edit);
3780         break;
3781     case CK_DeleteLine:
3782         edit_delete_line (edit);
3783         break;
3784     case CK_DeleteToHome:
3785         edit_delete_to_line_begin (edit);
3786         break;
3787     case CK_DeleteToEnd:
3788         edit_delete_to_line_end (edit);
3789         break;
3790     case CK_Enter:
3791         edit->over_col = 0;
3792         if (option_auto_para_formatting)
3793         {
3794             edit_double_newline (edit);
3795             if (option_return_does_auto_indent)
3796                 edit_auto_indent (edit);
3797             format_paragraph (edit, 0);
3798         }
3799         else
3800         {
3801             edit_insert (edit, '\n');
3802             if (option_return_does_auto_indent)
3803             {
3804                 edit_auto_indent (edit);
3805             }
3806         }
3807         break;
3808     case CK_Return:
3809         edit_insert (edit, '\n');
3810         break;
3811
3812     case CK_MarkColumnPageUp:
3813         edit->column_highlight = 1;
3814     case CK_PageUp:
3815     case CK_MarkPageUp:
3816         edit_move_up (edit, edit->widget.lines - 1, 1);
3817         break;
3818     case CK_MarkColumnPageDown:
3819         edit->column_highlight = 1;
3820     case CK_PageDown:
3821     case CK_MarkPageDown:
3822         edit_move_down (edit, edit->widget.lines - 1, 1);
3823         break;
3824     case CK_MarkColumnLeft:
3825         edit->column_highlight = 1;
3826     case CK_Left:
3827     case CK_MarkLeft:
3828         if (option_fake_half_tabs)
3829         {
3830             if (is_in_indent (edit) && right_of_four_spaces (edit))
3831             {
3832                 if (option_cursor_beyond_eol && edit->over_col > 0)
3833                     edit->over_col--;
3834                 else
3835                     edit_cursor_move (edit, -HALF_TAB_SIZE);
3836                 edit->force &= (0xFFF - REDRAW_CHAR_ONLY);
3837                 break;
3838             }
3839         }
3840         edit_left_char_move_cmd (edit);
3841         break;
3842     case CK_MarkColumnRight:
3843         edit->column_highlight = 1;
3844     case CK_Right:
3845     case CK_MarkRight:
3846         if (option_fake_half_tabs)
3847         {
3848             if (is_in_indent (edit) && left_of_four_spaces (edit))
3849             {
3850                 edit_cursor_move (edit, HALF_TAB_SIZE);
3851                 edit->force &= (0xFFF - REDRAW_CHAR_ONLY);
3852                 break;
3853             }
3854         }
3855         edit_right_char_move_cmd (edit);
3856         break;
3857     case CK_TopOnScreen:
3858     case CK_MarkToPageBegin:
3859         edit_begin_page (edit);
3860         break;
3861     case CK_BottomOnScreen:
3862     case CK_MarkToPageEnd:
3863         edit_end_page (edit);
3864         break;
3865     case CK_WordLeft:
3866     case CK_MarkToWordBegin:
3867         edit->over_col = 0;
3868         edit_left_word_move_cmd (edit);
3869         break;
3870     case CK_WordRight:
3871     case CK_MarkToWordEnd:
3872         edit->over_col = 0;
3873         edit_right_word_move_cmd (edit);
3874         break;
3875     case CK_MarkColumnUp:
3876         edit->column_highlight = 1;
3877     case CK_Up:
3878     case CK_MarkUp:
3879         edit_move_up (edit, 1, 0);
3880         break;
3881     case CK_MarkColumnDown:
3882         edit->column_highlight = 1;
3883     case CK_Down:
3884     case CK_MarkDown:
3885         edit_move_down (edit, 1, 0);
3886         break;
3887     case CK_MarkColumnParagraphUp:
3888         edit->column_highlight = 1;
3889     case CK_ParagraphUp:
3890     case CK_MarkParagraphUp:
3891         edit_move_up_paragraph (edit, 0);
3892         break;
3893     case CK_MarkColumnParagraphDown:
3894         edit->column_highlight = 1;
3895     case CK_ParagraphDown:
3896     case CK_MarkParagraphDown:
3897         edit_move_down_paragraph (edit, 0);
3898         break;
3899     case CK_MarkColumnScrollUp:
3900         edit->column_highlight = 1;
3901     case CK_ScrollUp:
3902     case CK_MarkScrollUp:
3903         edit_move_up (edit, 1, 1);
3904         break;
3905     case CK_MarkColumnScrollDown:
3906         edit->column_highlight = 1;
3907     case CK_ScrollDown:
3908     case CK_MarkScrollDown:
3909         edit_move_down (edit, 1, 1);
3910         break;
3911     case CK_Home:
3912     case CK_MarkToHome:
3913         edit_cursor_to_bol (edit);
3914         break;
3915     case CK_End:
3916     case CK_MarkToEnd:
3917         edit_cursor_to_eol (edit);
3918         break;
3919     case CK_Tab:
3920         /* if text marked shift block */
3921         if (edit->mark1 != edit->mark2 && !option_persistent_selections)
3922         {
3923             if (edit->mark2 < 0)
3924                 edit_mark_cmd (edit, 0);
3925             edit_move_block_to_right (edit);
3926         }
3927         else
3928         {
3929             if (option_cursor_beyond_eol)
3930                 edit_insert_over (edit);
3931             edit_tab_cmd (edit);
3932             if (option_auto_para_formatting)
3933             {
3934                 format_paragraph (edit, 0);
3935                 edit->force |= REDRAW_PAGE;
3936             }
3937             else
3938             {
3939                 check_and_wrap_line (edit);
3940             }
3941         }
3942         break;
3943
3944     case CK_InsertOverwrite:
3945         edit->overwrite = !edit->overwrite;
3946         break;
3947
3948     case CK_Mark:
3949         if (edit->mark2 >= 0)
3950         {
3951             if (edit->column_highlight)
3952                 edit_push_undo_action (edit, COLUMN_ON);
3953             edit->column_highlight = 0;
3954         }
3955         edit_mark_cmd (edit, 0);
3956         break;
3957     case CK_MarkColumn:
3958         if (!edit->column_highlight)
3959             edit_push_undo_action (edit, COLUMN_OFF);
3960         edit->column_highlight = 1;
3961         edit_mark_cmd (edit, 0);
3962         break;
3963     case CK_MarkAll:
3964         edit_set_markers (edit, 0, edit->last_byte, 0, 0);
3965         edit->force |= REDRAW_PAGE;
3966         break;
3967     case CK_Unmark:
3968         if (edit->column_highlight)
3969             edit_push_undo_action (edit, COLUMN_ON);
3970         edit->column_highlight = 0;
3971         edit_mark_cmd (edit, 1);
3972         break;
3973     case CK_MarkWord:
3974         if (edit->column_highlight)
3975             edit_push_undo_action (edit, COLUMN_ON);
3976         edit->column_highlight = 0;
3977         edit_mark_current_word_cmd (edit);
3978         break;
3979     case CK_MarkLine:
3980         if (edit->column_highlight)
3981             edit_push_undo_action (edit, COLUMN_ON);
3982         edit->column_highlight = 0;
3983         edit_mark_current_line_cmd (edit);
3984         break;
3985
3986     case CK_Bookmark:
3987         book_mark_clear (edit, edit->curs_line, BOOK_MARK_FOUND_COLOR);
3988         if (book_mark_query_color (edit, edit->curs_line, BOOK_MARK_COLOR))
3989             book_mark_clear (edit, edit->curs_line, BOOK_MARK_COLOR);
3990         else
3991             book_mark_insert (edit, edit->curs_line, BOOK_MARK_COLOR);
3992         break;
3993     case CK_BookmarkFlush:
3994         book_mark_flush (edit, BOOK_MARK_COLOR);
3995         book_mark_flush (edit, BOOK_MARK_FOUND_COLOR);
3996         edit->force |= REDRAW_PAGE;
3997         break;
3998     case CK_BookmarkNext:
3999         if (edit->book_mark)
4000         {
4001             struct _book_mark *p;
4002             p = (struct _book_mark *) book_mark_find (edit, edit->curs_line);
4003             if (p->next)
4004             {
4005                 p = p->next;
4006                 if (p->line >= edit->start_line + edit->widget.lines || p->line < edit->start_line)
4007                     edit_move_display (edit, p->line - edit->widget.lines / 2);
4008                 edit_move_to_line (edit, p->line);
4009             }
4010         }
4011         break;
4012     case CK_BookmarkPrev:
4013         if (edit->book_mark)
4014         {
4015             struct _book_mark *p;
4016             p = (struct _book_mark *) book_mark_find (edit, edit->curs_line);
4017             while (p->line == edit->curs_line)
4018                 if (p->prev)
4019                     p = p->prev;
4020             if (p->line >= 0)
4021             {
4022                 if (p->line >= edit->start_line + edit->widget.lines || p->line < edit->start_line)
4023                     edit_move_display (edit, p->line - edit->widget.lines / 2);
4024                 edit_move_to_line (edit, p->line);
4025             }
4026         }
4027         break;
4028
4029     case CK_Top:
4030     case CK_MarkToFileBegin:
4031         edit_move_to_top (edit);
4032         break;
4033     case CK_Bottom:
4034     case CK_MarkToFileEnd:
4035         edit_move_to_bottom (edit);
4036         break;
4037
4038     case CK_Copy:
4039         if (option_cursor_beyond_eol && edit->over_col > 0)
4040             edit_insert_over (edit);
4041         edit_block_copy_cmd (edit);
4042         break;
4043     case CK_Remove:
4044         edit_block_delete_cmd (edit);
4045         break;
4046     case CK_Move:
4047         edit_block_move_cmd (edit);
4048         break;
4049
4050     case CK_BlockShiftLeft:
4051         if (edit->mark1 != edit->mark2)
4052             edit_move_block_to_left (edit);
4053         break;
4054     case CK_BlockShiftRight:
4055         if (edit->mark1 != edit->mark2)
4056             edit_move_block_to_right (edit);
4057         break;
4058     case CK_Store:
4059         edit_copy_to_X_buf_cmd (edit);
4060         break;
4061     case CK_Cut:
4062         edit_cut_to_X_buf_cmd (edit);
4063         break;
4064     case CK_Paste:
4065         /* if non persistent selection and text selected */
4066         if (!option_persistent_selections)
4067         {
4068             if (edit->mark1 != edit->mark2)
4069                 edit_block_delete_cmd (edit);
4070         }
4071         if (option_cursor_beyond_eol && edit->over_col > 0)
4072             edit_insert_over (edit);
4073         edit_paste_from_X_buf_cmd (edit);
4074         break;
4075     case CK_History:
4076         edit_paste_from_history (edit);
4077         break;
4078
4079     case CK_SaveAs:
4080         edit_save_as_cmd (edit);
4081         break;
4082     case CK_Save:
4083         edit_save_confirm_cmd (edit);
4084         break;
4085     case CK_BlockSave:
4086         edit_save_block_cmd (edit);
4087         break;
4088     case CK_InsertFile:
4089         edit_insert_file_cmd (edit);
4090         break;
4091
4092     case CK_FilePrev:
4093         edit_load_back_cmd (edit);
4094         break;
4095     case CK_FileNext:
4096         edit_load_forward_cmd (edit);
4097         break;
4098
4099     case CK_SyntaxChoose:
4100         edit_syntax_dialog (edit);
4101         break;
4102
4103     case CK_Search:
4104         edit_search_cmd (edit, FALSE);
4105         break;
4106     case CK_SearchContinue:
4107         edit_search_cmd (edit, TRUE);
4108         break;
4109     case CK_Replace:
4110         edit_replace_cmd (edit, 0);
4111         break;
4112     case CK_ReplaceContinue:
4113         edit_replace_cmd (edit, 1);
4114         break;
4115     case CK_Complete:
4116         /* if text marked shift block */
4117         if (edit->mark1 != edit->mark2 && !option_persistent_selections)
4118         {
4119             edit_move_block_to_left (edit);
4120         }
4121         else
4122         {
4123             edit_complete_word_cmd (edit);
4124         }
4125         break;
4126     case CK_Find:
4127         edit_get_match_keyword_cmd (edit);
4128         break;
4129 #ifdef HAVE_ASPELL
4130     case CK_SpellCheckCurrentWord:
4131         edit_suggest_current_word (edit);
4132         break;
4133     case CK_SpellCheck:
4134         edit_spellcheck_file (edit);
4135         break;
4136     case CK_SpellCheckSelectLang:
4137         edit_set_spell_lang ();
4138         break;
4139 #endif
4140     case CK_Date:
4141         {
4142             char s[BUF_MEDIUM];
4143             /* fool gcc to prevent a Y2K warning */
4144             char time_format[] = "_c";
4145             time_format[0] = '%';
4146
4147             FMT_LOCALTIME_CURRENT (s, sizeof (s), time_format);
4148             edit_print_string (edit, s);
4149             edit->force |= REDRAW_PAGE;
4150             break;
4151         }
4152         break;
4153     case CK_Goto:
4154         edit_goto_cmd (edit);
4155         break;
4156     case CK_ParagraphFormat:
4157         format_paragraph (edit, 1);
4158         edit->force |= REDRAW_PAGE;
4159         break;
4160     case CK_MacroDelete:
4161         edit_delete_macro_cmd (edit);
4162         break;
4163     case CK_MatchBracket:
4164         edit_goto_matching_bracket (edit);
4165         break;
4166     case CK_UserMenu:
4167         user_menu (edit, NULL, -1);
4168         break;
4169     case CK_Sort:
4170         edit_sort_cmd (edit);
4171         break;
4172     case CK_ExternalCommand:
4173         edit_ext_cmd (edit);
4174         break;
4175     case CK_Mail:
4176         edit_mail_dialog (edit);
4177         break;
4178 #ifdef HAVE_CHARSET
4179     case CK_SelectCodepage:
4180         edit_select_codepage_cmd (edit);
4181         break;
4182 #endif
4183     case CK_InsertLiteral:
4184         edit_insert_literal_cmd (edit);
4185         break;
4186     case CK_MacroStartStopRecord:
4187         edit_begin_end_macro_cmd (edit);
4188         break;
4189     case CK_RepeatStartStopRecord:
4190         edit_begin_end_repeat_cmd (edit);
4191         break;
4192     case CK_ExtendedKeyMap:
4193         edit->extmod = TRUE;
4194         break;
4195     default:
4196         break;
4197     }
4198
4199     /* CK_PipeBlock */
4200     if ((command / CK_PipeBlock (0)) == 1)
4201         edit_block_process_cmd (edit, command - CK_PipeBlock (0));
4202
4203     /* keys which must set the col position, and the search vars */
4204     switch (command)
4205     {
4206     case CK_Search:
4207     case CK_SearchContinue:
4208     case CK_Replace:
4209     case CK_ReplaceContinue:
4210     case CK_Complete:
4211         edit->prev_col = edit_get_col (edit);
4212         break;
4213     case CK_Up:
4214     case CK_MarkUp:
4215     case CK_MarkColumnUp:
4216     case CK_Down:
4217     case CK_MarkDown:
4218     case CK_MarkColumnDown:
4219     case CK_PageUp:
4220     case CK_MarkPageUp:
4221     case CK_MarkColumnPageUp:
4222     case CK_PageDown:
4223     case CK_MarkPageDown:
4224     case CK_MarkColumnPageDown:
4225     case CK_Top:
4226     case CK_MarkToFileBegin:
4227     case CK_Bottom:
4228     case CK_MarkToFileEnd:
4229     case CK_ParagraphUp:
4230     case CK_MarkParagraphUp:
4231     case CK_MarkColumnParagraphUp:
4232     case CK_ParagraphDown:
4233     case CK_MarkParagraphDown:
4234     case CK_MarkColumnParagraphDown:
4235     case CK_ScrollUp:
4236     case CK_MarkScrollUp:
4237     case CK_MarkColumnScrollUp:
4238     case CK_ScrollDown:
4239     case CK_MarkScrollDown:
4240     case CK_MarkColumnScrollDown:
4241         edit->search_start = edit->curs1;
4242         edit->found_len = 0;
4243         break;
4244     default:
4245         edit->found_len = 0;
4246         edit->prev_col = edit_get_col (edit);
4247         edit->search_start = edit->curs1;
4248     }
4249     edit_find_bracket (edit);
4250
4251     if (option_auto_para_formatting)
4252     {
4253         switch (command)
4254         {
4255         case CK_BackSpace:
4256         case CK_Delete:
4257         case CK_DeleteToWordBegin:
4258         case CK_DeleteToWordEnd:
4259         case CK_DeleteToHome:
4260         case CK_DeleteToEnd:
4261             format_paragraph (edit, 0);
4262             edit->force |= REDRAW_PAGE;
4263         }
4264     }
4265 }
4266
4267 /* --------------------------------------------------------------------------------------------- */
4268
4269 void
4270 edit_stack_init (void)
4271 {
4272     for (edit_stack_iterator = 0; edit_stack_iterator < MAX_HISTORY_MOVETO; edit_stack_iterator++)
4273     {
4274         edit_history_moveto[edit_stack_iterator].filename_vpath = NULL;
4275         edit_history_moveto[edit_stack_iterator].line = -1;
4276     }
4277
4278     edit_stack_iterator = 0;
4279 }
4280
4281 /* --------------------------------------------------------------------------------------------- */
4282
4283 void
4284 edit_stack_free (void)
4285 {
4286     for (edit_stack_iterator = 0; edit_stack_iterator < MAX_HISTORY_MOVETO; edit_stack_iterator++)
4287         vfs_path_free (edit_history_moveto[edit_stack_iterator].filename_vpath);
4288 }
4289
4290 /* --------------------------------------------------------------------------------------------- */
4291 /** move i lines */
4292
4293 void
4294 edit_move_up (WEdit * edit, unsigned long i, int do_scroll)
4295 {
4296     edit_move_updown (edit, i, do_scroll, TRUE);
4297 }
4298
4299 /* --------------------------------------------------------------------------------------------- */
4300 /** move i lines */
4301
4302 void
4303 edit_move_down (WEdit * edit, unsigned long i, int do_scroll)
4304 {
4305     edit_move_updown (edit, i, do_scroll, FALSE);
4306 }
4307
4308 /* --------------------------------------------------------------------------------------------- */