ගොනුවක අවසානයට නව රේඛාවක් එකතු කරන්නේ කෙසේද?

අනුවාද පාලන පද්ධති භාවිතා කිරීම වෙනස පවසන විට ශබ්දය නිසා මා කෝපයට පත් No newline at end of fileවේ.

ඉතින් මම කල්පනා කළා: එම පණිවිඩ ඉවත් කිරීම සඳහා ගොනුවක් අවසානයේ නව රේඛාවක් එකතු කරන්නේ කෙසේද?

ව්‍යාපෘතියක් පුනරාවර්තනව සනීපාරක්ෂාව සඳහා මම මෙම ඔන්ලයින් භාවිතා කරමි:

git ls-files -z | while IFS= read -rd '' f; do tail -c1 < "$f" | read -r _ || echo >> "$f"; done

පැහැදිලි කිරීම:

• git ls-files -zගබඩාවේ ගොනු ලැයිස්තුගත කරයි. සමහර පරාමිතීන් ලෙස විකල්ප රටාවක් ගත යුතු අතර සමහර මෙහෙයුම් වලදී ඔබට සමහර ගොනු / නාමාවලි වලට පමණක් සීමා කිරීමට අවශ්‍ය නම් එය ප්‍රයෝජනවත් වේ. විකල්පයක් ලෙස, find -print0 ...බලපෑමට ලක්වූ ලිපිගොනු ලැයිස්තුගත කිරීම සඳහා ඔබට ඒ හා සමාන වැඩසටහන් භාවිතා කළ හැකිය - එය NULසීමා කළ ප්‍රවේශයන් විමෝචනය කරන බවට වග බලා ගන්න .

• while IFS= read -rd '' f; do ... done වයිට්ස්පේස් සහ / හෝ නව රේඛා ඇතුළත් ගොනු නාමයන් ආරක්ෂිතව හසුරුවමින් ඇතුළත් කිරීම් හරහා නැවත පැමිණේ.

• tail -c1 < "$f" ගොනුවකින් අවසන් වරහන කියවයි.

• read -r _ පසුපසින් සිටින නව රේඛාවක් අස්ථානගත වී ඇත්නම්, නොසරෝ පිටවීමේ තත්වයක් සමඟ පිටවීම.

• || echo >> "$f" පෙර විධානයෙහි පිටවීමේ තත්වය nonzero නම් ගොනුවට නව රේඛාවක් එකතු කරයි.

මෙන්න ඔබ යන්න :

sed -i -e '$a\' file

OS X සඳහා විකල්පයක් ලෙස sed:

sed -i '' -e '$a\' file

මෙය \nගොනුවේ අවසානයේ එකතු කරන්නේ එය දැනටමත් නව රේඛාවකින් අවසන් නොවන්නේ නම් පමණි . එබැවින් ඔබ එය දෙවරක් ධාවනය කරන්නේ නම්, එය තවත් නව රේඛාවක් එක් නොකරනු ඇත:

$ cd "$(mktemp -d)"
$ printf foo > test.txt
$ sed -e '$a\' test.txt > test-with-eol.txt
$ diff test*
1c1
< foo
\ No newline at end of file
---
> foo
$ echo $?
1
$ sed -e '$a\' test-with-eol.txt > test-still-with-one-eol.txt
$ diff test-with-eol.txt test-still-with-one-eol.txt
$ echo $?
0

බලන්න:

$ echo -n foo > foo 
$ cat foo
foo$
$ echo "" >> foo
$ cat foo
foo

ඒ නිසා echo "" >> noeol-fileඋපක්‍රමය කළ යුතුයි. (නැතහොත් ඔබ අදහස් කළේ මෙම ගොනු හඳුනා ගැනීම සඳහා ඉල්ලා හා ඔවුන් සවි?)

සංස්කරණය ඉවත් කර ""ඇත echo "" >> foo(බලන්න @ යූයිචාවෝගේ අදහස බලන්න) edit2"" නැවත එකතු කරන ලදි ( නමුත් e කීත් තොම්සන් ගේ අදහස බලන්න)

භාවිතා කරන තවත් විසඳුමක් ed. මෙම විසඳුම අවසාන පේළියට පමණක් බලපාන අතර \nඑය නොමැති නම් පමණි :

ed -s file <<< w

