contrib/diffutils-2.8/src/ifdef.c

   1 /* #ifdef-format output routines for GNU DIFF.
   2
   3    Copyright (C) 1989, 1991, 1992, 1993, 1994, 2001, 2002, 2004 Free
   4    Software Foundation, Inc.
   5
   6    This file is part of GNU DIFF.
   7
   8    GNU DIFF is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY.  No author or distributor
  10    accepts responsibility to anyone for the consequences of using it
  11    or for whether it serves any particular purpose or works at all,
  12    unless he says so in writing.  Refer to the GNU DIFF General Public
  13    License for full details.
  14
  15    Everyone is granted permission to copy, modify and redistribute
  16    GNU DIFF, but only under the conditions described in the
  17    GNU DIFF General Public License.   A copy of this license is
  18    supposed to have been given to you along with GNU DIFF so you
  19    can know your rights and responsibilities.  It should be in a
  20    file named COPYING.  Among other things, the copyright notice
  21    and this notice must be preserved on all copies.  */
  22
  23 #include "diff.h"
  24
  25 #include <xalloc.h>
  26
  27 struct group
  28 {
  29   struct file_data const *file;
  30   lin from, upto; /* start and limit lines for this group of lines */
  31 };
  32
  33 static char const *format_group (FILE *, char const *, char,
  34                                  struct group const *);
  35 static char const *do_printf_spec (FILE *, char const *,
  36                                    struct file_data const *, lin,
  37                                    struct group const *);
  38 static char const *scan_char_literal (char const *, char *);
  39 static lin groups_letter_value (struct group const *, char);
  40 static void format_ifdef (char const *, lin, lin, lin, lin);
  41 static void print_ifdef_hunk (struct change *);
  42 static void print_ifdef_lines (FILE *, char const *, struct group const *);
  43
  44 static lin next_line0;
  45 static lin next_line1;
  46
  47 /* Print the edit-script SCRIPT as a merged #ifdef file.  */
  48
  49 void
  50 print_ifdef_script (struct change *script)
  51 {
  52   next_line0 = next_line1 = - files[0].prefix_lines;
  53   print_script (script, find_change, print_ifdef_hunk);
  54   if (next_line0 < files[0].valid_lines
  55       || next_line1 < files[1].valid_lines)
  56     {
  57       begin_output ();
  58       format_ifdef (group_format[UNCHANGED],
  59                     next_line0, files[0].valid_lines,
  60                     next_line1, files[1].valid_lines);
  61     }
  62 }
  63
  64 /* Print a hunk of an ifdef diff.
  65    This is a contiguous portion of a complete edit script,
  66    describing changes in consecutive lines.  */
  67
  68 static void
  69 print_ifdef_hunk (struct change *hunk)
  70 {
  71   lin first0, last0, first1, last1;
  72
  73   /* Determine range of line numbers involved in each file.  */
  74   enum changes changes = analyze_hunk (hunk, &first0, &last0, &first1, &last1);
  75   if (!changes)
  76     return;
  77
  78   begin_output ();
  79
  80   /* Print lines up to this change.  */
  81   if (next_line0 < first0 || next_line1 < first1)
  82     format_ifdef (group_format[UNCHANGED],
  83                   next_line0, first0,
  84                   next_line1, first1);
  85
  86   /* Print this change.  */
  87   next_line0 = last0 + 1;
  88   next_line1 = last1 + 1;
  89   format_ifdef (group_format[changes],
  90                 first0, next_line0,
  91                 first1, next_line1);
  92 }
  93
  94 /* Print a set of lines according to FORMAT.
  95    Lines BEG0 up to END0 are from the first file;
  96    lines BEG1 up to END1 are from the second file.  */
  97
  98 static void
  99 format_ifdef (char const *format, lin beg0, lin end0, lin beg1, lin end1)
 100 {
 101   struct group groups[2];
 102
 103   groups[0].file = &files[0];
 104   groups[0].from = beg0;
 105   groups[0].upto = end0;
 106   groups[1].file = &files[1];
 107   groups[1].from = beg1;
 108   groups[1].upto = end1;
 109   format_group (outfile, format, 0, groups);
 110 }
 111
 112 /* Print to file OUT a set of lines according to FORMAT.
 113    The format ends at the first free instance of ENDCHAR.
 114    Yield the address of the terminating character.
 115    GROUPS specifies which lines to print.
 116    If OUT is zero, do not actually print anything; just scan the format.  */
 117
 118 static char const *
 119 format_group (register FILE *out, char const *format, char endchar,
 120               struct group const *groups)
 121 {
 122   register char c;
 123   register char const *f = format;
 124
 125   while ((c = *f) != endchar && c != 0)
 126     {
 127       char const *f1 = ++f;
 128       if (c == '%')
 129         switch ((c = *f++))
 130           {
 131           case '%':
 132             break;
 133
 134           case '(':
 135             /* Print if-then-else format e.g. `%(n=1?thenpart:elsepart)'.  */
 136             {
 137               int i;
 138               uintmax_t value[2];
 139               FILE *thenout, *elseout;
 140
 141               for (i = 0; i < 2; i++)
 142                 {
 143                   if (ISDIGIT (*f))
 144                     {
 145                       char *fend;
 146                       errno = 0;
 147                       value[i] = strtoumax (f, &fend, 10);
 148                       if (errno)
 149                         goto bad_format;
 150                       f = fend;
 151                     }
 152                   else
 153                     {
 154                       value[i] = groups_letter_value (groups, *f);
 155                       if (value[i] == -1)
 156                         goto bad_format;
 157                       f++;
 158                     }
 159                   if (*f++ != "=?"[i])
 160                     goto bad_format;
 161                 }
 162               if (value[0] == value[1])
 163                 thenout = out, elseout = 0;
 164               else
 165                 thenout = 0, elseout = out;
 166               f = format_group (thenout, f, ':', groups);
 167               if (*f)
 168                 {
 169                   f = format_group (elseout, f + 1, ')', groups);
 170                   if (*f)
 171                     f++;
 172                 }
 173             }
 174             continue;
 175
 176           case '<':
 177             /* Print lines deleted from first file.  */
 178             print_ifdef_lines (out, line_format[OLD], &groups[0]);
 179             continue;
 180
 181           case '=':
 182             /* Print common lines.  */
 183             print_ifdef_lines (out, line_format[UNCHANGED], &groups[0]);
 184             continue;
 185
 186           case '>':
 187             /* Print lines inserted from second file.  */
 188             print_ifdef_lines (out, line_format[NEW], &groups[1]);
 189             continue;
 190
 191           default:
 192             f = do_printf_spec (out, f - 2, 0, 0, groups);
 193             if (f)
 194               continue;
 195             /* Fall through. */
 196           bad_format:
 197             c = '%';
 198             f = f1;
 199             break;
 200           }
 201
 202       if (out)
 203         putc (c, out);
 204     }
 205
 206   return f;
 207 }
 208
 209 /* For the line group pair G, return the number corresponding to LETTER.
 210    Return -1 if LETTER is not a group format letter.  */
 211 static lin
 212 groups_letter_value (struct group const *g, char letter)
 213 {
 214   switch (letter)
 215     {
 216     case 'E': letter = 'e'; g++; break;
 217     case 'F': letter = 'f'; g++; break;
 218     case 'L': letter = 'l'; g++; break;
 219     case 'M': letter = 'm'; g++; break;
 220     case 'N': letter = 'n'; g++; break;
 221     }
 222
 223   switch (letter)
 224     {
 225       case 'e': return translate_line_number (g->file, g->from) - 1;
 226       case 'f': return translate_line_number (g->file, g->from);
 227       case 'l': return translate_line_number (g->file, g->upto) - 1;
 228       case 'm': return translate_line_number (g->file, g->upto);
 229       case 'n': return g->upto - g->from;
 230       default: return -1;
 231     }
 232 }
 233
 234 /* Print to file OUT, using FORMAT to print the line group GROUP.
 235    But do nothing if OUT is zero.  */
 236 static void
 237 print_ifdef_lines (register FILE *out, char const *format,
 238                    struct group const *group)
 239 {
 240   struct file_data const *file = group->file;
 241   char const * const *linbuf = file->linbuf;
 242   lin from = group->from, upto = group->upto;
 243
 244   if (!out)
 245     return;
 246
 247   /* If possible, use a single fwrite; it's faster.  */
 248   if (!expand_tabs && format[0] == '%')
 249     {
 250       if (format[1] == 'l' && format[2] == '\n' && !format[3] && from < upto)
 251         {
 252           fwrite (linbuf[from], sizeof (char),
 253                   linbuf[upto] + (linbuf[upto][-1] != '\n') -  linbuf[from],
 254                   out);
 255           return;
 256         }
 257       if (format[1] == 'L' && !format[2])
 258         {
 259           fwrite (linbuf[from], sizeof (char),
 260                   linbuf[upto] -  linbuf[from], out);
 261           return;
 262         }
 263     }
 264
 265   for (;  from < upto;  from++)
 266     {
 267       register char c;
 268       register char const *f = format;
 269
 270       while ((c = *f++) != 0)
 271         {
 272           char const *f1 = f;
 273           if (c == '%')
 274             switch ((c = *f++))
 275               {
 276               case '%':
 277                 break;
 278
 279               case 'l':
 280                 output_1_line (linbuf[from],
 281                                (linbuf[from + 1]
 282                                 - (linbuf[from + 1][-1] == '\n')),
 283                                0, 0);
 284                 continue;
 285
 286               case 'L':
 287                 output_1_line (linbuf[from], linbuf[from + 1], 0, 0);
 288                 continue;
 289
 290               default:
 291                 f = do_printf_spec (out, f - 2, file, from, 0);
 292                 if (f)
 293                   continue;
 294                 c = '%';
 295                 f = f1;
 296                 break;
 297               }
 298
 299           putc (c, out);
 300         }
 301     }
 302 }
 303
 304 static char const *
 305 do_printf_spec (FILE *out, char const *spec,
 306                 struct file_data const *file, lin n,
 307                 struct group const *groups)
 308 {
 309   char const *f = spec;
 310   char c;
 311   char c1;
 312
 313   /* Scan printf-style SPEC of the form %[-'0]*[0-9]*(.[0-9]*)?[cdoxX].  */
 314   /* assert (*f == '%'); */
 315   f++;
 316   while ((c = *f++) == '-' || c == '\'' || c == '0')
 317     continue;
 318   while (ISDIGIT (c))
 319     c = *f++;
 320   if (c == '.')
 321     while (ISDIGIT (c = *f++))
 322       continue;
 323   c1 = *f++;
 324
 325   switch (c)
 326     {
 327     case 'c':
 328       if (c1 != '\'')
 329         return 0;
 330       else
 331         {
 332           char value;
 333           f = scan_char_literal (f, &value);
 334           if (!f)
 335             return 0;
 336           if (out)
 337             putc (value, out);
 338         }
 339       break;
 340
 341     case 'd': case 'o': case 'x': case 'X':
 342       {
 343         lin value;
 344
 345         if (file)
 346           {
 347             if (c1 != 'n')
 348               return 0;
 349             value = translate_line_number (file, n);
 350           }
 351         else
 352           {
 353             value = groups_letter_value (groups, c1);
 354             if (value < 0)
 355               return 0;
 356           }
 357
 358         if (out)
 359           {
 360             /* For example, if the spec is "%3xn", use the printf
 361                format spec "%3lx".  Here the spec prefix is "%3".  */
 362             long int long_value = value;
 363             size_t spec_prefix_len = f - spec - 2;
 364 #if HAVE_C_VARARRAYS
 365             char format[spec_prefix_len + 3];
 366 #else
 367             char *format = xmalloc (spec_prefix_len + 3);
 368 #endif
 369             char *p = format + spec_prefix_len;
 370             memcpy (format, spec, spec_prefix_len);
 371             *p++ = 'l';
 372             *p++ = c;
 373             *p = '\0';
 374             fprintf (out, format, long_value);
 375 #if ! HAVE_C_VARARRAYS
 376             free (format);
 377 #endif
 378           }
 379       }
 380       break;
 381
 382     default:
 383       return 0;
 384     }
 385
 386   return f;
 387 }
 388
 389 /* Scan the character literal represented in the string LIT; LIT points just
 390    after the initial apostrophe.  Put the literal's value into *VALPTR.
 391    Yield the address of the first character after the closing apostrophe,
 392    or zero if the literal is ill-formed.  */
 393 static char const *
 394 scan_char_literal (char const *lit, char *valptr)
 395 {
 396   register char const *p = lit;
 397   char value;
 398   ptrdiff_t digits;
 399   char c = *p++;
 400
 401   switch (c)
 402     {
 403       case 0:
 404       case '\'':
 405         return 0;
 406
 407       case '\\':
 408         value = 0;
 409         while ((c = *p++) != '\'')
 410           {
 411             unsigned int digit = c - '0';
 412             if (8 <= digit)
 413               return 0;
 414             value = 8 * value + digit;
 415           }
 416         digits = p - lit - 2;
 417         if (! (1 <= digits && digits <= 3))
 418           return 0;
 419         break;
 420
 421       default:
 422         value = c;
 423         if (*p++ != '\'')
 424           return 0;
 425         break;
 426     }
 427
 428   *valptr = value;
 429   return p;
 430 }