gdb/contrib/ari/gdb_ari.sh

   1 #!/bin/sh
   2
   3 # GDB script to list of problems using awk.
   4 #
   5 # Copyright (C) 2002-2023 Free Software Foundation, Inc.
   6 #
   7 # This file is part of GDB.
   8 #
   9 # This program is free software; you can redistribute it and/or modify
  10 # it under the terms of the GNU General Public License as published by
  11 # the Free Software Foundation; either version 3 of the License, or
  12 # (at your option) any later version.
  13 #
  14 # This program is distributed in the hope that it will be useful,
  15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 # GNU General Public License for more details.
  18 #
  19 # You should have received a copy of the GNU General Public License
  20 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21
  22 # Make certain that the script is not running in an internationalized
  23 # environment.
  24
  25 LANG=C ; export LANG
  26 LC_ALL=C ; export LC_ALL
  27
  28 # Permanent checks take the form:
  29
  30 #     Do not use XXXX, C++11 implies YYYY
  31 #     Do not use XXXX, instead use YYYY''.
  32
  33 # and should never be removed.
  34
  35 # Temporary checks take the form:
  36
  37 #     Replace XXXX with YYYY
  38
  39 # and once they reach zero, can be eliminated.
  40
  41 # FIXME: It should be able to override this on the command line
  42 error="regression"
  43 warning="regression"
  44 ari="regression eol code comment deprecated legacy obsolete gettext"
  45 all="regression eol code comment deprecated legacy obsolete gettext deprecate internal gdbarch macro"
  46 print_doc=0
  47 print_idx=0
  48
  49 usage ()
  50 {
  51     cat <<EOF 1>&2
  52 Error: $1
  53
  54 Usage:
  55     $0 --print-doc --print-idx -Wall -Werror -WCATEGORY FILE ...
  56 Options:
  57   --print-doc    Print a list of all potential problems, then exit.
  58   --print-idx    Include the problems IDX (index or key) in every message.
  59   --src=file     Write source lines to file.
  60   -Werror        Treat all problems as errors.
  61   -Wall          Report all problems.
  62   -Wari          Report problems that should be fixed in new code.
  63   -WCATEGORY     Report problems in the specifed category.  The category
  64                  can be prefixed with "no-".  Valid categories
  65                  are: ${all}
  66 EOF
  67     exit 1
  68 }
  69
  70
  71 # Parse the various options
  72 Woptions=
  73 srclines=""
  74 while test $# -gt 0
  75 do
  76     case "$1" in
  77     -Wall ) Woptions="${all}" ;;
  78     -Wari ) Woptions="${ari}" ;;
  79     -Werror ) Werror=1 ;;
  80     -W* ) Woptions="${Woptions} `echo x$1 | sed -e 's/x-W//'`" ;;
  81     --print-doc ) print_doc=1 ;;
  82     --print-idx ) print_idx=1 ;;
  83     --src=* ) srclines="`echo $1 | sed -e 's/--src=/srclines=\"/'`\"" ;;
  84     -- ) shift ; break ;;
  85     - ) break ;;
  86     -* ) usage "$1: unknown option" ;;
  87     * ) break ;;
  88     esac
  89     shift
  90 done
  91 if test -n "$Woptions" ; then
  92     warning="$Woptions"
  93     error=
  94 fi
  95
  96
  97 # -Werror implies treating all warnings as errors.
  98 if test -n "${Werror}" ; then
  99     error="${error} ${warning}"
 100 fi
 101
 102
 103 # Validate all errors and warnings.
 104 for w in ${warning} ${error}
 105 do
 106     case "$w" in
 107         no-*) w=`echo x$w | sed -e 's/xno-//'`;;
 108     esac
 109
 110     case " ${all} " in
 111     *" ${w} "* ) ;;
 112     * ) usage "Unknown option -W${w}" ;;
 113     esac
 114 done
 115
 116
 117 # make certain that there is at least one file.
 118 if test $# -eq 0 -a ${print_doc} = 0
 119 then
 120     usage "Missing file."
 121 fi
 122
 123
 124 # Convert the errors/warnings into corresponding array entries.
 125 for a in ${all}
 126 do
 127     aris="${aris} ari_${a} = \"${a}\";"
 128 done
 129 for w in ${warning}
 130 do
 131     val=1
 132     case "$w" in
 133         no-*) w=`echo x$w | sed -e 's/xno-//'`; val=0 ;;
 134     esac
 135     warnings="${warnings} warning[ari_${w}] = $val;"
 136 done
 137 for e in ${error}
 138 do
 139     val=1
 140     case "$e" in
 141         no-*) e=`echo x$e | sed -e 's/xno-//'`; val=0 ;;
 142     esac
 143     errors="${errors} error[ari_${e}]  = $val;"
 144 done
 145
 146 if [ "$AWK" = "" ] ; then
 147   AWK=awk
 148 fi
 149
 150 ${AWK} -- '
 151 BEGIN {
 152     # NOTE, for a per-file begin use "FNR == 1".
 153     '"${aris}"'
 154     '"${errors}"'
 155     '"${warnings}"'
 156     '"${srclines}"'
 157     print_doc =  '$print_doc'
 158     print_idx =  '$print_idx'
 159     PWD = "'`pwd`'"
 160 }
 161
 162 # Print the error message for BUG.  Append SUPLEMENT if non-empty.
 163 function print_bug(file,line,prefix,category,bug,doc,supplement, suffix,idx) {
 164     if (print_idx) {
 165         idx = bug ": "
 166     } else {
 167         idx = ""
 168     }
 169     if (supplement) {
 170         suffix = " (" supplement ")"
 171     } else {
 172         suffix = ""
 173     }
 174     # ari.*.bug: <FILE>:<LINE>: <CATEGORY>: <BUG>: <DOC>
 175     print file ":" line ": " prefix category ": " idx doc suffix
 176     if (srclines != "") {
 177         print file ":" line ":" $0 >> srclines
 178     }
 179 }
 180
 181 function fix(bug,file,count) {
 182     skip[bug, file] = count
 183     skipped[bug, file] = 0
 184 }
 185
 186 function fail(bug,supplement) {
 187     if (doc[bug] == "") {
 188         print_bug("", 0, "internal: ", "internal", "internal", "Missing doc for bug " bug)
 189         exit
 190     }
 191     if (category[bug] == "") {
 192         print_bug("", 0, "internal: ", "internal", "internal", "Missing category for bug " bug)
 193         exit
 194     }
 195
 196     if (ARI_OK == bug) {
 197         return
 198     }
 199     # Trim the filename down to just DIRECTORY/FILE so that it can be
 200     # robustly used by the FIX code.
 201
 202     if (FILENAME ~ /^\//) {
 203         canonicalname = FILENAME
 204     } else {
 205         canonicalname = PWD "/" FILENAME
 206     }
 207     shortname = gensub (/^.*\/([^\\]*\/[^\\]*)$/, "\\1", 1, canonicalname)
 208
 209     skipped[bug, shortname]++
 210     if (skip[bug, shortname] >= skipped[bug, shortname]) {
 211         # print FILENAME, FNR, skip[bug, FILENAME], skipped[bug, FILENAME], bug
 212         # Do nothing
 213     } else if (error[category[bug]]) {
 214         # ari.*.bug: <FILE>:<LINE>: <CATEGORY>: <BUG>: <DOC>
 215         print_bug(FILENAME, FNR, "", category[bug], bug, doc[bug], supplement)
 216     } else if (warning[category[bug]]) {
 217         # ari.*.bug: <FILE>:<LINE>: <CATEGORY>: <BUG>: <DOC>
 218         print_bug(FILENAME, FNR, "warning: ", category[bug], bug, doc[bug], supplement)
 219     }
 220 }
 221
 222 FNR == 1 {
 223     seen[FILENAME] = 1
 224     if (match(FILENAME, "\\.[ly]$")) {
 225       # FILENAME is a lex or yacc source
 226       is_yacc_or_lex = 1
 227     }
 228     else {
 229       is_yacc_or_lex = 0
 230     }
 231 }
 232 END {
 233     if (print_idx) {
 234         idx = bug ": "
 235     } else {
 236         idx = ""
 237     }
 238     # Did we do only a partial skip?
 239     for (bug_n_file in skip) {
 240         split (bug_n_file, a, SUBSEP)
 241         bug = a[1]
 242         file = a[2]
 243         if (seen[file] && (skipped[bug_n_file] < skip[bug_n_file])) {
 244             # ari.*.bug: <FILE>:<LINE>: <CATEGORY>: <BUG>: <DOC>
 245             b = file " missing " bug
 246             print_bug(file, 0, "", "internal", file " missing " bug, "Expecting " skip[bug_n_file] " occurances of bug " bug " in file " file ", only found " skipped[bug_n_file])
 247         }
 248     }
 249 }
 250
 251
 252 # Skip OBSOLETE lines
 253 /(^|[^_[:alnum:]])OBSOLETE([^_[:alnum:]]|$)/ { next; }
 254
 255 # Skip ARI lines
 256
 257 BEGIN {
 258     ARI_OK = ""
 259 }
 260
 261 /\/\* ARI:[[:space:]]*(.*)[[:space:]]*\*\// {
 262     ARI_OK = gensub(/^.*\/\* ARI:[[:space:]]*(.*[^[:space:]])[[:space:]]*\*\/.*$/, "\\1", 1, $0)
 263     # print "ARI line found \"" $0 "\""
 264     # print "ARI_OK \"" ARI_OK "\""
 265 }
 266 ! /\/\* ARI:[[:space:]]*(.*)[[:space:]]*\*\// {
 267     ARI_OK = ""
 268 }
 269
 270
 271 # SNIP - Strip out comments - SNIP
 272
 273 FNR == 1 {
 274     comment_p = 0
 275 }
 276 comment_p && /\*\// { gsub (/^([^\*]|\*+[^\/\*])*\*+\//, " "); comment_p = 0; }
 277 comment_p { next; }
 278 !comment_p { gsub (/\/\*([^\*]|\*+[^\/\*])*\*+\//, " "); }
 279 !comment_p && /(^|[^"])\/\*/ { gsub (/\/\*.*$/, " "); comment_p = 1; }
 280
 281
 282 BEGIN { doc["_ markup"] = "\
 283 All messages should be marked up with _."
 284     category["_ markup"] = ari_gettext
 285 }
 286 /^[^"]*[[:space:]](warning|error|error_no_arg|query|perror_with_name)[[:space:]]*\([^_\(a-z]/ {
 287     if (! /\("%s"/) {
 288         fail("_ markup")
 289     }
 290 }
 291
 292 BEGIN { doc["trailing new line"] = "\
 293 A message should not have a trailing new line"
 294     category["trailing new line"] = ari_gettext
 295 }
 296 /(^|[^_[:alnum:]])(warning|error)[[:space:]]*\(_\(".*\\n"\)[\),]/ {
 297     fail("trailing new line")
 298 }
 299
 300 # Include files for which GDB has a custom version.
 301
 302 BEGIN { doc["assert.h"] = "\
 303 Do not include assert.h, instead include \"gdb_assert.h\"";
 304     category["assert.h"] = ari_regression
 305     fix("assert.h", "gdb/gdb_assert.h", 0) # it does not use it
 306 }
 307 /^#[[:space:]]*include[[:space:]]+.assert\.h./ {
 308     fail("assert.h")
 309 }
 310
 311 BEGIN { doc["regex.h"] = "\
 312 Do not include regex.h, instead include gdb_regex.h"
 313     category["regex.h"] = ari_regression
 314     fix("regex.h", "gdb/gdb_regex.h", 1)
 315 }
 316 /^#[[:space:]]*include[[:space:]]*.regex\.h./ {
 317     fail("regex.h")
 318 }
 319
 320 BEGIN { doc["xregex.h"] = "\
 321 Do not include xregex.h, instead include gdb_regex.h"
 322     category["xregex.h"] = ari_regression
 323     fix("xregex.h", "gdb/gdb_regex.h", 1)
 324 }
 325 /^#[[:space:]]*include[[:space:]]*.xregex\.h./ {
 326     fail("xregex.h")
 327 }
 328
 329 BEGIN { doc["gnu-regex.h"] = "\
 330 Do not include gnu-regex.h, instead include gdb_regex.h"
 331     category["gnu-regex.h"] = ari_regression
 332 }
 333 /^#[[:space:]]*include[[:space:]]*.gnu-regex\.h./ {
 334     fail("gnu regex.h")
 335 }
 336
 337 BEGIN { doc["wait.h"] = "\
 338 Do not include wait.h or sys/wait.h, instead include gdb_wait.h"
 339     fix("wait.h", "gdbsupport/gdb_wait.h", 2);
 340     category["wait.h"] = ari_regression
 341 }
 342 /^#[[:space:]]*include[[:space:]]*.wait\.h./ \
 343 || /^#[[:space:]]*include[[:space:]]*.sys\/wait\.h./ {
 344     fail("wait.h")
 345 }
 346
 347 BEGIN { doc["vfork.h"] = "\
 348 Do not include vfork.h, instead include gdb_vfork.h"
 349     fix("vfork.h", "gdb/gdb_vfork.h", 1);
 350     category["vfork.h"] = ari_regression
 351 }
 352 /^#[[:space:]]*include[[:space:]]*.vfork\.h./ {
 353     fail("vfork.h")
 354 }
 355
 356 BEGIN { doc["error not internal-warning"] = "\
 357 Do not use error(\"internal-warning\"), instead use internal_warning"
 358     category["error not internal-warning"] = ari_regression
 359 }
 360 /error.*\"[Ii]nternal.warning/ {
 361     fail("error not internal-warning")
 362 }
 363
 364 BEGIN { doc["%p"] = "\
 365 Do not use printf(\"%p\"), instead use printf(\"%s\",paddr()) to dump a \
 366 target address, or host_address_to_string() for a host address"
 367     category["%p"] = ari_code
 368 }
 369 # Allow gdb %p extensions, but not other uses of %p.
 370 /%p[^[\]sF]/ && !/%prec/ {
 371     fail("%p")
 372 }
 373
 374 BEGIN { doc["%ll"] = "\
 375 Do not use printf(\"%ll\"), instead use printf(\"%s\",phex()) to dump a \
 376 `long long'\'' value"
 377     category["%ll"] = ari_code
 378 }
 379 # Allow %ll in scanf
 380 /%[0-9]*ll/ && !/scanf \(.*%[0-9]*ll/ {
 381     fail("%ll")
 382 }
 383
 384
 385 # SNIP - Strip out strings - SNIP
 386
 387 # Test on top.c, scm-valprint.c, remote-rdi.c, ada-lang.c
 388 FNR == 1 {
 389     string_p = 0
 390     trace_string = 0
 391 }
 392 # Strip escaped characters.
 393 { gsub(/\\./, "."); }
 394 # Strip quoted quotes.
 395 { gsub(/'\''.'\''/, "'\''.'\''"); }
 396 # End of multi-line string
 397 string_p && /\"/ {
 398     if (trace_string) print "EOS:" FNR, $0;
 399     gsub (/^[^\"]*\"/, "'\''");
 400     string_p = 0;
 401 }
 402 # Middle of multi-line string, discard line.
 403 string_p {
 404     if (trace_string) print "MOS:" FNR, $0;
 405     $0 = ""
 406 }
 407 # Strip complete strings from the middle of the line
 408 !string_p && /\"[^\"]*\"/ {
 409     if (trace_string) print "COS:" FNR, $0;
 410     gsub (/\"[^\"]*\"/, "'\''");
 411 }
 412 # Start of multi-line string
 413 BEGIN { doc["multi-line string"] = "\
 414 Multi-line string must have the newline escaped"
 415     category["multi-line string"] = ari_regression
 416 }
 417 !string_p && /\"/ {
 418     if (trace_string) print "SOS:" FNR, $0;
 419     if (/[^\\]$/) {
 420         fail("multi-line string")
 421     }
 422     gsub (/\"[^\"]*$/, "'\''");
 423     string_p = 1;
 424 }
 425 # { print }
 426
 427 # Multi-line string
 428 string_p &&
 429
 430 # Accumulate continuation lines
 431 FNR == 1 {
 432     cont_p = 0
 433 }
 434 !cont_p { full_line = ""; }
 435 /[^\\]\\$/ { gsub (/\\$/, ""); full_line = full_line $0; cont_p = 1; next; }
 436 cont_p { $0 = full_line $0; cont_p = 0; full_line = ""; }
 437
 438
 439 BEGIN { doc["__FUNCTION__"] = "\
 440 Do not use __FUNCTION__, C++11 does not support this macro"
 441     category["__FUNCTION__"] = ari_regression
 442 }
 443 /(^|[^_[:alnum:]])__FUNCTION__([^_[:alnum:]]|$)/ {
 444     fail("__FUNCTION__")
 445 }
 446
 447 BEGIN { doc["__CYGWIN32__"] = "\
 448 Do not use __CYGWIN32__, instead use __CYGWIN__ or, better, an explicit \
 449 autoconf tests"
 450     category["__CYGWIN32__"] = ari_regression
 451 }
 452 /(^|[^_[:alnum:]])__CYGWIN32__([^_[:alnum:]]|$)/ {
 453     fail("__CYGWIN32__")
 454 }
 455
 456 BEGIN { doc["PTR"] = "\
 457 Do not use PTR, C++11 implies `void *'\''"
 458     category["PTR"] = ari_regression
 459     #fix("PTR", "gdb/utils.c", 6)
 460 }
 461 /(^|[^_[:alnum:]])PTR([^_[:alnum:]]|$)/ {
 462     fail("PTR")
 463 }
 464
 465 BEGIN { doc["UCASE function"] = "\
 466 Function name is uppercase."
 467     category["UCASE function"] = ari_code
 468     possible_UCASE = 0
 469     UCASE_full_line = ""
 470 }
 471 (possible_UCASE) {
 472     if (ARI_OK == "UCASE function") {
 473         possible_UCASE = 0
 474     }
 475     # Closing brace found?
 476     else if (UCASE_full_line ~ \
 477         /^[A-Z][[:alnum:]_]*[[:space:]]*\([^()]*\).*$/) {
 478         if ((UCASE_full_line ~ \
 479             /^[A-Z][[:alnum:]_]*[[:space:]]*\([^()]*\)[[:space:]]*$/) \
 480             && ($0 ~ /^\{/) && (is_yacc_or_lex == 0)) {
 481             store_FNR = FNR
 482             FNR = possible_FNR
 483             store_0 = $0;
 484             $0 = UCASE_full_line;
 485             fail("UCASE function")
 486             FNR = store_FNR
 487             $0 = store_0;
 488         }
 489         possible_UCASE = 0
 490         UCASE_full_line = ""
 491     } else {
 492         UCASE_full_line = UCASE_full_line $0;
 493     }
 494 }
 495 /^[A-Z][[:alnum:]_]*[[:space:]]*\([^()]*(|\))[[:space:]]*$/ {
 496     possible_UCASE = 1
 497     if (ARI_OK == "UCASE function") {
 498         possible_UCASE = 0
 499     }
 500     possible_FNR = FNR
 501     UCASE_full_line = $0
 502 }
 503
 504
 505 BEGIN { doc["editCase function"] = "\
 506 Function name starts lower case but has uppercased letters."
 507     category["editCase function"] = ari_code
 508     possible_editCase = 0
 509     editCase_full_line = ""
 510 }
 511 (possible_editCase) {
 512     if (ARI_OK == "editCase function") {
 513         possible_editCase = 0
 514     }
 515     # Closing brace found?
 516     else if (editCase_full_line ~ \
 517 /^[a-z][a-z0-9_]*[A-Z][a-z0-9A-Z_]*[[:space:]]*\([^()]*\).*$/) {
 518         if ((editCase_full_line ~ \
 519 /^[a-z][a-z0-9_]*[A-Z][a-z0-9A-Z_]*[[:space:]]*\([^()]*\)[[:space:]]*$/) \
 520             && ($0 ~ /^\{/) && (is_yacc_or_lex == 0)) {
 521             store_FNR = FNR
 522             FNR = possible_FNR
 523             store_0 = $0;
 524             $0 = editCase_full_line;
 525             fail("editCase function")
 526             FNR = store_FNR
 527             $0 = store_0;
 528         }
 529         possible_editCase = 0
 530         editCase_full_line = ""
 531     } else {
 532         editCase_full_line = editCase_full_line $0;
 533     }
 534 }
 535 /^[a-z][a-z0-9_]*[A-Z][a-z0-9A-Z_]*[[:space:]]*\([^()]*(|\))[[:space:]]*$/ {
 536     possible_editCase = 1
 537     if (ARI_OK == "editCase function") {
 538         possible_editCase = 0
 539     }
 540     possible_FNR = FNR
 541     editCase_full_line = $0
 542 }
 543
 544 # Only function implementation should be on first column
 545 BEGIN { doc["function call in first column"] = "\
 546 Function name in first column should be restricted to function implementation"
 547     category["function call in first column"] = ari_code
 548 }
 549 /^[a-z][a-z0-9_]*[[:space:]]*\((|[^*][^()]*)\)[[:space:]]*[^ \t]+/ {
 550     fail("function call in first column")
 551 }
 552
 553
 554 BEGIN { doc["hash"] = "\
 555 Do not use ` #...'\'', instead use `#...'\''(some compilers only correctly \
 556 parse a C preprocessor directive when `#'\'' is the first character on \
 557 the line)"
 558     category["hash"] = ari_regression
 559 }
 560 /^[[:space:]]+#/ {
 561     fail("hash")
 562 }
 563
 564 BEGIN { doc["OP eol"] = "\
 565 Do not use &&, or || at the end of a line"
 566     category["OP eol"] = ari_code
 567 }
 568 # * operator needs a special treatment as it can be a
 569 # valid end of line for a pointer type definition
 570 # Only catch case where an assignment or an opening brace is present
 571 /(\|\||\&\&|==|!=|[[:space:]][+\-\/])[[:space:]]*$/ \
 572 || /(\(|=)[[:space:]].*[[:space:]]\*[[:space:]]*$/ {
 573     fail("OP eol")
 574 }
 575
 576 BEGIN { doc["strerror"] = "\
 577 Do not use strerror(), instead use safe_strerror()"
 578     category["strerror"] = ari_regression
 579     fix("strerror", "gdb/gdb_string.h", 1)
 580     fix("strerror", "gdb/gdbsupport/mingw-strerror.c", 1)
 581     fix("strerror", "gdb/gdbsupport/posix-strerror.c", 1)
 582 }
 583 /(^|[^_[:alnum:]])strerror[[:space:]]*\(/ {
 584     fail("strerror")
 585 }
 586
 587 BEGIN { doc["long long"] = "\
 588 Do not use `long long'\'', instead use LONGEST"
 589     category["long long"] = ari_code
 590 }
 591 /(^|[^_[:alnum:]])long[[:space:]]+long([^_[:alnum:]]|$)/ {
 592     fail("long long")
 593 }
 594
 595 BEGIN { doc["ATTR_FORMAT"] = "\
 596 Do not use ATTR_FORMAT, use ATTRIBUTE_PRINTF instead"
 597     category["ATTR_FORMAT"] = ari_regression
 598 }
 599 /(^|[^_[:alnum:]])ATTR_FORMAT([^_[:alnum:]]|$)/ {
 600     fail("ATTR_FORMAT")
 601 }
 602
 603 BEGIN { doc["ATTR_NORETURN"] = "\
 604 Do not use ATTR_NORETURN, use ATTRIBUTE_NORETURN instead"
 605     category["ATTR_NORETURN"] = ari_regression
 606 }
 607 /(^|[^_[:alnum:]])ATTR_NORETURN([^_[:alnum:]]|$)/ {
 608     fail("ATTR_NORETURN")
 609 }
 610
 611 BEGIN { doc["NORETURN"] = "\
 612 Do not use NORETURN, use ATTRIBUTE_NORETURN instead"
 613     category["NORETURN"] = ari_regression
 614 }
 615 /(^|[^_[:alnum:]])NORETURN([^_[:alnum:]]|$)/ {
 616     fail("NORETURN")
 617 }
 618
 619
 620 # General problems
 621
 622 # Commented out, but left inside sources, just in case.
 623 # BEGIN { doc["inline"] = "\
 624 # Do not use the inline attribute; \
 625 # since the compiler generally ignores this, better algorithm selection \
 626 # is needed to improved performance"
 627 #    category["inline"] = ari_code
 628 # }
 629 # /(^|[^_[:alnum:]])inline([^_[:alnum:]]|$)/ {
 630 #     fail("inline")
 631 # }
 632
 633 # This test is obsolete as this type
 634 # has been deprecated and finally suppressed from GDB sources
 635 #BEGIN { doc["obj_private"] = "\
 636 #Replace obj_private with objfile_data"
 637 #    category["obj_private"] = ari_obsolete
 638 #}
 639 #/(^|[^_[:alnum:]])obj_private([^_[:alnum:]]|$)/ {
 640 #    fail("obj_private")
 641 #}
 642
 643 BEGIN { doc["abort"] = "\
 644 Do not use abort, instead use internal_error; GDB should never abort"
 645     category["abort"] = ari_regression
 646 }
 647 /(^|[^_[:alnum:]])abort[[:space:]]*\(/ {
 648     fail("abort")
 649 }
 650
 651 BEGIN { doc["basename"] = "\
 652 Do not use basename, instead use lbasename"
 653     category["basename"] = ari_regression
 654 }
 655 /(^|[^_[:alnum:]])basename[[:space:]]*\(/ {
 656     fail("basename")
 657 }
 658
 659 BEGIN { doc["assert"] = "\
 660 Do not use assert, instead use gdb_assert or internal_error; assert \
 661 calls abort and GDB should never call abort"
 662     category["assert"] = ari_regression
 663 }
 664 /(^|[^_[:alnum:]])assert[[:space:]]*\(/ {
 665     fail("assert")
 666 }
 667
 668 BEGIN { doc["TARGET_HAS_HARDWARE_WATCHPOINTS"] = "\
 669 Replace TARGET_HAS_HARDWARE_WATCHPOINTS with nothing, not needed"
 670     category["TARGET_HAS_HARDWARE_WATCHPOINTS"] = ari_regression
 671 }
 672 /(^|[^_[:alnum:]])TARGET_HAS_HARDWARE_WATCHPOINTS([^_[:alnum:]]|$)/ {
 673     fail("TARGET_HAS_HARDWARE_WATCHPOINTS")
 674 }
 675
 676 BEGIN { doc["ADD_SHARED_SYMBOL_FILES"] = "\
 677 Replace ADD_SHARED_SYMBOL_FILES with nothing, not needed?"
 678     category["ADD_SHARED_SYMBOL_FILES"] = ari_regression
 679 }
 680 /(^|[^_[:alnum:]])ADD_SHARED_SYMBOL_FILES([^_[:alnum:]]|$)/ {
 681     fail("ADD_SHARED_SYMBOL_FILES")
 682 }
 683
 684 BEGIN { doc["SOLIB_ADD"] = "\
 685 Replace SOLIB_ADD with nothing, not needed?"
 686     category["SOLIB_ADD"] = ari_regression
 687 }
 688 /(^|[^_[:alnum:]])SOLIB_ADD([^_[:alnum:]]|$)/ {
 689     fail("SOLIB_ADD")
 690 }
 691
 692 BEGIN { doc["SOLIB_CREATE_INFERIOR_HOOK"] = "\
 693 Replace SOLIB_CREATE_INFERIOR_HOOK with nothing, not needed?"
 694     category["SOLIB_CREATE_INFERIOR_HOOK"] = ari_regression
 695 }
 696 /(^|[^_[:alnum:]])SOLIB_CREATE_INFERIOR_HOOK([^_[:alnum:]]|$)/ {
 697     fail("SOLIB_CREATE_INFERIOR_HOOK")
 698 }
 699
 700 BEGIN { doc["SOLIB_LOADED_LIBRARY_PATHNAME"] = "\
 701 Replace SOLIB_LOADED_LIBRARY_PATHNAME with nothing, not needed?"
 702     category["SOLIB_LOADED_LIBRARY_PATHNAME"] = ari_regression
 703 }
 704 /(^|[^_[:alnum:]])SOLIB_LOADED_LIBRARY_PATHNAME([^_[:alnum:]]|$)/ {
 705     fail("SOLIB_LOADED_LIBRARY_PATHNAME")
 706 }
 707
 708 BEGIN { doc["REGISTER_U_ADDR"] = "\
 709 Replace REGISTER_U_ADDR with nothing, not needed?"
 710     category["REGISTER_U_ADDR"] = ari_regression
 711 }
 712 /(^|[^_[:alnum:]])REGISTER_U_ADDR([^_[:alnum:]]|$)/ {
 713     fail("REGISTER_U_ADDR")
 714 }
 715
 716 BEGIN { doc["PROCESS_LINENUMBER_HOOK"] = "\
 717 Replace PROCESS_LINENUMBER_HOOK with nothing, not needed?"
 718     category["PROCESS_LINENUMBER_HOOK"] = ari_regression
 719 }
 720 /(^|[^_[:alnum:]])PROCESS_LINENUMBER_HOOK([^_[:alnum:]]|$)/ {
 721     fail("PROCESS_LINENUMBER_HOOK")
 722 }
 723
 724 BEGIN { doc["PC_SOLIB"] = "\
 725 Replace PC_SOLIB with nothing, not needed?"
 726     category["PC_SOLIB"] = ari_regression
 727 }
 728 /(^|[^_[:alnum:]])PC_SOLIB([^_[:alnum:]]|$)/ {
 729     fail("PC_SOLIB")
 730 }
 731
 732 BEGIN { doc["IN_SOLIB_DYNSYM_RESOLVE_CODE"] = "\
 733 Replace IN_SOLIB_DYNSYM_RESOLVE_CODE with nothing, not needed?"
 734     category["IN_SOLIB_DYNSYM_RESOLVE_CODE"] = ari_regression
 735 }
 736 /(^|[^_[:alnum:]])IN_SOLIB_DYNSYM_RESOLVE_CODE([^_[:alnum:]]|$)/ {
 737     fail("IN_SOLIB_DYNSYM_RESOLVE_CODE")
 738 }
 739
 740 BEGIN { doc["GCC_COMPILED_FLAG_SYMBOL"] = "\
 741 Replace GCC_COMPILED_FLAG_SYMBOL with nothing, not needed?"
 742     category["GCC_COMPILED_FLAG_SYMBOL"] = ari_deprecate
 743 }
 744 /(^|[^_[:alnum:]])GCC_COMPILED_FLAG_SYMBOL([^_[:alnum:]]|$)/ {
 745     fail("GCC_COMPILED_FLAG_SYMBOL")
 746 }
 747
 748 BEGIN { doc["GCC2_COMPILED_FLAG_SYMBOL"] = "\
 749 Replace GCC2_COMPILED_FLAG_SYMBOL with nothing, not needed?"
 750     category["GCC2_COMPILED_FLAG_SYMBOL"] = ari_deprecate
 751 }
 752 /(^|[^_[:alnum:]])GCC2_COMPILED_FLAG_SYMBOL([^_[:alnum:]]|$)/ {
 753     fail("GCC2_COMPILED_FLAG_SYMBOL")
 754 }
 755
 756 BEGIN { doc["FUNCTION_EPILOGUE_SIZE"] = "\
 757 Replace FUNCTION_EPILOGUE_SIZE with nothing, not needed?"
 758     category["FUNCTION_EPILOGUE_SIZE"] = ari_regression
 759 }
 760 /(^|[^_[:alnum:]])FUNCTION_EPILOGUE_SIZE([^_[:alnum:]]|$)/ {
 761     fail("FUNCTION_EPILOGUE_SIZE")
 762 }
 763
 764 BEGIN { doc["HAVE_VFORK"] = "\
 765 Do not use HAVE_VFORK, instead include \"gdb_vfork.h\" and call vfork() \
 766 unconditionally"
 767     category["HAVE_VFORK"] = ari_regression
 768 }
 769 /(^|[^_[:alnum:]])HAVE_VFORK([^_[:alnum:]]|$)/ {
 770     fail("HAVE_VFORK")
 771 }
 772
 773 BEGIN { doc["bcmp"] = "\
 774 Do not use bcmp(), C++11 implies memcmp()"
 775     category["bcmp"] = ari_regression
 776 }
 777 /(^|[^_[:alnum:]])bcmp[[:space:]]*\(/ {
 778     fail("bcmp")
 779 }
 780
 781 BEGIN { doc["setlinebuf"] = "\
 782 Do not use setlinebuf(), C++11 implies setvbuf()"
 783     category["setlinebuf"] = ari_regression
 784 }
 785 /(^|[^_[:alnum:]])setlinebuf[[:space:]]*\(/ {
 786     fail("setlinebuf")
 787 }
 788
 789 BEGIN { doc["bcopy"] = "\
 790 Do not use bcopy(), C++11 implies memcpy() and memmove()"
 791     category["bcopy"] = ari_regression
 792 }
 793 /(^|[^_[:alnum:]])bcopy[[:space:]]*\(/ {
 794     fail("bcopy")
 795 }
 796
 797 BEGIN { doc["get_frame_base"] = "\
 798 Replace get_frame_base with get_frame_id, get_frame_base_address, \
 799 get_frame_locals_address, or get_frame_args_address."
 800     category["get_frame_base"] = ari_obsolete
 801 }
 802 /(^|[^_[:alnum:]])get_frame_base([^_[:alnum:]]|$)/ {
 803     fail("get_frame_base")
 804 }
 805
 806 BEGIN { doc["floatformat_to_double"] = "\
 807 Do not use floatformat_to_double() from libierty, \
 808 instead use floatformat_to_doublest()"
 809     category["floatformat_to_double"] = ari_regression
 810 }
 811 /(^|[^_[:alnum:]])floatformat_to_double[[:space:]]*\(/ {
 812     fail("floatformat_to_double")
 813 }
 814
 815 BEGIN { doc["floatformat_from_double"] = "\
 816 Do not use floatformat_from_double() from libierty, \
 817 instead use host_float_ops<T>::from_target()"
 818     category["floatformat_from_double"] = ari_regression
 819 }
 820 /(^|[^_[:alnum:]])floatformat_from_double[[:space:]]*\(/ {
 821     fail("floatformat_from_double")
 822 }
 823
 824 BEGIN { doc["BIG_ENDIAN"] = "\
 825 Do not use BIG_ENDIAN, instead use BFD_ENDIAN_BIG"
 826     category["BIG_ENDIAN"] = ari_regression
 827 }
 828 /(^|[^_[:alnum:]])BIG_ENDIAN([^_[:alnum:]]|$)/ {
 829     fail("BIG_ENDIAN")
 830 }
 831
 832 BEGIN { doc["LITTLE_ENDIAN"] = "\
 833 Do not use LITTLE_ENDIAN, instead use BFD_ENDIAN_LITTLE";
 834     category["LITTLE_ENDIAN"] = ari_regression
 835 }
 836 /(^|[^_[:alnum:]])LITTLE_ENDIAN([^_[:alnum:]]|$)/ {
 837     fail("LITTLE_ENDIAN")
 838 }
 839
 840 BEGIN { doc["BIG_ENDIAN"] = "\
 841 Do not use BIG_ENDIAN, instead use BFD_ENDIAN_BIG"
 842     category["BIG_ENDIAN"] = ari_regression
 843 }
 844 /(^|[^_[:alnum:]])BIG_ENDIAN([^_[:alnum:]]|$)/ {
 845     fail("BIG_ENDIAN")
 846 }
 847
 848 BEGIN { doc["sec_ptr"] = "\
 849 Instead of sec_ptr, use struct bfd_section";
 850     category["sec_ptr"] = ari_regression
 851 }
 852 /(^|[^_[:alnum:]])sec_ptr([^_[:alnum:]]|$)/ {
 853     fail("sec_ptr")
 854 }
 855
 856 BEGIN { doc["frame_unwind_unsigned_register"] = "\
 857 Replace frame_unwind_unsigned_register with frame_unwind_register_unsigned"
 858     category["frame_unwind_unsigned_register"] = ari_regression
 859 }
 860 /(^|[^_[:alnum:]])frame_unwind_unsigned_register([^_[:alnum:]]|$)/ {
 861     fail("frame_unwind_unsigned_register")
 862 }
 863
 864 BEGIN { doc["frame_register_read"] = "\
 865 Replace frame_register_read() with get_frame_register(), or \
 866 possibly introduce a new method safe_get_frame_register()"
 867     category["frame_register_read"] = ari_obsolete
 868 }
 869 /(^|[^_[:alnum:]])frame_register_read([^_[:alnum:]]|$)/ {
 870     fail("frame_register_read")
 871 }
 872
 873 BEGIN { doc["read_register"] = "\
 874 Replace read_register() with regcache_read() et.al."
 875     category["read_register"] = ari_regression
 876 }
 877 /(^|[^_[:alnum:]])read_register([^_[:alnum:]]|$)/ {
 878     fail("read_register")
 879 }
 880
 881 BEGIN { doc["write_register"] = "\
 882 Replace write_register() with regcache_read() et.al."
 883     category["write_register"] = ari_regression
 884 }
 885 /(^|[^_[:alnum:]])write_register([^_[:alnum:]]|$)/ {
 886     fail("write_register")
 887 }
 888
 889 function report(name) {
 890     # Drop any trailing _P.
 891     name = gensub(/(_P|_p)$/, "", 1, name)
 892     # Convert to lower case
 893     name = tolower(name)
 894     # Split into category and bug
 895     cat = gensub(/^([[:alpha:]]+)_([_[:alnum:]]*)$/, "\\1", 1, name)
 896     bug = gensub(/^([[:alpha:]]+)_([_[:alnum:]]*)$/, "\\2", 1, name)
 897     # Report it
 898     name = cat " " bug
 899     doc[name] = "Do not use " cat " " bug ", see declaration for details"
 900     category[name] = cat
 901     fail(name)
 902 }
 903
 904 /(^|[^_[:alnum:]])(DEPRECATED|deprecated|set_gdbarch_deprecated|LEGACY|legacy|set_gdbarch_legacy)_/ {
 905     line = $0
 906     # print "0 =", $0
 907     while (1) {
 908         name = gensub(/^(|.*[^_[:alnum:]])((DEPRECATED|deprecated|LEGACY|legacy)_[_[:alnum:]]*)(.*)$/, "\\2", 1, line)
 909         line = gensub(/^(|.*[^_[:alnum:]])((DEPRECATED|deprecated|LEGACY|legacy)_[_[:alnum:]]*)(.*)$/, "\\1 \\4", 1, line)
 910         # print "name =", name, "line =", line
 911         if (name == line) break;
 912         report(name)
 913     }
 914 }
 915
 916 # Count the number of times each architecture method is set
 917 /(^|[^_[:alnum:]])set_gdbarch_[_[:alnum:]]*([^_[:alnum:]]|$)/ {
 918     name = gensub(/^.*set_gdbarch_([_[:alnum:]]*).*$/, "\\1", 1, $0)
 919     doc["set " name] = "\
 920 Call to set_gdbarch_" name
 921     category["set " name] = ari_gdbarch
 922     fail("set " name)
 923 }
 924
 925 # Count the number of times each tm/xm/nm macro is defined or undefined
 926 /^#[[:space:]]*(undef|define)[[:space:]]+[[:alnum:]_]+.*$/ \
 927 && !/^#[[:space:]]*(undef|define)[[:space:]]+[[:alnum:]_]+_H($|[[:space:]])/ \
 928 && FILENAME ~ /(^|\/)config\/(|[^\/]*\/)(tm-|xm-|nm-).*\.h$/ {
 929     basename = gensub(/(^|.*\/)([^\/]*)$/, "\\2", 1, FILENAME)
 930     type = gensub(/^(tm|xm|nm)-.*\.h$/, "\\1", 1, basename)
 931     name = gensub(/^#[[:space:]]*(undef|define)[[:space:]]+([[:alnum:]_]+).*$/, "\\2", 1, $0)
 932     if (type == basename) {
 933         type = "macro"
 934     }
 935     doc[type " " name] = "\
 936 Do not define macros such as " name " in a tm, nm or xm file, \
 937 in fact do not provide a tm, nm or xm file"
 938     category[type " " name] = ari_macro
 939     fail(type " " name)
 940 }
 941
 942 BEGIN { doc["deprecated_registers"] = "\
 943 Replace deprecated_registers with nothing, they have reached \
 944 end-of-life"
 945     category["deprecated_registers"] = ari_eol
 946 }
 947 /(^|[^_[:alnum:]])deprecated_registers([^_[:alnum:]]|$)/ {
 948     fail("deprecated_registers")
 949 }
 950
 951 BEGIN { doc["read_pc"] = "\
 952 Replace READ_PC() with frame_pc_unwind; \
 953 at present the inferior function call code still uses this"
 954     category["read_pc"] = ari_deprecate
 955 }
 956 /(^|[^_[:alnum:]])read_pc[[:space:]]*\(/ || \
 957 /(^|[^_[:alnum:]])set_gdbarch_read_pc[[:space:]]*\(/ || \
 958 /(^|[^_[:alnum:]])TARGET_READ_PC[[:space:]]*\(/ {
 959     fail("read_pc")
 960 }
 961
 962 BEGIN { doc["write_pc"] = "\
 963 Replace write_pc() with get_frame_base_address or get_frame_id; \
 964 at present the inferior function call code still uses this when doing \
 965 a DECR_PC_AFTER_BREAK"
 966     category["write_pc"] = ari_deprecate
 967 }
 968 /(^|[^_[:alnum:]])write_pc[[:space:]]*\(/ || \
 969 /(^|[^_[:alnum:]])TARGET_WRITE_PC[[:space:]]*\(/ {
 970     fail("write_pc")
 971 }
 972
 973 BEGIN { doc["generic_target_write_pc"] = "\
 974 Replace generic_target_write_pc with a per-architecture implementation, \
 975 this relies on PC_REGNUM which is being eliminated"
 976     category["generic_target_write_pc"] = ari_regression
 977 }
 978 /(^|[^_[:alnum:]])generic_target_write_pc([^_[:alnum:]]|$)/ {
 979     fail("generic_target_write_pc")
 980 }
 981
 982 BEGIN { doc["read_sp"] = "\
 983 Replace read_sp() with frame_sp_unwind"
 984     category["read_sp"] = ari_regression
 985 }
 986 /(^|[^_[:alnum:]])read_sp[[:space:]]*\(/ || \
 987 /(^|[^_[:alnum:]])set_gdbarch_read_sp[[:space:]]*\(/ || \
 988 /(^|[^_[:alnum:]])TARGET_READ_SP[[:space:]]*\(/ {
 989     fail("read_sp")
 990 }
 991
 992 BEGIN { doc["register_cached"] = "\
 993 Replace register_cached() with nothing, does not have a regcache parameter"
 994     category["register_cached"] = ari_regression
 995 }
 996 /(^|[^_[:alnum:]])register_cached[[:space:]]*\(/ {
 997     fail("register_cached")
 998 }
 999
1000 BEGIN { doc["set_register_cached"] = "\
1001 Replace set_register_cached() with nothing, does not have a regcache parameter"
1002     category["set_register_cached"] = ari_regression
1003 }
1004 /(^|[^_[:alnum:]])set_register_cached[[:space:]]*\(/ {
1005     fail("set_register_cached")
1006 }
1007
1008 # Print functions: Use versions that either check for buffer overflow
1009 # or safely allocate a fresh buffer.
1010
1011 BEGIN { doc["sprintf"] = "\
1012 Do not use sprintf, instead use xsnprintf or xstrprintf"
1013     category["sprintf"] = ari_code
1014 }
1015 /(^|[^_[:alnum:]])sprintf[[:space:]]*\(/ {
1016     fail("sprintf")
1017 }
1018
1019 BEGIN { doc["vsprintf"] = "\
1020 Do not use vsprintf(), instead use xstrvprintf"
1021     category["vsprintf"] = ari_regression
1022 }
1023 /(^|[^_[:alnum:]])vsprintf[[:space:]]*\(/ {
1024     fail("vsprintf")
1025 }
1026
1027 BEGIN { doc["asprintf"] = "\
1028 Do not use asprintf(), instead use xstrprintf()"
1029     category["asprintf"] = ari_regression
1030 }
1031 /(^|[^_[:alnum:]])asprintf[[:space:]]*\(/ {
1032     fail("asprintf")
1033 }
1034
1035 BEGIN { doc["vasprintf"] = "\
1036 Do not use vasprintf(), instead use xstrvprintf"
1037     fix("vasprintf", "gdbsupport/common-utils.c", 1)
1038     category["vasprintf"] = ari_regression
1039 }
1040 /(^|[^_[:alnum:]])vasprintf[[:space:]]*\(/ {
1041     fail("vasprintf")
1042 }
1043
1044 BEGIN { doc["printf_vma"] = "\
1045 Do not use printf_vma, instead use paddress or phex_nz"
1046     category["printf_vma"] = ari_code
1047 }
1048 /(^|[^_[:alnum:]])printf_vma[[:space:]]*\(/ {
1049     fail("printf_vma")
1050 }
1051
1052 BEGIN { doc["sprintf_vma"] = "\
1053 Do not use sprintf_vma, instead use paddress or phex_nz"
1054     category["sprintf_vma"] = ari_code
1055 }
1056 /(^|[^_[:alnum:]])sprintf_vma[[:space:]]*\(/ {
1057     fail("sprintf_vma")
1058 }
1059
1060 # More generic memory operations
1061
1062 BEGIN { doc["bzero"] = "\
1063 Do not use bzero(), instead use memset()"
1064     category["bzero"] = ari_regression
1065 }
1066 /(^|[^_[:alnum:]])bzero[[:space:]]*\(/ {
1067     fail("bzero")
1068 }
1069
1070 BEGIN { doc["strdup"] = "\
1071 Do not use strdup(), instead use xstrdup()";
1072     category["strdup"] = ari_regression
1073 }
1074 /(^|[^_[:alnum:]])strdup[[:space:]]*\(/ {
1075     fail("strdup")
1076 }
1077
1078 BEGIN { doc["strsave"] = "\
1079 Do not use strsave(), instead use xstrdup() et.al."
1080     category["strsave"] = ari_regression
1081 }
1082 /(^|[^_[:alnum:]])strsave[[:space:]]*\(/ {
1083     fail("strsave")
1084 }
1085
1086 # String compare functions
1087
1088 BEGIN { doc["strnicmp"] = "\
1089 Do not use strnicmp(), instead use strncasecmp()"
1090     category["strnicmp"] = ari_regression
1091 }
1092 /(^|[^_[:alnum:]])strnicmp[[:space:]]*\(/ {
1093     fail("strnicmp")
1094 }
1095
1096 # Typedefs that are either redundant or can be reduced to `struct
1097 # type *''.
1098 # Must be placed before if assignment otherwise ARI exceptions
1099 # are not handled correctly.
1100
1101 BEGIN { doc["d_namelen"] = "\
1102 Do not use dirent.d_namelen, instead use NAMELEN"
1103     category["d_namelen"] = ari_regression
1104 }
1105 /(^|[^_[:alnum:]])d_namelen([^_[:alnum:]]|$)/ {
1106     fail("d_namelen")
1107 }
1108
1109 BEGIN { doc["strlen d_name"] = "\
1110 Do not use strlen dirent.d_name, instead use NAMELEN"
1111     category["strlen d_name"] = ari_regression
1112 }
1113 /(^|[^_[:alnum:]])strlen[[:space:]]*\(.*[^_[:alnum:]]d_name([^_[:alnum:]]|$)/ {
1114     fail("strlen d_name")
1115 }
1116
1117 BEGIN { doc["generic_use_struct_convention"] = "\
1118 Replace generic_use_struct_convention with nothing, \
1119 EXTRACT_STRUCT_VALUE_ADDRESS is a predicate"
1120     category["generic_use_struct_convention"] = ari_regression
1121 }
1122 /(^|[^_[:alnum:]])generic_use_struct_convention([^_[:alnum:]]|$)/ {
1123     fail("generic_use_struct_convention")
1124 }
1125
1126 BEGIN { doc["if assignment"] = "\
1127 An IF statement'\''s expression contains an assignment (the GNU coding \
1128 standard discourages this)"
1129     category["if assignment"] = ari_code
1130 }
1131 BEGIN { doc["if clause more than 50 lines"] = "\
1132 An IF statement'\''s expression expands over 50 lines"
1133     category["if clause more than 50 lines"] = ari_code
1134 }
1135 #
1136 # Accumulate continuation lines
1137 FNR == 1 {
1138     in_if = 0
1139 }
1140
1141 /(^|[^_[:alnum:]])if / {
1142     in_if = 1;
1143     if_brace_level = 0;
1144     if_cont_p = 0;
1145     if_count = 0;
1146     if_brace_end_pos = 0;
1147     if_full_line = "";
1148 }
1149 (in_if)  {
1150     # We want everything up to closing brace of same level
1151     if_count++;
1152     if (if_count > 50) {
1153         print "multiline if: " if_full_line $0
1154         fail("if clause more than 50 lines")
1155         if_brace_level = 0;
1156         if_full_line = "";
1157     } else {
1158         if (if_count == 1) {
1159             i = index($0,"if ");
1160         } else {
1161             i = 1;
1162         }
1163         for (i=i; i <= length($0); i++) {
1164             char = substr($0,i,1);
1165             if (char == "(") { if_brace_level++; }
1166             if (char == ")") {
1167                 if_brace_level--;
1168                 if (!if_brace_level) {
1169                     if_brace_end_pos = i;
1170                     after_if = substr($0,i+1,length($0));
1171                     # Do not parse what is following
1172                     break;
1173                 }
1174             }
1175         }
1176         if (if_brace_level == 0) {
1177             $0 = substr($0,1,i);
1178             in_if = 0;
1179         } else {
1180             if_full_line = if_full_line $0;
1181             if_cont_p = 1;
1182             next;
1183         }
1184     }
1185 }
1186 # if we arrive here, we need to concatenate, but we are at brace level 0
1187
1188 (if_brace_end_pos) {
1189     $0 = if_full_line substr($0,1,if_brace_end_pos);
1190     if (if_count > 1) {
1191         # print "IF: multi line " if_count " found at " FILENAME ":" FNR " \"" $0 "\""
1192     }
1193     if_cont_p = 0;
1194     if_full_line = "";
1195 }
1196 /(^|[^_[:alnum:]])if .* = / {
1197     # print "fail in if " $0
1198     fail("if assignment")
1199 }
1200 (if_brace_end_pos) {
1201     $0 = $0 after_if;
1202     if_brace_end_pos = 0;
1203     in_if = 0;
1204 }
1205
1206 # Printout of all found bug
1207
1208 BEGIN {
1209     if (print_doc) {
1210         for (bug in doc) {
1211             fail(bug)
1212         }
1213         exit
1214     }
1215 }' "$@"
1216