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