disp_hnd.c

功能强大的文本编辑器

               }
            }

         /* fortran style */
            if (hi_light[FILE_TYPE].comment_fc)
            {
               if (strnicmp(buffer,hi_light[FILE_TYPE].comment_fc,
                            strlen(hi_light[FILE_TYPE].comment_fc)) == 0)
			   {
				  if (buffer == buff_0)
				  {
                     if (is_comment_active ())
					 {
                        attr [min (max (REL_COL, 0), COLUMNS)] |=  BEG_COMMENT;
                        attr [min (max (REL_COL, 0), COLUMNS)] &= ~END_COMMENT;
					 }
                     comment_type = 2;
				  }
				  else if ((buffer[-1] == 0x0d) || (buffer[-1] == 0x0a))
				  {
                     if (is_comment_active ())
					 {
                        attr [min (max (REL_COL, 0), COLUMNS)] |=  BEG_COMMENT;
                        attr [min (max (REL_COL, 0), COLUMNS)] &= ~END_COMMENT;
					 }
                     comment_type = 2;
				  }
			   }
            }
         }
      }
#endif

      buffer++;

      if (EOLN_LEN_2)
      {
         if ((ckey == EOLN_HIGH) && (*buffer == EOLN_LOW))
         {
            ckey = ' ';    /* blank <cr> (only at end of line !) */
            cr_flag = 1;
         }
      }

      sav_eol = (ckey == EOLN_LOW);

   /* end of file ? */
      if (index >= byte_anz)
      {
         ckey = '|';   /* EOF */
         eof_flag = 1;
      }
      else
      {
         eof_flag = 0;
      }

   /* is this char '@' mark 0 for Buffer/Delete ? */
      if ((save_d.toggle) && 
          (index == save_d.index0))
         mark_0_flag = 1;
      else
         mark_0_flag = 0;

   /* end of line ? */
      if ((sav_eol) && (!mark_0_flag) && (!eof_flag)) break;

   /* <tab>: replace with n blanks */
      if (ckey == 0x09)
      {
         ckey = ' ';
         tab_diff = set.tabs - (column % set.tabs);
      }
      else
      {
         tab_diff = 1;
      }

   /* loop for display characters */
      for (char_cnt = 0 ; char_cnt < tab_diff ; char_cnt++)
      {
         if ((REL_COL >= 0) && (REL_COL < COLUMNS))   /* @@ vorher: -1 */
         {
         /* '@' mark for Buffer/Delete */
            if ((mark_0_flag) && 
                (char_cnt == 0))
            {
               text [REL_COL] = '@';        /* buffer, mark 0 */
            }
            else
            {
               if ((mb_isprint (ckey)) ||    /* normal printable */
                   (ckey & 0x80))            /* umlaute, usw */
                  text [REL_COL] = ckey;   
               else
                  text [REL_COL] = '?';      /* control char */
            }
         }
   
         column++;
      }  /* for char_cnt */

   /* end of line ? */
      if (sav_eol)  break;

   }  /* for index */

/* drop <cr> at end of line */
   column -= cr_flag;

/* first position in line ? */
   if (left_col > 0)
      text [0] = '!';

/* last position in line ? */
   if (REL_COL > COLUMNS)     /* @@ vorher: >= */
      text [COLUMNS-1] = '!';

/* buffer, mark 1 ? */
   if ((save_d.toggle) && 
       (row == fc->lrow))
   {
      col_diff = fc->column - left_col;
      col_diff = max (0, min ((COLUMNS - 1), col_diff));
      text [col_diff] = '@';

   /* ggf. mit blanks auffuellen */
      if (col_diff > (int) strlen (text))
      {
         for (ii = strlen (text) ; ii < col_diff ; ii++)
         {
            text [ii] = ' ';
         }
      }
   }

/* string output */
   optimize_output (row, 0, text, attr, (start_comment != 0), 0);

   pop_cursor ();

   return (index + 1);

}  /* disp_1_line */

/* -FF-  */

