switches.c

功能强大的文本编辑器

      /* check, if macro with "single char name" */
         macro_ex = get_macro_adress (key_2_string (toupper (get_1_key (1))));

         BREAK_IF_REPEAT_0

         if (macro_ex == NULL)
         {
            end_of_edit = -1;
            err_message (ILLEGAL_COMMAND);
         }
         else
         {
            end_of_edit = -2;
            exe_flag = push_macro_stack (macro_ex, MACRO_EXECUTE,
                                         repeat_max, mode_flag);
            if (exe_flag == -1)
            {
               err_message (MACRO_EXEC_NESTING_TO_DEEP);
               reset_macro_stack ();
            }
         }

      /* status line 1 restaurieren */
         get_cursor_pos (&row, &column);
         show_status_line_1 (get_line_1_text (), fc);
         set_cursor_to (row, column);

         line_2_flag = 1;
         break;

      case SEQU_MM:    /* last key in macro sequence */
         mode_flag = get_save_mode_flag ();   /* restore mode_flag */
         /* fall through */

      case SEQU_EM:    /* last key in macro sequence */
         if (get_macro_nesting_level () == 0)
         {
            line_2_flag = 1 + (set.display != 0);
         }
         break;

      case KEY_DO_NOTHING:  /* after end of redirected file */
      case KEY_TIMEOUT:     /* after timeout user input     */
         break;

      case 0x03:  /* ^C */
      /* abort macro create ? */
         if (get_macro_status () == MACRO_CREATE)
         {
            pop_macro_stack (macro_cr, 0);
            free_current_macro (macro_cr);
         }
         /* fall through */

      default:
         end_of_edit = switch_mode_flag (key_0, repeat_count, repeat_max);
         break;

   }  /* switch key_0 */

/* fuer naechsten aufruf merken */
   last_key = key_0;

   REFRESH_WHEN_BUFFER_ACTIVE
   
   return end_of_edit;
}  /* switch_key_0 */

/* -FF-  */

static int switch_last_key (int loc_key)
{
int end_of_edit;

   end_of_edit = 0;

   switch (loc_key)
   {
      case KEY_LEFT:
         end_of_edit = -2;
         perform_begin_of_line (1);
         break;
   
      case KEY_RIGHT:
         end_of_edit = -2;
         perform_end_of_line (1);
         break;
   
      case KEY_UP:
         end_of_edit = perform_page_up () - 1;
         break;
   
      case KEY_DOWN:
         end_of_edit = perform_page_down () - 1;
         break;

      default:
         end_of_edit = -2;
         err_message (ILLEGAL_COMMAND);
         break;
   }
   
   return end_of_edit;
}  /* switch_last_key */

/* -FF-  */

static int check_for_macro (int key, long repeat_max)
{
static struct MACRO *macro_ex;          /* for "Macro Execute" */
int exe_flag;

   if (key >= 0x20)
   {
      return 0;   /* normal character, can't be a macro */
   }
   else           /* special char */
   {
      macro_ex = get_macro_adress (key_2_string (key));
      if (macro_ex == NULL)
      {
         return 0;     /* wasn't a macro */
      }
      else
      {
         exe_flag = push_macro_stack (macro_ex, MACRO_EXECUTE,
                                      repeat_max, mode_flag);
         if (exe_flag == -1)
         {
            err_message (MACRO_EXEC_NESTING_TO_DEEP);
            reset_macro_stack ();
         }
         return 1;     /* it was a macro */
      }
   }

}  /* check_for_macro */

/* -FF-  */

#define EXCHANGE_HEX_CHARS 0

#if (EXCHANGE_HEX_CHARS)

void exchange_chars (char *a, char *b)
{
char c;

    c = *a;
   *a = *b;
   *b =  c;

   return;
}  /* exchange_chars */

#endif

/* -FF-  */

