fb41727b7e · matheusbsbs/matheus-bagliano

@@ -1,399 +0,0 @@

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?!", as are lines which

28 -# chain commands with ";" internally rather than "&&". A line may be flagged

29 -# 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 "&&", but an internal "?!AMP?!" is

51 -# never removed from a line even though a line-ending "?!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" is seen, the here-doc tag is copied to the front of

66 -# the line enclosed in angle brackets as a sentinel, giving "<EOF>cat <<EOF".

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 <<EOF\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 <<EOF\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 <<EOF".

79 -#------------------------------------------------------------------------------

80 -

81 -# incomplete line -- slurp up next line

82 -:squash

83 -/\\$/ {

84 - N

85 - s/\\\n//

86 - bsquash

87 -}

88 -

89 -# here-doc -- swallow it to avoid false hits within its body (but keep the

90 -# command to which it was attached)

91 -/<<-*[ ]*[\\'"]*[A-Za-z0-9_]/ {

92 - /"[^"]*<<[^"]*"/bnotdoc

93 - s/^$.*<<-*[ ]*$[\\'"]*$[A-Za-z0-9_][A-Za-z0-9_]*$['"]*/<\2>\1\2/

94 - :hered

95 - N

96 - /^<$[^>]*$>.*\n[ ]*\1[ ]*$/!{

97 - s/\n.*$//

98 - bhered

99 - }

100 - s/^<[^>]*>//

101 - s/\n.*$//

102 -}

103 -:notdoc

104 -

105 -# one-liner "(...) &&"

106 -/^[ ]*!*[ ]*(..*)[ ]*&&[ ]*$/boneline

107 -

108 -# same as above but without trailing "&&"

109 -/^[ ]*!*[ ]*(..*)[ ]*$/boneline

110 -

111 -# one-liner "(...) >x" (or "2>x" or "<x" or "|x" or "&"

112 -/^[ ]*!*[ ]*(..*)[ ]*[0-9]*[<>|&]/boneline

113 -

114 -# multi-line "(...\n...)"

115 -/^[ ]*(/bsubsh

116 -

117 -# innocuous line -- print it and advance to next line

118 -b

119 -

120 -# found one-liner "(...)" -- mark suspect if it uses ";" internally rather than

121 -# "&&" (but not ";" in a string)

122 -:oneline

123 -/;/{

124 - /"[^"]*;[^"]*"/!s/;/; ?!AMP?!/

125 -}

126 -b

127 -

128 -:subsh

129 -# bare "(" line? -- stash for later printing

130 -/^[ ]*([ ]*$/ {

131 - h

132 - bnextln

133 -}

134 -# "(..." line -- "(" opening subshell cuddled with command; temporarily replace

135 -# "(" with sentinel "^" and process the line as if "(" had been seen solo on

136 -# the preceding line; this temporary replacement prevents several rules from

137 -# accidentally thinking "(" introduces a nested subshell; "^" is changed back

138 -# to "(" at output time

139 -x

140 -s/.*//

141 -x

142 -s/(/^/

143 -bslurp

144 -

145 -:nextln

146 -N

147 -s/.*\n//

148 -

149 -:slurp

150 -# incomplete line "...\"

151 -/\\$/bicmplte

152 -# multi-line quoted string "...\n..."?

153 -/"/bdqstr

154 -# multi-line quoted string '...\n...'? (but not contraction in string "it's")

155 -/'/{

156 - /"[^'"]*'[^'"]*"/!bsqstr

157 -}

158 -:folded

159 -# here-doc -- swallow it (but not "<<" in a string)

160 -/<<-*[ ]*[\\'"]*[A-Za-z0-9_]/{

161 - /"[^"]*<<[^"]*"/!bheredoc

162 -}

163 -# comment or empty line -- discard since final non-comment, non-empty line

164 -# before closing ")", "done", "elsif", "else", or "fi" will need to be

165 -# re-visited to drop "suspect" marking since final line of those constructs

166 -# legitimately lacks "&&", so "suspect" mark must be removed

167 -/^[ ]*#/bnextln

168 -/^[ ]*$/bnextln

169 -# in-line comment -- strip it (but not "#" in a string, Bash ${#...} array

170 -# length, or Perforce "//depot/path#42" revision in filespec)

171 -/[ ]#/{

172 - /"[^"]*#[^"]*"/!s/[ ]#.*$//

173 -}

174 -# one-liner "case ... esac"

175 -/^[ ^]*case[ ]*..*esac/bchkchn