long get_line_2_repeat (char *text, long old_value, int *key)
{
long new_value, help, return_value;
char l_text [80];

   sprintf (l_text, "%s %ld", text, old_value);
   show_status_line_2 (l_text, 0, -1, 0);

#if 0
#if (WITH_MOUSE)
   MouSetMoveArea (  0, 0,
                   255, 0,
                     3);
#endif

#if (ACT_SERVER == SERVER_VT_100)
   text_area++;
#endif
#endif

/* keep old value ! */
   new_value = old_value;
   return_value = -1;
   while (return_value == -1)
   {
      *key = get_1_key (1);
   
      if (mb_isdigit (*key))
      {
         help = 10 * new_value + (*key - '0');
         if (help >= 0)
            new_value = help;
         else
            beep ();
      }
      else
      {
         switch (*key)
         {
            case 0x1b:          /* <esc> */
            case 0x03:          /* ^C    */
               return_value = 0;          /* input aborted */
               break;

            case 0x08:          /* backspace */
            case 0x7f:          /* rubout */
               new_value /= 10;           /* letzte stelle wegnehmen */
               break;

            default:
               return_value = new_value;  /* input ready */
               break;
         }  /* switch *key */
      }

      sprintf (l_text, "%s %ld", text, new_value);
      show_status_line_2 (l_text, 0, -1, 0);
   }  /* while */

/* exit function */

#if 0
#if (WITH_MOUSE)
   MouSetMoveArea ( 0                , (byte) TOP_ROW,
                   (byte) (COLUMNS-1), (byte) MAX_ROW,
                    -1);
#endif

#if (ACT_SERVER == SERVER_VT_100)
   text_area--;
#endif
#endif

   return (return_value);
}  /* get_line_2_repeat */

/* -FF-  */

char *build_modified_string (char *str_buf, int index1,
                             int *index2, int *error)
{
/* erzeuge aus input-string "str_buf" den output-string "str_mod"  */
/* ersetze sonderzeichen durch ersatz-strings (z.B. 0x09--> "<tab>") */
/* index1: act. position in str_buf */
/* index2: act. position in str_mod */

#define R_NL   "<nl>"   /* mod. char for EOL  <cr><lf>    */
#define R_TAB  "<tab>"  /* mod. char for 0x09 <tab>       */
#define R_CTLC "\\03"   /* mod. char for 0x03 ^C          */
#define R_NPR  '?'      /* mod. char for <not printable>  */
#define RESERVE 5       /* max. laenge der ersatz-strings */

static char help [BUF_256];
char *str_mod, *str_hlp;
size_t new_len;
int ii, jj;


/* init */
   memset (help, 0, sizeof (help));
   *index2 = 0;   /* not defined */
   *error  = 0;
   new_len = 1;   /* for safety reasons */

/* copy old string, replace special chars */
   for (ii = 0          , jj = 0        , str_mod = help ;
        ;  /* abbruch durch abfrage am ende der schleife */
        ii++ , str_buf++, jj += new_len , str_mod += new_len)
   {
      if (index1 == ii) *index2 = jj;  /* index2 is now defined */

      if (jj >= (BUF_256 - RESERVE))
      {
         err_message (STRING_TOO_LONG);
         *error = 1;
         break;  /* for safety reasons */
      }

      if (perform_test_eol (str_buf, 0))
      {
      /* <cr>/<lf> */
         new_len = strlen (R_NL);
         memcpy (str_mod, R_NL, new_len);
         if (EOLN_LEN_2)
         {
            ii++;         /* 1 incr. */
            str_buf++;    /* das 2. incr in der for-loop */
         }
      }
      else
      {
         switch (*str_buf)
         {
            case 0x09:   /* <tab> */
               new_len = strlen (R_TAB);
               memcpy (str_mod, R_TAB, new_len);
               break;
   
            case 0x03:   /* ^C */
               new_len = strlen (R_CTLC);
               memcpy (str_mod, R_CTLC, new_len);
               break;
   
            case '\0':   /* end of string */
               new_len  = 1;
               *str_mod = *str_buf;
               break;
   
            default:
               if ((mb_isprint  (*str_buf)) ||
                   ((*str_buf) & 0x80))
               {
                  new_len  = 1;
                  *str_mod = *str_buf;
               }
               else
               {
                  str_hlp = key_2_string ((int) *str_buf);
                  new_len = strlen (str_hlp);
                  if (new_len <= 1)
                  {                     /* not found in table */
                     new_len  = 1;
                     *str_mod = R_NPR;
                  }
                  else
                  {
                     memcpy (str_mod, str_hlp, new_len);
                  }
               }
               break;
         }  /* switch */
      }

      if (*str_buf == '\0') break;     /* end of string selbst included */

   }  /* for */

/* forced end of string */
   help [BUF_256 - 1] = '\0';

   return help;
   
}  /* build_modified_string */