එය අත්‍යවශ්‍යයෙන්ම ස්ක්‍රිප්ට් එකක් හරහා සංස්කරණය කිරීම සඳහා ගොනුව විවෘත කරයි, ස්ක්‍රිප්ට් යනු තනි wවිධානයකි, එය ගොනුව නැවත තැටියට ලියයි. එය පදනම් වී ඇත්තේ ed(1)මිනිසාගේ පිටුවේ ඇති මෙම වාක්‍යය මත ය :

සීමාවන්
       (...)

       පෙළ (ද්විමය නොවන) ගොනුවක් නව අක්ෂරයකින් අවසන් නොවන්නේ නම්,
       ඉන්පසු එය කියවීමට / ලිවීමට එඩ් එක් කරයි. ද්විමය සම්බන්ධයෙන්
       ගොනුව, සංස්කරණය කියවීම / ලිවීම පිළිබඳ නව රේඛාවක් එකතු නොකරයි.

නොසලකා නව රේඛාවක් එක් කරන්න:

echo >> filename

පයිතන් භාවිතා කිරීමෙන් එකක් එක් කිරීමට පෙර අවසානයේ නව රේඛාවක් තිබේදැයි පරීක්ෂා කිරීමට ක්‍රමයක් මෙන්න:

f=filename; python -c "import sys; sys.exit(open(\"$f\").read().endswith('\n'))" && echo >> $f

නොපැමිණෙන, අවසාන නව රේඛාවක් a ට එකතු කිරීම සඳහා සරල, අතේ ගෙන යා හැකි, පොසික්ස් අනුකූල ක්‍රමයක් පෙළ ගොනුවක් වනු ඇත:

[ -n "$(tail -c1 file)" ] && echo >> file

මෙම ප්රවේශය සම්පූර්ණ ගොනුව කියවීමට අවශ්ය නොවේ; එය හුදෙක් EOF වෙත ගොස් එහි සිට වැඩ කළ හැකිය.

මෙම ප්‍රවේශය මඟින් ඔබේ පිටුපස තාවකාලික ලිපිගොනු සෑදීම අවශ්‍ය නොවේ (උදා: sed -i), එබැවින් දෘඩ සබැඳි බලපාන්නේ නැත.

echo ගොනුවට නව රේඛාවක් එකතු කරන්නේ විධාන ආදේශනයේ ප්‍රති result ලය හිස් නොවන නූලක් වූ විට පමණි. මෙය සිදුවිය හැක්කේ ගොනුව හිස් නොවන්නේ නම් සහ අවසාන බයිට් නව රේඛාවක් නොවේ නම් පමණි.

ගොනුවේ අවසාන බයිට් එක නව රේඛාවක් නම්, වලිගය එය නැවත ලබා දෙයි, පසුව විධාන ආදේශනය එය ඉවත් කරයි; ප්‍රති result ලය හිස් නූලකි. -N පරීක්ෂණය අසමත් වන අතර දෝංකාරය ක්‍රියාත්මක නොවේ.

ගොනුව හිස් නම්, විධාන ආදේශනයේ ප්‍රති result ලය ද හිස් නූලක් වන අතර නැවත දෝංකාරය ක්‍රියාත්මක නොවේ. මෙය සුදුසු වන්නේ හිස් ගොනුවක් අවලංගු පෙළ ගොනුවක් නොවන නිසාත් එය හිස් රේඛාවක් සහිත හිස් නොවන පෙළ ගොනුවකට සමාන නොවන නිසාත් ය.

වේගවත්ම විසඳුම නම්:

[ -n "$(tail -c1 file)" ] && printf '\n' >>file 

1. ඇත්තෙන්ම වේගවත්.
   මධ්‍යම ප්‍රමාණයේ ගොනුවකට seq 99999999 >fileමෙය මිලි තත්පර ගත වේ.
   වෙනත් විසඳුම් සඳහා බොහෝ කාලයක් ගතවේ:

   [ -n "$(tail -c1 file)" ] && printf '\n' >>file  0.013 sec
   vi -ecwq file                                    2.544 sec
   paste file 1<> file                             31.943 sec
   ed -s file <<< w                             1m  4.422 sec
   sed -i -e '$a\' file                         3m 20.931 sec

2. අළු, බාෂ්, lksh, mksh, ksh93, attsh සහ zsh වලින් ක්‍රියා කරන නමුත් යෂ් නොවේ.

