commands.c

功能强大的文本编辑器

/*      commands.c                                19.03.04       */
/*
/  --------------------------------------------------------------
/  Copyright (C) 2004: Michael Braun
/                      Kaetinger Muehlenweg 103 A
/                      D-28816 Stuhr
/  --------------------------------------------------------------
/
/    command line functions
/
*/


/************************/
/*  include files       */
/************************/

#include "config.h"
#include "global.h"
#include "standard.h"
#include "commands.h"
#include "memo_hnd.h"
#include "perform.h"
#include "err_mess.h"
#include "mb_ctype.h"
#include "history.h"
#include "disp_hnd.h"


/************************/
/* some defines         */
/************************/


/************************/
/* local structures     */
/************************/


/************************/
/*  module definitions  */
/************************/

/* -FF-  */

#if 0

Hinweis !!

Die deutschen Umlaute in diesem Source-File sind 
  - im Programm-Code als Hex-Werte, 
  - in Kommentaren mit normalen ASCII-Charactern (ae, usw...) 
dargestellt.

Grund: Der c-compiler auf dem os-9-rechner meckert ueber Umlaute im File.

#endif

int is_german (char byte1)
{
byte key;

/* returns 1, if byte1 is in "Ae Oe Ue ae oe ue ss", else 0 */

   key = (byte) byte1;

   switch (key)
   {
      case 0x8e: return 1; break;  /* Ae */
      case 0x99: return 1; break;  /* Oe */
      case 0x9a: return 1; break;  /* Ue */
      case 0x84: return 1; break;  /* ae */
      case 0x94: return 1; break;  /* oe */
      case 0x81: return 1; break;  /* ue */
      case 0xe1: return 1; break;  /* ss */

      default:   return 0; break;
   }

}  /* is_german */

/* -FF-  */

void comm_umlaut (char *buffer)
{
byte key;

/* convert chars "AOUaous" <--> "Ae Oe Ue ae oe ue ss" */

   key = (byte) *buffer;

   switch (key)
   {
   /* hin */
      case 'A':   *buffer = (char)0x8e; break;
      case 'O':   *buffer = (char)0x99; break;
      case 'U':   *buffer = (char)0x9a; break;
      case 'a':   *buffer = (char)0x84; break;
      case 'o':   *buffer = (char)0x94; break;
      case 'u':   *buffer = (char)0x81; break;
      case 's':   *buffer = (char)0xe1; break;

   /* und zurueck */
      case 0x8e:  *buffer = 'A';  break;
      case 0x99:  *buffer = 'O';  break;
      case 0x9a:  *buffer = 'U';  break;
      case 0x84:  *buffer = 'a';  break;
      case 0x94:  *buffer = 'o';  break;
      case 0x81:  *buffer = 'u';  break;
      case 0xe1:  *buffer = 's';  break;

      default: break;
   }
}  /* comm_umlaut */

/* -FF-  */

void lower_upper_umlaut (char *buffer, int up_flag)
{
byte key;

/* convert chars "Ae Oe Ue " <--> "ae oe ue " */

   key = (byte) *buffer;

   if (up_flag)
   {
      switch (key)
      {
         case 0x84:  *buffer = (char)0x8e;  break;  /* ae  --> Ae  */
         case 0x94:  *buffer = (char)0x99;  break;  /* oe  --> Oe  */
         case 0x81:  *buffer = (char)0x9a;  break;  /* ue  --> Ue  */
   
         default: break;
      }
   }
   else
   {
      switch (key)
      {
         case 0x8e:  *buffer = (char)0x84;  break;  /* Ae  --> ae  */
         case 0x99:  *buffer = (char)0x94;  break;  /* Oe  --> oe  */
         case 0x9a:  *buffer = (char)0x81;  break;  /* Ue  --> ue  */
   
         default: break;
      }
   }

}  /* lower_upper_umlaut */

/* -FF-  */

char tolower_german (char byte1)
{
char key;

/* convert all chars incl. "ae oe ue " to lower case */

   key = byte1;

   if (is_german (key))
      lower_upper_umlaut (&key, 0);
   else
      key = (char) tolower (key);  

   return key;

}  /* to_lower_german */

/* -FF-  */

char toupper_german (char byte1)
{
char key;

/* convert all chars incl. "ae oe ue " to upper case */

   key = byte1;

   if (is_german (key))
      lower_upper_umlaut (&key, 1);
   else
      key = (char) toupper (key);

   return key;

}  /* toupper_german */

/* -FF-  */

static char unchanged_char (char byte1)
{
   return byte1;
}  /* unchanged_char */

/* -FF-  */

int is_delimiter (char byte1)
{
/* Funktion gibt 1 zurueck, wenn der angegebene char ein delimiter ist. */

#if (WITH_E_DELIMIT)

char *c_ptr;

   if (isspace (byte1))
      return 1;

   for (c_ptr = fc->e_delimit ; *c_ptr ; c_ptr++)
   {
      if (byte1 == *c_ptr)
         return 1;
   }
   return 0;    /* nothing found */

#else

/* is character a letter, number or underscore ? */
   byte1 = (char) toupper (byte1);
   if (((byte1 >= 'A') && (byte1 <= 'Z')) ||
       ((byte1 >= '0') && (byte1 <= '9')) ||
        (byte1 == '_')                    ||
        (is_german(byte1)))
      return 0;
   else
      return 1;

#endif

}  /* is_delimiter */

/* -FF-  */

