Получение текста от последнего маркера до EOF в POSIX.2

У меня есть текст с маркерными линиями, такими как:

aaa
---
bbb
---
ccc

Мне нужно получить текст от последнего маркера (не включительно) до EOF. В этом случае это будет

ccc

Есть ли элегантный способ в POSIX.2? Прямо сейчас я использую два прогона: первый с nlи grepдля последнего вхождения с соответствующим номером строки. Затем я извлекаю номер строки и использую sedдля извлечения рассматриваемого фрагмента.

Сегменты текста могут быть довольно большими, поэтому я боюсь использовать какой-либо метод добавления текста, например, мы добавляем текст в буфер, если мы сталкиваемся с маркером, мы очищаем буфер, чтобы в EOF у нас был последний фрагмент в буфера.

Если ваши сегменты не очень большие (как, например: вы действительно не можете сэкономить столько ОЗУ, предположительно потому, что это крошечная встроенная система, управляющая большой файловой системой), один подход - действительно лучший подход. Не только потому, что это будет быстрее, но и самое главное, потому что это позволяет источнику быть потоком, из которого любые данные, считанные и не сохраненные, будут потеряны. Это действительно работа для awk, хотя sed тоже может это сделать.

sed -n -e 's/^---$//' -e 't a' \
       -e 'H' -e '$g' -e '$s/^\n//' -e '$p' -e 'b' \
       -e ':a' -e 'h'              # you are not expected to understand this
awk '{if (/^---$/) {chunk=""}      # separator ==> start new chunk
      else {chunk=chunk $0 RS}}    # append line to chunk
     END {printf "%s", chunk}'     # print last chunk (without adding a newline)

Если вы должны использовать двухпроходный подход, определите смещение строки последнего разделителя и напечатайте из него. Или определите смещение байта и распечатайте с него.

</input/file tail -n +$((1 + $(</input/file         # print the last N lines, where N=…
                               grep -n -e '---' |   # list separator line numbers
                               tail -n 1 |          # take the last one
                               cut -d ':' -f 1) ))  # retain only line number
</input/file tail -n +$(</input/file awk '/^---$/ {n=NR+1} END {print n}')
</input/file tail -c +$(</input/file LC_CTYPE=C awk '
    {pos+=length($0 RS)}        # pos contains the current byte offset in the file
    /^---$/ {last=pos}          # last contains the byte offset after the last separator
    END {print last+1}          # print characters from last (+1 because tail counts from 1)
')

Приложение: Если у вас больше POSIX, вот простая однопроходная версия, основанная на общем расширении awk, которое позволяет разделителю записей RSбыть регулярным выражением (POSIX допускает только один символ). Это не совсем правильно: если файл заканчивается разделителем записей, он печатает фрагмент перед разделителем последней записи вместо пустой записи. Вторая версия использует RTэтот недостаток, но RTона специфична для GNU awk.

awk -vRS='(^|\n)---+($|\n)' 'END{printf $0}'
gawk -vRS='(^|\n)---+($|\n)' 'END{if (RT == "") printf $0}'

Стратегия с двумя проходами кажется правильной. Вместо sed я бы использовал awk(1). Два прохода могут выглядеть так:

$ LINE=`awk '/^---$/{n=NR}END{print n}' file`

чтобы получить номер строки. И затем отобразите весь текст, начиная с этого номера строки:

$ awk "NR>$LINE" file

Это не должно требовать чрезмерной буферизации.

lnum=$(($(sed -n '/^---$/=' file | sed '$!d') +1)); sed -n "${lnum},$ p" file 

Первый sedвыводит номера строк строк "---" ...
Второй sedизвлекает последний номер из выходных данных первого sed ...
Добавьте 1 к этому числу, чтобы получить начало вашего блока "ccc" ...
Третий 'sed' выводит из начала блока "ccc" в EOF

Обновление (с исправленной информацией о методах Жиля)

Что ж, меня интересовало, как будут работать Гленн Джекман tac , поэтому я проверил время на три ответа (на момент написания) ... Каждый тестовый файл (-ы) содержал 1 миллион строк (их собственных номеров строк).
Все ответы сделали то, что ожидалось ...

Вот времена ..

Жиль sed (один проход)

# real    0m0.470s
# user    0m0.448s
# sys     0m0.020s

Жиль awk (один проход)

# very slow, but my data had a very large data block which awk needed to cache.

Жиль «два прохода» (первый метод)

# real    0m0.048s
# user    0m0.052s
# sys     0m0.008s

Жиль "два прохода" (второй метод) ... очень быстро

# real    0m0.204s
# user    0m0.196s
# sys     0m0.008s

Жиль «два прохода» (третий метод)

# real    0m0.774s
# user    0m0.688s
# sys     0m0.012s

Жиль "gawk" (метод RT) ... очень быстрый , но не POSIX.

# real    0m0.221s
# user    0m0.200s
# sys     0m0.020s

Гленн Джекман ... очень быстро , но не POSIX.

# real    0m0.022s
# user    0m0.000s
# sys     0m0.036s

fred.bear

# real    0m0.464s
# user    0m0.432s
# sys     0m0.052s

Маки Мессер

# real    0m0.856s
# user    0m0.832s
# sys     0m0.028s

Используйте « tac », который выводит строки файла от конца к началу:

tac afile | awk '/---/ {exit} {print}' | tac

Вы могли бы просто использовать ed

ed -s infile <<\IN
.t.
1,?===?d
$d
,p
q
IN

Как это работает: tдублирует .строку current ( ) - которая всегда является последней строкой, когда edначинается (только в случае, если в последней строке присутствует разделитель), 1,?===?dудаляет все строки до и включая предыдущее совпадение ( edвсе еще находится на последней строке ) затем $dудаляет (дублирует) последнюю строку, ,pпечатает текстовый буфер (замените на, wчтобы отредактировать файл на месте) и, наконец, qзавершает работу ed.

Если вы знаете, что на входе есть хотя бы один разделитель (и вам все равно, напечатан ли он), тогда

sed 'H;/===/h;$!d;x' infile

будет короче.
Как это работает: он добавляет все строки в Hстарый буфер, перезаписывает hстарый буфер при обнаружении совпадения, он dвыбирает все строки, кроме $последней, когда он xизменяет буферы (и автопечать).