3. නව රේඛාවක් එක් කිරීමට අවශ්‍ය නැතිනම් ගොනු කාලරාමුව වෙනස් නොකරයි.
   මෙහි ඉදිරිපත් කර ඇති අනෙකුත් සියලුම විසඳුම් ගොනුවේ කාලරාමුව වෙනස් කරයි.
4. ඉහත සියලුම විසඳුම් වලංගු POSIX වේ.

ඔබට යෂ් (සහ ඉහත ලැයිස්තුගත කර ඇති අනෙකුත් සියලුම ෂෙල් වෙඩි) සඳහා අතේ ගෙන යා හැකි විසඳුමක් අවශ්‍ය නම්, එය තව ටිකක් සංකීර්ණ විය හැකිය:

f=file
if       [ "$(tail -c1 "$f"; echo x)" != "$(printf '\nx')" ]
then     printf '\n' >>"$f"
fi

ගොනුවක අවසාන බයිට් නව රේඛාවක් දැයි පරීක්ෂා කිරීමට වේගවත්ම ක්‍රමය වන්නේ එම අවසාන බයිට් එක පමණක් කියවීමයි. එය කළ හැකිය tail -c1 file. කෙසේ වෙතත්, බයිට් අගය නව රේඛාවක් දැයි පරීක්ෂා කිරීම සඳහා සරලම ක්‍රමය, විධාන ප්‍රසාරණය තුළ සිරස් අතට අළුත් රේඛාවක් ඉවත් කිරීම සාමාන්‍යයෙන් යෂ් වලින් අසමත් වේ (නිදසුනක් ලෙස), ගොනුවේ අවසාන අක්‍ෂරය යූටීඑෆ්- 8 අගය.

ගොනුවක අවසාන බයිට් නව රේඛාවක් දැයි සොයා ගැනීමට නිවැරදි, POSIX- අනුකූල, සියලු (සාධාරණ) ෂෙල් වෙඩි ක්‍රමය වන්නේ xxd හෝ hexdump භාවිතා කිරීමයි:

tail -c1 file | xxd -u -p
tail -c1 file | hexdump -v -e '/1 "%02X"'

එවිට, ඉහත ප්‍රතිදානය සංසන්දනය කිරීමෙන් 0Aශක්තිමත් පරීක්ෂණයක් ලබා දෙනු ඇත.
වෙනත් ආකාරයකින් හිස් ගොනුවකට නව පේළියක් එක් කිරීමෙන් වැළකී සිටීම ප්‍රයෝජනවත් වේ. ඇත්ත වශයෙන්ම
අවසාන චරිතය සැපයීමට අපොහොසත් වන ගොනුව 0A:

f=file
a=$(tail -c1 "$f" | hexdump -v -e '/1 "%02X"')
[ -s "$f" -a "$a" != "0A" ] && echo >> "$f"

කෙටි හා මිහිරි. අන්තිම බයිටය කියවන විට මෙය ඉතා සුළු කාලයක් ගතවේ (EOF වෙත යොමුවන්න). ගොනුව විශාල නම් කමක් නැත. අවශ්‍ය නම් එක් බයිට් එකක් පමණක් එක් කරන්න.

තාවකාලික ලිපිගොනු අවශ්‍ය නොවේ. දෘඩ සබැඳි වලට බලපෑමක් නැත.

මෙම පරීක්ෂණය දෙවරක් ක්රියාත්මක වන්නේ නම්, එය වනු ඇත නොවන තවත් නව පේළියකට යොමු කිරීමේ අක්ෂරය එකතු කරන්න.

ගොනුව අවසන් වරට සංස්කරණය කළ පරිශීලකයාගේ සංස්කාරකය නිවැරදි කිරීම වඩා හොඳය. ගොනුව සංස්කරණය කළ අවසන් පුද්ගලයා ඔබ නම් - ඔබ භාවිතා කරන්නේ කුමන සංස්කාරකයද, මම අනුමාන කරන්නේ පෙළපොත් ..?

සමහර නල මාර්ග සැකසීමේදී ඔබට ඉක්මනින් නව රේඛාවක් එක් කිරීමට අවශ්‍ය නම්, මෙය භාවිතා කරන්න:

outputting_program | { cat ; echo ; }

එය ද POSIX අනුකූල වේ.

ඇත්ත වශයෙන්ම, ඔබට එය ගොනුවකට හරවා යැවිය හැකිය.

