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