static int get_part_strings (char *text, int wild_cards)
{
/* no of partial strings in search string = no of '*'s plus 1 */

int count;

   count = 1;

   if (wild_cards)
   {
      while (*text)
      {
         if (*text == '*')
            count++;
         text++;
      }
   }

   return count;
}  /* get_part_strings */

/* -FF-  */

long comm_find (char FA_HU *buff, long index_1,
                long max_ind, char *such_string,
                int direction, int consider_case, int k_token,
                int wild_cards, size_t *len1)
{

/* Funktion sucht zwischen buff[index_1]...buff[max_ind] nach such_string, */
/* wenn erfolgreich, return new byte_index, sonst -1.                        */

#define TEST static
TEST int  found, pp, part_strings, exp_search;
TEST long ii, ianf, iend, d_ii, kk, i1, i2, i_limit;
TEST char FA_HU *abuf;
TEST char FA_HU *cbuf;
TEST char       *astr, *bstr;
TEST char       *ustr;
TEST size_t t_len, p_len, t_rest, p_rest;

STATIC char act_search [BUF_256];
char (*function)(char byte1);
#define ss_len *len1

#define WILDCARDS_HIGHSPEED 1


/* init */
   ss_len = strlen (such_string);
   t_len  = ss_len;

/* search with wild_cards: remove leading, trailing, and double '*'s */
   if (wild_cards)
   {
   /* remove leading '*'s */
      for (ii = 0 ; ii < (long) ss_len ; ii++)
      {
         if (*such_string == '*')
            memcpy (&such_string[0],
                    &such_string[1],
                    (ss_len - (size_t)ii));
         else
            break;
      }
      ss_len = strlen (such_string);

   /* remove trailing '*'s */
      for (ii = (((long)ss_len)-1) ; ii >= 0 ; ii--)
      {
         if (such_string[ii] == '*')
            such_string[ii] = '\0';
         else
            break;
      }
      ss_len = strlen (such_string);

   /* remove double '*'s */
      for (ii = 0 ; ii < (((long)ss_len)-1) ; ii++)
      {
         if ((such_string[ii  ] == '*') &&
             (such_string[ii+1] == '*'))
         {
            memcpy (&such_string[ii],
                    &such_string[ii+1],
                    (ss_len - (size_t)ii));
            ii--;
         }
      }
      ss_len = strlen (such_string);
   }  /* if wild_cards */

   if (ss_len == 0) return -1;                /* abort --> */

/* fallunterscheidung case sensitive or not */
   if (consider_case)
   {
      function = unchanged_char;

   /* uebernehmen suchstring 1:1 */
      strncpy (act_search, such_string, sizeof(act_search));
   }
   else
   {
      function = toupper_german;

   /* umsetzen suchstring --> upper case */
      astr = such_string;
      ustr = act_search;
      for (ii = 0 ; ii < sizeof(act_search) ; ii++)
      {
         *ustr = toupper_german (*astr);
         astr++;
         ustr++;
      }
   }
   act_search [sizeof(act_search) - 1] = '\0';    /* forced end of string */

/* anzahl teilstrings */
   part_strings = get_part_strings (act_search, wild_cards);

/* fallunterscheidung vor / zurueck suchen */
   if (direction)
   {                                       /* vorwaerts */
   /* aeussere schleife fuer buffer */
      ianf = index_1;
      iend = max_ind - (ss_len - (part_strings-1)) + 1;
      i_limit = max_ind;
      d_ii = 1;
      if (ianf >= iend) return -1;            /* abort --> */
   }
   else
   {                                       /* rueckwaerts */
   /* aeussere schleife fuer buffer */
      ianf = index_1 - (ss_len - (part_strings-1));
      iend = -1;
      i_limit = index_1;
      d_ii = -1;
      if (ianf <= iend) return -1;            /* abort --> */
   }

/* -FF-  */

/*---------------------------------------------------------------------------*/

/* suchschleife */
   found = 0;
   abuf  = &buff[ianf];

   for (ii = ianf ; ii != iend ; ii += d_ii)
   {
#if (WILDCARDS_HIGHSPEED)
   /* fallunterscheidung wg. speed */
      if (!wild_cards)
      {
      /* innere schleife fuer string */
         cbuf = abuf;
   
         astr = act_search;
         for (kk = 0 ; kk < (long) ss_len ; kk++)
         {
            if (*astr == function (*cbuf))     /* characters match */
            {
               astr++;
               cbuf++;
            }
            else
            {
               goto next_c1;  /* no match at this char */
            }
         }
      }
      else
#endif
      {
         cbuf   = abuf;
         bstr   = act_search;
         t_len  = 0;        /* total length and rest */
         t_rest = ss_len;
         exp_search = 0;
   
      /* schleife fuer teilstrings */
         for (pp = 0 ; pp < part_strings ; pp++)
         {
            astr   = bstr;
            p_len  = 0;      /* partial length and rest */
            p_rest = t_rest;
   
         /* innere schleife fuer string */
            for (kk = 0 ; kk < (long) p_rest ; kk++)
            {
#define BUGFIX_28_09_94  1
#if (BUGFIX_28_09_94)
                     if (*astr == '*')      /* NEU ! sonst probleme mit */
                     {                      /* text: r*.c               */
                        astr++;             /* such: r*.c               */
                        bstr = astr;
                        t_rest -= (p_len + 1);
                        exp_search = 1;   /* from now on */
                        break;   /* for kk */
                     }
                     else