ආදානයේ කිසිදු ශුන්‍යතාවයක් නොමැති බව සපයා ඇත:

paste - <>infile >&0

... සෑම විටම නව රේඛාවක් අනන්තයෙහි වලිගය කෙළවරට එකතු කිරීමට පමණක් ප්‍රමාණවත් වේ. එය නිවැරදිව ලබා ගැනීම සඳහා එක් වරක් පමණක් ආදාන ගොනුව කියවිය යුතුය.

එය ප්‍රශ්නයට කෙලින්ම පිළිතුරු නොදුන්නද, නව රේඛාවෙන් අවසන් නොවන ලිපිගොනු සොයා ගැනීමට මා ලියූ අදාළ පිටපතක් මෙන්න. එය ඉතා වේගවත් ය.

find . -type f | # sort |        # sort file names if you like
/usr/bin/perl -lne '
   open FH, "<", $_ or do { print " error: $_"; next };
   $pos = sysseek FH, 0, 2;                     # seek to EOF
   if (!defined $pos)     { print " error: $_"; next }
   if ($pos == 0)         { print " empty: $_"; next }
   $pos = sysseek FH, -1, 1;                    # seek to last char
   if (!defined $pos)     { print " error: $_"; next }
   $cnt = sysread FH, $c, 1;
   if (!$cnt)             { print " error: $_"; next }
   if ($c eq "\n")        { print "   EOL: $_"; next }
   else                   { print "no EOL: $_"; next }
'

පර්ල් ස්ක්‍රිප්ට් එක stdin වෙතින් (විකල්ප වශයෙන් වර්ග කර ඇති) ගොනු නාම ලැයිස්තුවක් කියවන අතර සෑම ගොනුවක් සඳහාම ගොනුව නව රේඛාවකින් අවසන් වේද නැද්ද යන්න තීරණය කිරීම සඳහා අවසාන බයිට් එක කියවයි. එය ඉතා වේගවත් බැවින් එය එක් එක් ගොනුවේ සම්පූර්ණ අන්තර්ගතය කියවීමෙන් වළක්වයි. එය කියවන සෑම ගොනුවක් සඳහාම එක් පේළියක් ප්‍රතිදානය කරයි, යම් දෝෂයක් සිදුවුවහොත් "හිස්:" ගොනුව හිස් නම් (නව රේඛාවෙන් අවසන් නොවේ!), "ඊඕඑල්:" ("අවසානය පේළිය ") ගොනුව නව රේඛාවකින් අවසන් වන්නේ නම් සහ" ඊඕඑල් නැත: "ගොනුව නව රේඛාවකින් අවසන් නොවන්නේ නම්.

සටහන: ස්ක්‍රිප්ටයේ නව රේඛා අඩංගු ගොනු නම් හසුරුවන්නේ නැත. ඔබ GNU හෝ BSD පද්ධතියක සිටී නම්, සොයා ගැනීමට -print0, -z වර්ග කිරීමට සහ -0 perl වෙත එකතු කිරීමෙන් ඔබට හැකි සියලුම ගොනු නම් හැසිරවිය හැකිය:

find . -type f -print0 | sort -z |
/usr/bin/perl -ln0e '
   open FH, "<", $_ or do { print " error: $_"; next };
   $pos = sysseek FH, 0, 2;                     # seek to EOF
   if (!defined $pos)     { print " error: $_"; next }
   if ($pos == 0)         { print " empty: $_"; next }
   $pos = sysseek FH, -1, 1;                    # seek to last char
   if (!defined $pos)     { print " error: $_"; next }
   $cnt = sysread FH, $c, 1;
   if (!$cnt)             { print " error: $_"; next }
   if ($c eq "\n")        { print "   EOL: $_"; next }
   else                   { print "no EOL: $_"; next }
'

ඇත්ත වශයෙන්ම, ඔබට තවමත් නිමැවුම් වල නව රේඛා සමඟ ගොනු නාම කේතනය කිරීමේ ක්‍රමයක් ඉදිරිපත් කළ යුතුව ඇත (පා er කයාට අභ්‍යාසයක් ලෙස ඉතිරිව ඇත).

අවශ්‍ය නම්, එකක් නොමැති ගොනු වලට නව රේඛාවක් එකතු කිරීම සඳහා ප්‍රතිදානය පෙරීම කළ හැකිය

 echo >> "$filename"

