diff.c

C语言实战105例 随书光盘 王为青 张圣亮编著 中国邮电出版社出版

            }
         }

         /*
          * if one of the node pointers has come to EOL, move to next
          *   diff line.
          */
         if (diff.ignore_eol) {
            if (r1 >= len1) {
               node1 = skip_eol( node1, &r1, &rcol1, &rline1, &bin_offset1 );
               len1  = node1->len;
               if (len1 != EOF) {
                  diff1 = node1->line;
                  c1 =  (char)(r1 < len1  ?  *(diff1 + r1) : 0);
                  if (c1 == '\t'  &&  tabs)
                     c1 = ' ';
               }
            }
            if (r2 >= len2) {
               node2 = skip_eol( node2, &r2, &rcol2, &rline2, &bin_offset2 );
               len2  = node2->len;
               if (len2 != EOF) {
                  diff2 = node2->line;
                  c2 =  (char)(r2 < len2  ? *(diff2 + r2)  :  0);
                  if (c2 == '\t'  &&  tabs)
                     c2 = ' ';
               }
            }
         }

         /*
          * convert the characters to lower case, if needed.
          */
         if (mode.search_case == IGNORE) {
            c1 = (char)tolower( c1 );
            c2 = (char)tolower( c2 );
         }

         /*
          * diff each character in the diff lines until we reach EOL
          */
         while (r1 < len1  && r2 < len2) {
            if (c1 == c2) {
               if (diff.all_space) {
                  do {
                     ++rcol1;
                     r1 = tabs ? entab_adjust_rcol( diff1,len1,rcol1 ) : rcol1;
                     c1 =  (char)(r1 < len1  ?  *(diff1 + r1)  :  0);
                     if (c1 == '\t'  &&  tabs)
                        c1 = ' ';
                  } while (c1 == ' '  &&  r1 < len1);
                  do {
                     ++rcol2;
                     r2 = tabs ? entab_adjust_rcol( diff2,len2,rcol2 ) : rcol2;
                     c2 =  (char)(r2 < len2  ?  *(diff2 + r2)  :  0);
                     if (c2 == '\t'  &&  tabs)
                        c2 = ' ';
                  } while (c2 == ' '  &&  r2 < len2);
               } else {
                  ++rcol1;
                  ++rcol2;
                  r1 = tabs ? entab_adjust_rcol( diff1, len1, rcol1 ) : rcol1;
                  r2 = tabs ? entab_adjust_rcol( diff2, len2, rcol2 ) : rcol2;
                  c1 =  (char)(r1 < len1  ?  *(diff1 + r1)  :  0);
                  c2 =  (char)(r2 < len2  ?  *(diff2 + r2)  :  0);
                  if (tabs) {
                     if (c1 == '\t')
                        c1 = ' ';
                     if (c2 == '\t')
                        c2 = ' ';
                  }
               }
               if (diff.ignore_eol) {
                  if (r1 >= len1) {
                     node1 = skip_eol(node1, &r1, &rcol1, &rline1,&bin_offset1);
                     len1  = node1->len;
                     if (len1 != EOF) {
                        diff1 = node1->line;
                        c1 =  (char)(r1 < len1  ?  *(diff1 + r1)  : 0);
                        if (c1 == '\t'  &&  tabs)
                           c1 = ' ';
                     }
                  }
                  if (r2 >= len2) {
                     node2 = skip_eol(node2, &r2, &rcol2, &rline2,&bin_offset2);
                     len2  = node2->len;
                     if (len2 != EOF) {
                        diff2 = node2->line;
                        c2 = (char)(r2 < len2  ? *(diff2 + r2)  :  0);
                        if (c2 == '\t'  &&  tabs)
                           c2 = ' ';
                     }
                  }
               }
               if (mode.search_case == IGNORE) {
                  c1 = (char)tolower( c1 );
                  c2 = (char)tolower( c2 );
               }
            } else {

               /*
                * when we show the diff, use rcol1 and rcol2, as
                *   find_adjust does not adjust rcol for tabs.
                */
               update_line( diff.w1 );
               diff.w1->bin_offset = bin_offset1;
               find_adjust( diff.w1, node1, rline1, rcol1 );
               check_virtual_col( diff.w1, rcol1, rcol1 );
               show_diff_window( diff.w1 );
               update_line( diff.w2 );
               diff.w2->bin_offset = bin_offset2;
               bin_offset_adjust( diff.w2, rline2 );
               find_adjust( diff.w2, node2, rline2, rcol2 );
               check_virtual_col( diff.w2, rcol2, rcol2 );
               show_diff_window( diff.w2 );
               s_output( diff_blank, g_display.mode_line, 67,
                         g_display.mode_color );
               return( OK );
            }
         }

         /*
          * if we haven't come to the end of a file buffer, check the last
          *   characters.  see if pointers are at EOL.
          */
         if (node1->len != EOF && node2->len != EOF) {
            if (rcol1 != len1  &&  rcol2 != len2) {
               update_line( diff.w1 );
               diff.w1->bin_offset = bin_offset1;
               find_adjust( diff.w1, node1, rline1, rcol1 );
               show_diff_window( diff.w1 );
               update_line( diff.w2 );
               diff.w2->bin_offset = bin_offset2;
               find_adjust( diff.w2, node2, rline2, rcol2 );
               show_diff_window( diff.w2 );
               s_output( diff_blank, g_display.mode_line, 67,
                         g_display.mode_color );
               return( OK );
            } else {
               node1 = skip_eol( node1, &r1, &rcol1, &rline1, &bin_offset1 );
               len1  = node1->len;
               diff1 = node1->line;
               node2 = skip_eol( node2, &r2, &rcol2, &rline2, &bin_offset2 );
               len2  = node2->len;
               diff2 = node2->line;
            }
         }

         assert( rcol1 >= 0 );
         assert( rcol1 < MAX_LINE_LENGTH );
         assert( rcol2 >= 0 );
         assert( rcol2 < MAX_LINE_LENGTH );
         assert( r1 >= 0 );
         assert( r1 < MAX_LINE_LENGTH );
         assert( r2 >= 0 );
         assert( r2 < MAX_LINE_LENGTH );
         assert( r1 <= rcol1 );
         assert( r2 <= rcol2 );
         if (node1->len == EOF)
            assert( len1 == EOF );
         else {
            assert( len1 >= 0 );
            assert( len1 < MAX_LINE_LENGTH );
         }
         if (node2->len == EOF)
            assert( len2 == EOF );
         else {
            assert( len2 >= 0 );
            assert( len2 < MAX_LINE_LENGTH );
         }
      }
      save_screen_line( 0, bottom, line_buff );
      set_prompt( diff_prompt4, bottom );
      getkey( );
      restore_screen_line( 0, bottom, line_buff );
      s_output( diff_blank, g_display.mode_line, 67, g_display.mode_color );
   }
   return( ERROR );
}