static int switch_mode_flag (int key_0, long repeat_count, long repeat_max)
{
static int lf_strings;
static int first;
char string [80];   /* for "Calc", "Hex Output", usw ... */
STATIC char tmp_filename [BUF_256 + FILENAME_LEN];

static int  exe_flag;
static struct MACRO *macro_ex;          /* for "Macro Execute" */

static int key_1, key_2;

int delta, end_of_edit;
static int do_it;

/* for insert, exchange */
int ii, tab_diff;

/* for quit */
long read_anz, ind0, len, ok_flag;
int  write_flag, read_flag, quit_allowed, abort_flag, quit_mode;

/* for dez + hex input */
int  help_int, help_int2, help_int3, num;
long help_long;
char komma;

#if (WITH_HEX_FIND)
char c1, c2;
#endif

/* for Find/Replace */
long new_index, old_index, delt_bi;
size_t len1, len2;
int    replace_flag, direction;
static int all_flag, first_call, last_call, abort;
static char str_help [BUF_256];

/* for Jump */
static int  new_col;
static long new_line;

/* for Get */
char FA_HU *file_buf;
long file_length;

/* for Calc */
CALC_RESULT calc_result;


   end_of_edit = 0;

   switch (mode_flag)
   {
      case 1:    /* insert   */
         switch (key_0)
         {
            case 0x1b:   /* <esc> */
            case 0x03:   /* ^C    */
               mode_flag = 0;
               line_2_flag = 1;
               break;

            case 0x12:   /* ^R */
               key_1 = get_hex_value ();
               if (key_1 >= 0)
               {
                  perform_key_insert (key_1, 0);
                  fc->change_flag = 1;
               }

               if (key_1 == -3)  /* ^C entered */
               {
                  mode_flag = 0;
                  line_2_flag = 1;
               }
               break;

            case 0x0e:   /* ^N */
            case 0x13:   /* ^S */
            case 0x16:   /* ^V */
               perform_special_keys (key_0, mode_flag);
               break;

            default:
               if (!check_for_macro (key_0, repeat_max))
               {
                  if ((key_0 == 0x09) && (set.notab == 1))
                  {
                     tab_diff = set.tabs - (fc->column % set.tabs);
                     for (ii = 0 ; ii < tab_diff ; ii++)
                     {
                        perform_key_insert (' ', 0);
                     }
                  }
                  else
                  {
                     perform_key_insert (key_0, 1);
                  }
                  fc->change_flag = 1;

                  check_for_autonl ();
               }
               break;
         }
         break;

      case 2:    /* exchange */
         switch (key_0)
         {
            case 0x1b:   /* <esc> */
            case 0x03:   /* ^C    */
               mode_flag = 0;
               line_2_flag = 1;
               break;

            case 0x12:   /* ^R */
               key_1 = get_hex_value ();
               if (key_1 >= 0)
               {
                  perform_key_exchange (key_1, 0);
                  fc->change_flag = 1;
               }

               if (key_1 == -3)  /* ^C entered */
               {
                  mode_flag = 0;
                  line_2_flag = 1;
               }
               break;

            case 0x0e:   /* ^N */
            case 0x13:   /* ^S */
            case 0x16:   /* ^V */
               perform_special_keys (key_0, mode_flag);
               break;

            default:
               if (!check_for_macro (key_0, repeat_max))
               {
                  if ((key_0 == 0x09) && (set.notab == 1))
                  {
                     tab_diff = set.tabs - (fc->column % set.tabs);
                     for (ii = 0 ; ii < tab_diff ; ii++)
                     {
                        perform_key_exchange (' ', 0);
                     }
                  }
                  else
                  {
                     perform_key_exchange (key_0, 1);
                  }
                  fc->change_flag = 1;
               }
               break;
         }
         break;

      case 0:    /* command  */
         switch (toupper (key_0))    /* switch (toupper (key_0)) : KEY_F1 ==> error */
         {
            case 'H':    /* Hex Input, Output */
               LOCK_WHEN_BUFFER_ACTIVE
               line_2_flag = 1;

               if (repeat_count == 0)
               {
                  show_status_line_2 ("Hex: Input Output Stdout Find View Edit",
                                                                       0, -1, 0);
                  key_1 = toupper(get_1_key (1));
               }

#if (WITH_HEX_FIND)
               if (key_1 != 'F')
#endif
                  end_of_edit = -2;

               switch (key_1)
               {
                  case 'I':
                     LOCK_WHEN_VIEW_ONLY
                     str_numb [0] = '\0';
                     do_it = get_line_2_string ("Hex Input:",
                                                str_numb, C_R, ID_NUMB);
                     if (do_it)
                     {
                        if ((sscanf (str_numb, "%x", &help_int)) == 1)
                        {
                           perform_key_insert (help_int, 0);
                           fc->change_flag = 1;
                        }
                        else
                        {
                           err_message (INVALID_HEX_VALUE);
                        }
                     }
                     break;               

                  case 'O':
                     line_2_flag = 2;
                     sprintf (string, "Hex Output: 0x%02x",
                                       (((byte) *fc->buffer) & 0xff));
                     show_status_line_2 (string, 0, -2, 1);
                     break;

                  case 'S':
                     str_numb [0] = '\0';
                     do_it = get_line_2_string ("Hex as string to Stdout:",
                                                str_numb, C_R, ID_NUMB);
                     if (do_it)
                     {
                        ii = 0;
                        while ((sscanf (&str_numb[ii], "%2x", &help_int)) >= 1)
                        {
                           printf ("%c", (char) (help_int & 0xff));
                           ii += 2;
                           if (str_numb[ii] == ' ')
                             ii++;
                        }