අවසාන නව රේඛාවක් නොමැතිකම ස්ක්‍රිප්ට් වල දෝෂ ඇති විය හැකි බැවින් සමහර ගොනුවල අනුවාදයන් සහ වෙනත් උපයෝගිතා එවැනි ගොනුවක් කියවීමේදී නැතිවූ අවසාන නව රේඛාවක් නිසියාකාරව හසුරුවන්නේ නැත.

මගේ අත්දැකීම් අනුව, අවසාන නව රේඛාවක් නොමැතිකම සිදුවන්නේ ලිපිගොනු සංස්කරණය කිරීම සඳහා විවිධ වින්ඩෝස් උපයෝගිතා භාවිතා කිරීමෙනි. ගොනුවක් සංස්කරණය කිරීමේදී අවසාන නව රේඛාවක් අස්ථානගත වී ඇති බව මා දැක නැත, එය එවැනි ලිපිගොනු පිළිබඳ වාර්තා කරනු ඇත.

අවසාන වශයෙන්, නව රේඛාවෙන් අවසන් නොවන ලිපිගොනු මුද්‍රණය කිරීම සඳහා ඒවායේ ගොනු නාම යෙදවුම් හරහා ලූප කළ හැකි කෙටි (නමුත් මන්දගාමී) ස්ක්‍රිප්ට් තිබේ:

/usr/bin/perl -ne 'print "$ARGV\n" if /.\z/' -- FILE1 FILE2 ...

මෙම vi/ vim/ exසංස්කාරකවරුන් ස්වයංක්රීයව එකතු කරන්න <EOL>EOF දී ගොනුව දැනටමත් එය නොමැති නම් මිස,.

එබැවින් උත්සාහ කරන්න:

vi -ecwq foo.txt

එය සමාන වේ:

ex -cwq foo.txt

පරීක්ෂා කිරීම:

$ printf foo > foo.txt && wc foo.txt
0 1 3 foo.txt
$ ex -scwq foo.txt && wc foo.txt
1 1 4 foo.txt

බහුවිධ ලිපිගොනු නිවැරදි කිරීම සඳහා, පරීක්ෂා කරන්න: බොහෝ ගොනු සඳහා 'ගොනුව අවසානයේ නව රේඛාවක් නැත' යන්න නිවැරදි කරන්නේ කෙසේද? SO හි

මෙය එතරම් වැදගත් වන්නේ ඇයි? අපගේ ලිපිගොනු POSIX අනුකූලව තබා ගැනීමට .

වත්මන් නාමාවලියෙහි ඇති සියලුම ලිපිගොනු වලට පිළිගත් පිළිතුර යෙදීම සඳහා (ඊට අමතරව උප බහලුම්):

$ find . -type f -exec sed -i -e '$a\' {} \;

මෙය ලිනක්ස් (උබුන්ටු) මත ක්‍රියා කරයි. OS X හි ඔබට බොහෝ විට භාවිතා කිරීමට සිදුවනු ඇත -i ''(පරීක්ෂා නොකළ).

අවම වශයෙන් GNU අනුවාද වල, එහි ආදානය සරලව grep ''හෝawk 1 කැනොනිකල් කර, දැනටමත් නොමැති නම් අවසාන නව රේඛාවක් එක් කරයි. ඔවුන් ක්‍රියාවලිය තුළ ගොනුව පිටපත් කරයි, එය විශාල නම් කාලය ගත වේ (නමුත් ප්‍රභවය කෙසේ හෝ කියවීමට තරම් විශාල නොවිය යුතුද?) සහ ඔබ වැනි දෙයක් නොකරන්නේ නම් මෝඩමය යාවත්කාලීන කරයි

 mv file old; grep '' <old >file; touch -r old file

.

මෙය AIX ksh හි ක්‍රියාත්මක වේ:

lastchar=`tail -c 1 *filename*`
if [ `echo "$lastchar" | wc -c` -gt "1" ]
then
    echo "/n" >> *filename*
fi

මගේ නඩුවේදී, ගොනුවේ නව රේඛාව අස්ථානගත වී ඇත්නම්, wcවිධානය මඟින් වටිනාකමක් ලබා දෙන 2අතර අපි නව රේඛාවක් ලියන්නෙමු.

