gcc/testsuite/c-c++-common/Wmisleading-indentation.c

   1 /* { dg-options "-Wmisleading-indentation -Wall" } */
   2 /* { dg-do compile } */
   3
   4 extern int foo (int);
   5 extern int bar (int, int);
   6 extern int flagA;
   7 extern int flagB;
   8 extern int flagC;
   9 extern int flagD;
  10
  11 int
  12 fn_1 (int flag)
  13 {
  14   int x = 4, y = 5;
  15   if (flag) /* { dg-message "3: ...this 'if' clause, but it is not" } */
  16     x = 3;
  17     y = 2; /* { dg-warning "statement is indented as if it were guarded by..." } */
  18   return x * y;
  19 }
  20
  21 int
  22 fn_2 (int flag, int x, int y)
  23 {
  24   if (flag) /* { dg-message "3: ...this 'if' clause, but it is not" } */
  25     x++; y++; /* { dg-warning "statement is indented as if it were guarded by..." } */
  26
  27   return x * y;
  28 }
  29
  30 int
  31 fn_3 (int flag)
  32 {
  33   int x = 4, y = 5;
  34   if (flag)
  35     x = 3;
  36   else /* { dg-message "3: ...this 'else' clause, but it is not" } */
  37     x = 2;
  38     y = 2; /* { dg-warning "statement is indented as if it were guarded by..." } */
  39   return x * y;
  40 }
  41
  42 void
  43 fn_4 (double *a, double *b, double *c)
  44 {
  45   int i = 0;
  46   while (i < 10) /* { dg-message "3: ...this 'while' clause, but it is not" } */
  47     a[i] = b[i] * c[i];
  48     i++; /* { dg-warning "statement is indented as if it were guarded by..." } */
  49 }
  50
  51 void
  52 fn_5 (double *a, double *b, double *sum, double *prod)
  53 {
  54   int i = 0;
  55   for (i = 0; i < 10; i++) /* { dg-output "3: ...this 'for' clause, but it is not" } */
  56     sum[i] = a[i] * b[i];
  57     prod[i] = a[i] * b[i]; /* { dg-warning "statement is indented as if it were guarded by..." } */
  58 }
  59
  60 /* Based on CVE-2014-1266 aka "goto fail" */
  61 int fn_6 (int a, int b, int c)
  62 {
  63         int err;
  64
  65         /* ... */
  66         if ((err = foo (a)) != 0)
  67                 goto fail;
  68         if ((err = foo (b)) != 0) /* { dg-message "2: ...this 'if' clause, but it is not" } */
  69                 goto fail;
  70                 goto fail; /* { dg-warning "statement is indented as if it were guarded by..." } */
  71         if ((err = foo (c)) != 0)
  72                 goto fail;
  73         /* ... */
  74
  75 fail:
  76         return err;
  77 }
  78
  79 int fn_7 (int p, int q, int r, int s, int t)
  80 {
  81   if (bar (p, q))
  82     {
  83       if (p) /* { dg-message "7: ...this 'if' clause, but it is not" } */
  84         q++; r++; /* { dg-warning "statement is indented as if it were guarded by..." } */
  85       t++;
  86     }
  87   return p + q + r + s + t;
  88 }
  89
  90 int fn_8 (int a, int b, int c)
  91 {
  92   /* This should *not* be flagged as misleading indentation.  */
  93   if (a) return b; else return c;
  94 }
  95
  96 void fn_9 (int flag)
  97 {
  98   if (flag) /* { dg-message "3: ...this 'if' clause, but it is not" } */
  99     foo (0);
 100     foo (1); /* { dg-warning "statement is indented as if it were guarded by..." } */
 101 }
 102
 103 void fn_10 (int flag)
 104 {
 105   if (flag) /* { dg-message "3: ...this 'if' clause, but it is not" } */
 106     if (flag / 2)
 107       {
 108         foo (0);
 109         foo (1);
 110       }
 111     foo (2); /* { dg-warning "statement is indented as if it were guarded by..." } */
 112   foo (3);
 113 }
 114
 115 void fn_11 (void)
 116 {
 117   if (flagA)
 118     if (flagB)
 119       if (flagC) /* { dg-message "7: ...this 'if' clause, but it is not" } */
 120         foo (0);
 121         bar (1, 2); /* { dg-warning "statement is indented as if it were guarded by..." } */
 122 }
 123
 124 void fn_12 (void)
 125 {
 126   if (flagA)
 127     if (flagB) /* { dg-message "5: ...this 'if' clause, but it is not" } */
 128       if (flagC)
 129         foo (0);
 130       bar (1, 2); /* { dg-warning "statement is indented as if it were guarded by..." } */
 131 }
 132
 133 void fn_13 (void)
 134 {
 135   if (flagA) /* { dg-message "3: ...this 'if' clause, but it is not" } */
 136     if (flagB)
 137       if (flagC)
 138         foo (0);
 139     bar (1, 2); /* { dg-warning "statement is indented as if it were guarded by..." } */
 140 }
 141
 142 #define FOR_EACH(VAR, START, STOP) \
 143   for ((VAR) = (START); (VAR) < (STOP); (VAR++)) /* { dg-message "3: ...this 'for' clause, but it is not" } */
 144
 145 void fn_14 (void)
 146 {
 147   int i;
 148   FOR_EACH (i, 0, 10) /* { dg-message "3: in expansion of macro" } */
 149     foo (i);
 150     bar (i, i); /* { dg-warning "statement is indented as if it were guarded by..." } */
 151 }
 152 #undef FOR_EACH
 153
 154 #define FOR_EACH(VAR, START, STOP) for ((VAR) = (START); (VAR) < (STOP); (VAR++)) /* { dg-message "36: ...this 'for' clause, but it is not" } */
 155 void fn_15 (void)
 156 {
 157   int i;
 158   FOR_EACH (i, 0, 10) /* { dg-message "3: in expansion of macro" } */
 159     foo (i);
 160     bar (i, i); /* { dg-warning "statement is indented as if it were guarded by..." } */
 161 }
 162 #undef FOR_EACH
 163
 164 void fn_16_spaces (void)
 165 {
 166   int i;
 167   for (i = 0; i < 10; i++)
 168     while (flagA)
 169       if (flagB) /* { dg-message "7: ...this 'if' clause, but it is not" } */
 170         foo (0);
 171         foo (1); /* { dg-warning "statement is indented as if it were guarded by..." } */
 172 }
 173
 174 void fn_16_tabs (void)
 175 {
 176   int i;
 177   for (i = 0; i < 10; i++)
 178     while (flagA)
 179       if (flagB) /* { dg-message "7: ...this 'if' clause, but it is not" } */
 180         foo (0);
 181         foo (1);/* { dg-warning "statement is indented as if it were guarded by..." } */
 182 }
 183
 184 void fn_17_spaces (void)
 185 {
 186   int i;
 187   for (i = 0; i < 10; i++) /* { dg-message "3: ...this 'for' clause, but it is not" } */
 188     while (flagA)
 189       if (flagB)
 190         foo (0);
 191     foo (1);/* { dg-warning "statement is indented as if it were guarded by..." } */
 192 }
 193
 194 void fn_17_tabs (void)
 195 {
 196   int i;
 197   for (i = 0; i < 10; i++) /* { dg-message "3: ...this 'for' clause, but it is not" } */
 198     while (flagA)
 199       if (flagB)
 200         foo (0);
 201     foo (1);/* { dg-warning "statement is indented as if it were guarded by..." } */
 202 }
 203
 204 void fn_18_spaces (void)
 205 {
 206   int i;
 207   for (i = 0; i < 10; i++)
 208     while (flagA) /* { dg-message "5: ...this 'while' clause, but it is not" } */
 209       if (flagB)
 210         foo (0);
 211       foo (1);/* { dg-warning "statement is indented as if it were guarded by..." } */
 212 }
 213
 214 void fn_18_tabs (void)
 215 {
 216   int i;
 217   for (i = 0; i < 10; i++)
 218     while (flagA) /* { dg-message "5: ...this 'while' clause, but it is not" } */
 219       if (flagB)
 220         foo (0);
 221       foo (1);/* { dg-warning "statement is indented as if it were guarded by..." } */
 222 }
 223
 224 /* This shouldn't lead to a warning.  */
 225 int fn_19 (void) { if (flagA) return 1; else return 0; }
 226
 227 /* A deeply-nested mixture of spaces and tabs, adapted from
 228    c-c++-common/pr60101.c.
 229    This should not lead to a warning.  */
 230 void
 231 fn_20 (unsigned int l)
 232 {
 233   unsigned int i;
 234
 235   for (i = 0; i < 10; i++)
 236     {
 237       unsigned int n0, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11;
 238
 239       for (n0 = 0; n0 < l; n0++)
 240         for (n1 = 0; n1 < l; n1++)
 241           for (n2 = 0; n2 < l; n2++)
 242             for (n3 = 0; n3 < l; n3++)
 243               for (n4 = 0; n4 < l; n4++)
 244                 for (n5 = 0; n5 < l; n5++)
 245                   for (n6 = 0; n6 < l; n6++)
 246                     for (n7 = 0; n7 < l; n7++)
 247                       for (n8 = 0; n8 < l; n8++)
 248                         for (n9 = 0; n9 < l; n9++)
 249                           for (n10 = 0; n10 < l; n10++)
 250                             for (n11 = 0; n11 < l; n11++)
 251                               {
 252                                 if (flagA)
 253                                   foo (0);
 254                                 foo (1);
 255                               }
 256       foo (2);
 257     }
 258 }
 259
 260 /* Another nested mix of tabs and spaces that shouldn't lead to a warning,
 261    with a preprocessor directive thrown in for good measure
 262    (adapted from libgomp/loop.c: gomp_loop_init).  */
 263 void fn_21 (void)
 264 {
 265   foo (0);
 266   if (flagA)
 267     {
 268       foo (1);
 269
 270 #if 1
 271       {
 272         foo (2);
 273         if (flagB)
 274           {
 275             if (flagC)
 276               foo (3);
 277             else
 278               foo (4);
 279           }
 280         else if (flagD)
 281           foo (5);
 282         else
 283           foo (6);
 284       }
 285 #endif
 286     }
 287 }
 288
 289 /* The conditionals within the following macros shouldn't be warned about.
 290    Adapted from libgomp/driver.c: gomp_load_plugin_for_device.  */
 291 int fn_22 (void)
 292 {
 293   int err = 0;
 294
 295 #define DLSYM()                                                 \
 296   do                                                                    \
 297     {                                                                   \
 298       err = foo (0);                                                    \
 299       if (err)                                                          \
 300         goto out;                                                       \
 301     }                                                                   \
 302   while (0)
 303 #define DLSYM_OPT()                                                     \
 304   do                                                                    \
 305     {                                                                   \
 306       err = foo (1);                                                    \
 307       if (err)                                                          \
 308         foo (2);                                                        \
 309       else                                                              \
 310         foo (3);                                                        \
 311       foo (4);                                                          \
 312     }                                                                   \
 313   while (0)
 314   DLSYM ();
 315   DLSYM_OPT ();
 316 #undef DLSYM
 317 #undef DLSYM_OPT
 318
 319  out:
 320   return err;
 321 }
 322
 323 /* This shouldn't be warned about.  */
 324 void fn_23 (void) { foo (0); foo (1); if (flagA) foo (2); foo (3); foo (4); }
 325
 326 /* Code that simply doesn't bother indenting anywhere (e.g. autogenerated
 327    code) shouldn't be warned about.  */
 328 void fn_24 (void)
 329 {
 330   foo (0);
 331   if (flagA)
 332   foo (1);
 333   foo (2);
 334 }
 335
 336 /* Adapted from libiberty/regex.c; an example of a conditional in a
 337    macro where the successor statement begins with a macro arg:
 338
 339             if (num < 0)
 340               num = 0;
 341             num = num * 10 + c - '0';
 342             ^ this successor statement
 343
 344    and hence "num" has a spelling location at the argument of the
 345    macro usage site ("lower_bound"), we want the definition of the
 346    parameter ("num") for the indentation comparison to be meaninful.
 347
 348    This should not generate a misleading indentation warning.  */
 349
 350 # define GET_UNSIGNED_NUMBER(num) \
 351   {                                                                     \
 352     while (flagA)                                                       \
 353       {                                                                 \
 354         if (flagB)                                              \
 355           {                                                             \
 356             if (num < 0)                                                \
 357               num = 0;                                                  \
 358             num = num * 10 + c - '0';                                   \
 359           }                                                             \
 360       }                                                                 \
 361   }
 362 void fn_25 (int c, int lower_bound, int upper_bound)
 363 {
 364   GET_UNSIGNED_NUMBER (lower_bound);
 365 }
 366 #undef GET_UNSIGNED_NUMBER
 367
 368 /* Example adapted from libdecnumber/decNumber.c:decExpOp that shouldn't
 369    trigger a warning.  */
 370 void fn_26 (void)
 371 {
 372   if (flagA) {
 373     if (flagB) foo (0); }
 374   foo (1);
 375 }
 376
 377 /* Ensure that we don't get confused by mixed tabs and spaces; the line
 378    "foo (1);" has leading spaces before a tab, but this should not
 379    lead to a warning from -Wmisleading-indentation.  */
 380 void fn_27 (void)
 381 {
 382               if (flagA)
 383                 foo (0);
 384               foo (1);
 385 }
 386
 387 /* Example adapted from gcc/cgraph.h:symtab_node::get_availability of
 388    a spurious trailing semicolon that shouldn't generate a warning.  */
 389 void fn_28 (void)
 390 {
 391   if (flagA)
 392     foo (0);
 393   else
 394     foo (1);;
 395 }
 396
 397 /* However, other kinds of spurious semicolons can be a problem.  Sadly
 398    we don't yet report for the misleading-indented "foo (1);" in the
 399    following, due to the spurious semicolon.  */
 400 void fn_29 (void)
 401 {
 402   if (flagA)
 403     if (flagB)
 404       foo (0);;
 405     foo (1);
 406 }
 407
 408 /* Adapted from usage site of #ifdef HAVE_cc0.  This should not lead
 409    to a warning from -Wmisleading-indentation.  */
 410 void fn_30 (void)
 411 {
 412   if (flagA)
 413     foo (0);
 414 #if SOME_CONDITION_THAT_DOES_NOT_HOLD
 415   if (flagB)
 416 #endif
 417     foo (1);
 418 }
 419
 420 /* This shouldn't lead to a warning.  */
 421 void fn_31 (void)
 422 {
 423   if (flagA)
 424     foo (0);
 425   else if (flagB)
 426     foo (1);
 427   else if (flagC)
 428     foo (2);
 429   else
 430     foo (3);
 431 }
 432
 433 /* Ensure that we can disable the warning.  */
 434 int
 435 fn_32 (int flag)
 436 {
 437   int x = 4, y = 5;
 438 #pragma GCC diagnostic push
 439 #pragma GCC diagnostic ignored "-Wmisleading-indentation"
 440   if (flag)
 441     x = 3;
 442     y = 2;
 443 #pragma GCC diagnostic pop
 444
 445   return x * y;
 446 }
 447
 448 /* Verify that a variety of different indentation styles are supported
 449    without leading to warnings.  */
 450 void
 451 fn_33_k_and_r_style (void)
 452 {
 453   int i;
 454   for (i = 0; i < 10; i++) {
 455     if (flagB) {
 456       foo(0);
 457       foo(1);
 458     } else {
 459       foo(2);
 460       foo(3);
 461     }
 462     foo(4);
 463   }
 464 }
 465
 466 void
 467 fn_33_stroustrup_style (void)
 468 {
 469   int i;
 470   for (i = 0; i < 10; i++) {
 471     if (flagA) {
 472       foo(0);
 473       foo(1);
 474     }
 475     else {
 476       foo(2);
 477       foo(3);
 478     }
 479     foo(4);
 480   }
 481 }
 482
 483 void
 484 fn_33_allman_style (void)
 485 {
 486   int i;
 487   for (i = 0; i < 10; i++)
 488   {
 489     if (flagA)
 490     {
 491       foo(0);
 492       foo(1);
 493     }
 494     else
 495     {
 496       foo(2);
 497       foo(3);
 498     }
 499     foo(4);
 500   }
 501 }
 502
 503 void
 504 fn_33_whitesmiths_style (void)
 505 {
 506     int i;
 507     for (i = 0; i < 10; i++)
 508         {
 509         if (flagA)
 510             {
 511             foo(0);
 512             foo(1);
 513             }
 514         else
 515             {
 516             foo(2);
 517             foo(3);
 518             }
 519         foo(4);
 520         }
 521 }
 522
 523 void
 524 fn_33_horstmann_style (void)
 525 {
 526     int i;
 527     for (i = 0; i < 10; i++)
 528     {   if (flagA)
 529         {   foo(0);
 530             foo(1);
 531         }
 532         else
 533         {   foo(2);
 534             foo(3);
 535         }
 536         foo(4);
 537     }
 538 }
 539
 540 void
 541 fn_33_ratliff_banner_style (void)
 542 {
 543     int i;
 544     for (i = 0; i < 10; i++) {
 545        if (flagA) {
 546            foo(0);
 547            foo(1);
 548            }
 549        else {
 550             foo(2);
 551             foo(3);
 552             }
 553        foo(4);
 554        }
 555 }
 556
 557 void
 558 fn_33_lisp_style (void)
 559 {
 560   int i;
 561   for (i = 0; i < 10; i++) {
 562     if (flagA) {
 563         foo(0);
 564         foo(1); }
 565     else {
 566         foo(2);
 567         foo(3); }
 568     foo(4); }
 569 }
 570
 571 /* A function run through GNU "indent" with various options.
 572    None of these should lead to warnings.  */
 573
 574 /* "indent -gnu".  */
 575 void
 576 fn_34_indent_dash_gnu (void)
 577 {
 578   int i;
 579   while (flagA)
 580     for (i = 0; i < 10; i++)
 581       {
 582         if (flagB)
 583           {
 584             foo (0);
 585             foo (1);
 586           }
 587         else
 588           {
 589             foo (2);
 590             foo (3);
 591           }
 592         foo (4);
 593       }
 594   foo (5);
 595 }
 596
 597 /* "indent -kr".  */
 598 void fn_34_indent_dash_kr(void)
 599 {
 600     int i;
 601     while (flagA)
 602         for (i = 0; i < 10; i++) {
 603             if (flagB) {
 604                 foo(0);
 605                 foo(1);
 606             } else {
 607                 foo(2);
 608                 foo(3);
 609             }
 610             foo(4);
 611         }
 612     foo(5);
 613 }
 614
 615 /* "indent -orig".  */
 616 void
 617 fn_34_indent_dash_orig(void)
 618 {
 619     int             i;
 620     while (flagA)
 621         for (i = 0; i < 10; i++) {
 622             if (flagB) {
 623                 foo(0);
 624                 foo(1);
 625             } else {
 626                 foo(2);
 627                 foo(3);
 628             }
 629             foo(4);
 630         }
 631     foo(5);
 632 }
 633
 634 /* Linux style:
 635    "indent \
 636       -nbad -bap -nbc -bbo -hnl -br -brs -c33 -cd33 -ncdb -ce -ci4  \
 637       -cli0 -d0 -di1 -nfc1 -i8 -ip0 -l80 -lp -npcs -nprs -npsl -sai \
 638       -saf -saw -ncs -nsc -sob -nfca -cp33 -ss -ts8 -il1".  */
 639
 640 void fn_34_indent_linux_style(void)
 641 {
 642         int i;
 643         while (flagA)
 644                 for (i = 0; i < 10; i++) {
 645                         if (flagB) {
 646                                 foo(0);
 647                                 foo(1);
 648                         } else {
 649                                 foo(2);
 650                                 foo(3);
 651                         }
 652                         foo(4);
 653                 }
 654         foo(5);
 655 }
 656
 657 /* PR 66220.  */
 658 int fn_35 (int v)
 659 {
 660     int res = 28;
 661
 662     if (v == 2)
 663     {
 664         res = 27;
 665     } else
 666     {
 667         res = 18;
 668     }
 669     return res;
 670 }
 671
 672 /* This variant of K&R-style formatting (in the presence of conditional
 673    compilation) shouldn't lead to a warning.
 674
 675    Based on false positive seen with r223098 when compiling
 676    linux-4.0.3:arch/x86/crypto/aesni-intel_glue.c:aesni_init.  */
 677 void
 678 fn_36 (void)
 679 {
 680 #if 1 /* e.g. some configuration variable.  */
 681         if (flagA) {
 682                 foo(0);
 683                 foo(1);
 684                 foo(2);
 685         } else
 686 #endif
 687         {
 688                 foo(3);
 689                 foo(4);
 690                 foo(5);
 691         }
 692         foo(6); /* We shouldn't warn here.  */
 693 }
 694
 695 /* The following function contain code whose indentation is misleading, thus
 696    we warn about it.  */
 697
 698 void
 699 fn_37 (void)
 700 {
 701   int i;
 702
 703 #define EMPTY
 704 #define FOR_EACH(VAR, START, STOP) for (VAR = START; VAR < STOP; VAR++)
 705
 706   while (flagA); /* { dg-message "3: ...this 'while' clause" } */
 707     foo (0); /* { dg-warning "statement is indented as if" } */
 708
 709   if (flagA)
 710     ;
 711   else if (flagB); /* { dg-message "8: ...this 'if' clause" } */
 712     foo (0); /* { dg-warning "statement is indented as if" } */
 713   while (flagA) /* { dg-message "3: ...this 'while' clause" } */
 714     /* blah */;
 715     foo (0); /* { dg-warning "statement is indented as if" } */
 716
 717   if (flagA)
 718     ;
 719   else if (flagB) /* { dg-message "8: ...this 'if' clause" } */
 720     foo (1);
 721     foo (2); /* { dg-warning "statement is indented as if" } */
 722
 723   if (flagA)
 724     foo (1);
 725   else if (flagB) /* { dg-message "8: ...this 'if' clause" } */
 726     foo (2);
 727     foo (3); /* { dg-warning "statement is indented as if" } */
 728
 729   if (flagB) /* { dg-message "3: ...this 'if' clause" } */
 730     /* blah */;
 731     { /* { dg-warning "statement is indented as if" } */
 732       foo (0);
 733     }
 734
 735   if (flagB) /* { dg-message "3: ...this 'if' clause" } */
 736     /* blah */;
 737    { /* { dg-warning "statement is indented as if" } */
 738      foo (0);
 739    }
 740
 741
 742   if (flagB)
 743     ;
 744   else; foo (0); /* { dg-warning "statement is indented as if" } */
 745
 746   if (flagC); foo (2); /* { dg-warning "statement is indented as if" } */
 747
 748   if (flagA)
 749     ; /* blah */ { /* { dg-warning "statement is indented as if" } */
 750       foo (1);
 751     }
 752
 753   if (flagB) ; /* { dg-message "3: ...this 'if' clause" } */
 754     return; /* { dg-warning "statement is indented as if" } */
 755
 756   if (flagB) EMPTY; /* { dg-message "3: ...this 'if' clause" } */
 757     foo (1); /* { dg-warning "statement is indented as if" } */
 758
 759   for (i = 0; i < 10; i++); /* { dg-message "3: ...this 'for' clause" } */
 760     foo (2); /* { dg-warning "statement is indented as if" } */
 761
 762   FOR_EACH (i, 0, 10);
 763     foo (2); /* { dg-warning "statement is indented as if" } */
 764
 765   FOR_EACH (i, 0, 10);
 766     { /* { dg-warning "statement is indented as if" } */
 767       foo (3);
 768     }
 769
 770   FOR_EACH (i, 0, 10);
 771   { /* { dg-warning "statement is indented as if" } */
 772     foo (3);
 773   }
 774
 775   while (i++); { /* { dg-warning "statement is indented as if" } */
 776     foo (3);
 777   }
 778
 779   if (i++); { /* { dg-warning "statement is indented as if" } */
 780     foo (3);
 781   }
 782
 783   if (flagA) {
 784     foo (1);
 785   } else /* { dg-message "5: ...this 'else' clause" } */
 786     if (flagB)
 787        foo (2);
 788     foo (3); /* { dg-warning "statement is indented as if" } */
 789
 790   if (flagA)
 791     foo (1);
 792   else if (flagB); /* { dg-message "8: ...this 'if' clause" } */
 793     foo (2); /* { dg-warning "statement is indented as if" } */
 794
 795   for (i = 0; /* { dg-message "3: ...this 'for' clause" } */
 796        i < 10;
 797        i++);
 798     foo (i); /* { dg-warning "statement is indented as if" } */
 799
 800   if (flagA)
 801   {
 802     foo (1);
 803   }
 804   else if (flagB); /* { dg-message "8: ...this 'if' clause" } */
 805   { /* { dg-warning "statement is indented as if" } */
 806     foo (2);
 807   }
 808
 809 #undef EMPTY
 810 #undef FOR_EACH
 811 }
 812
 813 /* The following function contains code whose indentation is not great but not
 814    misleading, thus we don't warn.  */
 815
 816 void
 817 fn_38 (void)
 818 {
 819   int i = 0;
 820
 821   while (flagA)
 822     ;
 823     foo (0);
 824
 825   if (flagB)
 826     ;
 827     {
 828       foo (0);
 829     }
 830
 831   while (flagC);
 832   foo (2);
 833
 834   if (flagA)
 835     while (flagC++);
 836   else
 837     foo (2);
 838
 839   if (i)
 840     while (i++ < 10000);
 841   foo (5);
 842
 843   if (i) while (i++ < 10000);
 844   foo (5);
 845
 846   if (flagA) {
 847     foo (1);
 848   } else
 849   if (flagB)
 850     foo (2);
 851   foo (3);
 852
 853   if (flagA)
 854     {
 855     foo (1);
 856     } else
 857   if (flagB)
 858     foo (2);
 859   foo (3);
 860
 861   for (i = 0;
 862        i < 10;
 863        i++
 864   );
 865   foo (i);
 866 }
 867
 868 /* The following function contains good indentation which we definitely should
 869    not warn about.  */
 870
 871 void
 872 fn_39 (void)
 873 {
 874   int i;
 875
 876   if (flagA)
 877     ;
 878   if (flagB)
 879     ;
 880
 881   if (flagA)
 882     if (flagB)
 883       foo (0);
 884     else
 885       foo (1);
 886   else
 887     foo (2);
 888
 889   for (i = 0;
 890        i < 10;
 891        i++);
 892   foo (i);
 893 }