gnu/dist/diffutils/src/side.c

   1 /*      $NetBSD$        */
   2
   3 /* sdiff-format output routines for GNU DIFF.
   4
   5    Copyright (C) 1991, 1992, 1993, 1998, 2001, 2002 Free Software
   6    Foundation, Inc.
   7
   8    This file is part of GNU DIFF.
   9
  10    GNU DIFF is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY.  No author or distributor
  12    accepts responsibility to anyone for the consequences of using it
  13    or for whether it serves any particular purpose or works at all,
  14    unless he says so in writing.  Refer to the GNU DIFF General Public
  15    License for full details.
  16
  17    Everyone is granted permission to copy, modify and redistribute
  18    GNU DIFF, but only under the conditions described in the
  19    GNU DIFF General Public License.   A copy of this license is
  20    supposed to have been given to you along with GNU DIFF so you
  21    can know your rights and responsibilities.  It should be in a
  22    file named COPYING.  Among other things, the copyright notice
  23    and this notice must be preserved on all copies.  */
  24
  25 #include "diff.h"
  26
  27 static void print_sdiff_common_lines (lin, lin);
  28 static void print_sdiff_hunk (struct change *);
  29
  30 /* Next line number to be printed in the two input files.  */
  31 static lin next0, next1;
  32
  33 /* Print the edit-script SCRIPT as a sdiff style output.  */
  34
  35 void
  36 print_sdiff_script (struct change *script)
  37 {
  38   begin_output ();
  39
  40   next0 = next1 = - files[0].prefix_lines;
  41   print_script (script, find_change, print_sdiff_hunk);
  42
  43   print_sdiff_common_lines (files[0].valid_lines, files[1].valid_lines);
  44 }
  45
  46 /* Tab from column FROM to column TO, where FROM <= TO.  Yield TO.  */
  47
  48 static unsigned int
  49 tab_from_to (unsigned int from, unsigned int to)
  50 {
  51   FILE *out = outfile;
  52   unsigned int tab;
  53
  54   if (!expand_tabs)
  55     for (tab = from + TAB_WIDTH - from % TAB_WIDTH;  tab <= to;  tab += TAB_WIDTH)
  56       {
  57         putc ('\t', out);
  58         from = tab;
  59       }
  60   while (from++ < to)
  61     putc (' ', out);
  62   return to;
  63 }
  64
  65 /*
  66  * Print the text for half an sdiff line.  This means truncate to width
  67  * observing tabs, and trim a trailing newline.  Returns the last column
  68  * written (not the number of chars).
  69  */
  70 static unsigned int
  71 print_half_line (char const *const *line, unsigned int indent,
  72                  unsigned int out_bound)
  73 {
  74   FILE *out = outfile;
  75   register unsigned int in_position = 0;
  76   register unsigned int out_position = 0;
  77   register char const *text_pointer = line[0];
  78   register char const *text_limit = line[1];
  79
  80   while (text_pointer < text_limit)
  81     {
  82       register unsigned char c = *text_pointer++;
  83
  84       switch (c)
  85         {
  86         case '\t':
  87           {
  88             unsigned int spaces = TAB_WIDTH - in_position % TAB_WIDTH;
  89             if (in_position == out_position)
  90               {
  91                 unsigned int tabstop = out_position + spaces;
  92                 if (expand_tabs)
  93                   {
  94                     if (out_bound < tabstop)
  95                       tabstop = out_bound;
  96                     for (;  out_position < tabstop;  out_position++)
  97                       putc (' ', out);
  98                   }
  99                 else
 100                   if (tabstop < out_bound)
 101                     {
 102                       out_position = tabstop;
 103                       putc (c, out);
 104                     }
 105               }
 106             in_position += spaces;
 107           }
 108           break;
 109
 110         case '\r':
 111           {
 112             putc (c, out);
 113             tab_from_to (0, indent);
 114             in_position = out_position = 0;
 115           }
 116           break;
 117
 118         case '\b':
 119           if (in_position != 0 && --in_position < out_bound)
 120             {
 121               if (out_position <= in_position)
 122                 /* Add spaces to make up for suppressed tab past out_bound.  */
 123                 for (;  out_position < in_position;  out_position++)
 124                   putc (' ', out);
 125               else
 126                 {
 127                   out_position = in_position;
 128                   putc (c, out);
 129                 }
 130             }
 131           break;
 132
 133         case '\f':
 134         case '\v':
 135         control_char:
 136           if (in_position < out_bound)
 137             putc (c, out);
 138           break;
 139
 140         default:
 141           if (! ISPRINT (c))
 142             goto control_char;
 143           /* falls through */
 144         case ' ':
 145           if (in_position++ < out_bound)
 146             {
 147               out_position = in_position;
 148               putc (c, out);
 149             }
 150           break;
 151
 152         case '\n':
 153           return out_position;
 154         }
 155     }
 156
 157   return out_position;
 158 }
 159
 160 /*
 161  * Print side by side lines with a separator in the middle.
 162  * 0 parameters are taken to indicate white space text.
 163  * Blank lines that can easily be caught are reduced to a single newline.
 164  */
 165
 166 static void
 167 print_1sdiff_line (char const *const *left, char sep,
 168                    char const *const *right)
 169 {
 170   FILE *out = outfile;
 171   unsigned int hw = sdiff_half_width, c2o = sdiff_column2_offset;
 172   unsigned int col = 0;
 173   bool put_newline = 0;
 174
 175   if (left)
 176     {
 177       put_newline |= left[1][-1] == '\n';
 178       col = print_half_line (left, 0, hw);
 179     }
 180
 181   if (sep != ' ')
 182     {
 183       col = tab_from_to (col, (hw + c2o - 1) / 2) + 1;
 184       if (sep == '|' && put_newline != (right[1][-1] == '\n'))
 185         sep = put_newline ? '/' : '\\';
 186       putc (sep, out);
 187     }
 188
 189   if (right)
 190     {
 191       put_newline |= right[1][-1] == '\n';
 192       if (**right != '\n')
 193         {
 194           col = tab_from_to (col, c2o);
 195           print_half_line (right, col, hw);
 196         }
 197     }
 198
 199   if (put_newline)
 200     putc ('\n', out);
 201 }
 202
 203 /* Print lines common to both files in side-by-side format.  */
 204 static void
 205 print_sdiff_common_lines (lin limit0, lin limit1)
 206 {
 207   lin i0 = next0, i1 = next1;
 208
 209   if (!suppress_common_lines && (i0 != limit0 || i1 != limit1))
 210     {
 211       if (sdiff_merge_assist)
 212         {
 213           long len0 = limit0 - i0;
 214           long len1 = limit1 - i1;
 215           fprintf (outfile, "i%ld,%ld\n", len0, len1);
 216         }
 217
 218       if (!left_column)
 219         {
 220           while (i0 != limit0 && i1 != limit1)
 221             print_1sdiff_line (&files[0].linbuf[i0++], ' ',
 222                                &files[1].linbuf[i1++]);
 223           while (i1 != limit1)
 224             print_1sdiff_line (0, ')', &files[1].linbuf[i1++]);
 225         }
 226       while (i0 != limit0)
 227         print_1sdiff_line (&files[0].linbuf[i0++], '(', 0);
 228     }
 229
 230   next0 = limit0;
 231   next1 = limit1;
 232 }
 233
 234 /* Print a hunk of an sdiff diff.
 235    This is a contiguous portion of a complete edit script,
 236    describing changes in consecutive lines.  */
 237
 238 static void
 239 print_sdiff_hunk (struct change *hunk)
 240 {
 241   lin first0, last0, first1, last1;
 242   register lin i, j;
 243
 244   /* Determine range of line numbers involved in each file.  */
 245   enum changes changes =
 246     analyze_hunk (hunk, &first0, &last0, &first1, &last1);
 247   if (!changes)
 248     return;
 249
 250   /* Print out lines up to this change.  */
 251   print_sdiff_common_lines (first0, first1);
 252
 253   if (sdiff_merge_assist)
 254     {
 255       long len0 = last0 - first0 + 1;
 256       long len1 = last1 - first1 + 1;
 257       fprintf (outfile, "c%ld,%ld\n", len0, len1);
 258     }
 259
 260   /* Print ``xxx  |  xxx '' lines */
 261   if (changes == CHANGED)
 262     {
 263       for (i = first0, j = first1;  i <= last0 && j <= last1;  i++, j++)
 264         print_1sdiff_line (&files[0].linbuf[i], '|', &files[1].linbuf[j]);
 265       changes = (i <= last0 ? OLD : 0) + (j <= last1 ? NEW : 0);
 266       next0 = first0 = i;
 267       next1 = first1 = j;
 268     }
 269
 270   /* Print ``     >  xxx '' lines */
 271   if (changes & NEW)
 272     {
 273       for (j = first1; j <= last1; ++j)
 274         print_1sdiff_line (0, '>', &files[1].linbuf[j]);
 275       next1 = j;
 276     }
 277
 278   /* Print ``xxx  <     '' lines */
 279   if (changes & OLD)
 280     {
 281       for (i = first0; i <= last0; ++i)
 282         print_1sdiff_line (&files[0].linbuf[i], '<', 0);
 283       next0 = i;
 284     }
 285 }