src/editor/editcmd.c

   1 /* editor high level editing commands
   2
   3    Copyright (C) 1996, 1997, 1998, 2001, 2002, 2003, 2004, 2005, 2006,
   4    2007 Free Software Foundation, Inc.
   5
   6    Authors: 1996, 1997 Paul Sheer
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23  */
  24
  25 /** \file
  26  *  \brief Source: editor high level editing commands
  27  *  \author Paul Sheer
  28  *  \date 1996, 1997
  29  */
  30
  31 /* #define PIPE_BLOCKS_SO_READ_BYTE_BY_BYTE */
  32
  33 #include <config.h>
  34
  35 #include <assert.h>
  36 #include <ctype.h>
  37
  38 #include <stdio.h>
  39 #include <stdarg.h>
  40 #include <sys/types.h>
  41 #include <unistd.h>
  42 #include <string.h>
  43 #include <errno.h>
  44 #include <sys/stat.h>
  45 #include <stdlib.h>
  46 #include <fcntl.h>
  47
  48 #include "lib/global.h"
  49 #include "lib/tty/tty.h"
  50 #include "lib/tty/key.h"        /* XCTRL */
  51 #include "lib/mcconfig.h"
  52 #include "lib/skin.h"
  53 #include "lib/strutil.h"        /* utf string functions */
  54 #include "lib/lock.h"
  55 #include "lib/util.h"           /* tilde_expand() */
  56 #include "lib/vfs/mc-vfs/vfs.h"
  57 #include "lib/widget.h"
  58 #include "lib/charsets.h"
  59
  60 #include "src/filemanager/layout.h"     /* clr_scr() */
  61
  62 #include "src/history.h"
  63 #include "src/main.h"           /* mc_home, midnight_shutdown */
  64 #include "src/setup.h"          /* option_tab_spacing */
  65 #include "src/help.h"           /* interactive_display() */
  66 #include "src/selcodepage.h"
  67 #include "src/keybind-defaults.h"
  68 #include "src/clipboard.h"      /* copy_file_to_ext_clip, paste_to_file_from_ext_clip */
  69
  70 #include "edit-impl.h"
  71 #include "edit-widget.h"
  72 #include "editcmd_dialogs.h"
  73 #include "etags.h"
  74
  75 /*** global variables ****************************************************************************/
  76
  77 /* search and replace: */
  78 int search_create_bookmark = FALSE;
  79
  80 /* queries on a save */
  81 int edit_confirm_save = 1;
  82
  83 static int edit_save_cmd (WEdit * edit);
  84 static unsigned char *edit_get_block (WEdit * edit, long start, long finish, int *l);
  85
  86 /*** file scope macro definitions ****************************************************************/
  87
  88 #define space_width 1
  89
  90 #define TEMP_BUF_LEN 1024
  91
  92 #define INPUT_INDEX 9
  93
  94 /* thanks to  Liviu Daia <daia@stoilow.imar.ro>  for getting this
  95    (and the above) routines to work properly - paul */
  96
  97 #define is_digit(x) ((x) >= '0' && (x) <= '9')
  98
  99 #define MAIL_DLG_HEIGHT 12
 100
 101 #define MAX_WORD_COMPLETIONS 100        /* in listbox */
 102
 103 /*** file scope type declarations ****************************************************************/
 104
 105 /*** file scope variables ************************************************************************/
 106
 107 /*** file scope functions ************************************************************************/
 108 /* --------------------------------------------------------------------------------------------- */
 109
 110 /*  If 0 (quick save) then  a) create/truncate <filename> file,
 111    b) save to <filename>;
 112    if 1 (safe save) then   a) save to <tempnam>,
 113    b) rename <tempnam> to <filename>;
 114    if 2 (do backups) then  a) save to <tempnam>,
 115    b) rename <filename> to <filename.backup_ext>,
 116    c) rename <tempnam> to <filename>. */
 117
 118 /* returns 0 on error, -1 on abort */
 119
 120 static int
 121 edit_save_file (WEdit * edit, const char *filename)
 122 {
 123     char *p;
 124     gchar *tmp;
 125     long filelen = 0;
 126     char *savename = 0;
 127     gchar *real_filename;
 128     int this_save_mode, fd = -1;
 129
 130     if (!filename)
 131         return 0;
 132     if (!*filename)
 133         return 0;
 134
 135     if (*filename != PATH_SEP && edit->dir)
 136     {
 137         real_filename = concat_dir_and_file (edit->dir, filename);
 138     }
 139     else
 140     {
 141         real_filename = g_strdup (filename);
 142     }
 143
 144     this_save_mode = option_save_mode;
 145     if (this_save_mode != EDIT_QUICK_SAVE)
 146     {
 147         if (!vfs_file_is_local (real_filename) ||
 148             (fd = mc_open (real_filename, O_RDONLY | O_BINARY)) == -1)
 149         {
 150             /*
 151              * The file does not exists yet, so no safe save or
 152              * backup are necessary.
 153              */
 154             this_save_mode = EDIT_QUICK_SAVE;
 155         }
 156         if (fd != -1)
 157             mc_close (fd);
 158     }
 159
 160     if (this_save_mode == EDIT_QUICK_SAVE && !edit->skip_detach_prompt)
 161     {
 162         int rv;
 163         struct stat sb;
 164
 165         rv = mc_stat (real_filename, &sb);
 166         if (rv == 0 && sb.st_nlink > 1)
 167         {
 168             rv = edit_query_dialog3 (_("Warning"),
 169                                      _("File has hard-links. Detach before saving?"),
 170                                      _("&Yes"), _("&No"), _("&Cancel"));
 171             switch (rv)
 172             {
 173             case 0:
 174                 this_save_mode = EDIT_SAFE_SAVE;
 175                 /* fallthrough */
 176             case 1:
 177                 edit->skip_detach_prompt = 1;
 178                 break;
 179             default:
 180                 g_free (real_filename);
 181                 return -1;
 182             }
 183         }
 184
 185         /* Prevent overwriting changes from other editor sessions. */
 186         if (rv == 0 && edit->stat1.st_mtime != 0 && edit->stat1.st_mtime != sb.st_mtime)
 187         {
 188
 189             /* The default action is "Cancel". */
 190             query_set_sel (1);
 191
 192             rv = edit_query_dialog2 (_("Warning"),
 193                                      _("The file has been modified in the meantime. Save anyway?"),
 194                                      _("&Yes"), _("&Cancel"));
 195             if (rv != 0)
 196             {
 197                 g_free (real_filename);
 198                 return -1;
 199             }
 200         }
 201     }
 202
 203     if (this_save_mode != EDIT_QUICK_SAVE)
 204     {
 205         char *savedir, *saveprefix;
 206         const char *slashpos;
 207         slashpos = strrchr (real_filename, PATH_SEP);
 208         if (slashpos)
 209         {
 210             savedir = g_strdup (real_filename);
 211             savedir[slashpos - real_filename + 1] = '\0';
 212         }
 213         else
 214             savedir = g_strdup (".");
 215         saveprefix = concat_dir_and_file (savedir, "cooledit");
 216         g_free (savedir);
 217         fd = mc_mkstemps (&savename, saveprefix, NULL);
 218         g_free (saveprefix);
 219         if (!savename)
 220         {
 221             g_free (real_filename);
 222             return 0;
 223         }
 224         /* FIXME:
 225          * Close for now because mc_mkstemps use pure open system call
 226          * to create temporary file and it needs to be reopened by
 227          * VFS-aware mc_open().
 228          */
 229         close (fd);
 230     }
 231     else
 232         savename = g_strdup (real_filename);
 233     {
 234         int ret;
 235         ret = mc_chown (savename, edit->stat1.st_uid, edit->stat1.st_gid);
 236         ret = mc_chmod (savename, edit->stat1.st_mode);
 237     }
 238
 239     fd = mc_open (savename, O_CREAT | O_WRONLY | O_TRUNC | O_BINARY, edit->stat1.st_mode);
 240     if (fd == -1)
 241         goto error_save;
 242
 243     /* pipe save */
 244     p = edit_get_write_filter (savename, real_filename);
 245     if (p != NULL)
 246     {
 247         FILE *file;
 248
 249         mc_close (fd);
 250         file = (FILE *) popen (p, "w");
 251
 252         if (file)
 253         {
 254             filelen = edit_write_stream (edit, file);
 255 #if 1
 256             pclose (file);
 257 #else
 258             if (pclose (file) != 0)
 259             {
 260                 tmp = g_strdup_printf (_("Error writing to pipe: %s"), p);
 261                 edit_error_dialog (_("Error"), tmp);
 262                 g_free (tmp);
 263                 g_free (p);
 264                 goto error_save;
 265             }
 266 #endif
 267         }
 268         else
 269         {
 270             tmp = g_strdup_printf (_("Cannot open pipe for writing: %s"), p);
 271             edit_error_dialog (_("Error"), get_sys_error (tmp));
 272             g_free (p);
 273             g_free (tmp);
 274             goto error_save;
 275         }
 276         g_free (p);
 277     }
 278     else if (edit->lb == LB_ASIS)
 279     {                           /* do not change line breaks */
 280         long buf;
 281         buf = 0;
 282         filelen = edit->last_byte;
 283         while (buf <= (edit->curs1 >> S_EDIT_BUF_SIZE) - 1)
 284         {
 285             if (mc_write (fd, (char *) edit->buffers1[buf], EDIT_BUF_SIZE) != EDIT_BUF_SIZE)
 286             {
 287                 mc_close (fd);
 288                 goto error_save;
 289             }
 290             buf++;
 291         }
 292         if (mc_write
 293             (fd, (char *) edit->buffers1[buf],
 294              edit->curs1 & M_EDIT_BUF_SIZE) != (edit->curs1 & M_EDIT_BUF_SIZE))
 295         {
 296             filelen = -1;
 297         }
 298         else if (edit->curs2)
 299         {
 300             edit->curs2--;
 301             buf = (edit->curs2 >> S_EDIT_BUF_SIZE);
 302             if (mc_write
 303                 (fd,
 304                  (char *) edit->buffers2[buf] + EDIT_BUF_SIZE -
 305                  (edit->curs2 & M_EDIT_BUF_SIZE) - 1,
 306                  1 + (edit->curs2 & M_EDIT_BUF_SIZE)) != 1 + (edit->curs2 & M_EDIT_BUF_SIZE))
 307             {
 308                 filelen = -1;
 309             }
 310             else
 311             {
 312                 while (--buf >= 0)
 313                 {
 314                     if (mc_write (fd, (char *) edit->buffers2[buf], EDIT_BUF_SIZE) != EDIT_BUF_SIZE)
 315                     {
 316                         filelen = -1;
 317                         break;
 318                     }
 319                 }
 320             }
 321             edit->curs2++;
 322         }
 323         if (mc_close (fd))
 324             goto error_save;
 325
 326         /* Update the file information, especially the mtime. */
 327         if (mc_stat (savename, &edit->stat1) == -1)
 328             goto error_save;
 329     }
 330     else
 331     {                           /* change line breaks */
 332         FILE *file;
 333
 334         mc_close (fd);
 335
 336         file = (FILE *) fopen (savename, "w");
 337
 338         if (file)
 339         {
 340             filelen = edit_write_stream (edit, file);
 341             fclose (file);
 342         }
 343         else
 344         {
 345             char *msg;
 346
 347             msg = g_strdup_printf (_("Cannot open file for writing: %s"), savename);
 348             edit_error_dialog (_("Error"), msg);
 349             g_free (msg);
 350             goto error_save;
 351         }
 352     }
 353
 354     if (filelen != edit->last_byte)
 355         goto error_save;
 356
 357     if (this_save_mode == EDIT_DO_BACKUP)
 358     {
 359         assert (option_backup_ext != NULL);
 360         tmp = g_strconcat (real_filename, option_backup_ext, (char *) NULL);
 361         if (mc_rename (real_filename, tmp) == -1)
 362         {
 363             g_free (tmp);
 364             goto error_save;
 365         }
 366     }
 367
 368     if (this_save_mode != EDIT_QUICK_SAVE)
 369         if (mc_rename (savename, real_filename) == -1)
 370             goto error_save;
 371     g_free (savename);
 372     g_free (real_filename);
 373     return 1;
 374   error_save:
 375     /*  FIXME: Is this safe ?
 376      *  if (this_save_mode != EDIT_QUICK_SAVE)
 377      *      mc_unlink (savename);
 378      */
 379     g_free (real_filename);
 380     g_free (savename);
 381     return 0;
 382 }
 383
 384 /* --------------------------------------------------------------------------------------------- */
 385
 386 static gboolean
 387 edit_check_newline (WEdit * edit)
 388 {
 389     return !(option_check_nl_at_eof && edit->last_byte > 0
 390              && edit_get_byte (edit, edit->last_byte - 1) != '\n'
 391              && edit_query_dialog2 (_("Warning"),
 392                                     _("The file you are saving is not finished with a newline"),
 393                                     _("C&ontinue"), _("&Cancel")));
 394 }
 395
 396 /* --------------------------------------------------------------------------------------------- */
 397
 398 static char *
 399 edit_get_save_file_as (WEdit * edit)
 400 {
 401 #define DLG_WIDTH 64
 402 #define DLG_HEIGHT 14
 403
 404     static LineBreaks cur_lb = LB_ASIS;
 405
 406     char *filename = edit->filename;
 407
 408     const char *lb_names[LB_NAMES] = {
 409         N_("&Do not change"),
 410         N_("&Unix format (LF)"),
 411         N_("&Windows/DOS format (CR LF)"),
 412         N_("&Macintosh format (CR)")
 413     };
 414
 415     QuickWidget quick_widgets[] = {
 416         QUICK_BUTTON (6, 10, DLG_HEIGHT - 3, DLG_HEIGHT, N_("&Cancel"), B_CANCEL, NULL),
 417         QUICK_BUTTON (2, 10, DLG_HEIGHT - 3, DLG_HEIGHT, N_("&OK"), B_ENTER, NULL),
 418         QUICK_RADIO (5, DLG_WIDTH, DLG_HEIGHT - 8, DLG_HEIGHT, LB_NAMES, lb_names, (int *) &cur_lb),
 419         QUICK_LABEL (3, DLG_WIDTH, DLG_HEIGHT - 9, DLG_HEIGHT, N_("Change line breaks to:")),
 420         QUICK_INPUT (3, DLG_WIDTH, DLG_HEIGHT - 11, DLG_HEIGHT, filename, DLG_WIDTH - 6, 0,
 421                      "save-as", &filename),
 422         QUICK_LABEL (3, DLG_WIDTH, DLG_HEIGHT - 12, DLG_HEIGHT, N_("Enter file name:")),
 423         QUICK_END
 424     };
 425
 426     QuickDialog Quick_options = {
 427         DLG_WIDTH, DLG_HEIGHT, -1, -1,
 428         N_("Save As"), "[Save File As]",
 429         quick_widgets, NULL, FALSE
 430     };
 431
 432     if (quick_dialog (&Quick_options) != B_CANCEL)
 433     {
 434         char *fname;
 435
 436         edit->lb = cur_lb;
 437         fname = tilde_expand (filename);
 438         g_free (filename);
 439         return fname;
 440     }
 441
 442     return NULL;
 443
 444 #undef DLG_WIDTH
 445 #undef DLG_HEIGHT
 446 }
 447
 448 /* {{{ Macro stuff starts here */
 449
 450 /* --------------------------------------------------------------------------------------------- */
 451 /** creates a macro file if it doesn't exist */
 452
 453 static FILE *
 454 edit_open_macro_file (const char *r)
 455 {
 456     gchar *filename;
 457     FILE *fd;
 458     int file;
 459     filename = concat_dir_and_file (home_dir, EDIT_MACRO_FILE);
 460     file = open (filename, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 461     if (file == -1)
 462     {
 463         g_free (filename);
 464         return 0;
 465     }
 466     close (file);
 467     fd = fopen (filename, r);
 468     g_free (filename);
 469     return fd;
 470 }
 471
 472 #define MAX_MACROS 1024
 473 static int saved_macro[MAX_MACROS + 1];
 474 static int saved_macros_loaded = 0;
 475
 476 /* --------------------------------------------------------------------------------------------- */
 477 /**
 478    This is just to stop the macro file be loaded over and over for keys
 479    that aren't defined to anything. On slow systems this could be annoying.
 480  */
 481
 482 static int
 483 macro_exists (int k)
 484 {
 485     int i;
 486     for (i = 0; i < MAX_MACROS && saved_macro[i]; i++)
 487         if (saved_macro[i] == k)
 488             return i;
 489     return -1;
 490 }
 491
 492 /* --------------------------------------------------------------------------------------------- */
 493 /** returns 1 on error */
 494
 495 static int
 496 edit_delete_macro (WEdit * edit, int k)
 497 {
 498     gchar *tmp, *tmp2;
 499     struct macro macro[MAX_MACRO_LENGTH];
 500     FILE *f, *g;
 501     int s, i, n, j = 0;
 502
 503     (void) edit;
 504
 505     if (saved_macros_loaded)
 506     {
 507         j = macro_exists (k);
 508         if (j < 0)
 509             return 0;
 510     }
 511     tmp = concat_dir_and_file (home_dir, EDIT_TEMP_FILE);
 512     g = fopen (tmp, "w");
 513     g_free (tmp);
 514     if (!g)
 515     {
 516         edit_error_dialog (_("Delete macro"), get_sys_error (_("Cannot open temp file")));
 517         return 1;
 518     }
 519     f = edit_open_macro_file ("r");
 520     if (!f)
 521     {
 522         edit_error_dialog (_("Delete macro"), get_sys_error (_("Cannot open macro file")));
 523         fclose (g);
 524         return 1;
 525     }
 526     for (;;)
 527     {
 528         n = fscanf (f, ("key '%d 0': "), &s);
 529         if (!n || n == EOF)
 530             break;
 531         n = 0;
 532         while (fscanf (f, "%lu %d, ", &macro[n].command, &macro[n].ch))
 533             n++;
 534         {
 535             int ret;
 536             ret = fscanf (f, ";\n");
 537         }
 538         if (s != k)
 539         {
 540             fprintf (g, ("key '%d 0': "), s);
 541             for (i = 0; i < n; i++)
 542                 fprintf (g, "%lu %d, ", macro[i].command, macro[i].ch);
 543             fprintf (g, ";\n");
 544         }
 545     }
 546     fclose (f);
 547     fclose (g);
 548     tmp = concat_dir_and_file (home_dir, EDIT_TEMP_FILE);
 549     tmp2 = concat_dir_and_file (home_dir, EDIT_MACRO_FILE);
 550     if (rename (tmp, tmp2) == -1)
 551     {
 552         edit_error_dialog (_("Delete macro"), get_sys_error (_("Cannot overwrite macro file")));
 553         g_free (tmp);
 554         g_free (tmp2);
 555         return 1;
 556     }
 557     g_free (tmp);
 558     g_free (tmp2);
 559
 560     if (saved_macros_loaded)
 561         memmove (saved_macro + j, saved_macro + j + 1, sizeof (int) * (MAX_MACROS - j - 1));
 562     return 0;
 563 }
 564
 565 /* }}} */
 566
 567 /* --------------------------------------------------------------------------------------------- */
 568 /** returns 1 on success */
 569
 570 static int
 571 edit_save_cmd (WEdit * edit)
 572 {
 573     int res, save_lock = 0;
 574
 575     if (!edit->locked && !edit->delete_file)
 576         save_lock = edit_lock_file (edit);
 577     res = edit_save_file (edit, edit->filename);
 578
 579     /* Maintain modify (not save) lock on failure */
 580     if ((res > 0 && edit->locked) || save_lock)
 581         edit->locked = edit_unlock_file (edit);
 582
 583     /* On failure try 'save as', it does locking on its own */
 584     if (!res)
 585         return edit_save_as_cmd (edit);
 586     edit->force |= REDRAW_COMPLETELY;
 587     if (res > 0)
 588     {
 589         edit->delete_file = 0;
 590         edit->modified = 0;
 591     }
 592
 593     return 1;
 594 }
 595
 596 /* --------------------------------------------------------------------------------------------- */
 597 /** returns 1 on error */
 598
 599 static int
 600 edit_load_file_from_filename (WEdit * edit, char *exp)
 601 {
 602     int prev_locked = edit->locked;
 603     char *prev_filename = g_strdup (edit->filename);
 604
 605     if (!edit_reload (edit, exp))
 606     {
 607         g_free (prev_filename);
 608         return 1;
 609     }
 610
 611     if (prev_locked)
 612     {
 613         char *fullpath;
 614
 615         fullpath = g_build_filename (edit->dir, prev_filename, (char *) NULL);
 616         unlock_file (fullpath);
 617         g_free (fullpath);
 618     }
 619     g_free (prev_filename);
 620     return 0;
 621 }
 622
 623 /* --------------------------------------------------------------------------------------------- */
 624
 625 static void
 626 edit_load_syntax_file (WEdit * edit)
 627 {
 628     char *extdir;
 629     int dir = 0;
 630
 631     if (geteuid () == 0)
 632     {
 633         dir = query_dialog (_("Syntax file edit"),
 634                             _("Which syntax file you want to edit?"), D_NORMAL, 2,
 635                             _("&User"), _("&System Wide"));
 636     }
 637
 638     extdir = g_build_filename (mc_home, "syntax", "Syntax", (char *) NULL);
 639     if (!exist_file (extdir))
 640     {
 641         g_free (extdir);
 642         extdir = g_build_filename (mc_home_alt, "syntax", "Syntax", (char *) NULL);
 643     }
 644
 645     if (dir == 0)
 646     {
 647         char *buffer;
 648
 649         buffer = concat_dir_and_file (home_dir, EDIT_SYNTAX_FILE);
 650         check_for_default (extdir, buffer);
 651         edit_load_file_from_filename (edit, buffer);
 652         g_free (buffer);
 653     }
 654     else if (dir == 1)
 655         edit_load_file_from_filename (edit, extdir);
 656
 657     g_free (extdir);
 658 }
 659
 660 /* --------------------------------------------------------------------------------------------- */
 661
 662 static void
 663 edit_load_menu_file (WEdit * edit)
 664 {
 665     char *buffer;
 666     char *menufile;
 667     int dir = 0;
 668
 669     dir = query_dialog (_("Menu edit"),
 670                         _("Which menu file do you want to edit?"), D_NORMAL,
 671                         geteuid () != 0 ? 2 : 3, _("&Local"), _("&User"), _("&System Wide"));
 672
 673     menufile = concat_dir_and_file (mc_home, EDIT_GLOBAL_MENU);
 674
 675     if (!exist_file (menufile))
 676     {
 677         g_free (menufile);
 678         menufile = concat_dir_and_file (mc_home_alt, EDIT_GLOBAL_MENU);
 679     }
 680
 681     switch (dir)
 682     {
 683     case 0:
 684         buffer = g_strdup (EDIT_LOCAL_MENU);
 685         check_for_default (menufile, buffer);
 686         chmod (buffer, 0600);
 687         break;
 688
 689     case 1:
 690         buffer = concat_dir_and_file (home_dir, EDIT_HOME_MENU);
 691         check_for_default (menufile, buffer);
 692         break;
 693
 694     case 2:
 695         buffer = concat_dir_and_file (mc_home, EDIT_GLOBAL_MENU);
 696         if (!exist_file (buffer))
 697         {
 698             g_free (buffer);
 699             buffer = concat_dir_and_file (mc_home_alt, EDIT_GLOBAL_MENU);
 700         }
 701         break;
 702
 703     default:
 704         g_free (menufile);
 705         return;
 706     }
 707
 708     edit_load_file_from_filename (edit, buffer);
 709
 710     g_free (buffer);
 711     g_free (menufile);
 712 }
 713
 714 /* --------------------------------------------------------------------------------------------- */
 715
 716 static void
 717 edit_delete_column_of_text (WEdit * edit)
 718 {
 719     long p, q, r, m1, m2;
 720     long b, c, d, n;
 721
 722     eval_marks (edit, &m1, &m2);
 723     n = edit_move_forward (edit, m1, 0, m2) + 1;
 724     c = edit_move_forward3 (edit, edit_bol (edit, m1), 0, m1);
 725     d = edit_move_forward3 (edit, edit_bol (edit, m2), 0, m2);
 726     b = max (min (c, d), min (edit->column1, edit->column2));
 727     c = max (c, max (edit->column1, edit->column2));
 728
 729     while (n--)
 730     {
 731         r = edit_bol (edit, edit->curs1);
 732         p = edit_move_forward3 (edit, r, b, 0);
 733         q = edit_move_forward3 (edit, r, c, 0);
 734         if (p < m1)
 735             p = m1;
 736         if (q > m2)
 737             q = m2;
 738         edit_cursor_move (edit, p - edit->curs1);
 739         while (q > p)
 740         {
 741             /* delete line between margins */
 742             if (edit_get_byte (edit, edit->curs1) != '\n')
 743                 edit_delete (edit, 1);
 744             q--;
 745         }
 746         if (n)
 747             /* move to next line except on the last delete */
 748             edit_cursor_move (edit, edit_move_forward (edit, edit->curs1, 1, 0) - edit->curs1);
 749     }
 750 }
 751
 752 /* --------------------------------------------------------------------------------------------- */
 753 /** if success return 0 */
 754
 755 static int
 756 edit_block_delete (WEdit * edit)
 757 {
 758     long count;
 759     long start_mark, end_mark;
 760     int curs_pos, line_width;
 761     long curs_line, c1, c2;
 762
 763     if (eval_marks (edit, &start_mark, &end_mark))
 764         return 0;
 765     if (edit->column_highlight && edit->mark2 < 0)
 766         edit_mark_cmd (edit, 0);
 767     if ((end_mark - start_mark) > option_max_undo / 2)
 768     {
 769         /* Warning message with a query to continue or cancel the operation */
 770         if (edit_query_dialog2
 771             (_("Warning"),
 772              _
 773              ("Block is large, you may not be able to undo this action"),
 774              _("C&ontinue"), _("&Cancel")))
 775         {
 776             return 1;
 777         }
 778     }
 779     c1 = min (edit->column1, edit->column2);
 780     c2 = max (edit->column1, edit->column2);
 781     edit->column1 = c1;
 782     edit->column2 = c2;
 783
 784     edit_push_markers (edit);
 785
 786     curs_line = edit->curs_line;
 787
 788     /* calculate line width and cursor position before cut */
 789     line_width = edit_move_forward3 (edit, edit_bol (edit, edit->curs1), 0,
 790                                      edit_eol (edit, edit->curs1));
 791     curs_pos = edit->curs_col + edit->over_col;
 792
 793     /* move cursor to start of selection */
 794     edit_cursor_move (edit, start_mark - edit->curs1);
 795     edit_scroll_screen_over_cursor (edit);
 796     count = start_mark;
 797     if (start_mark < end_mark)
 798     {
 799         if (edit->column_highlight)
 800         {
 801             if (edit->mark2 < 0)
 802                 edit_mark_cmd (edit, 0);
 803             edit_delete_column_of_text (edit);
 804             /* move cursor to the saved position */
 805             edit_move_to_line (edit, curs_line);
 806             /* calculate line width after cut */
 807             line_width = edit_move_forward3 (edit, edit_bol (edit, edit->curs1), 0,
 808                                              edit_eol (edit, edit->curs1));
 809             if (option_cursor_beyond_eol && curs_pos > line_width)
 810                 edit->over_col = curs_pos - line_width;
 811         }
 812         else
 813         {
 814             while (count < end_mark)
 815             {
 816                 edit_delete (edit, 1);
 817                 count++;
 818             }
 819         }
 820     }
 821     edit_set_markers (edit, 0, 0, 0, 0);
 822     edit->force |= REDRAW_PAGE;
 823     return 0;
 824 }
 825
 826 /* --------------------------------------------------------------------------------------------- */
 827
 828 static gboolean
 829 editcmd_find (WEdit * edit, gsize * len)
 830 {
 831     off_t search_start = edit->search_start;
 832     off_t search_end;
 833     long start_mark = 0;
 834     long end_mark = edit->last_byte;
 835     int mark_res = 0;
 836
 837     if (edit_search_options.only_in_selection)
 838     {
 839         mark_res = eval_marks (edit, &start_mark, &end_mark);
 840         if (mark_res != 0)
 841         {
 842             edit->search->error = MC_SEARCH_E_NOTFOUND;
 843             edit->search->error_str = g_strdup (_("Search string not found"));
 844             return FALSE;
 845         }
 846         if (edit_search_options.backwards)
 847         {
 848             if (search_start > end_mark || search_start <= start_mark)
 849             {
 850                 search_start = end_mark;
 851             }
 852         }
 853         else
 854         {
 855             if (search_start < start_mark || search_start >= end_mark)
 856             {
 857                 search_start = start_mark;
 858             }
 859         }
 860     }
 861     else
 862     {
 863         if (edit_search_options.backwards)
 864             end_mark = max (1, edit->curs1) - 1;
 865     }
 866     if (edit_search_options.backwards)
 867     {
 868         search_end = end_mark;
 869         while ((int) search_start >= start_mark)
 870         {
 871             if (search_end > (off_t) (search_start + edit->search->original_len) &&
 872                 mc_search_is_fixed_search_str (edit->search))
 873             {
 874                 search_end = search_start + edit->search->original_len;
 875             }
 876             if (mc_search_run (edit->search, (void *) edit, search_start, search_end, len)
 877                 && edit->search->normal_offset == search_start)
 878             {
 879                 return TRUE;
 880             }
 881             search_start--;
 882         }
 883         edit->search->error_str = g_strdup (_("Search string not found"));
 884     }
 885     else
 886     {
 887         return mc_search_run (edit->search, (void *) edit, search_start, end_mark, len);
 888     }
 889     return FALSE;
 890 }
 891
 892 /* --------------------------------------------------------------------------------------------- */
 893
 894 static char *
 895 edit_replace_cmd__conv_to_display (char *str)
 896 {
 897 #ifdef HAVE_CHARSET
 898     GString *tmp;
 899
 900     tmp = str_convert_to_display (str);
 901     if (tmp != NULL)
 902     {
 903         if (tmp->len != 0)
 904             return g_string_free (tmp, FALSE);
 905         g_string_free (tmp, TRUE);
 906     }
 907 #endif
 908     return g_strdup (str);
 909 }
 910
 911 /* --------------------------------------------------------------------------------------------- */
 912
 913 static char *
 914 edit_replace_cmd__conv_to_input (char *str)
 915 {
 916 #ifdef HAVE_CHARSET
 917     GString *tmp;
 918
 919     tmp = str_convert_to_input (str);
 920     if (tmp != NULL)
 921     {
 922         if (tmp->len != 0)
 923             return g_string_free (tmp, FALSE);
 924         g_string_free (tmp, TRUE);
 925     }
 926 #endif
 927     return g_strdup (str);
 928 }
 929
 930 /* --------------------------------------------------------------------------------------------- */
 931
 932 static void
 933 edit_do_search (WEdit * edit)
 934 {
 935     gsize len = 0;
 936
 937     if (edit->search == NULL)
 938         edit->search_start = edit->curs1;
 939
 940     edit_push_action (edit, KEY_PRESS + edit->start_display);
 941
 942     if (search_create_bookmark)
 943     {
 944         int found = 0, books = 0;
 945         long l = 0, l_last = -1;
 946         long q = 0;
 947
 948         search_create_bookmark = FALSE;
 949         book_mark_flush (edit, -1);
 950
 951         while (TRUE)
 952         {
 953             if (!mc_search_run (edit->search, (void *) edit, q, edit->last_byte, &len))
 954                 break;
 955             if (found == 0)
 956                 edit->search_start = edit->search->normal_offset;
 957             found++;
 958             l += edit_count_lines (edit, q, edit->search->normal_offset);
 959             if (l != l_last)
 960             {
 961                 book_mark_insert (edit, l, BOOK_MARK_FOUND_COLOR);
 962                 books++;
 963             }
 964             l_last = l;
 965             q = edit->search->normal_offset + 1;
 966         }
 967
 968         if (found == 0)
 969             edit_error_dialog (_("Search"), _("Search string not found"));
 970         else
 971             edit_cursor_move (edit, edit->search_start - edit->curs1);
 972     }
 973     else
 974     {
 975         if (edit->found_len != 0 && edit->search_start == edit->found_start + 1
 976             && edit_search_options.backwards)
 977             edit->search_start--;
 978
 979         if (edit->found_len != 0 && edit->search_start == edit->found_start - 1
 980             && !edit_search_options.backwards)
 981             edit->search_start++;
 982
 983         if (editcmd_find (edit, &len))
 984         {
 985             edit->found_start = edit->search_start = edit->search->normal_offset;
 986             edit->found_len = len;
 987             edit->over_col = 0;
 988             edit_cursor_move (edit, edit->search_start - edit->curs1);
 989             edit_scroll_screen_over_cursor (edit);
 990             if (edit_search_options.backwards)
 991                 edit->search_start--;
 992             else
 993                 edit->search_start++;
 994         }
 995         else
 996         {
 997             edit->search_start = edit->curs1;
 998             if (edit->search->error_str != NULL)
 999                 edit_error_dialog (_("Search"), edit->search->error_str);
1000         }
1001     }
1002
1003     edit->force |= REDRAW_COMPLETELY;
1004     edit_scroll_screen_over_cursor (edit);
1005 }
1006
1007 /* --------------------------------------------------------------------------------------------- */
1008
1009 static void
1010 edit_search (WEdit *edit)
1011 {
1012     if (editcmd_dialog_search_show (edit))
1013         edit_do_search (edit);
1014 }
1015
1016 /* --------------------------------------------------------------------------------------------- */
1017 /** Return a null terminated length of text. Result must be g_free'd */
1018
1019 static unsigned char *
1020 edit_get_block (WEdit * edit, long start, long finish, int *l)
1021 {
1022     unsigned char *s, *r;
1023     r = s = g_malloc0 (finish - start + 1);
1024     if (edit->column_highlight)
1025     {
1026         *l = 0;
1027         /* copy from buffer, excluding chars that are out of the column 'margins' */
1028         while (start < finish)
1029         {
1030             int c;
1031             long x;
1032             x = edit_move_forward3 (edit, edit_bol (edit, start), 0, start);
1033             c = edit_get_byte (edit, start);
1034             if ((x >= edit->column1 && x < edit->column2)
1035                 || (x >= edit->column2 && x < edit->column1) || c == '\n')
1036             {
1037                 *s++ = c;
1038                 (*l)++;
1039             }
1040             start++;
1041         }
1042     }
1043     else
1044     {
1045         *l = finish - start;
1046         while (start < finish)
1047             *s++ = edit_get_byte (edit, start++);
1048     }
1049     *s = 0;
1050     return r;
1051 }
1052
1053 /* --------------------------------------------------------------------------------------------- */
1054 /** copies a block to clipboard file */
1055
1056 static int
1057 edit_save_block_to_clip_file (WEdit * edit, long start, long finish)
1058 {
1059     int ret;
1060     gchar *tmp;
1061     tmp = concat_dir_and_file (home_dir, EDIT_CLIP_FILE);
1062     ret = edit_save_block (edit, tmp, start, finish);
1063     g_free (tmp);
1064     return ret;
1065 }
1066
1067 /* --------------------------------------------------------------------------------------------- */
1068
1069 static void
1070 pipe_mail (WEdit * edit, char *to, char *subject, char *cc)
1071 {
1072     FILE *p = 0;
1073     char *s;
1074
1075     to = name_quote (to, 0);
1076     subject = name_quote (subject, 0);
1077     cc = name_quote (cc, 0);
1078     s = g_strconcat ("mail -s ", subject, *cc ? " -c " : "", cc, " ", to, (char *) NULL);
1079     g_free (to);
1080     g_free (subject);
1081     g_free (cc);
1082
1083     if (s)
1084     {
1085         p = popen (s, "w");
1086         g_free (s);
1087     }
1088
1089     if (p)
1090     {
1091         long i;
1092         for (i = 0; i < edit->last_byte; i++)
1093             fputc (edit_get_byte (edit, i), p);
1094         pclose (p);
1095     }
1096 }
1097
1098 /* --------------------------------------------------------------------------------------------- */
1099
1100 static gboolean
1101 is_break_char (char c)
1102 {
1103     return (isspace (c) || strchr ("{}[]()<>=|/\\!?~'\",.;:#$%^&*", c));
1104 }
1105
1106 /* --------------------------------------------------------------------------------------------- */
1107 /** find first character of current word */
1108
1109 static int
1110 edit_find_word_start (WEdit * edit, long *word_start, gsize * word_len)
1111 {
1112     int c, last;
1113     gsize i;
1114
1115     /* return if at begin of file */
1116     if (edit->curs1 <= 0)
1117         return 0;
1118
1119     c = (unsigned char) edit_get_byte (edit, edit->curs1 - 1);
1120     /* return if not at end or in word */
1121     if (is_break_char (c))
1122         return 0;
1123
1124     /* search start of word to be completed */
1125     for (i = 2;; i++)
1126     {
1127         /* return if at begin of file */
1128         if ((gsize) edit->curs1 < i)
1129             return 0;
1130
1131         last = c;
1132         c = (unsigned char) edit_get_byte (edit, edit->curs1 - i);
1133
1134         if (is_break_char (c))
1135         {
1136             /* return if word starts with digit */
1137             if (isdigit (last))
1138                 return 0;
1139
1140             *word_start = edit->curs1 - (i - 1);        /* start found */
1141             *word_len = i - 1;
1142             break;
1143         }
1144     }
1145     /* success */
1146     return 1;
1147 }
1148
1149 /* --------------------------------------------------------------------------------------------- */
1150 /** collect the possible completions */
1151 static gsize
1152 edit_collect_completions (WEdit * edit, long start, gsize word_len,
1153                           char *match_expr, struct selection *compl, gsize * num)
1154 {
1155     gsize len = 0;
1156     gsize max_len = 0;
1157     gsize i;
1158     int skip;
1159     GString *temp;
1160     mc_search_t *srch;
1161
1162     long last_byte;
1163
1164     srch = mc_search_new (match_expr, -1);
1165     if (srch == NULL)
1166         return 0;
1167
1168     if (mc_config_get_bool
1169         (mc_main_config, CONFIG_APP_SECTION, "editor_wordcompletion_collect_entire_file", 0))
1170     {
1171         last_byte = edit->last_byte;
1172     }
1173     else
1174     {
1175         last_byte = start;
1176     }
1177
1178     srch->search_type = MC_SEARCH_T_REGEX;
1179     srch->is_case_sensitive = TRUE;
1180     srch->search_fn = edit_search_cmd_callback;
1181
1182     /* collect max MAX_WORD_COMPLETIONS completions */
1183     start = -1;
1184     while (1)
1185     {
1186         /* get next match */
1187         if (mc_search_run (srch, (void *) edit, start + 1, last_byte, &len) == FALSE)
1188             break;
1189         start = srch->normal_offset;
1190
1191         /* add matched completion if not yet added */
1192         temp = g_string_new ("");
1193         for (i = 0; i < len; i++)
1194         {
1195             skip = edit_get_byte (edit, start + i);
1196             if (isspace (skip))
1197                 continue;
1198             g_string_append_c (temp, skip);
1199         }
1200
1201         skip = 0;
1202
1203         for (i = 0; i < (gsize) * num; i++)
1204         {
1205             if (strncmp
1206                 ((char *) &compl[i].text[word_len],
1207                  (char *) &temp->str[word_len], max (len, compl[i].len) - (gsize) word_len) == 0)
1208             {
1209                 struct selection this = compl[i];
1210                 for (++i; i < *num; i++)
1211                 {
1212                     compl[i - 1] = compl[i];
1213                 }
1214                 compl[*num - 1] = this;
1215                 skip = 1;
1216                 break;          /* skip it, already added */
1217             }
1218         }
1219         if (skip)
1220         {
1221             g_string_free (temp, TRUE);
1222             continue;
1223         }
1224         if (*num == MAX_WORD_COMPLETIONS && MAX_WORD_COMPLETIONS)
1225         {
1226             g_free (compl[0].text);
1227             for (i = 1; i < *num; i++)
1228             {
1229                 compl[i - 1] = compl[i];
1230             }
1231             (*num)--;
1232         }
1233 #ifdef HAVE_CHARSET
1234         {
1235             GString *recoded;
1236             recoded = str_convert_to_display (temp->str);
1237
1238             if (recoded && recoded->len)
1239             {
1240                 g_string_free (temp, TRUE);
1241                 temp = recoded;
1242             }
1243             else
1244                 g_string_free (recoded, TRUE);
1245         }
1246 #endif
1247         compl[*num].text = temp->str;
1248         compl[*num].len = temp->len;
1249         (*num)++;
1250         start += len;
1251         g_string_free (temp, FALSE);
1252
1253         /* note the maximal length needed for the completion dialog */
1254         if (len > max_len)
1255             max_len = len;
1256     }
1257     mc_search_free (srch);
1258     return max_len;
1259 }
1260
1261
1262 /* --------------------------------------------------------------------------------------------- */
1263 /*** public functions ****************************************************************************/
1264 /* --------------------------------------------------------------------------------------------- */
1265
1266 void
1267 edit_help_cmd (WEdit * edit)
1268 {
1269     interactive_display (NULL, "[Internal File Editor]");
1270     edit->force |= REDRAW_COMPLETELY;
1271 }
1272
1273 /* --------------------------------------------------------------------------------------------- */
1274
1275 void
1276 edit_refresh_cmd (WEdit * edit)
1277 {
1278 #ifdef HAVE_SLANG
1279     int color;
1280
1281     edit_get_syntax_color (edit, -1, &color);
1282     tty_touch_screen ();
1283     mc_refresh ();
1284 #else
1285     (void) edit;
1286
1287     clr_scr ();
1288     repaint_screen ();
1289 #endif /* !HAVE_SLANG */
1290     tty_keypad (TRUE);
1291 }
1292
1293 /* --------------------------------------------------------------------------------------------- */
1294
1295 void
1296 menu_save_mode_cmd (void)
1297 {
1298     /* diaog sizes */
1299     const int DLG_X = 38;
1300     const int DLG_Y = 13;
1301
1302     char *str_result;
1303
1304     const char *str[] = {
1305         N_("&Quick save"),
1306         N_("&Safe save"),
1307         N_("&Do backups with following extension:")
1308     };
1309
1310     QuickWidget widgets[] = {
1311         /* 0 */
1312         QUICK_BUTTON (18, DLG_X, DLG_Y - 3, DLG_Y, N_("&Cancel"), B_CANCEL, NULL),
1313         /* 1 */
1314         QUICK_BUTTON (6, DLG_X, DLG_Y - 3, DLG_Y, N_("&OK"), B_ENTER, NULL),
1315         /* 2 */
1316         QUICK_CHECKBOX (4, DLG_X, 8, DLG_Y, N_("Check &POSIX new line"), &option_check_nl_at_eof),
1317         /* 3 */
1318         QUICK_INPUT (8, DLG_X, 6, DLG_Y, option_backup_ext, 9, 0, "edit-backup-ext", &str_result),
1319         /* 4 */
1320         QUICK_RADIO (4, DLG_X, 3, DLG_Y, 3, str, &option_save_mode),
1321         QUICK_END
1322     };
1323
1324     QuickDialog dialog = {
1325         DLG_X, DLG_Y, -1, -1, N_("Edit Save Mode"),
1326         "[Edit Save Mode]", widgets, NULL, FALSE
1327     };
1328
1329     size_t i;
1330     size_t maxlen = 0;
1331     size_t w0, w1, b_len, w3;
1332
1333     assert (option_backup_ext != NULL);
1334
1335     /* OK/Cancel buttons */
1336     w0 = str_term_width1 (_(widgets[0].u.button.text)) + 3;
1337     w1 = str_term_width1 (_(widgets[1].u.button.text)) + 5;     /* default button */
1338     b_len = w0 + w1 + 3;
1339
1340     maxlen = max (b_len, (size_t) str_term_width1 (_(dialog.title)) + 2);
1341
1342     w3 = 0;
1343     for (i = 0; i < 3; i++)
1344     {
1345 #ifdef ENABLE_NLS
1346         str[i] = _(str[i]);
1347 #endif
1348         w3 = max (w3, (size_t) str_term_width1 (str[i]));
1349     }
1350
1351     maxlen = max (maxlen, w3 + 4);
1352
1353     dialog.xlen = min ((size_t) COLS, maxlen + 8);
1354
1355     widgets[3].u.input.len = w3;
1356     widgets[1].relative_x = (dialog.xlen - b_len) / 2;
1357     widgets[0].relative_x = widgets[1].relative_x + w0 + 2;
1358
1359     for (i = 0; i < sizeof (widgets) / sizeof (widgets[0]); i++)
1360         widgets[i].x_divisions = dialog.xlen;
1361
1362     if (quick_dialog (&dialog) != B_CANCEL)
1363     {
1364         g_free (option_backup_ext);
1365         option_backup_ext = str_result;
1366     }
1367 }
1368
1369 /* --------------------------------------------------------------------------------------------- */
1370
1371 void
1372 edit_set_filename (WEdit * edit, const char *name)
1373 {
1374     g_free (edit->filename);
1375
1376     if (name == NULL)
1377         name = "";
1378
1379     edit->filename = tilde_expand (name);
1380     if (edit->dir == NULL && !g_path_is_absolute (name))
1381         edit->dir = g_strdup (vfs_get_current_dir ());
1382 }
1383
1384 /* --------------------------------------------------------------------------------------------- */
1385 /* Here we want to warn the users of overwriting an existing file,
1386    but only if they have made a change to the filename */
1387 /* returns 1 on success */
1388 int
1389 edit_save_as_cmd (WEdit * edit)
1390 {
1391     /* This heads the 'Save As' dialog box */
1392     char *exp;
1393     int save_lock = 0;
1394     int different_filename = 0;
1395
1396     if (!edit_check_newline (edit))
1397         return 0;
1398
1399     exp = edit_get_save_file_as (edit);
1400     edit_push_action (edit, KEY_PRESS + edit->start_display);
1401
1402     if (exp)
1403     {
1404         if (!*exp)
1405         {
1406             g_free (exp);
1407             edit->force |= REDRAW_COMPLETELY;
1408             return 0;
1409         }
1410         else
1411         {
1412             int rv;
1413             if (strcmp (edit->filename, exp))
1414             {
1415                 int file;
1416                 different_filename = 1;
1417                 file = mc_open (exp, O_RDONLY | O_BINARY);
1418                 if (file != -1)
1419                 {
1420                     /* the file exists */
1421                     mc_close (file);
1422                     /* Overwrite the current file or cancel the operation */
1423                     if (edit_query_dialog2
1424                         (_("Warning"),
1425                          _("A file already exists with this name"), _("&Overwrite"), _("&Cancel")))
1426                     {
1427                         edit->force |= REDRAW_COMPLETELY;
1428                         g_free (exp);
1429                         return 0;
1430                     }
1431                 }
1432                 else
1433                 {
1434                     edit->stat1.st_mode |= S_IWUSR;
1435                 }
1436                 save_lock = lock_file (exp);
1437             }
1438             else
1439             {
1440                 /* filenames equal, check if already locked */
1441                 if (!edit->locked && !edit->delete_file)
1442                     save_lock = lock_file (exp);
1443             }
1444
1445             if (different_filename)
1446             {
1447                 /*
1448                  * Allow user to write into saved (under another name) file
1449                  * even if original file had r/o user permissions.
1450                  */
1451                 edit->stat1.st_mode |= S_IWRITE;
1452             }
1453
1454             rv = edit_save_file (edit, exp);
1455             switch (rv)
1456             {
1457             case 1:
1458                 /* Succesful, so unlock both files */
1459                 if (different_filename)
1460                 {
1461                     if (save_lock)
1462                         unlock_file (exp);
1463                     if (edit->locked)
1464                         edit->locked = edit_unlock_file (edit);
1465                 }
1466                 else
1467                 {
1468                     if (edit->locked || save_lock)
1469                         edit->locked = edit_unlock_file (edit);
1470                 }
1471
1472                 edit_set_filename (edit, exp);
1473                 if (edit->lb != LB_ASIS)
1474                     edit_reload (edit, exp);
1475                 g_free (exp);
1476                 edit->modified = 0;
1477                 edit->delete_file = 0;
1478                 if (different_filename)
1479                     edit_load_syntax (edit, NULL, edit->syntax_type);
1480                 edit->force |= REDRAW_COMPLETELY;
1481                 return 1;
1482             default:
1483                 edit_error_dialog (_("Save as"), get_sys_error (_("Cannot save file")));
1484                 /* fallthrough */
1485             case -1:
1486                 /* Failed, so maintain modify (not save) lock */
1487                 if (save_lock)
1488                     unlock_file (exp);
1489                 g_free (exp);
1490                 edit->force |= REDRAW_COMPLETELY;
1491                 return 0;
1492             }
1493         }
1494     }
1495     edit->force |= REDRAW_COMPLETELY;
1496     return 0;
1497 }
1498
1499 /* {{{ Macro stuff starts here */
1500
1501
1502 /* --------------------------------------------------------------------------------------------- */
1503 /** returns 0 on error */
1504
1505 int
1506 edit_save_macro_cmd (WEdit * edit, struct macro macro[], int n)
1507 {
1508     FILE *f;
1509     int s, i;
1510
1511     edit_push_action (edit, KEY_PRESS + edit->start_display);
1512     s = editcmd_dialog_raw_key_query (_("Save macro"), _("Press the macro's new hotkey:"), 1);
1513     edit->force |= REDRAW_COMPLETELY;
1514     if (s)
1515     {
1516         if (edit_delete_macro (edit, s))
1517             return 0;
1518         f = edit_open_macro_file ("a+");
1519         if (f)
1520         {
1521             fprintf (f, ("key '%d 0': "), s);
1522             for (i = 0; i < n; i++)
1523                 fprintf (f, "%lu %d, ", macro[i].command, macro[i].ch);
1524             fprintf (f, ";\n");
1525             fclose (f);
1526             if (saved_macros_loaded)
1527             {
1528                 for (i = 0; i < MAX_MACROS && saved_macro[i]; i++);
1529                 saved_macro[i] = s;
1530             }
1531             return 1;
1532         }
1533         else
1534             edit_error_dialog (_("Save macro"), get_sys_error (_("Cannot open macro file")));
1535     }
1536     return 0;
1537 }
1538
1539 /* --------------------------------------------------------------------------------------------- */
1540
1541 void
1542 edit_delete_macro_cmd (WEdit * edit)
1543 {
1544     int command;
1545
1546     command = editcmd_dialog_raw_key_query (_("Delete macro"), _("Press macro hotkey:"), 1);
1547
1548     if (command != 0)
1549         edit_delete_macro (edit, command);
1550 }
1551
1552 /* --------------------------------------------------------------------------------------------- */
1553 /** return 0 on error */
1554
1555 int
1556 edit_load_macro_cmd (WEdit * edit, struct macro macro[], int *n, int k)
1557 {
1558     FILE *f;
1559     int s, i = 0, found = 0;
1560
1561     (void) edit;
1562
1563     if (saved_macros_loaded)
1564         if (macro_exists (k) < 0)
1565             return 0;
1566
1567     f = edit_open_macro_file ("r");
1568     if (f != NULL)
1569     {
1570         struct macro dummy;
1571         do
1572         {
1573             int u;
1574             u = fscanf (f, ("key '%d 0': "), &s);
1575             if (!u || u == EOF)
1576                 break;
1577             if (!saved_macros_loaded)
1578                 saved_macro[i++] = s;
1579             if (!found)
1580             {
1581                 *n = 0;
1582                 while (*n < MAX_MACRO_LENGTH
1583                        && 2 == fscanf (f, "%lu %d, ", &macro[*n].command, &macro[*n].ch))
1584                     (*n)++;
1585             }
1586             else
1587             {
1588                 while (2 == fscanf (f, "%lu %d, ", &dummy.command, &dummy.ch));
1589             }
1590             {
1591                 int ret;
1592                 ret = fscanf (f, ";\n");
1593             }
1594             if (s == k)
1595                 found = 1;
1596         }
1597         while (!found || !saved_macros_loaded);
1598         if (!saved_macros_loaded)
1599         {
1600             saved_macro[i] = 0;
1601             saved_macros_loaded = 1;
1602         }
1603         fclose (f);
1604         return found;
1605     }
1606     else
1607         edit_error_dialog (_("Load macro"), get_sys_error (_("Cannot open macro file")));
1608     return 0;
1609 }
1610
1611 /* }}} Macro stuff starts here */
1612
1613 /* --------------------------------------------------------------------------------------------- */
1614 /** returns 1 on success */
1615
1616 int
1617 edit_save_confirm_cmd (WEdit * edit)
1618 {
1619     gchar *f = NULL;
1620
1621     if (!edit_check_newline (edit))
1622         return 0;
1623
1624     if (edit_confirm_save)
1625     {
1626         f = g_strdup_printf (_("Confirm save file: \"%s\""), edit->filename);
1627         if (edit_query_dialog2 (_("Save file"), f, _("&Save"), _("&Cancel")))
1628         {
1629             g_free (f);
1630             return 0;
1631         }
1632         g_free (f);
1633     }
1634     return edit_save_cmd (edit);
1635 }
1636
1637
1638 /* --------------------------------------------------------------------------------------------- */
1639 /** returns 1 on success */
1640
1641 int
1642 edit_new_cmd (WEdit * edit)
1643 {
1644     if (edit->modified)
1645     {
1646         if (edit_query_dialog2
1647             (_("Warning"),
1648              _
1649              ("Current text was modified without a file save.\nContinue discards these changes"),
1650              _("C&ontinue"), _("&Cancel")))
1651         {
1652             edit->force |= REDRAW_COMPLETELY;
1653             return 0;
1654         }
1655     }
1656     edit->force |= REDRAW_COMPLETELY;
1657
1658     return edit_renew (edit);   /* if this gives an error, something has really screwed up */
1659 }
1660
1661 /* --------------------------------------------------------------------------------------------- */
1662
1663 int
1664 edit_load_cmd (WEdit * edit, edit_current_file_t what)
1665 {
1666     char *exp;
1667
1668     if (edit->modified
1669         && (edit_query_dialog2
1670             (_("Warning"),
1671              _("Current text was modified without a file save.\n"
1672                "Continue discards these changes"), _("C&ontinue"), _("&Cancel")) == 1))
1673     {
1674         edit->force |= REDRAW_COMPLETELY;
1675         return 0;
1676     }
1677
1678     switch (what)
1679     {
1680     case EDIT_FILE_COMMON:
1681         exp = input_expand_dialog (_("Load"), _("Enter file name:"),
1682                                    MC_HISTORY_EDIT_LOAD, edit->filename);
1683
1684         if (exp)
1685         {
1686             if (*exp)
1687                 edit_load_file_from_filename (edit, exp);
1688             g_free (exp);
1689         }
1690         break;
1691
1692     case EDIT_FILE_SYNTAX:
1693         edit_load_syntax_file (edit);
1694         break;
1695
1696     case EDIT_FILE_MENU:
1697         edit_load_menu_file (edit);
1698         break;
1699
1700     default:
1701         break;
1702     }
1703
1704     edit->force |= REDRAW_COMPLETELY;
1705     return 0;
1706 }
1707
1708 /* --------------------------------------------------------------------------------------------- */
1709 /**
1710    if mark2 is -1 then marking is from mark1 to the cursor.
1711    Otherwise its between the markers. This handles this.
1712    Returns 1 if no text is marked.
1713  */
1714
1715 int
1716 eval_marks (WEdit * edit, long *start_mark, long *end_mark)
1717 {
1718     if (edit->mark1 != edit->mark2)
1719     {
1720         long start_bol, start_eol;
1721         long end_bol, end_eol;
1722         long col1, col2;
1723         long diff1, diff2;
1724         if (edit->mark2 >= 0)
1725         {
1726             *start_mark = min (edit->mark1, edit->mark2);
1727             *end_mark = max (edit->mark1, edit->mark2);
1728         }
1729         else
1730         {
1731             *start_mark = min (edit->mark1, edit->curs1);
1732             *end_mark = max (edit->mark1, edit->curs1);
1733             edit->column2 = edit->curs_col + edit->over_col;
1734         }
1735         if (edit->column_highlight
1736             && (((edit->mark1 > edit->curs1) && (edit->column1 < edit->column2))
1737                 || ((edit->mark1 < edit->curs1) && (edit->column1 > edit->column2))))
1738         {
1739
1740             start_bol = edit_bol (edit, *start_mark);
1741             start_eol = edit_eol (edit, start_bol - 1) + 1;
1742             end_bol = edit_bol (edit, *end_mark);
1743             end_eol = edit_eol (edit, *end_mark);
1744             col1 = min (edit->column1, edit->column2);
1745             col2 = max (edit->column1, edit->column2);
1746
1747             diff1 =
1748                 edit_move_forward3 (edit, start_bol, col2, 0) - edit_move_forward3 (edit, start_bol,
1749                                                                                     col1, 0);
1750             diff2 =
1751                 edit_move_forward3 (edit, end_bol, col2, 0) - edit_move_forward3 (edit, end_bol,
1752                                                                                   col1, 0);
1753
1754             *start_mark -= diff1;
1755             *end_mark += diff2;
1756             *start_mark = max (*start_mark, start_eol);
1757             *end_mark = min (*end_mark, end_eol);
1758         }
1759         return 0;
1760     }
1761     else
1762     {
1763         *start_mark = *end_mark = 0;
1764         edit->column2 = edit->column1 = 0;
1765         return 1;
1766     }
1767 }
1768
1769 /* --------------------------------------------------------------------------------------------- */
1770
1771 void
1772 edit_insert_column_of_text (WEdit * edit, unsigned char *data, int size, int width)
1773 {
1774     long cursor;
1775     int i, col;
1776     cursor = edit->curs1;
1777     col = edit_get_col (edit);
1778     for (i = 0; i < size; i++)
1779     {
1780         if (data[i] == '\n')
1781         {                       /* fill in and move to next line */
1782             int l;
1783             long p;
1784             if (edit_get_byte (edit, edit->curs1) != '\n')
1785             {
1786                 l = width - (edit_get_col (edit) - col);
1787                 while (l > 0)
1788                 {
1789                     edit_insert (edit, ' ');
1790                     l -= space_width;
1791                 }
1792             }
1793             for (p = edit->curs1;; p++)
1794             {
1795                 if (p == edit->last_byte)
1796                 {
1797                     edit_cursor_move (edit, edit->last_byte - edit->curs1);
1798                     edit_insert_ahead (edit, '\n');
1799                     p++;
1800                     break;
1801                 }
1802                 if (edit_get_byte (edit, p) == '\n')
1803                 {
1804                     p++;
1805                     break;
1806                 }
1807             }
1808             edit_cursor_move (edit, edit_move_forward3 (edit, p, col, 0) - edit->curs1);
1809             l = col - edit_get_col (edit);
1810             while (l >= space_width)
1811             {
1812                 edit_insert (edit, ' ');
1813                 l -= space_width;
1814             }
1815             continue;
1816         }
1817         edit_insert (edit, data[i]);
1818     }
1819     edit_cursor_move (edit, cursor - edit->curs1);
1820 }
1821
1822 /* --------------------------------------------------------------------------------------------- */
1823
1824 int
1825 edit_insert_column_of_text_from_file (WEdit * edit, int file)
1826 {
1827     long cursor;
1828     int i, col;
1829     int blocklen = -1, width;
1830     unsigned char *data;
1831     cursor = edit->curs1;
1832     col = edit_get_col (edit);
1833     data = g_malloc0 (TEMP_BUF_LEN);
1834     while ((blocklen = mc_read (file, (char *) data, TEMP_BUF_LEN)) > 0)
1835     {
1836         for (width = 0; width < blocklen; width++)
1837         {
1838             if (data[width] == '\n')
1839                 break;
1840         }
1841         for (i = 0; i < blocklen; i++)
1842         {
1843             if (data[i] == '\n')
1844             {                   /* fill in and move to next line */
1845                 int l;
1846                 long p;
1847                 if (edit_get_byte (edit, edit->curs1) != '\n')
1848                 {
1849                     l = width - (edit_get_col (edit) - col);
1850                     while (l > 0)
1851                     {
1852                         edit_insert (edit, ' ');
1853                         l -= space_width;
1854                     }
1855                 }
1856                 for (p = edit->curs1;; p++)
1857                 {
1858                     if (p == edit->last_byte)
1859                     {
1860                         edit_cursor_move (edit, edit->last_byte - edit->curs1);
1861                         edit_insert_ahead (edit, '\n');
1862                         p++;
1863                         break;
1864                     }
1865                     if (edit_get_byte (edit, p) == '\n')
1866                     {
1867                         p++;
1868                         break;
1869                     }
1870                 }
1871                 edit_cursor_move (edit, edit_move_forward3 (edit, p, col, 0) - edit->curs1);
1872                 l = col - edit_get_col (edit);
1873                 while (l >= space_width)
1874                 {
1875                     edit_insert (edit, ' ');
1876                     l -= space_width;
1877                 }
1878                 continue;
1879             }
1880             edit_insert (edit, data[i]);
1881         }
1882     }
1883     edit_cursor_move (edit, cursor - edit->curs1);
1884     g_free (data);
1885     edit->force |= REDRAW_PAGE;
1886     return blocklen;
1887 }
1888
1889 /* --------------------------------------------------------------------------------------------- */
1890
1891 void
1892 edit_block_copy_cmd (WEdit * edit)
1893 {
1894     long start_mark, end_mark, current = edit->curs1;
1895     int size;
1896     unsigned char *copy_buf;
1897
1898     edit_update_curs_col (edit);
1899     if (eval_marks (edit, &start_mark, &end_mark))
1900         return;
1901
1902     copy_buf = edit_get_block (edit, start_mark, end_mark, &size);
1903
1904     /* all that gets pushed are deletes hence little space is used on the stack */
1905
1906     edit_push_markers (edit);
1907
1908     if (edit->column_highlight)
1909     {
1910         edit_insert_column_of_text (edit, copy_buf, size, abs (edit->column2 - edit->column1));
1911     }
1912     else
1913     {
1914         while (size--)
1915             edit_insert_ahead (edit, copy_buf[size]);
1916     }
1917
1918     g_free (copy_buf);
1919     edit_scroll_screen_over_cursor (edit);
1920
1921     if (edit->column_highlight)
1922     {
1923         edit_set_markers (edit, 0, 0, 0, 0);
1924         edit_push_action (edit, COLUMN_ON);
1925         edit->column_highlight = 0;
1926     }
1927     else if (start_mark < current && end_mark > current)
1928         edit_set_markers (edit, start_mark, end_mark + end_mark - start_mark, 0, 0);
1929
1930     edit->force |= REDRAW_PAGE;
1931 }
1932
1933
1934 /* --------------------------------------------------------------------------------------------- */
1935
1936 void
1937 edit_block_move_cmd (WEdit * edit)
1938 {
1939     long count;
1940     long current;
1941     unsigned char *copy_buf;
1942     long start_mark, end_mark;
1943     int deleted = 0;
1944     int x = 0;
1945
1946     if (eval_marks (edit, &start_mark, &end_mark))
1947         return;
1948     if (edit->column_highlight)
1949     {
1950         edit_update_curs_col (edit);
1951         x = edit->curs_col;
1952         if (start_mark <= edit->curs1 && end_mark >= edit->curs1)
1953             if ((x > edit->column1 && x < edit->column2)
1954                 || (x > edit->column2 && x < edit->column1))
1955                 return;
1956     }
1957     else if (start_mark <= edit->curs1 && end_mark >= edit->curs1)
1958         return;
1959
1960     if ((end_mark - start_mark) > option_max_undo / 2)
1961         if (edit_query_dialog2
1962             (_("Warning"),
1963              _
1964              ("Block is large, you may not be able to undo this action"),
1965              _("C&ontinue"), _("&Cancel")))
1966             return;
1967
1968     edit_push_markers (edit);
1969     current = edit->curs1;
1970     if (edit->column_highlight)
1971     {
1972         long line;
1973         int size, c1, c2;
1974         line = edit->curs_line;
1975         if (edit->mark2 < 0)
1976             edit_mark_cmd (edit, 0);
1977         c1 = min (edit->column1, edit->column2);
1978         c2 = max (edit->column1, edit->column2);
1979         copy_buf = edit_get_block (edit, start_mark, end_mark, &size);
1980         if (x < c2)
1981         {
1982             edit_block_delete_cmd (edit);
1983             deleted = 1;
1984         }
1985         edit_move_to_line (edit, line);
1986         edit_cursor_move (edit,
1987                           edit_move_forward3 (edit,
1988                                               edit_bol (edit, edit->curs1), x, 0) - edit->curs1);
1989         edit_insert_column_of_text (edit, copy_buf, size, c2 - c1);
1990         if (!deleted)
1991         {
1992             line = edit->curs_line;
1993             edit_update_curs_col (edit);
1994             x = edit->curs_col;
1995             edit_block_delete_cmd (edit);
1996             edit_move_to_line (edit, line);
1997             edit_cursor_move (edit,
1998                               edit_move_forward3 (edit,
1999                                                   edit_bol (edit,
2000                                                             edit->curs1), x, 0) - edit->curs1);
2001         }
2002         edit_set_markers (edit, 0, 0, 0, 0);
2003         edit_push_action (edit, COLUMN_ON);
2004         edit->column_highlight = 0;
2005     }
2006     else
2007     {
2008         copy_buf = g_malloc0 (end_mark - start_mark);
2009         edit_cursor_move (edit, start_mark - edit->curs1);
2010         edit_scroll_screen_over_cursor (edit);
2011         count = start_mark;
2012         while (count < end_mark)
2013         {
2014             copy_buf[end_mark - count - 1] = edit_delete (edit, 1);
2015             count++;
2016         }
2017         edit_scroll_screen_over_cursor (edit);
2018         edit_cursor_move (edit,
2019                           current - edit->curs1 -
2020                           (((current - edit->curs1) > 0) ? end_mark - start_mark : 0));
2021         edit_scroll_screen_over_cursor (edit);
2022         while (count-- > start_mark)
2023             edit_insert_ahead (edit, copy_buf[end_mark - count - 1]);
2024         edit_set_markers (edit, edit->curs1, edit->curs1 + end_mark - start_mark, 0, 0);
2025     }
2026     edit_scroll_screen_over_cursor (edit);
2027     g_free (copy_buf);
2028     edit->force |= REDRAW_PAGE;
2029 }
2030
2031 /* --------------------------------------------------------------------------------------------- */
2032 /** returns 1 if canceelled by user */
2033
2034 int
2035 edit_block_delete_cmd (WEdit * edit)
2036 {
2037     long start_mark, end_mark;
2038     if (eval_marks (edit, &start_mark, &end_mark))
2039     {
2040         edit_delete_line (edit);
2041         return 0;
2042     }
2043     return edit_block_delete (edit);
2044 }
2045
2046 /* --------------------------------------------------------------------------------------------- */
2047 /** call with edit = 0 before shutdown to close memory leaks */
2048
2049 void
2050 edit_replace_cmd (WEdit * edit, int again)
2051 {
2052     /* 1 = search string, 2 = replace with */
2053     static char *saved1 = NULL; /* saved default[123] */
2054     static char *saved2 = NULL;
2055     char *input1 = NULL;        /* user input from the dialog */
2056     char *input2 = NULL;
2057     char *disp1 = NULL;
2058     char *disp2 = NULL;
2059     long times_replaced = 0;
2060     gboolean once_found = FALSE;
2061
2062     if (!edit)
2063     {
2064         g_free (saved1), saved1 = NULL;
2065         g_free (saved2), saved2 = NULL;
2066         return;
2067     }
2068
2069     edit->force |= REDRAW_COMPLETELY;
2070
2071     if (again && !saved1 && !saved2)
2072         again = 0;
2073
2074     if (again)
2075     {
2076         input1 = g_strdup (saved1 ? saved1 : "");
2077         input2 = g_strdup (saved2 ? saved2 : "");
2078     }
2079     else
2080     {
2081         char *tmp_inp1, *tmp_inp2;
2082         disp1 = edit_replace_cmd__conv_to_display (saved1 ? saved1 : (char *) "");
2083         disp2 = edit_replace_cmd__conv_to_display (saved2 ? saved2 : (char *) "");
2084
2085         edit_push_action (edit, KEY_PRESS + edit->start_display);
2086
2087         editcmd_dialog_replace_show (edit, disp1, disp2, &input1, &input2);
2088
2089         g_free (disp1);
2090         g_free (disp2);
2091
2092         if (input1 == NULL || *input1 == '\0')
2093         {
2094             edit->force = REDRAW_COMPLETELY;
2095             goto cleanup;
2096         }
2097
2098         tmp_inp1 = input1;
2099         tmp_inp2 = input2;
2100         input1 = edit_replace_cmd__conv_to_input (input1);
2101         input2 = edit_replace_cmd__conv_to_input (input2);
2102         g_free (tmp_inp1);
2103         g_free (tmp_inp2);
2104
2105         g_free (saved1), saved1 = g_strdup (input1);
2106         g_free (saved2), saved2 = g_strdup (input2);
2107
2108         mc_search_free (edit->search);
2109         edit->search = NULL;
2110     }
2111
2112     if (!edit->search)
2113     {
2114         edit->search = mc_search_new (input1, -1);
2115         if (edit->search == NULL)
2116         {
2117             edit->search_start = edit->curs1;
2118             goto cleanup;
2119         }
2120         edit->search->search_type = edit_search_options.type;
2121         edit->search->is_all_charsets = edit_search_options.all_codepages;
2122         edit->search->is_case_sensitive = edit_search_options.case_sens;
2123         edit->search->whole_words = edit_search_options.whole_words;
2124         edit->search->search_fn = edit_search_cmd_callback;
2125     }
2126
2127     if (edit->found_len && edit->search_start == edit->found_start + 1
2128         && edit_search_options.backwards)
2129         edit->search_start--;
2130
2131     if (edit->found_len && edit->search_start == edit->found_start - 1
2132         && !edit_search_options.backwards)
2133         edit->search_start++;
2134
2135     do
2136     {
2137         gsize len = 0;
2138
2139         if (!editcmd_find (edit, &len))
2140         {
2141             if (!(edit->search->error == MC_SEARCH_E_OK ||
2142                   (once_found && edit->search->error == MC_SEARCH_E_NOTFOUND)))
2143             {
2144                 edit_error_dialog (_("Search"), edit->search->error_str);
2145             }
2146             break;
2147         }
2148         once_found = TRUE;
2149
2150         edit->search_start = edit->search->normal_offset;
2151         /*returns negative on not found or error in pattern */
2152
2153         if ((edit->search_start >= 0) && (edit->search_start < edit->last_byte))
2154         {
2155             gsize i;
2156             GString *tmp_str, *repl_str;
2157
2158             edit->found_start = edit->search_start;
2159             i = edit->found_len = len;
2160
2161             edit_cursor_move (edit, edit->search_start - edit->curs1);
2162             edit_scroll_screen_over_cursor (edit);
2163
2164             if (edit->replace_mode == 0)
2165             {
2166                 int l;
2167                 int prompt;
2168
2169                 l = edit->curs_row - edit->num_widget_lines / 3;
2170                 if (l > 0)
2171                     edit_scroll_downward (edit, l);
2172                 if (l < 0)
2173                     edit_scroll_upward (edit, -l);
2174
2175                 edit_scroll_screen_over_cursor (edit);
2176                 edit->force |= REDRAW_PAGE;
2177                 edit_render_keypress (edit);
2178
2179                 /*so that undo stops at each query */
2180                 edit_push_key_press (edit);
2181                 /* and prompt 2/3 down */
2182                 disp1 = edit_replace_cmd__conv_to_display (saved1);
2183                 disp2 = edit_replace_cmd__conv_to_display (saved2);
2184                 prompt = editcmd_dialog_replace_prompt_show (edit, disp1, disp2, -1, -1);
2185                 g_free (disp1);
2186                 g_free (disp2);
2187
2188                 if (prompt == B_REPLACE_ALL)
2189                     edit->replace_mode = 1;
2190                 else if (prompt == B_SKIP_REPLACE)
2191                 {
2192                     if (edit_search_options.backwards)
2193                         edit->search_start--;
2194                     else
2195                         edit->search_start++;
2196                     continue;   /* loop */
2197                 }
2198                 else if (prompt == B_CANCEL)
2199                 {
2200                     edit->replace_mode = -1;
2201                     break;      /* loop */
2202                 }
2203             }
2204
2205             /* don't process string each time */
2206             tmp_str = g_string_new (input2);
2207             repl_str = mc_search_prepare_replace_str (edit->search, tmp_str);
2208             g_string_free (tmp_str, TRUE);
2209
2210             if (edit->search->error != MC_SEARCH_E_OK)
2211             {
2212                 edit_error_dialog (_("Replace"), edit->search->error_str);
2213                 g_string_free (repl_str, TRUE);
2214                 break;
2215             }
2216
2217             /* delete then insert new */
2218             for (i = 0; i < len; i++)
2219                 edit_delete (edit, 1);
2220
2221             for (i = 0; i < repl_str->len; i++)
2222                 edit_insert (edit, repl_str->str[i]);
2223
2224             edit->found_len = repl_str->len;
2225             g_string_free (repl_str, TRUE);
2226             times_replaced++;
2227
2228             /* so that we don't find the same string again */
2229             if (edit_search_options.backwards)
2230                 edit->search_start--;
2231             else
2232             {
2233                 edit->search_start += edit->found_len;
2234
2235                 if (edit->search_start >= edit->last_byte)
2236                     break;
2237             }
2238
2239             edit_scroll_screen_over_cursor (edit);
2240         }
2241         else
2242         {
2243             /* try and find from right here for next search */
2244             edit->search_start = edit->curs1;
2245             edit_update_curs_col (edit);
2246
2247             edit->force |= REDRAW_PAGE;
2248             edit_render_keypress (edit);
2249
2250             if (times_replaced == 0)
2251                 query_dialog (_("Replace"), _("Search string not found"), D_NORMAL, 1, _("&OK"));
2252             break;
2253         }
2254     }
2255     while (edit->replace_mode >= 0);
2256
2257     edit_scroll_screen_over_cursor (edit);
2258     edit->force |= REDRAW_COMPLETELY;
2259     edit_render_keypress (edit);
2260
2261     if ((edit->replace_mode == 1) && (times_replaced != 0))
2262         message (D_NORMAL, _("Replace"), _("%ld replacements made"), times_replaced);
2263
2264   cleanup:
2265     g_free (input1);
2266     g_free (input2);
2267 }
2268
2269 /* --------------------------------------------------------------------------------------------- */
2270
2271 int
2272 edit_search_cmd_callback (const void *user_data, gsize char_offset)
2273 {
2274     return edit_get_byte ((WEdit *) user_data, (long) char_offset);
2275 }
2276
2277 /* --------------------------------------------------------------------------------------------- */
2278
2279 void
2280 edit_search_cmd (WEdit * edit, gboolean again)
2281 {
2282     if (edit == NULL)
2283         return;
2284
2285     if (!again)
2286         edit_search (edit);
2287     else if (edit->last_search_string != NULL)
2288         edit_do_search (edit);
2289     else
2290     {
2291         /* find last search string in history */
2292         GList *history;
2293
2294         history = history_get (MC_HISTORY_SHARED_SEARCH);
2295         if (history != NULL && history->data != NULL)
2296         {
2297             edit->last_search_string = (char *) history->data;
2298             history->data = NULL;
2299             history = g_list_first (history);
2300             g_list_foreach (history, (GFunc) g_free, NULL);
2301             g_list_free (history);
2302
2303             edit->search = mc_search_new (edit->last_search_string, -1);
2304             if (edit->search == NULL)
2305             {
2306                 /* if not... then ask for an expression */
2307                 g_free (edit->last_search_string);
2308                 edit->last_search_string = NULL;
2309                 edit_search (edit);
2310             }
2311             else
2312             {
2313                 edit->search->search_type = edit_search_options.type;
2314                 edit->search->is_all_charsets = edit_search_options.all_codepages;
2315                 edit->search->is_case_sensitive = edit_search_options.case_sens;
2316                 edit->search->whole_words = edit_search_options.whole_words;
2317                 edit->search->search_fn = edit_search_cmd_callback;
2318                 edit_do_search (edit);
2319             }
2320         }
2321         else
2322         {
2323             /* if not... then ask for an expression */
2324             g_free (edit->last_search_string);
2325             edit->last_search_string = NULL;
2326             edit_search (edit);
2327         }
2328     }
2329 }
2330
2331
2332 /* --------------------------------------------------------------------------------------------- */
2333 /**
2334  * Check if it's OK to close the editor.  If there are unsaved changes,
2335  * ask user.  Return 1 if it's OK to exit, 0 to continue editing.
2336  */
2337
2338 gboolean
2339 edit_ok_to_exit (WEdit * edit)
2340 {
2341     int act;
2342
2343     if (!edit->modified)
2344         return TRUE;
2345
2346     if (!midnight_shutdown)
2347     {
2348         if (!edit_check_newline (edit))
2349             return FALSE;
2350
2351         query_set_sel (2);
2352         act = edit_query_dialog3 (_("Quit"), _("File was modified. Save with exit?"),
2353                                   _("&Yes"), _("&No"), _("&Cancel quit"));
2354     }
2355     else
2356     {
2357         act =
2358             edit_query_dialog2 (_("Quit"),
2359                                 _("Midnight Commander is being shut down.\nSave modified file?"),
2360                                 _("&Yes"), _("&No"));
2361
2362         /* Esc is No */
2363         if (act == -1)
2364             act = 1;
2365     }
2366
2367     switch (act)
2368     {
2369     case 0:                    /* Yes */
2370         edit_push_markers (edit);
2371         edit_set_markers (edit, 0, 0, 0, 0);
2372         if (!edit_save_cmd (edit) || midnight_shutdown)
2373             return (gboolean) midnight_shutdown;
2374         break;
2375     case 1:                    /* No */
2376         break;
2377     case 2:                    /* Cancel quit */
2378     case -1:                   /* Esc */
2379         return FALSE;
2380     }
2381
2382     return TRUE;
2383 }
2384
2385 /* --------------------------------------------------------------------------------------------- */
2386 /** save block, returns 1 on success */
2387
2388 int
2389 edit_save_block (WEdit * edit, const char *filename, long start, long finish)
2390 {
2391     int len, file;
2392
2393     file = mc_open (filename, O_CREAT | O_WRONLY | O_TRUNC,
2394                     S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH | O_BINARY);
2395     if (file == -1)
2396         return 0;
2397
2398     if (edit->column_highlight)
2399     {
2400         int r;
2401         r = mc_write (file, VERTICAL_MAGIC, sizeof (VERTICAL_MAGIC));
2402         if (r > 0)
2403         {
2404             unsigned char *block, *p;
2405             p = block = edit_get_block (edit, start, finish, &len);
2406             while (len)
2407             {
2408                 r = mc_write (file, p, len);
2409                 if (r < 0)
2410                     break;
2411                 p += r;
2412                 len -= r;
2413             }
2414             g_free (block);
2415         }
2416     }
2417     else
2418     {
2419         unsigned char *buf;
2420         int i = start, end;
2421         len = finish - start;
2422         buf = g_malloc0 (TEMP_BUF_LEN);
2423         while (start != finish)
2424         {
2425             end = min (finish, start + TEMP_BUF_LEN);
2426             for (; i < end; i++)
2427                 buf[i - start] = edit_get_byte (edit, i);
2428             len -= mc_write (file, (char *) buf, end - start);
2429             start = end;
2430         }
2431         g_free (buf);
2432     }
2433     mc_close (file);
2434     if (len)
2435         return 0;
2436     return 1;
2437 }
2438
2439 /* --------------------------------------------------------------------------------------------- */
2440
2441 void
2442 edit_paste_from_history (WEdit * edit)
2443 {
2444     (void) edit;
2445     edit_error_dialog (_("Error"), _("This function is not implemented"));
2446 }
2447
2448 /* --------------------------------------------------------------------------------------------- */
2449
2450 int
2451 edit_copy_to_X_buf_cmd (WEdit * edit)
2452 {
2453     long start_mark, end_mark;
2454     if (eval_marks (edit, &start_mark, &end_mark))
2455         return 0;
2456     if (!edit_save_block_to_clip_file (edit, start_mark, end_mark))
2457     {
2458         edit_error_dialog (_("Copy to clipboard"), get_sys_error (_("Unable to save to file")));
2459         return 1;
2460     }
2461     /* try use external clipboard utility */
2462     copy_file_to_ext_clip ();
2463
2464     return 0;
2465 }
2466
2467 /* --------------------------------------------------------------------------------------------- */
2468
2469 int
2470 edit_cut_to_X_buf_cmd (WEdit * edit)
2471 {
2472     long start_mark, end_mark;
2473     if (eval_marks (edit, &start_mark, &end_mark))
2474         return 0;
2475     if (!edit_save_block_to_clip_file (edit, start_mark, end_mark))
2476     {
2477         edit_error_dialog (_("Cut to clipboard"), _("Unable to save to file"));
2478         return 1;
2479     }
2480     /* try use external clipboard utility */
2481     copy_file_to_ext_clip ();
2482
2483     edit_block_delete_cmd (edit);
2484     edit_mark_cmd (edit, 1);
2485     return 0;
2486 }
2487
2488 /* --------------------------------------------------------------------------------------------- */
2489
2490 void
2491 edit_paste_from_X_buf_cmd (WEdit * edit)
2492 {
2493     gchar *tmp;
2494     /* try use external clipboard utility */
2495     paste_to_file_from_ext_clip ();
2496     tmp = concat_dir_and_file (home_dir, EDIT_CLIP_FILE);
2497     edit_insert_file (edit, tmp);
2498     g_free (tmp);
2499 }
2500
2501
2502 /* --------------------------------------------------------------------------------------------- */
2503 /**
2504  * Ask user for the line and go to that line.
2505  * Negative numbers mean line from the end (i.e. -1 is the last line).
2506  */
2507
2508 void
2509 edit_goto_cmd (WEdit * edit)
2510 {
2511     char *f;
2512     static long line = 0;       /* line as typed, saved as default */
2513     long l;
2514     char *error;
2515     char s[32];
2516
2517     g_snprintf (s, sizeof (s), "%ld", line);
2518     f = input_dialog (_("Goto line"), _("Enter line:"), MC_HISTORY_EDIT_GOTO_LINE, line ? s : "");
2519     if (!f)
2520         return;
2521
2522     if (!*f)
2523     {
2524         g_free (f);
2525         return;
2526     }
2527
2528     l = strtol (f, &error, 0);
2529     if (*error)
2530     {
2531         g_free (f);
2532         return;
2533     }
2534
2535     line = l;
2536     if (l < 0)
2537         l = edit->total_lines + l + 2;
2538     edit_move_display (edit, l - edit->num_widget_lines / 2 - 1);
2539     edit_move_to_line (edit, l - 1);
2540     edit->force |= REDRAW_COMPLETELY;
2541     g_free (f);
2542 }
2543
2544
2545 /* --------------------------------------------------------------------------------------------- */
2546 /** Return 1 on success */
2547
2548 int
2549 edit_save_block_cmd (WEdit * edit)
2550 {
2551     long start_mark, end_mark;
2552     char *exp, *tmp;
2553
2554     if (eval_marks (edit, &start_mark, &end_mark))
2555         return 1;
2556
2557     tmp = concat_dir_and_file (home_dir, EDIT_CLIP_FILE);
2558     exp =
2559         input_expand_dialog (_("Save block"), _("Enter file name:"),
2560                              MC_HISTORY_EDIT_SAVE_BLOCK, tmp);
2561     g_free (tmp);
2562     edit_push_action (edit, KEY_PRESS + edit->start_display);
2563     if (exp)
2564     {
2565         if (!*exp)
2566         {
2567             g_free (exp);
2568             return 0;
2569         }
2570         else
2571         {
2572             if (edit_save_block (edit, exp, start_mark, end_mark))
2573             {
2574                 g_free (exp);
2575                 edit->force |= REDRAW_COMPLETELY;
2576                 return 1;
2577             }
2578             else
2579             {
2580                 g_free (exp);
2581                 edit_error_dialog (_("Save block"), get_sys_error (_("Cannot save file")));
2582             }
2583         }
2584     }
2585     edit->force |= REDRAW_COMPLETELY;
2586     return 0;
2587 }
2588
2589
2590 /* --------------------------------------------------------------------------------------------- */
2591 /** returns 1 on success */
2592
2593 int
2594 edit_insert_file_cmd (WEdit * edit)
2595 {
2596     gchar *tmp;
2597     char *exp;
2598
2599     tmp = concat_dir_and_file (home_dir, EDIT_CLIP_FILE);
2600     exp = input_expand_dialog (_("Insert file"), _("Enter file name:"),
2601                                MC_HISTORY_EDIT_INSERT_FILE, tmp);
2602     g_free (tmp);
2603     edit_push_action (edit, KEY_PRESS + edit->start_display);
2604     if (exp)
2605     {
2606         if (!*exp)
2607         {
2608             g_free (exp);
2609             return 0;
2610         }
2611         else
2612         {
2613             if (edit_insert_file (edit, exp))
2614             {
2615                 g_free (exp);
2616                 edit->force |= REDRAW_COMPLETELY;
2617                 return 1;
2618             }
2619             else
2620             {
2621                 g_free (exp);
2622                 edit_error_dialog (_("Insert file"), get_sys_error (_("Cannot insert file")));
2623             }
2624         }
2625     }
2626     edit->force |= REDRAW_COMPLETELY;
2627     return 0;
2628 }
2629
2630 /* --------------------------------------------------------------------------------------------- */
2631 /** sorts a block, returns -1 on system fail, 1 on cancel and 0 on success */
2632
2633 int
2634 edit_sort_cmd (WEdit * edit)
2635 {
2636     static char *old = 0;
2637     char *exp, *tmp;
2638     long start_mark, end_mark;
2639     int e;
2640
2641     if (eval_marks (edit, &start_mark, &end_mark))
2642     {
2643         edit_error_dialog (_("Sort block"), _("You must first highlight a block of text"));
2644         return 0;
2645     }
2646
2647     tmp = concat_dir_and_file (home_dir, EDIT_BLOCK_FILE);
2648     edit_save_block (edit, tmp, start_mark, end_mark);
2649     g_free (tmp);
2650
2651     exp = input_dialog (_("Run sort"),
2652                         _("Enter sort options (see manpage) separated by whitespace:"),
2653                         MC_HISTORY_EDIT_SORT, (old != NULL) ? old : "");
2654
2655     if (!exp)
2656         return 1;
2657     g_free (old);
2658     old = exp;
2659     tmp = g_strconcat (" sort ", exp, " ", home_dir, PATH_SEP_STR EDIT_BLOCK_FILE, " > ",
2660                        home_dir, PATH_SEP_STR EDIT_TEMP_FILE, (char *) NULL);
2661     e = system (tmp);
2662     g_free (tmp);
2663     if (e)
2664     {
2665         if (e == -1 || e == 127)
2666         {
2667             edit_error_dialog (_("Sort"), get_sys_error (_("Cannot execute sort command")));
2668         }
2669         else
2670         {
2671             char q[8];
2672             sprintf (q, "%d ", e);
2673             tmp = g_strdup_printf (_("Sort returned non-zero: %s"), q);
2674             edit_error_dialog (_("Sort"), tmp);
2675             g_free (tmp);
2676         }
2677         return -1;
2678     }
2679
2680     edit->force |= REDRAW_COMPLETELY;
2681
2682     if (edit_block_delete_cmd (edit))
2683         return 1;
2684     tmp = concat_dir_and_file (home_dir, EDIT_TEMP_FILE);
2685     edit_insert_file (edit, tmp);
2686     g_free (tmp);
2687     return 0;
2688 }
2689
2690 /* --------------------------------------------------------------------------------------------- */
2691 /**
2692  * Ask user for a command, execute it and paste its output back to the
2693  * editor.
2694  */
2695
2696 int
2697 edit_ext_cmd (WEdit * edit)
2698 {
2699     char *exp, *tmp;
2700     int e;
2701
2702     exp =
2703         input_dialog (_("Paste output of external command"),
2704                       _("Enter shell command(s):"), MC_HISTORY_EDIT_PASTE_EXTCMD, NULL);
2705
2706     if (!exp)
2707         return 1;
2708
2709     tmp = g_strconcat (exp, " > ", home_dir, PATH_SEP_STR EDIT_TEMP_FILE, (char *) NULL);
2710     e = system (tmp);
2711     g_free (tmp);
2712     g_free (exp);
2713
2714     if (e)
2715     {
2716         edit_error_dialog (_("External command"), get_sys_error (_("Cannot execute command")));
2717         return -1;
2718     }
2719
2720     edit->force |= REDRAW_COMPLETELY;
2721     tmp = concat_dir_and_file (home_dir, EDIT_TEMP_FILE);
2722     edit_insert_file (edit, tmp);
2723     g_free (tmp);
2724     return 0;
2725 }
2726
2727 /* --------------------------------------------------------------------------------------------- */
2728 /** if block is 1, a block must be highlighted and the shell command
2729    processes it. If block is 0 the shell command is a straight system
2730    command, that just produces some output which is to be inserted */
2731
2732 void
2733 edit_block_process_cmd (WEdit * edit, const char *shell_cmd, int block)
2734 {
2735     long start_mark, end_mark;
2736     char buf[BUFSIZ];
2737     FILE *script_home = NULL;
2738     FILE *block_file = NULL;
2739     gchar *o, *h, *b, *tmp;
2740     char *quoted_name = NULL;
2741
2742     o = g_strconcat (mc_home, shell_cmd, (char *) NULL);        /* original source script */
2743     h = g_strconcat (home_dir, PATH_SEP_STR EDIT_DIR, shell_cmd, (char *) NULL);        /* home script */
2744     b = concat_dir_and_file (home_dir, EDIT_BLOCK_FILE);        /* block file */
2745
2746     script_home = fopen (h, "r");
2747     if (script_home == NULL)
2748     {
2749         FILE *script_src = NULL;
2750
2751         script_home = fopen (h, "w");
2752         if (script_home == NULL)
2753         {
2754             tmp = g_strconcat (_("Error creating script:"), h, (char *) NULL);
2755             edit_error_dialog ("", get_sys_error (tmp));
2756             g_free (tmp);
2757             goto edit_block_process_cmd__EXIT;
2758         }
2759
2760         script_src = fopen (o, "r");
2761         if (script_src == NULL)
2762         {
2763             o = g_strconcat (mc_home_alt, shell_cmd, (char *) NULL);
2764             script_src = fopen (o, "r");
2765             if (script_src == NULL)
2766             {
2767                 fclose (script_home);
2768                 unlink (h);
2769                 tmp = g_strconcat (_("Error reading script:"), o, (char *) NULL);
2770                 edit_error_dialog ("", get_sys_error (tmp));
2771                 g_free (tmp);
2772                 goto edit_block_process_cmd__EXIT;
2773             }
2774         }
2775         while (fgets (buf, sizeof (buf), script_src))
2776             fputs (buf, script_home);
2777         fclose (script_src);
2778
2779         if (fclose (script_home))
2780         {
2781             tmp = g_strconcat (_("Error closing script:"), h, (char *) NULL);
2782             edit_error_dialog ("", get_sys_error (tmp));
2783             g_free (tmp);
2784             goto edit_block_process_cmd__EXIT;
2785         }
2786         chmod (h, 0700);
2787         tmp = g_strconcat (_("Script created:"), h, (char *) NULL);
2788         edit_error_dialog ("", get_sys_error (tmp));
2789         g_free (tmp);
2790     }
2791
2792     open_error_pipe ();
2793
2794     if (block)
2795     {                           /* for marked block run indent formatter */
2796         if (eval_marks (edit, &start_mark, &end_mark))
2797         {
2798             edit_error_dialog (_("Process block"), _("You must first highlight a block of text"));
2799             goto edit_block_process_cmd__EXIT;
2800         }
2801         edit_save_block (edit, b, start_mark, end_mark);
2802         quoted_name = name_quote (edit->filename, 0);
2803         /*
2804          * Run script.
2805          * Initial space is to avoid polluting bash history.
2806          * Arguments:
2807          *   $1 - name of the edited file (to check its extension etc).
2808          *   $2 - file containing the current block.
2809          *   $3 - file where error messages should be put
2810          *        (for compatibility with old scripts).
2811          */
2812         tmp = g_strconcat (" ", home_dir, PATH_SEP_STR EDIT_DIR, shell_cmd, " ", quoted_name,
2813                            " ", home_dir, PATH_SEP_STR EDIT_BLOCK_FILE " /dev/null", (char *) NULL);
2814     }
2815     else
2816     {
2817         /*
2818          * No block selected, just execute the command for the file.
2819          * Arguments:
2820          *   $1 - name of the edited file.
2821          */
2822         tmp = g_strconcat (" ", home_dir, PATH_SEP_STR EDIT_DIR, shell_cmd, " ",
2823                            quoted_name, (char *) NULL);
2824     }
2825
2826     if (system (tmp) == -1)
2827     {
2828         edit_error_dialog (_("Process block"), _("Error calling program"));
2829     }
2830     else
2831     {
2832
2833         g_free (quoted_name);
2834         close_error_pipe (D_NORMAL, NULL);
2835
2836         edit_refresh_cmd (edit);
2837         edit->force |= REDRAW_COMPLETELY;
2838
2839         /* insert result block */
2840         if (block && !edit_block_delete_cmd (edit))
2841         {
2842             edit_insert_file (edit, b);
2843             block_file = fopen (b, "w");
2844             if (block_file != NULL)
2845                 fclose (block_file);
2846         }
2847     }
2848     g_free (tmp);
2849
2850   edit_block_process_cmd__EXIT:
2851     g_free (b);
2852     g_free (h);
2853     g_free (o);
2854 }
2855
2856 /* --------------------------------------------------------------------------------------------- */
2857 /**
2858  * prints at the cursor
2859  * @returns the number of chars printed
2860  */
2861
2862 int
2863 edit_print_string (WEdit * e, const char *s)
2864 {
2865     size_t i = 0;
2866     while (s[i] != '\0')
2867         edit_execute_cmd (e, CK_Insert_Char, (unsigned char) s[i++]);
2868     e->force |= REDRAW_COMPLETELY;
2869     edit_update_screen (e);
2870     return i;
2871 }
2872
2873 /* --------------------------------------------------------------------------------------------- */
2874
2875 void
2876 edit_mail_dialog (WEdit * edit)
2877 {
2878     char *tmail_to;
2879     char *tmail_subject;
2880     char *tmail_cc;
2881
2882     static char *mail_cc_last = 0;
2883     static char *mail_subject_last = 0;
2884     static char *mail_to_last = 0;
2885
2886     QuickWidget quick_widgets[] = {
2887         /* 0 */ QUICK_BUTTON (6, 10, 9, MAIL_DLG_HEIGHT, N_("&Cancel"), B_CANCEL, NULL),
2888         /* 1 */ QUICK_BUTTON (2, 10, 9, MAIL_DLG_HEIGHT, N_("&OK"), B_ENTER, NULL),
2889         /* 2 */ QUICK_INPUT (3, 50, 8, MAIL_DLG_HEIGHT, "", 44, 0, "mail-dlg-input", &tmail_cc),
2890         /* 3 */ QUICK_LABEL (3, 50, 7, MAIL_DLG_HEIGHT, N_("Copies to")),
2891         /* 4 */ QUICK_INPUT (3, 50, 6, MAIL_DLG_HEIGHT, "", 44, 0, "mail-dlg-input-2",
2892                              &tmail_subject),
2893         /* 5 */ QUICK_LABEL (3, 50, 5, MAIL_DLG_HEIGHT, N_("Subject")),
2894         /* 6 */ QUICK_INPUT (3, 50, 4, MAIL_DLG_HEIGHT, "", 44, 0, "mail-dlg-input-3", &tmail_to),
2895         /* 7 */ QUICK_LABEL (3, 50, 3, MAIL_DLG_HEIGHT, N_("To")),
2896         /* 8 */ QUICK_LABEL (3, 50, 2, MAIL_DLG_HEIGHT, N_("mail -s <subject> -c <cc> <to>")),
2897         QUICK_END
2898     };
2899
2900     QuickDialog Quick_input = {
2901         50, MAIL_DLG_HEIGHT, -1, -1, N_("Mail"),
2902         "[Input Line Keys]", quick_widgets, NULL, FALSE
2903     };
2904
2905     quick_widgets[2].u.input.text = mail_cc_last ? mail_cc_last : "";
2906     quick_widgets[4].u.input.text = mail_subject_last ? mail_subject_last : "";
2907     quick_widgets[6].u.input.text = mail_to_last ? mail_to_last : "";
2908
2909     if (quick_dialog (&Quick_input) != B_CANCEL)
2910     {
2911         g_free (mail_cc_last);
2912         g_free (mail_subject_last);
2913         g_free (mail_to_last);
2914         mail_cc_last = tmail_cc;
2915         mail_subject_last = tmail_subject;
2916         mail_to_last = tmail_to;
2917         pipe_mail (edit, mail_to_last, mail_subject_last, mail_cc_last);
2918     }
2919 }
2920
2921
2922 /*******************/
2923 /* Word Completion */
2924 /*******************/
2925
2926 /* --------------------------------------------------------------------------------------------- */
2927 /**
2928  * Complete current word using regular expression search
2929  * backwards beginning at the current cursor position.
2930  */
2931
2932 void
2933 edit_complete_word_cmd (WEdit * edit)
2934 {
2935     gsize i, max_len, word_len = 0, num_compl = 0;
2936     long word_start = 0;
2937     unsigned char *bufpos;
2938     char *match_expr;
2939     struct selection compl[MAX_WORD_COMPLETIONS];       /* completions */
2940
2941     /* search start of word to be completed */
2942     if (!edit_find_word_start (edit, &word_start, &word_len))
2943         return;
2944
2945     /* prepare match expression */
2946     bufpos = &edit->buffers1[word_start >> S_EDIT_BUF_SIZE][word_start & M_EDIT_BUF_SIZE];
2947
2948     /* match_expr = g_strdup_printf ("\\b%.*s[a-zA-Z_0-9]+", word_len, bufpos); */
2949     match_expr =
2950         g_strdup_printf
2951         ("(^|\\s+|\\b)%.*s[^\\s\\.=\\+\\[\\]\\(\\)\\,\\;\\:\\\"\\'\\-\\?\\/\\|\\\\\\{\\}\\*\\&\\^\\%%\\$#@\\!]+",
2952          (int) word_len, bufpos);
2953
2954     /* collect the possible completions              */
2955     /* start search from begin to end of file */
2956     max_len =
2957         edit_collect_completions (edit, word_start, word_len, match_expr,
2958                                   (struct selection *) &compl, &num_compl);
2959
2960     if (num_compl > 0)
2961     {
2962         /* insert completed word if there is only one match */
2963         if (num_compl == 1)
2964         {
2965             for (i = word_len; i < compl[0].len; i++)
2966                 edit_insert (edit, *(compl[0].text + i));
2967         }
2968         /* more than one possible completion => ask the user */
2969         else
2970         {
2971             /* !!! usually only a beep is expected and when <ALT-TAB> is !!! */
2972             /* !!! pressed again the selection dialog pops up, but that  !!! */
2973             /* !!! seems to require a further internal state             !!! */
2974             /*tty_beep (); */
2975
2976             /* let the user select the preferred completion */
2977             editcmd_dialog_completion_show (edit, max_len, word_len,
2978                                             (struct selection *) &compl, num_compl);
2979         }
2980     }
2981
2982     g_free (match_expr);
2983     /* release memory before return */
2984     for (i = 0; i < num_compl; i++)
2985         g_free (compl[i].text);
2986 }
2987
2988 /* --------------------------------------------------------------------------------------------- */
2989
2990 void
2991 edit_select_codepage_cmd (WEdit * edit)
2992 {
2993 #ifdef HAVE_CHARSET
2994     if (do_select_codepage ())
2995         edit_set_codeset (edit);
2996
2997     edit->force = REDRAW_COMPLETELY;
2998     edit_refresh_cmd (edit);
2999 #else
3000     (void) edit;
3001 #endif
3002 }
3003
3004 /* --------------------------------------------------------------------------------------------- */
3005
3006 void
3007 edit_insert_literal_cmd (WEdit * edit)
3008 {
3009     int char_for_insertion = editcmd_dialog_raw_key_query (_("Insert literal"),
3010                                                            _("Press any key:"), 0);
3011     edit_execute_key_command (edit, -1, ascii_alpha_to_cntrl (char_for_insertion));
3012 }
3013
3014 /* --------------------------------------------------------------------------------------------- */
3015
3016 void
3017 edit_execute_macro_cmd (WEdit * edit)
3018 {
3019     int command =
3020         CK_Macro (editcmd_dialog_raw_key_query (_("Execute macro"), _("Press macro hotkey:"),
3021                                                 1));
3022     if (command == CK_Macro (0))
3023         command = CK_Insert_Char;
3024
3025     edit_execute_key_command (edit, command, -1);
3026 }
3027
3028 /* --------------------------------------------------------------------------------------------- */
3029
3030 void
3031 edit_begin_end_macro_cmd (WEdit * edit)
3032 {
3033     /* edit is a pointer to the widget */
3034     if (edit)
3035     {
3036         unsigned long command = edit->macro_i < 0 ? CK_Begin_Record_Macro : CK_End_Record_Macro;
3037         edit_execute_key_command (edit, command, -1);
3038     }
3039 }
3040
3041 /* --------------------------------------------------------------------------------------------- */
3042
3043 int
3044 edit_load_forward_cmd (WEdit * edit)
3045 {
3046     if (edit->modified)
3047     {
3048         if (edit_query_dialog2
3049             (_("Warning"),
3050              _("Current text was modified without a file save\n"
3051                "Continue discards these changes"), _("C&ontinue"), _("&Cancel")))
3052         {
3053             edit->force |= REDRAW_COMPLETELY;
3054             return 0;
3055         }
3056     }
3057     if (edit_stack_iterator + 1 < MAX_HISTORY_MOVETO)
3058     {
3059         if (edit_history_moveto[edit_stack_iterator + 1].line < 1)
3060         {
3061             return 1;
3062         }
3063         edit_stack_iterator++;
3064         if (edit_history_moveto[edit_stack_iterator].filename)
3065         {
3066             edit_reload_line (edit, edit_history_moveto[edit_stack_iterator].filename,
3067                               edit_history_moveto[edit_stack_iterator].line);
3068             return 0;
3069         }
3070         else
3071         {
3072             return 1;
3073         }
3074     }
3075     else
3076     {
3077         return 1;
3078     }
3079 }
3080
3081 /* --------------------------------------------------------------------------------------------- */
3082
3083 int
3084 edit_load_back_cmd (WEdit * edit)
3085 {
3086     if (edit->modified)
3087     {
3088         if (edit_query_dialog2
3089             (_("Warning"),
3090              _("Current text was modified without a file save\n"
3091                "Continue discards these changes"), _("C&ontinue"), _("&Cancel")))
3092         {
3093             edit->force |= REDRAW_COMPLETELY;
3094             return 0;
3095         }
3096     }
3097     if (edit_stack_iterator > 0)
3098     {
3099         edit_stack_iterator--;
3100         if (edit_history_moveto[edit_stack_iterator].filename)
3101         {
3102             edit_reload_line (edit, edit_history_moveto[edit_stack_iterator].filename,
3103                               edit_history_moveto[edit_stack_iterator].line);
3104             return 0;
3105         }
3106         else
3107         {
3108             return 1;
3109         }
3110     }
3111     else
3112     {
3113         return 1;
3114     }
3115 }
3116
3117 /* --------------------------------------------------------------------------------------------- */
3118
3119 void
3120 edit_get_match_keyword_cmd (WEdit * edit)
3121 {
3122     gsize word_len = 0, max_len = 0;
3123     int num_def = 0;
3124     int i;
3125     long word_start = 0;
3126     unsigned char *bufpos;
3127     char *match_expr;
3128     char *path = NULL;
3129     char *ptr = NULL;
3130     char *tagfile = NULL;
3131
3132     etags_hash_t def_hash[MAX_DEFINITIONS];
3133
3134     for (i = 0; i < MAX_DEFINITIONS; i++)
3135     {
3136         def_hash[i].filename = NULL;
3137     }
3138
3139     /* search start of word to be completed */
3140     if (!edit_find_word_start (edit, &word_start, &word_len))
3141         return;
3142
3143     /* prepare match expression */
3144     bufpos = &edit->buffers1[word_start >> S_EDIT_BUF_SIZE][word_start & M_EDIT_BUF_SIZE];
3145     match_expr = g_strdup_printf ("%.*s", (int) word_len, bufpos);
3146
3147     ptr = g_get_current_dir ();
3148     path = g_strconcat (ptr, G_DIR_SEPARATOR_S, (char *) NULL);
3149     g_free (ptr);
3150
3151     /* Recursive search file 'TAGS' in parent dirs */
3152     do
3153     {
3154         ptr = g_path_get_dirname (path);
3155         g_free (path);
3156         path = ptr;
3157         g_free (tagfile);
3158         tagfile = g_build_filename (path, TAGS_NAME, (char *) NULL);
3159         if (exist_file (tagfile))
3160             break;
3161     }
3162     while (strcmp (path, G_DIR_SEPARATOR_S) != 0);
3163
3164     if (tagfile)
3165     {
3166         num_def =
3167             etags_set_definition_hash (tagfile, path, match_expr, (etags_hash_t *) & def_hash);
3168         g_free (tagfile);
3169     }
3170     g_free (path);
3171
3172     max_len = MAX_WIDTH_DEF_DIALOG;
3173     word_len = 0;
3174     if (num_def > 0)
3175     {
3176         editcmd_dialog_select_definition_show (edit, match_expr, max_len, word_len,
3177                                                (etags_hash_t *) & def_hash, num_def);
3178     }
3179     g_free (match_expr);
3180 }
3181
3182 /* --------------------------------------------------------------------------------------------- */
3183
3184 void
3185 edit_move_block_to_right (WEdit * edit)
3186 {
3187     long start_mark, end_mark;
3188     long cur_bol, start_bol;
3189
3190     if (eval_marks (edit, &start_mark, &end_mark))
3191         return;
3192
3193     start_bol = edit_bol (edit, start_mark);
3194     cur_bol = edit_bol (edit, end_mark - 1);
3195     do
3196     {
3197         edit_cursor_move (edit, cur_bol - edit->curs1);
3198         if (option_fill_tabs_with_spaces)
3199         {
3200             if (option_fake_half_tabs)
3201             {
3202                 insert_spaces_tab (edit, 1);
3203             }
3204             else
3205             {
3206                 insert_spaces_tab (edit, 0);
3207             }
3208         }
3209         else
3210         {
3211             edit_insert (edit, '\t');
3212         }
3213         edit_cursor_move (edit, edit_bol (edit, cur_bol) - edit->curs1);
3214         if (cur_bol == 0)
3215         {
3216             break;
3217         }
3218         cur_bol = edit_bol (edit, cur_bol - 1);
3219     }
3220     while (cur_bol >= start_bol);
3221     edit->force |= REDRAW_PAGE;
3222 }
3223
3224 /* --------------------------------------------------------------------------------------------- */
3225
3226 void
3227 edit_move_block_to_left (WEdit * edit)
3228 {
3229     long start_mark, end_mark;
3230     long cur_bol, start_bol;
3231     int i, del_tab_width;
3232     int next_char;
3233
3234     if (eval_marks (edit, &start_mark, &end_mark))
3235         return;
3236
3237     start_bol = edit_bol (edit, start_mark);
3238     cur_bol = edit_bol (edit, end_mark - 1);
3239     do
3240     {
3241         edit_cursor_move (edit, cur_bol - edit->curs1);
3242         if (option_fake_half_tabs)
3243         {
3244             del_tab_width = HALF_TAB_SIZE;
3245         }
3246         else
3247         {
3248             del_tab_width = option_tab_spacing;
3249         }
3250         next_char = edit_get_byte (edit, edit->curs1);
3251         if (next_char == '\t')
3252         {
3253             edit_delete (edit, 1);
3254         }
3255         else if (next_char == ' ')
3256         {
3257             for (i = 1; i <= del_tab_width; i++)
3258             {
3259                 if (next_char == ' ')
3260                 {
3261                     edit_delete (edit, 1);
3262                 }
3263                 next_char = edit_get_byte (edit, edit->curs1);
3264             }
3265         }
3266         if (cur_bol == 0)
3267         {
3268             break;
3269         }
3270         cur_bol = edit_bol (edit, cur_bol - 1);
3271     }
3272     while (cur_bol >= start_bol);
3273     edit->force |= REDRAW_PAGE;
3274 }
3275
3276 /* --------------------------------------------------------------------------------------------- */