switches.c

功能强大的文本编辑器

                  replace_count = 0;
                  all_flag = 0;
                  first_call = 1;
               }
               else
               {
                  first_call = 0;
               }

               new_index = perform_find (1, str_find, 
                                        (first_call || (key_0 == '?')), &len1);

               save_find_indizes (1, new_index, len1);

#if 0
            /* ?Replace --> Replace (question has been switched off) */
               if (all_flag)
                  key_0 = 'R';
#endif

               if (new_index < 0L)
               {
                  find_ok = 0;
                  end_of_edit = -1;
               }
               else
               {
                  find_ok = 1;
                  find_count++;

               /* perform_replace */
               /* len1 = strlen (str_find); wird in comm_find bestimmt !! */
                  len2 = strlen (str_repl);
                  delta = len2 - len1;

               /* passt neuer string noch mit rein ? */
                  if (check_and_increase_buffer (fc,
                                                 (fc->byte_anz + delta),
                                                  FILE_RESERVE, 0) < 0)
                  {                      /* nein ! */
                     end_of_edit = -1;

                  /* zeiger bewegen */
                     perform_move (new_index);

                  /* ggf. zeigen */
                     if (fc->lrow >= MAX_ROW)
                        perform_view ();

                     err_message (BUFFER_OVERFLOW);
                  }
                  else
                  {
                  /* save old position */
                     old_index = fc->byte_index;
                        
                  /* ersetzen mit nachfrage ? */
                     if ((key_0 != '?') || (all_flag))
                     {
                        replace_flag = 1;
                     }
                     else
                     {
                     /* zeiger bewegen */
                        perform_move (new_index);

                     /* ggf. zeigen */
                        if (fc->lrow >= MAX_ROW)
                           perform_view ();
                        else
                           if (set.wildcards)
                           {
                              update_entire_window (fc->top_left);
                              perform_update (fc->buff_0, fc->byte_anz,
                                              fc->left_col);
                           }

                     /* abfragen, ob loeschen erlaubt */
                        show_status_line_1 (get_line_1_text (), fc);
                        show_status_line_2 ("Replace ? [Y/N/A]", 0, -1, 0);
                        set_cursor_to (fc->lrow, REL_COLUMN); /* stelle zeigen */

                        key_2 = get_1_key (0);

                        switch (toupper (key_2))
                        {
                           case 'A':
                              all_flag = 1;
                              /* fall through */

                           case 'Y':
                              replace_flag = 1;
                              break;

                           case 0x03:  /* ^C */
                              end_of_edit = -1;       /* Quit Replace Mode */
                              /* fall through */

                           default:
                              replace_flag = 0;
                              break;
                        }
                     }  /* if key_0 == '?'  */

                  /* jetzt aber wirklich ! */
                     if (replace_flag)
                     {
                     /* restore old position */
                        perform_move (old_index);

                        replace_count++;

                     /* new_index = zeiger hinter gef. string, */
                     /* setzen hinter ende des ersatz-strings  */
                        new_index += delta;
   
                     /* buffer um delta verschieben */
                        memcpy_rev (&fc->buff_0 [new_index],
                                    &fc->buff_0 [new_index - delta],
                                    (fc->byte_anz - (new_index - delta) + 1));

                        fc->byte_anz += delta;

                     /* ersatz-string einschieben */
                        { /* MS-C 6.00A ist zu doof fuer diesen befehl */ 
                          long help = new_index - len2;
                          
                          memcpy (&fc->buff_0 [help],
                                  str_repl, len2);
                        }

                     /* wg. kompatibilitaet zu AEDIT */
                        check_tag_index ((new_index - len2), -(long) len1);
                        check_tag_index ((new_index - len2),  (long) len2);
   
                     /* zeiger steht noch hinter ende des neuen strings */
                        perform_move (new_index);
      
                        save_find_indizes (1, new_index, len2);

                     /* anzahl lines wieder restaurieren */
                        fc->line_anz -= get_total_lines (
                                            (char FA_HU *) str_find,
                                             0L, (long) strlen (str_find));
                                                /* hier ^ nicht len1 !! */
                        fc->line_anz += get_total_lines (
                                            (char FA_HU *) str_repl,
                                             0L, (long) len2);
                        fc->change_flag = 1;
                     }  /* if replace_flag */
                  }  /* kein buffer overflow */
               }  /* if new_index >= 0L */

            /* letzter durchlauf ? */
               last_call = ((repeat_count >= (repeat_max - 1)) ||
                            (find_ok == 0));
               abort = show_find_display (key_0, all_flag, lf_strings,
                                          first_call, last_call, find_ok);
               if (abort)
                  end_of_edit = -1;

               if (last_call)
                  show_find_result (str_find, find_count, replace_count);

            /* display status restaurieren */
               set.display &= ~0x02;
               break;

            case 0x1b:   /* <esc> : switch off 'B'/'D', if active */
            case 0x03:   /* ^C    */
               end_of_edit = -2;
               line_2_flag = 1 + (get_macro_status () == MACRO_EXECUTE);
               if (save_d.toggle)
               {
                  save_d.toggle = 0;
                  view_or_update ();
               }
               break;

            case 'D':   /* Delete */
               LOCK_WHEN_VIEW_ONLY
               /* no break !! fall through to case 'B' */

            case 'B':   /* Buffer */
               end_of_edit = -2;
               line_2_flag = 1;

               if (save_d.toggle == 0)    /* 1. command */
               {
                  save_d.toggle = 1;
                  save_d.index0 = fc->byte_index;
                  update_this_line (fc->lin_left, fc->lrow);
               }
               else
               {
                  save_d.toggle = 0;

               /* save it */
                  save_d.index1 = fc->byte_index;
                  len  = labs (save_d.index0 - save_d.index1);
                  if (block_save (fc->buff_0, save_d.index0, save_d.index1))
                  {
                     end_of_edit = -1;
                     err_message (OUT_OF_MEMORY);
                  }
                  else
                  {
                     sprintf (string, "*** buffer saved (%ld Bytes) ***", len);
                     show_status_line_2 (string, 0, -2, 0);
                  }
                  line_2_flag = 2;

               /* delete ? */
                  if (toupper (key_0) == 'D')
                  {
                     new_index = min (save_d.index0, save_d.index1);
                     perform_move (new_index);

                  /* anzahl lines wieder restaurieren */
                     fc->line_anz -= get_total_lines (&fc->buff_0 [new_index],
                                                      0L, len);

                     delt_bi = block_remove (fc->buff_0,
                                             save_d.index0,
                                             save_d.index1,
                                             fc->byte_anz);
                     fc->byte_anz -= delt_bi;
                     check_tag_index (fc->byte_index, -delt_bi);

                     fc->change_flag = 1;
                  }
                  check_dirty_cursor ();

                  if (fc->line_index >= fc->line_anz)
                     view_or_update ();
                  else
                     update_entire_window (fc->top_left);
               }
               break;

            case 'G':   /* Get file or saved buffer */
               LOCK_WHEN_BUFFER_ACTIVE   LOCK_WHEN_VIEW_ONLY
               line_2_flag = 1;
               if (repeat_count == 0)
               {
                  do_it = get_line_2_string ("Get:<cr>,<filename>", str_getf,
                                             C_R, ID_FILE);
                  if (!do_it)
                  {
                     end_of_edit = -1;
                     break;
                  }
               }
               BREAK_IF_REPEAT_0

               if (*str_getf)
               {                          /* read from file */
                  file_length = get_file_length (str_getf, 1);
                  if (file_length > 0)
                  {
                     file_buf = loc_malloc (file_length);
                     if (file_buf == NULL)
                     {
                        end_of_edit = -1;
                        err_message (OUT_OF_MEMORY);
                     }
                     else
                     {
                        read_anz = read_datafile (str_getf, file_buf,
                                                  file_length, 1);
                        if (read_anz >= 0)
                        {
                        /* einfuegen in buffer */
                           if (check_and_increase_buffer (fc,
                                                         (fc->byte_anz + read_anz),
                                                          FILE_RESERVE, 0) < 0)
                           {                      /* nein ! */
                              end_of_edit = -1;
                              err_message (BUFFER_OVERFLOW);
                           }
                           else
                           {
                              delt_bi = block_insert (fc->buff_0, fc->byte_index,
                                                      fc->byte_anz, fc->buffer_size,
                                                      file_buf, (long) read_anz);
                              if (delt_bi < 0L)
                              {
                                 end_of_edit = -1;
                                 err_message (FATAL_ERROR);
                              }
                              else
                              {
                                 fc->byte_anz += read_anz;
                                 check_tag_index (fc->byte_index, read_anz);
      
                              /* anzahl lines wieder restaurieren */
                                 fc->line_anz = get_total_lines (fc->buff_0, 0L,
                                                                fc->byte_anz);
                                 fc->change_flag = 1;
                                 view_or_update ();
                              }
                           }
                        }
                     }
                     loc_free (file_buf);
                  }  /* file_buf != NULL */
               }
               else
               {                          /* read from buffer */
                  delt_bi = block_restore (fc);
                  if (delt_bi >= 0L)
                  {
                     fc->byte_anz += delt_bi;
                     check_tag_index (fc->byte_index, delt_bi);

                  /* anzahl lines wieder restaurieren */
                     fc->line_anz += get_total_lines (
                                            (char FA_HU *) get_save_buffer (),
                                                       0L, get_save_length ());
                  }
                  else
                  {
                     end_of_edit = -1;
                     err_message (BUFFER_OVERFLOW);
                  }

                  fc->change_flag = 1;
                  view_or_update ();
               }
               break;

            case 'V':   /* View */
               end_of_edit = -2;
               check_dirty_cursor ();

#if ((WITH_WINCH) && ((ACT_OP_SYSTEM == SCO_UNIX) || !(UNIX)))
               set_window_size ();
#endif
               perform_view ();
               break;

            case 'O':   /* Other forward */
               LOCK_WHEN_BUFFER_ACTIVE
               end_of_edit = -2;

#if WINDOW_COMMAND
               window_set (1);
#endif
            /* get other work buffer */
               if (get_next_file_buffer (1))
               {
 			      set_highbit();
                  check_dirty_cursor ();
#if WINDOW_COMMAND
                  window_set (2);
#endif
                  perform_view ();
               }
               break;

            case ALT_O: /* Other backward */
               LOCK_WHEN_BUFFER_ACTIVE
               end_of_edit = -2;

#if WINDOW_COMMAND
               window_set (1);
#endif
            /* get other work buffer */
               if (get_next_file_buffer (-1))
               {
			      set_highbit();
                  check_dirty_cursor ();
#if WINDOW_COMMAND
                  window_set (2);
#en