ed.c

c语言写的一个多文本编辑器代码

int  rc;

   win = window;
   if (win->rline > win->file_info->length  || win->ll->len == EOF)
      return( ERROR );

   rc = OK;
   copy_line( win->ll );
   detab_linebuff( );
   if (win->rcol >= (len = g_status.line_buff_len)) {
      rc = join_line( win );
      if (rc == OK) {
         p = win->ll->line;
         if (p != NULL) {
            p += win->rcol;
            if (win->rcol < win->ll->len) {
               len = win->ll->len - win->rcol;
               load_undo_buffer( win->file_info, p, len );
            }
         }
      }
   } else {

      assert( len >= 0);
      assert( len < MAX_LINE_LENGTH );

    
      start = win->rcol;
      if (isspace( g_status.line_buff[start] )) {
      
         while (start < len  &&  isspace( g_status.line_buff[start] ))
            ++start;
      } else {
      
         while (start < len  &&  !isspace( g_status.line_buff[start] ))
            ++start;
         while (start < len  &&  isspace( g_status.line_buff[start] ))
            ++start;
      }

      
      count = start - win->rcol;
      source = g_status.line_buff + start;
      dest = g_status.line_buff + win->rcol;

      assert( len - start >= 0 );

      memmove( dest, source, len - start );
      g_status.line_buff_len = len - count;
      entab_linebuff( );
      win->file_info->modified = TRUE;
      win->file_info->dirty = GLOBAL;
      win->ll->dirty = TRUE;

    
      if (g_status.command == WordDelete)
         show_changed_line( win );
   }
   return( rc );
}



int  dup_line( WINDOW *window )
{
register int len;       
text_ptr p;
register WINDOW *win;   
line_list_ptr next_node;
int  rc;

   win = window;

   if (win->rline > win->file_info->length  ||  win->ll->len == EOF)
      return( ERROR );

   entab_linebuff( );
   rc = un_copy_line( win->ll, win, TRUE );
   len = win->ll->len;

   assert( len >= 0);
   assert( len < MAX_LINE_LENGTH );

   p = NULL;
   next_node = NULL;
   if (rc == OK) {
      p = (text_ptr)my_malloc( len, &rc );
      next_node = (line_list_ptr)my_malloc( sizeof(line_list_struc), &rc );
   }

   if (rc == OK) {
      win->file_info->modified = TRUE;
      if (mode.do_backups == TRUE)
         rc = backup_file( win );
      ++win->file_info->length;

      if (len > 0)
         _fmemcpy( p, win->ll->line, len );

      next_node->line  = p;
      next_node->dirty = TRUE;
      next_node->len   = len;

      if (win->ll->next != NULL)
         win->ll->next->prev = next_node;

      next_node->next = win->ll->next;
      next_node->prev = win->ll;
      win->ll->next = next_node;

      adjust_windows_cursor( win, 1 );

      
      if  (win->cline != win->bottom_line)
         my_scroll_down( win );
      win->file_info->dirty = NOT_LOCAL;

      
      restore_marked_block( win, 1 );
      show_size( win );
      show_avail_mem( );
   } else {
      
      if (p != NULL)
         my_free( p );
      if (next_node != NULL)
         my_free( next_node );
      error( WARNING, win->bottom_line, ed5 );
   }
   return( rc );
}



int  back_space( WINDOW *window )
{
int  rc;                
int  len;               
char *source;           
char *dest;             
text_ptr p;             
int  plen;              
int  del_count;         
int  pos;               
register int rcol;
int  ccol;
int  old_bcol;
register WINDOW *win;  
WINDOW *wp;
line_list_ptr temp_ll;

   win = window;
   if (win->rline > win->file_info->length || win->ll->len == EOF)
      return( ERROR );
   rc = OK;
   copy_line( win->ll );
   detab_linebuff( );
   len = g_status.line_buff_len;
   rcol = win->rcol;
   ccol = win->ccol;
   old_bcol = win->bcol;
   if (rcol == 0) {
      if (win->rline > 1) {
        

         assert( win->ll->prev != NULL );

         p = win->ll->prev->line;
         plen = win->ll->prev->len;
         if (len + 2 + plen >= g_display.line_length) {
          
            error( WARNING, win->bottom_line, ed4 );
            return( ERROR );
         }

         win->file_info->modified = TRUE;
         if ((rc = un_copy_line( win->ll, win, TRUE )) == OK) {
            --win->rline;
            win->ll = win->ll->prev;
            win->bin_offset -= win->ll->len;
            win->ll->dirty = TRUE;
            copy_line( win->ll );
            detab_linebuff( );
            len = g_status.line_buff_len;
            rcol = len;

            p = win->ll->next->line;
            plen = win->ll->next->len;

            
            assert( plen >= 0 );
            assert( len  >= 0 );

            _fmemcpy( g_status.line_buff+len, p, plen );
            g_status.line_buff_len = len + plen;

            load_undo_buffer( win->file_info, p, plen );
            if (p != NULL)
               my_free( p );

            temp_ll = win->ll->next;

            if (temp_ll->prev != NULL)
               temp_ll->prev->next = temp_ll->next;
            temp_ll->next->prev = temp_ll->prev;

            --win->file_info->length;
            ++win->rline;
            restore_marked_block( win, -1 );
            adjust_windows_cursor( win, -1 );
            --win->rline;

            wp = g_status.window_list;
            while (wp != NULL) {
               if (wp->file_info == win->file_info) {
                  if (wp != win) {
                     if (wp->ll == temp_ll)
                        wp->ll = win->ll->next;
                  }
               }
               wp = wp->next;
            }

            my_free( temp_ll );

            if (win->cline > win->top_line + win->ruler)
               --win->cline;

            
            ccol = rcol - win->bcol;
            show_size( win );
            show_avail_mem( );
            check_virtual_col( win, rcol, ccol );
            win->file_info->dirty = GLOBAL;
            make_ruler( win );
            show_ruler( win );
         }
      } else
         return( ERROR );
   } else {
    
      del_count = 1;   
      if (mode.indent) {
        
         pos = first_non_blank( (text_ptr)g_status.line_buff, len );
         if (pos == rcol  ||
                         is_line_blank( (text_ptr)g_status.line_buff, len )) {
           
            temp_ll = win->ll->prev;
            for (; temp_ll != NULL; temp_ll=temp_ll->prev) {
               p = temp_ll->line;
               plen = first_non_blank( p, temp_ll->len );
               if (plen < rcol  &&  plen != temp_ll->len) {
                
                  del_count = rcol - plen;
                  break;
               }
            }
         }
      }

      
      if (rcol - del_count < len) {
         dest = g_status.line_buff + rcol - del_count;
         if (rcol > len) {
            source = g_status.line_buff + len;
            pos = 0;
            len = (rcol + 1) - del_count;
         } else {
            source = g_status.line_buff + rcol;
            pos = len - rcol;
            len = len - del_count;
         }

         assert( pos >= 0 );
         assert( len >= 0 );
         assert( len <= MAX_LINE_LENGTH );

         memmove( dest, source, pos );
         g_status.line_buff_len = len;
         entab_linebuff( );
      }
      rcol -= del_count;
      ccol -= del_count;
      win->file_info->dirty = NOT_LOCAL;
      win->ll->dirty = TRUE;
      show_ruler_char( win );
      show_changed_line( win );
      check_virtual_col( win, rcol, ccol );
      if (!win->file_info->dirty)
         show_curl_line( win );
      if (old_bcol != win->bcol) {
         make_ruler( win );
         show_ruler( win );
      }
   }
   win->file_info->modified = TRUE;
   return( rc );
}