176 -# multi-line "case ... esac"

177 -/^[ ^]*case[ ]..*[ ]in/bcase

178 -# multi-line "for ... done" or "while ... done"

179 -/^[ ^]*for[ ]..*[ ]in/bcont

180 -/^[ ^]*while[ ]/bcont

181 -/^[ ]*do[ ]/bcont

182 -/^[ ]*do[ ]*$/bcont

183 -/;[ ]*do/bcont

184 -/^[ ]*done[ ]*&&[ ]*$/bdone

185 -/^[ ]*done[ ]*$/bdone

186 -/^[ ]*done[ ]*[<>|]/bdone

187 -/^[ ]*done[ ]*)/bdone

188 -/||[ ]*exit[ ]/bcont

189 -/||[ ]*exit[ ]*$/bcont

190 -# multi-line "if...elsif...else...fi"

191 -/^[ ^]*if[ ]/bcont

192 -/^[ ]*then[ ]/bcont

193 -/^[ ]*then[ ]*$/bcont

194 -/;[ ]*then/bcont

195 -/^[ ]*elif[ ]/belse

196 -/^[ ]*elif[ ]*$/belse

197 -/^[ ]*else[ ]/belse

198 -/^[ ]*else[ ]*$/belse

199 -/^[ ]*fi[ ]*&&[ ]*$/bdone

200 -/^[ ]*fi[ ]*$/bdone

201 -/^[ ]*fi[ ]*[<>|]/bdone

202 -/^[ ]*fi[ ]*)/bdone

203 -# nested one-liner "(...) &&"

204 -/^[ ^]*(.*)[ ]*&&[ ]*$/bchkchn

205 -# nested one-liner "(...)"

206 -/^[ ^]*(.*)[ ]*$/bchkchn

207 -# nested one-liner "(...) >x" (or "2>x" or "<x" or "|x")

208 -/^[ ^]*(.*)[ ]*[0-9]*[<>|]/bchkchn

209 -# nested multi-line "(...\n...)"

210 -/^[ ^]*(/bnest

211 -# multi-line "{...\n...}"

212 -/^[ ^]*{/bblock

213 -# closing ")" on own line -- exit subshell

214 -/^[ ]*)/bclssolo

215 -# "$((...))" -- arithmetic expansion; not closing ")"

216 -/\$(([^)][^)]*))[^)]*$/bchkchn

217 -# "$(...)" -- command substitution; not closing ")"

218 -/\$([^)][^)]*)[^)]*$/bchkchn

219 -# multi-line "$(...\n...)" -- command substitution; treat as nested subshell

220 -/\$([^)]*$/bnest

221 -# "=(...)" -- Bash array assignment; not closing ")"

222 -/=(/bchkchn

223 -# closing "...) &&"

224 -/)[ ]*&&[ ]*$/bclose

225 -# closing "...)"

226 -/)[ ]*$/bclose

227 -# closing "...) >x" (or "2>x" or "<x" or "|x")

228 -/)[ ]*[<>|]/bclose

229 -:chkchn

230 -# mark suspect if line uses ";" internally rather than "&&" (but not ";" in a

231 -# string and not ";;" in one-liner "case...esac")

232 -/;/{

233 - /;;/!{

234 - /"[^"]*;[^"]*"/!s/;/; ?!AMP?!/

235 - }

236 -}

237 -# line ends with pipe "...|" -- valid; not missing "&&"

238 -/|[ ]*$/bcont

239 -# missing end-of-line "&&" -- mark suspect

240 -/&&[ ]*$/!s/$/ ?!AMP?!/

241 -:cont

242 -# retrieve and print previous line

243 -x

244 -s/^$[ ]*$^/\1(/

245 -s/?!HERE?!/<</g

246 -n

247 -bslurp

248 -

249 -# found incomplete line "...\" -- slurp up next line

250 -:icmplte

251 -N

252 -s/\\\n//

253 -bslurp

254 -

255 -# check for multi-line double-quoted string "...\n..." -- fold to one line

256 -:dqstr

257 -# remove all quote pairs

258 -s/"$[^"]*$"/@!\1@!/g

259 -# done if no dangling quote

260 -/"/!bdqdone

261 -# otherwise, slurp next line and try again

262 -N

263 -s/\n//

264 -bdqstr

265 -:dqdone

266 -s/@!/"/g

267 -bfolded

268 -

269 -# check for multi-line single-quoted string '...\n...' -- fold to one line