/* -FF-  */

int get_line_2_string (char *text, char *str_buf,
                       int end_char, enum HIST_ID id)
{
int  key, key_1, last_key, help, str_len_1, first, justify, return_val;

#define TEXT_RESERVE 80         /* max. zulaessige strlen(text) */
#define EXTRA_CHARS   2         /* die beiden \" im format string */
#define TILDE_7E     '~'        /* 0x7e */

int index1, index2, error, sav_index = 0;
static char tmp_buf [BUF_256];  /* temp. buffer */
static char sav_buf [BUF_256];  /* fuer ^A, ^X, ^Z, ^U */
static char l_text  [BUF_256 + TEXT_RESERVE];

char *str_mod;            /* for display */
char *str_hlp;            /* for conversion of special keys (macro.c) */
int  len_hlp, byte_num;
char *hist_adr;

/* build text line */
   index1 = 0;
/* index2 = 0; */
   first = 0;

#if (WITH_MOUSE)
   MouSetMoveArea (  0, 0,
                   255, 0,
                     3);
#endif

#if (ACT_SERVER == SERVER_VT_100)
   text_area++;
#endif

/* after selecting a filename from a wildcard input, we do one more run */
   return_val = -1;
   while (return_val == -1)
   {

   /* take original buffer in temp */
      memcpy (tmp_buf, str_buf, sizeof(tmp_buf));
   
   /* laenge von "text" ueberpruefen */
      str_len_1 = strlen (text);
      if (str_len_1 >= (TEXT_RESERVE - 1 - EXTRA_CHARS))
      {
         err_message (STRING_TOO_LONG);
         text [0] = '\0';    /* clear text string */
      }
      
   /* get new string */
      last_key = 0;
      for (/* hier nicht: index1 = 0 !! */ ;
           index1 < (BUF_256 - 1) ;
           /* hier nicht: index1++ !! */)
      {
      /* display actual buffer */
         str_mod = build_modified_string (tmp_buf, index1, &index2, &error);
         if (error)   /* buffer overflow */
         {
            index1 = 0;               /* clear current string up to here */
            tmp_buf [index1] = '\0';
            continue;
         }

         sprintf (l_text, "%s\"%s\"", text, str_mod);
   
         if (index1 == 0)
            justify = 2;
         else
            justify = 0;
         
         show_status_line_2 (l_text, justify, 
                             (str_len_1 + EXTRA_CHARS + index2), 0);
   
      /* get command */
         key = get_1_key (1);
   
      /* abort function ? */
         if (key == 0x03)               /* ^C                           */
         {
            return_val = 0;             /* invalid, don't use result    */
            break;
         }
   
      /* input finished ? */
         if (key == 0x1b)               /* <esc> */
         {
            break;                      /* take whole line */
         }
   
         if ((key == end_char) &&
             (end_char == C_R))          /* <cr> */
         {
            tmp_buf [index1] = '\0';     /* take line up to cursor position */
            break;
         }
   
      /* keep old string ? */
         if (first == 0)
         {
            first = 1;
            if ((key != KEY_HOME)  &&
#if (!STRICTLY_AEDIT_COMPATIBLE)
                (key != KEY_END)   &&
#endif
                (key != KEY_LEFT)  &&
                (key != KEY_RIGHT) &&
                (key != KEY_UP)    &&
                (key != KEY_DOWN)  &&
                (key != KEY_DEL)   &&
                (key != KEY_DO_NOTHING) &&
#if (ACT_OP_SYSTEM == SCO_UNIX)
                (key != KEY_RUBOUT) &&        /* rubout */
#endif
                (key != 0x08))                /* <backspace> */
            {
               tmp_buf [0] = '\0';            /* delete old string */
               tmp_buf [1] = '\0';
            }
         }
   
      /* handle inputs */
         if ((key >= 0) &&
             (mb_isprint (key) || (key & 0x80)))
         {
            if ((key == TILDE_7E) && (set.tilde_home))
            {
               set_string_buff (HOME_DIR, strlen (HOME_DIR));
            }
            else
            {
               help = strlen (tmp_buf) - index1 + 1;
               memcpy_rev ((char FA_HU *)(&tmp_buf[index1+1]), 
                           (char FA_HU *) &tmp_buf[index1],