t/chainlint.sed

   1 #------------------------------------------------------------------------------
   2 # Detect broken &&-chains in tests.
   3 #
   4 # At present, only &&-chains in subshells are examined by this linter;
   5 # top-level &&-chains are instead checked directly by the test framework. Like
   6 # the top-level &&-chain linter, the subshell linter (intentionally) does not
   7 # check &&-chains within {...} blocks.
   8 #
   9 # Checking for &&-chain breakage is done line-by-line by pure textual
  10 # inspection.
  11 #
  12 # Incomplete lines (those ending with "\") are stitched together with following
  13 # lines to simplify processing, particularly of "one-liner" statements.
  14 # Top-level here-docs are swallowed to avoid false positives within the
  15 # here-doc body, although the statement to which the here-doc is attached is
  16 # retained.
  17 #
  18 # Heuristics are used to detect end-of-subshell when the closing ")" is cuddled
  19 # with the final subshell statement on the same line:
  20 #
  21 #    (cd foo &&
  22 #        bar)
  23 #
  24 # in order to avoid misinterpreting the ")" in constructs such as "x=$(...)"
  25 # and "case $x in *)" as ending the subshell.
  26 #
  27 # Lines missing a final "&&" are flagged with "?!AMP?!", and lines which chain
  28 # commands with ";" internally rather than "&&" are flagged "?!SEMI?!". A line
  29 # may be flagged for both violations.
  30 #
  31 # Detection of a missing &&-link in a multi-line subshell is complicated by the
  32 # fact that the last statement before the closing ")" must not end with "&&".
  33 # Since processing is line-by-line, it is not known whether a missing "&&" is
  34 # legitimate or not until the _next_ line is seen. To accommodate this, within
  35 # multi-line subshells, each line is stored in sed's "hold" area until after
  36 # the next line is seen and processed. If the next line is a stand-alone ")",
  37 # then a missing "&&" on the previous line is legitimate; otherwise a missing
  38 # "&&" is a break in the &&-chain.
  39 #
  40 #    (
  41 #         cd foo &&
  42 #         bar
  43 #    )
  44 #
  45 # In practical terms, when "bar" is encountered, it is flagged with "?!AMP?!",
  46 # but when the stand-alone ")" line is seen which closes the subshell, the
  47 # "?!AMP?!" violation is removed from the "bar" line (retrieved from the "hold"
  48 # area) since the final statement of a subshell must not end with "&&". The
  49 # final line of a subshell may still break the &&-chain by using ";" internally
  50 # to chain commands together rather than "&&", so "?!SEMI?!" is never removed
  51 # from a line (even though "?!AMP?!" might be).
  52 #
  53 # Care is taken to recognize the last _statement_ of a multi-line subshell, not
  54 # necessarily the last textual _line_ within the subshell, since &&-chaining
  55 # applies to statements, not to lines. Consequently, blank lines, comment
  56 # lines, and here-docs are swallowed (but not the command to which the here-doc
  57 # is attached), leaving the last statement in the "hold" area, not the last
  58 # line, thus simplifying &&-link checking.
  59 #
  60 # The final statement before "done" in for- and while-loops, and before "elif",
  61 # "else", and "fi" in if-then-else likewise must not end with "&&", thus
  62 # receives similar treatment.
  63 #
  64 # Swallowing here-docs with arbitrary tags requires a bit of finesse. When a
  65 # line such as "cat <<EOF >out" is seen, the here-doc tag is moved to the front
  66 # of the line enclosed in angle brackets as a sentinel, giving "<EOF>cat >out".
  67 # As each subsequent line is read, it is appended to the target line and a
  68 # (whitespace-loose) back-reference match /^<(.*)>\n\1$/ is attempted to see if
  69 # the content inside "<...>" matches the entirety of the newly-read line. For
  70 # instance, if the next line read is "some data", when concatenated with the
  71 # target line, it becomes "<EOF>cat >out\nsome data", and a match is attempted
  72 # to see if "EOF" matches "some data". Since it doesn't, the next line is
  73 # attempted. When a line consisting of only "EOF" (and possible whitespace) is
  74 # encountered, it is appended to the target line giving "<EOF>cat >out\nEOF",
  75 # in which case the "EOF" inside "<...>" does match the text following the
  76 # newline, thus the closing here-doc tag has been found. The closing tag line
  77 # and the "<...>" prefix on the target line are then discarded, leaving just
  78 # the target line "cat >out".
  79 #
  80 # To facilitate regression testing (and manual debugging), a ">" annotation is
  81 # applied to the line containing ")" which closes a subshell, ">>" to a line
  82 # closing a nested subshell, and ">>>" to a line closing both at once. This
  83 # makes it easy to detect whether the heuristics correctly identify
  84 # end-of-subshell.
  85 #------------------------------------------------------------------------------
  86
  87 # incomplete line -- slurp up next line
  88 :squash
  89 /\\$/ {
  90         N
  91         s/\\\n//
  92         bsquash
  93 }
  94
  95 # here-doc -- swallow it to avoid false hits within its body (but keep the
  96 # command to which it was attached)
  97 /<<[    ]*[-\\'"]*[A-Za-z0-9_]/ {
  98         s/^\(.*\)<<[    ]*[-\\'"]*\([A-Za-z0-9_][A-Za-z0-9_]*\)['"]*/<\2>\1<</
  99         s/[     ]*<<//
 100         :hered
 101         N
 102         /^<\([^>]*\)>.*\n[      ]*\1[   ]*$/!{
 103                 s/\n.*$//
 104                 bhered
 105         }
 106         s/^<[^>]*>//
 107         s/\n.*$//
 108 }
 109
 110 # one-liner "(...) &&"
 111 /^[     ]*!*[   ]*(..*)[        ]*&&[   ]*$/boneline
 112
 113 # same as above but without trailing "&&"
 114 /^[     ]*!*[   ]*(..*)[        ]*$/boneline
 115
 116 # one-liner "(...) >x" (or "2>x" or "<x" or "|x" or "&"
 117 /^[     ]*!*[   ]*(..*)[        ]*[0-9]*[<>|&]/boneline
 118
 119 # multi-line "(...\n...)"
 120 /^[     ]*(/bsubshell
 121
 122 # innocuous line -- print it and advance to next line
 123 b
 124
 125 # found one-liner "(...)" -- mark suspect if it uses ";" internally rather than
 126 # "&&" (but not ";" in a string)
 127 :oneline
 128 /;/{
 129         /"[^"]*;[^"]*"/!s/^/?!SEMI?!/
 130 }
 131 b
 132
 133 :subshell
 134 # bare "(" line? -- stash for later printing
 135 /^[     ]*([    ]*$/ {
 136         h
 137         bnextline
 138 }
 139 # "(..." line -- split off and stash "(", then process "..." as its own line
 140 x
 141 s/.*/(/
 142 x
 143 s/(//
 144 bslurp
 145
 146 :nextline
 147 N
 148 s/.*\n//
 149
 150 :slurp
 151 # incomplete line "...\"
 152 /\\$/bicmplte
 153 # multi-line quoted string "...\n..."?
 154 /"/bdqstring
 155 # multi-line quoted string '...\n...'? (but not contraction in string "it's")
 156 /'/{
 157         /"[^'"]*'[^'"]*"/!bsqstring
 158 }
 159 :folded
 160 # here-doc -- swallow it
 161 /<<[    ]*[-\\'"]*[A-Za-z0-9_]/bheredoc
 162 # comment or empty line -- discard since final non-comment, non-empty line
 163 # before closing ")", "done", "elsif", "else", or "fi" will need to be
 164 # re-visited to drop "suspect" marking since final line of those constructs
 165 # legitimately lacks "&&", so "suspect" mark must be removed
 166 /^[     ]*#/bnextline
 167 /^[     ]*$/bnextline
 168 # in-line comment -- strip it (but not "#" in a string, Bash ${#...} array
 169 # length, or Perforce "//depot/path#42" revision in filespec)
 170 /[      ]#/{
 171         /"[^"]*#[^"]*"/!s/[     ]#.*$//
 172 }
 173 # one-liner "case ... esac"
 174 /^[     ]*case[         ]*..*esac/bchkchn
 175 # multi-line "case ... esac"
 176 /^[     ]*case[         ]..*[   ]in/bcase
 177 # multi-line "for ... done" or "while ... done"
 178 /^[     ]*for[  ]..*[   ]in/bcontinue
 179 /^[     ]*while[        ]/bcontinue
 180 /^[     ]*do[   ]/bcontinue
 181 /^[     ]*do[   ]*$/bcontinue
 182 /;[     ]*do/bcontinue
 183 /^[     ]*done[         ]*&&[   ]*$/bdone
 184 /^[     ]*done[         ]*$/bdone
 185 /^[     ]*done[         ]*[<>|]/bdone
 186 /^[     ]*done[         ]*)/bdone
 187 /||[    ]*exit[         ]/bcontinue
 188 /||[    ]*exit[         ]*$/bcontinue
 189 # multi-line "if...elsif...else...fi"
 190 /^[     ]*if[   ]/bcontinue
 191 /^[     ]*then[         ]/bcontinue
 192 /^[     ]*then[         ]*$/bcontinue
 193 /;[     ]*then/bcontinue
 194 /^[     ]*elif[         ]/belse
 195 /^[     ]*elif[         ]*$/belse
 196 /^[     ]*else[         ]/belse
 197 /^[     ]*else[         ]*$/belse
 198 /^[     ]*fi[   ]*&&[   ]*$/bdone
 199 /^[     ]*fi[   ]*$/bdone
 200 /^[     ]*fi[   ]*[<>|]/bdone
 201 /^[     ]*fi[   ]*)/bdone
 202 # nested one-liner "(...) &&"
 203 /^[     ]*(.*)[         ]*&&[   ]*$/bchkchn
 204 # nested one-liner "(...)"
 205 /^[     ]*(.*)[         ]*$/bchkchn
 206 # nested one-liner "(...) >x" (or "2>x" or "<x" or "|x")
 207 /^[     ]*(.*)[         ]*[0-9]*[<>|]/bchkchn
 208 # nested multi-line "(...\n...)"
 209 /^[     ]*(/bnest
 210 # multi-line "{...\n...}"
 211 /^[     ]*{/bblock
 212 # closing ")" on own line -- exit subshell
 213 /^[     ]*)/bclssolo
 214 # "$((...))" -- arithmetic expansion; not closing ")"
 215 /\$(([^)][^)]*))[^)]*$/bchkchn
 216 # "$(...)" -- command substitution; not closing ")"
 217 /\$([^)][^)]*)[^)]*$/bchkchn
 218 # multi-line "$(...\n...)" -- command substitution; treat as nested subshell
 219 /\$([^)]*$/bnest
 220 # "=(...)" -- Bash array assignment; not closing ")"
 221 /=(/bchkchn
 222 # closing "...) &&"
 223 /)[     ]*&&[   ]*$/bclose
 224 # closing "...)"
 225 /)[     ]*$/bclose
 226 # closing "...) >x" (or "2>x" or "<x" or "|x")
 227 /)[     ]*[<>|]/bclose
 228 :chkchn
 229 # mark suspect if line uses ";" internally rather than "&&" (but not ";" in a
 230 # string and not ";;" in one-liner "case...esac")
 231 /;/{
 232         /;;/!{
 233                 /"[^"]*;[^"]*"/!s/^/?!SEMI?!/
 234         }
 235 }
 236 # line ends with pipe "...|" -- valid; not missing "&&"
 237 /|[     ]*$/bcontinue
 238 # missing end-of-line "&&" -- mark suspect
 239 /&&[    ]*$/!s/^/?!AMP?!/
 240 :continue
 241 # retrieve and print previous line
 242 x
 243 n
 244 bslurp
 245
 246 # found incomplete line "...\" -- slurp up next line
 247 :icmplte
 248 N
 249 s/\\\n//
 250 bslurp
 251
 252 # check for multi-line double-quoted string "...\n..." -- fold to one line
 253 :dqstring
 254 # remove all quote pairs
 255 s/"\([^"]*\)"/@!\1@!/g
 256 # done if no dangling quote
 257 /"/!bdqdone
 258 # otherwise, slurp next line and try again
 259 N
 260 s/\n//
 261 bdqstring
 262 :dqdone
 263 s/@!/"/g
 264 bfolded
 265
 266 # check for multi-line single-quoted string '...\n...' -- fold to one line
 267 :sqstring
 268 # remove all quote pairs
 269 s/'\([^']*\)'/@!\1@!/g
 270 # done if no dangling quote
 271 /'/!bsqdone
 272 # otherwise, slurp next line and try again
 273 N
 274 s/\n//
 275 bsqstring
 276 :sqdone
 277 s/@!/'/g
 278 bfolded
 279
 280 # found here-doc -- swallow it to avoid false hits within its body (but keep
 281 # the command to which it was attached)
 282 :heredoc
 283 s/^\(.*\)<<[    ]*[-\\'"]*\([A-Za-z0-9_][A-Za-z0-9_]*\)['"]*/<\2>\1<</
 284 s/[     ]*<<//
 285 :heredsub
 286 N
 287 /^<\([^>]*\)>.*\n[      ]*\1[   ]*$/!{
 288         s/\n.*$//
 289         bheredsub
 290 }
 291 s/^<[^>]*>//
 292 s/\n.*$//
 293 bfolded
 294
 295 # found "case ... in" -- pass through untouched
 296 :case
 297 x
 298 n
 299 /^[     ]*esac/bslurp
 300 bcase
 301
 302 # found "else" or "elif" -- drop "suspect" from final line before "else" since
 303 # that line legitimately lacks "&&"
 304 :else
 305 x
 306 s/?!AMP?!//
 307 x
 308 bcontinue
 309
 310 # found "done" closing for-loop or while-loop, or "fi" closing if-then -- drop
 311 # "suspect" from final contained line since that line legitimately lacks "&&"
 312 :done
 313 x
 314 s/?!AMP?!//
 315 x
 316 # is 'done' or 'fi' cuddled with ")" to close subshell?
 317 /done.*)/bclose
 318 /fi.*)/bclose
 319 bchkchn
 320
 321 # found nested multi-line "(...\n...)" -- pass through untouched
 322 :nest
 323 x
 324 :nstslurp
 325 n
 326 # closing ")" on own line -- stop nested slurp
 327 /^[     ]*)/bnstclose
 328 # comment -- not closing ")" if in comment
 329 /^[     ]*#/bnstcnt
 330 # "$((...))" -- arithmetic expansion; not closing ")"
 331 /\$(([^)][^)]*))[^)]*$/bnstcnt
 332 # "$(...)" -- command substitution; not closing ")"
 333 /\$([^)][^)]*)[^)]*$/bnstcnt
 334 # closing "...)" -- stop nested slurp
 335 /)/bnstclose
 336 :nstcnt
 337 x
 338 bnstslurp
 339 :nstclose
 340 s/^/>>/
 341 # is it "))" which closes nested and parent subshells?
 342 /)[     ]*)/bslurp
 343 bchkchn
 344
 345 # found multi-line "{...\n...}" block -- pass through untouched
 346 :block
 347 x
 348 n
 349 # closing "}" -- stop block slurp
 350 /}/bchkchn
 351 bblock
 352
 353 # found closing ")" on own line -- drop "suspect" from final line of subshell
 354 # since that line legitimately lacks "&&" and exit subshell loop
 355 :clssolo
 356 x
 357 s/?!AMP?!//
 358 p
 359 x
 360 s/^/>/
 361 b
 362
 363 # found closing "...)" -- exit subshell loop
 364 :close
 365 x
 366 p
 367 x
 368 s/^/>/
 369 b