270 -:sqstr

271 -# remove all quote pairs

272 -s/'$[^']*$'/@!\1@!/g

273 -# done if no dangling quote

274 -/'/!bsqdone

275 -# otherwise, slurp next line and try again

276 -N

277 -s/\n//

278 -bsqstr

279 -:sqdone

280 -s/@!/'/g

281 -bfolded

282 -

283 -# found here-doc -- swallow it to avoid false hits within its body (but keep

284 -# the command to which it was attached)

285 -:heredoc

286 -s/^$.*$<<$-*[ ]*$[\\'"]*$[A-Za-z0-9_][A-Za-z0-9_]*$['"]*/<\3>\1?!HERE?!\2\3/

287 -:hdocsub

288 -N

289 -/^<$[^>]*$>.*\n[ ]*\1[ ]*$/!{

290 - s/\n.*$//

291 - bhdocsub

292 -}

293 -s/^<[^>]*>//

294 -s/\n.*$//

295 -bfolded

296 -

297 -# found "case ... in" -- pass through untouched

298 -:case

299 -x

300 -s/^$[ ]*$^/\1(/

301 -s/?!HERE?!/<</g

302 -n

303 -:cascom

304 -/^[ ]*#/{

305 - N

306 - s/.*\n//

307 - bcascom

308 -}

309 -/^[ ]*esac/bslurp

310 -bcase

311 -

312 -# found "else" or "elif" -- drop "suspect" from final line before "else" since

313 -# that line legitimately lacks "&&"

314 -:else

315 -x

316 -s/$ ?!AMP?!$* ?!AMP?!$//

317 -x

318 -bcont

319 -

320 -# found "done" closing for-loop or while-loop, or "fi" closing if-then -- drop

321 -# "suspect" from final contained line since that line legitimately lacks "&&"

322 -:done

323 -x

324 -s/$ ?!AMP?!$* ?!AMP?!$//

325 -x

326 -# is 'done' or 'fi' cuddled with ")" to close subshell?

327 -/done.*)/bclose

328 -/fi.*)/bclose

329 -bchkchn

330 -

331 -# found nested multi-line "(...\n...)" -- pass through untouched

332 -:nest

333 -x

334 -:nstslrp

335 -s/^$[ ]*$^/\1(/

336 -s/?!HERE?!/<</g

337 -n

338 -:nstcom

339 -# comment -- not closing ")" if in comment

340 -/^[ ]*#/{

341 - N

342 - s/.*\n//

343 - bnstcom

344 -}

345 -# closing ")" on own line -- stop nested slurp

346 -/^[ ]*)/bnstcl

347 -# "$((...))" -- arithmetic expansion; not closing ")"

348 -/\$(([^)][^)]*))[^)]*$/bnstcnt

349 -# "$(...)" -- command substitution; not closing ")"

350 -/\$([^)][^)]*)[^)]*$/bnstcnt

351 -# closing "...)" -- stop nested slurp

352 -/)/bnstcl

353 -:nstcnt

354 -x

355 -bnstslrp

356 -:nstcl

357 -# is it "))" which closes nested and parent subshells?

358 -/)[ ]*)/bslurp

359 -bchkchn

360 -

361 -# found multi-line "{...\n...}" block -- pass through untouched

362 -:block

363 -x

364 -s/^$[ ]*$^/\1(/

365 -s/?!HERE?!/<</g

366 -n

367 -:blkcom

368 -/^[ ]*#/{

369 - N

370 - s/.*\n//

371 - bblkcom

372 -}

373 -# closing "}" -- stop block slurp

374 -/}/bchkchn

375 -bblock

376 -

377 -# found closing ")" on own line -- drop "suspect" from final line of subshell

378 -# since that line legitimately lacks "&&" and exit subshell loop

379 -:clssolo

380 -x

381 -s/$ ?!AMP?!$* ?!AMP?!$//

382 -s/^$[ ]*$^/\1(/

383 -s/?!HERE?!/<</g

384 -p

385 -x

386 -s/^$[ ]*$^/\1(/

387 -s/?!HERE?!/<</g

388 -b

389 -

390 -# found closing "...)" -- exit subshell loop

391 -:close

392 -x

393 -s/^$[ ]*$^/\1(/

394 -s/?!HERE?!/<</g

395 -p

396 -x

397 -s/^$[ ]*$^/\1(/

398 -s/?!HERE?!/<</g

399 -b

t: retire unused chainlint.sed