/*
 * Name:    skip_leading_space
 * Purpose: put the diff on the first non-blank character
 * Date:    October 31, 1992
 * Passed:  s:  the string to search
 *          len: length of string
 * Returns: the first non-blank column
 */
int  skip_leading_space( text_ptr s, int len )
{
register int count = 0;

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

   if (s != NULL) {
      if (mode.inflate_tabs) {
         while (len > 0  &&  (*s == ' ' || *s == '\t')) {
            ++count;
            ++s;
            --len;
         }
      } else {
         while (len > 0  &&  *s == ' ') {
           ++count;
           ++s;
           --len;
         }
      }
   }
   if (len == 0)
      count = 0;
   return( count );
}


/*
 * Name:    skip_eol
 * Purpose: move the diff to the next line
 * Date:    October 31, 1992
 * Passed:  d:           pointer to current node
 *          r:           tab adjusted real col
 *          rcol:        real real col
 *          rline:       current line number
 *          bin_offset:  offset from the beginning of the file
 * Returns: next non-blank node
 */
line_list_ptr skip_eol( line_list_ptr d, int *r, int *rcol, long *rline,
                        long *bin_offset )
{
int  leading;
long rl;
long bo;

   *r = *rcol = 0;
   rl = *rline;
   bo = *bin_offset;
   if (d->len != EOF) {
      bo += d->len;
      d = d->next;
      ++rl;
      if (diff.blank_lines) {
         while (d->len != EOF  &&  is_line_blank( d->line, d->len )) {
            bo += d->len;
            d = d->next;
            ++rl;
         }
      }
      if (d->len != EOF) {
         if (diff.leading) {
            leading = skip_leading_space( d->line, d->len );
            if (mode.inflate_tabs)
               leading = detab_adjust_rcol( d->line, leading );
            *rcol = leading;
         } else
            *rcol = 0;
         *r = *rcol;
         if (mode.inflate_tabs)
            *r = entab_adjust_rcol( d->line, d->len, *rcol );
      }
   }
   *rline = rl;
   *bin_offset = bo;
   return( d );
}


/*
 * Name:    show_diff_window
 * Purpose: update the contents of a diff window
 * Date:    October 31, 1992
 * Passed:  win:  pointer to window
 */
void show_diff_window( WINDOW *win )
{
   if (win->file_info->dirty == LOCAL)
      display_current_window( win );
   else
      show_curl_line( win );
   show_line_col( win );
   make_ruler( win );
   show_ruler( win );
   show_ruler_pointer( win );
   win->file_info->dirty = FALSE;
}


/*
 * Name:    verify_number
 * Purpose: given a window number, verify the number
 * Date:    October 31, 1992
 * Passed:  temp:  string that contains number
 *          num:   successfully converted number.
 */
int  verify_number( char *temp, int *num )
{
register file_infos *fp;

   /*
    * see if string has a number.  if string does have a number, convert it.
    */
   if (*temp == '\0' || !isdigit( *temp ))
      return( ERROR );
   *num = 0;
   while (isdigit( *temp ))
      *num = *num * 10 + *temp++ - '0';

   /*
    * now that we have a window number, see if any files have that number
    */
   for (fp=g_status.file_list; fp != NULL; fp=fp->next) {
      if (fp->file_no == *num)
         return( OK );
   }
   return( ERROR );
}



/*
 * Name:    verify_letter
 * Purpose: given a window letter, verify the letter
 * Date:    October 31, 1992
 * Passed:  temp:  string that contains letter
 *          let:   window letter
 *          win:   pointer to window that contains letter and number
 */
int  verify_letter( char *temp, int *let, WINDOW **win )
{
register file_infos *fp;
register WINDOW *wp;
int  num;

   if (verify_number( temp, &num ) == OK) {
      while (isdigit( *temp ))
         temp++;
      if (*temp == '\0' || !isalpha( *temp ))
         return( ERROR );
      *let = (int)tolower( *temp );
      for (fp=g_status.file_list; fp != NULL; fp=fp->next) {
         if (fp->file_no == num)
            break;
      }
      for (wp=g_status.window_list; wp != NULL; wp=wp->next) {
         if (wp->file_info == fp  &&  wp->letter == *let  &&  wp->visible) {
            *win = wp;
            return( OK );
         }
      }
   }
   return( ERROR );
}