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