පැට්‍රික් ඔස්සිටිගේ පිළිතුරට එකතු කරමින් , ඔබට එය විශේෂිත නාමාවලියකට යෙදවීමට අවශ්‍ය නම්, ඔබට මෙයද භාවිතා කළ හැකිය:

find -type f | while read f; do tail -n1 $f | read -r _ || echo >> $f; done

ඔබ නව රේඛා එක් කිරීමට කැමති නාමාවලිය තුළ මෙය ක්‍රියාත්මක කරන්න.

echo $'' >> <FILE_NAME> ගොනුවේ අවසානයට හිස් පේළියක් එක් කරයි.

echo $'\n\n' >> <FILE_NAME> ගොනුවේ අවසානයට හිස් පේළි 3 ක් එකතු කරයි.

ඔබේ ගොනුව වින්ඩෝස් රේඛා අවසානය සමඟ අවසන් \r\nකර ඔබ ලිනක්ස් හි සිටී නම් ඔබට මෙම sedවිධානය භාවිතා කළ හැකිය . එය \r\nඅවසන් පේළියට එකතු කරන්නේ එය දැනටමත් නොමැති නම් පමණි:

sed -i -e '$s/\([^\r]\)$/\1\r\n/'

පැහැදිලි කිරීම:

-i    replace in place
-e    script to run
$     matches last line of a file
s     substitute
\([^\r]\)$    search the last character in the line which is not a \r
\1\r\n    replace it with itself and add \r\n

අවසාන පේළියේ දැනටමත් a අඩංගු \r\nනම් සෙවුම් regexp නොගැලපේ, එබැවින් කිසිවක් සිදු නොවේ.

ඔබට පිටපතක් ලිවිය හැකිය fix-non-delimited-line:

#! /bin/zsh -
zmodload zsh/system || exit
ret=0
for file do
  if sysopen -rwu0 -- "$file"; then
    if sysseek -w end -1; then
      read -r x || print -u0
    else
      syserror -p "Can't seek in $file before the last byte: "
      ret=1
    fi
  else
    ret=1
  fi
done
exit $ret

මෙහි දී ඇති සමහර විසඳුම් වලට පටහැනිව, එය

• එය කිසිදු ක්‍රියාවලියක් සඳහා නොයෙදෙන, සෑම ගොනුවක් සඳහාම එක් බයිට් එකක් පමණක් කියවන අතර ගොනුව නැවත ලිවීම නොකිරීමට කාර්යක්ෂම විය යුතුය (නව රේඛාවක් එකතු කරයි)
• සිම්ලින්ක් / දෘඩ සබැඳි බිඳ නොදමනු ඇත හෝ පාර-දත්ත වලට බලපාන්නේ නැත (එසේම, ctime / mtime යාවත්කාලීන වන්නේ නව රේඛාවක් එකතු කළ විට පමණි)
• අන්තිම බයිට් NUL හෝ බහු-බයිට් අක්ෂරයක කොටසක් වුවද හරි ක්‍රියා කළ යුතුය.
• ලිපිගොනු නාමවල අඩංගු විය හැකි අක්ෂර හෝ අක්‍ෂර නොසලකා හරි ක්‍රියා කළ යුතුය
• නිවැරදිව කියවිය නොහැකි හෝ ලිවිය නොහැකි හෝ නොපෙනෙන ලිපිගොනු හැසිරවිය යුතුය (සහ ඒ අනුව දෝෂ වාර්තා කරන්න)
• හිස් ලිපිගොනු සඳහා නව රේඛාවක් එක් නොකළ යුතුය (නමුත් එම අවස්ථාවේදී අවලංගු සෙවීමක් පිළිබඳ දෝෂයක් වාර්තා කරයි)

උදාහරණයක් ලෙස ඔබට එය භාවිතා කළ හැකිය:

that-script *.txt

හෝ:

git ls-files -z | xargs -0 that-script

POSIXly, ඔබට සමාන ක්‍රියාකාරී යමක් කළ හැකිය

export LC_ALL=C
ret=0
for file do
  [ -s "$file" ] || continue
  {
    c=$(tail -c 1 | od -An -vtc)
    case $c in
      (*'\n'*) ;;
      (*[![:space:]]*) printf '\n' >&0 || ret=$?;;
      (*) ret=1;; # tail likely failed
    esac
  } 0<> "$file" || ret=$? # record failure to open
done