int  line_kill( WINDOW *window )
{
register WINDOW *win;   
register WINDOW *wp;
line_list_ptr killed_node;
int  rc;

   win = window;
   killed_node = win->ll;
   rc = OK;
   if (killed_node->len != EOF) {
      win->file_info->modified = TRUE;
      if (mode.do_backups == TRUE)
         rc = backup_file( win );

      if (rc == OK) {
         load_undo_buffer( win->file_info,
            g_status.copied ? (text_ptr)g_status.line_buff : killed_node->line,
            g_status.copied ? g_status.line_buff_len       : killed_node->len );

         --win->file_info->length;

         win->ll = win->ll->next;

         if (killed_node->prev != NULL)
            killed_node->prev->next = killed_node->next;
         else
            win->file_info->line_list = win->ll;

         killed_node->next->prev = killed_node->prev;

         wp = g_status.window_list;
         while (wp != NULL) {
            if (wp->file_info == win->file_info) {
               if (wp != win) {
                  if (wp->ll == killed_node)
                     wp->ll = win->ll;
               }
            }
            wp = wp->next;
         }

        
         if (killed_node->line != NULL)
            my_free( killed_node->line );
         my_free( killed_node );

         win->file_info->dirty = NOT_LOCAL;

         g_status.copied = FALSE;
         
         adjust_windows_cursor( win, -1 );
         restore_marked_block( win, -1 );

         
         if (win->file_info->dirty == NOT_LOCAL)
            my_scroll_down( win );
         show_size( win );
         show_avail_mem( );
      }
   } else
      rc = ERROR;
   return( rc );
}



int  char_del_under( WINDOW *window )
{
char *source;    
int  len;
register WINDOW *win;   

   win = window;
   if (win->rline > win->file_info->length || win->ll->len == EOF)
      return( OK );
   copy_line( win->ll );
   detab_linebuff( );
   if (win->rcol < (len = g_status.line_buff_len)) {
      
      source = g_status.line_buff + win->rcol + 1;

      assert( len - win->rcol >= 0 );

      memmove( source-1, source, len - win->rcol );
      --g_status.line_buff_len;
      entab_linebuff( );
      win->file_info->dirty    = GLOBAL;
      win->file_info->modified = TRUE;
      win->ll->dirty = TRUE;
      show_changed_line( win );
   } else if (g_status.command == StreamDeleteChar)
      join_line( win );
   return( OK );
}



int  eol_kill( WINDOW *window )
{
register WINDOW *win;   

   win = window;
   if (win->rline > win->file_info->length  ||  win->ll->len == EOF)
      return( OK );
   copy_line( win->ll );
   detab_linebuff( );
   load_undo_buffer( win->file_info, (text_ptr)g_status.line_buff,
                     g_status.line_buff_len );
   if (win->rcol < g_status.line_buff_len) {
     
      g_status.line_buff_len = win->rcol;
      entab_linebuff( );
      win->file_info->dirty = GLOBAL;
      win->ll->dirty = TRUE;
      show_changed_line( win );
   }
   return( OK );
}



int  undo_line( WINDOW *window )
{
register WINDOW *win;   

   win = window;
   if (win->rline <= win->file_info->length  &&  win->ll->len != EOF &&
                            g_status.copied) {
      g_status.copied = FALSE;
      copy_line( win->ll );
      detab_linebuff( );
      win->file_info->dirty = GLOBAL;
      show_changed_line( win );
   }
   return( OK );
}