Gawk зависает при использовании регулярного выражения для RS в сочетании с чтением непрерывного потока со стандартного ввода

Awk ожидает разделения записи. Запись будет разделена, когда произойдут две вещи: есть совпадение с регулярным выражением RS или ввод заканчивается.

Вы его тоже не указали, потому что использовали cat <file> -, что означает, что выходной поток cat продолжается со стандартным вводом (вашим TTY) после того, как <file> исчерпан.

Вы должны использовать Ctrl-D в пустой строке, чтобы сгенерировать необходимое условие EOF, которое ищет Gawk.

Редактировать:

Проблема в том, почему последняя запись не отображается, хотя она ограничена завершающим =?

Такое поведение точно воспроизводится в реализации Awk, которую я написал в виде макроса на языке Lisp, параллельно с GNU Awk.

$ (echo -n 'AAAA=AAAA;AAAA;AAAA='; cat) | gawk 'BEGIN { RS = "=|;"; } { print $0; fflush(); }'
AAAA
AAAA
AAAA
# hangs here until Ctrl-D, then:
AAAA

Точно то же самое:

$ (echo -n 'AAAA=AAAA;AAAA;AAAA='; cat) | txr -e '(awk (:set rs #/=|;/) (t))'
AAAA
AAAA
AAAA
# hangs here until Ctrl-D, then:
AAAA

В случае второй реализации Awk, поскольку я написал все с нуля, включая движок регулярных выражений, я могу объяснить поведение того, что формирует гипотезу о том, почему Gawk такой же.

Чтение с разделителями регулярными выражениями основано на функции read_until_match, написанной на C, которая является оболочкой для помощника scan_until_common. Эта функция работает, подавая символы один за другим из потока в конечный автомат регулярных выражений, проверяя состояние.

Вот в чем дело. Когда конечный автомат регулярных выражений говорит: «У нас есть совпадение!» мы не можем останавливаться на достигнутом. Причина в том, что нам нужно найти самое длинное совпадение.

Функция не знает, что регулярное выражение является тривиальным односимвольным регулярным выражением, для которого первое совпадение уже является самым длинным совпадением. Следовательно, ему необходимо передать еще один символ ввода. В этот момент конечный автомат регулярных выражений сообщает «Ошибка!». Тогда функция узнает, что ранее было успешное совпадение. Он возвращается к этой точке, возвращая лишний символ обратно в поток.

Поэтому, конечно, если в потоке нет следующего доступного символа, мы получим зависание блокировки ввода-вывода.

Причина, по которой это должно работать таким образом, заключается в том, что некоторые регулярные выражения успешно сопоставляют префиксы самого длинного совпадения. Тривиальный пример: предположим, что в качестве разделителя у нас есть #+. Когда виден один #, это совпадение! Но когда появляется еще один #, это тоже совпадение! Нам нужно увидеть все символы #, чтобы получить полное совпадение, а это значит, что мы должны увидеть первый несовпадающий символ, следующий за ним.

GNU Awk не может легко избежать выполнения чего-то очень похожего; теория требует этого.

Способом решения проблемы было бы создание функции maxmatchlen(R), которая для регулярного выражения R сообщает максимальную длину совпадения с регулярным выражением (возможно, бесконечную). maxmatchlen(/.*/) — это Inf, а matchmatchlen(/abc/) — это 3. Вы поняли. С помощью этой функции мы будем знать, что если мы только что ввели символы регулярного выражения matchmatchlen, а конечный автомат регулярного выражения сообщает о соответствующем состоянии, то все готово; нам не нужно смотреть вперед, в поток.

Multiple Line (Руководство пользователя GNU Awk) говорит, что

RS == any single character

Записи разделяются по каждому вхождению символа. Несколько последовательных вхождений ограничивают пустые записи. (...)

RS == regexp

Записи разделяются по вхождению символов, соответствующих регулярному выражению. Пустые записи разделяются ведущими и конечными совпадениями регулярного выражения.(...)

Обратите внимание, что начальный и конечный значения упоминаются только для последнего, поэтому я подозреваю, что источником проблем может быть то, как это реализовано в GNU AWK.

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

cat -u example.txt - | sed -u 'y/;/=/' | gawk '
BEGIN {
    RS = " = ";
}
{
    if ($0 != "") {
        print $0;
        fflush();
    }
}
'

что для example.txt контента

=AAAA=AAAA;AAAA;AAAA=

дает результат

AAAA
AAAA
AAAA
AAAA

и висит. Объяснение: я добавил GNU sed, работающий в небуферизованном режиме (-u) с помощью одной команды y, которая делает

Транслитерировать любые символы в пространстве шаблонов, которые соответствуют любому из исходные символы с соответствующим символом в dest-chars.

При этом ; заменяется использованием =. Затем заменил RS в команде gawk на односимвольную строку =.

(проверено в GNU sed 4.8 и GNU Awk 5.1.0)

Обходной путь, включающий цикл чтения оболочки в конвейер для разделения исходного ввода awk (фактического вывода netcat OP) на отдельные символы, а затем подачи их в awk по одному:

cat example.txt - |
while IFS= read -r -d '' -N1 char; do printf '%s\0' "$char"; done |
awk -v RS='\0' '
    /[;=]/ { if (rec != "") { print rec; fflush() }; rec = ""; next }
    { rec=rec $0 }
'
AAAA
AAAA
AAAA
AAAA

Для этого требуется GNU awk или какой-либо другой, который может обрабатывать символ NUL как RS, поскольку это поведение, отличное от POSIX. Предполагается, что ваш ввод не может содержать NUL-байты, т. е. это действительный текстовый «файл» POSIX.

Если интересно, читайте, как мы туда попали...

Я подумал, что здесь есть как минимум одна ошибка, поскольку обнаружил множество странностей (см. ниже), поэтому открыл отчет об ошибке на странице https://lists.gnu.org/archive/html/bug-gawk/2024-07/ msg00006.html но, по мнению провайдера gawk, Арнольда, различия в поведении в этом случае — это всего лишь детали реализации, требующие предварительного чтения, чтобы убедиться, что регулярное выражение соответствует правильной строке.

Кажется, здесь есть 3 проблемы, например. использование GNU awk 5.3.0 в Cygwin:

1. Различные предположительно эквивалентные регулярные выражения приводят к разному поведению:

$ printf 'A;B;C;\n' > file

$ cat file - | awk -v RS='(;|=)' '{print NR, $0}'
1 A

$ cat file - | awk -v RS=';|=' '{print NR, $0}'
1 A
2 B

$ cat file - | awk -v RS='[;=]' '{print NR, $0}'
1 A
2 B
3 C

(;|=), ;|= и [;=] должны быть эквивалентны, но в данном случае это явно не так.

Хорошей новостью является то, что вы, очевидно, можете обойти эту проблему, используя выражение в скобках, как в третьем случае выше, вместо «или».

2. Выходная запись следует за входной записью, если символ разделителя записей является последним во входных данных, например без новой строки после последней ;:

$ printf 'A;B;C;' > file

$ cat file - | awk -v RS='(;|=)' '{print $0; fflush()}'

$ cat file - | awk -v RS=';|=' '{print $0; fflush()}'
A

$ cat file - | awk -v RS='[;=]' '{print $0; fflush()}'
A
B

Плохая новость заключается в том, что это влияет на пример OP:

$ printf ';AAAA;BBBB;CCCC;DDDD;' > file

С буквенным символом RS:

$ cat file - | awk -v RS=';' '{print $0; fflush()}'

AAAA
BBBB
CCCC
DDDD

С регулярным выражением RS, которое также должно сделать этот символьный литерал:

$ cat file - | awk -v RS='[;]' '{print $0; fflush()}'

AAAA
BBBB
CCCC

$ printf ';AAAA;BBBB;CCCC;DDDD;x' > file

$ cat file - | awk -v RS='[;]' '{print $0; fflush()}'

AAAA
BBBB
CCCC
DDDD

3. Добавление разных символов в выражение в скобках RS приводит к противоречивому поведению (я наткнулся на это случайно):

$ printf 'A;B;C;\n' > file

$ cat file - | awk -v RS='[;|=]' '{print $0; fflush()}'
A

$ cat file - | awk -v RS='[;a=]' '{print $0; fflush()}'
A
B
C

Кстати, я попробовал установить тайм-аут:

$ cat file - | awk -v RS='[;]' 'BEGIN{PROCINFO["-", "READ_TIMEOUT"]=100} {print $0; fflush()}'
A
B
awk: cmd. line:1: (FILENAME=- FNR=3) fatal: error reading input file `-': Connection timed out

$ cat file - | awk -v RS='[;]' -v GAWK_READ_TIMEOUT=1 '{print $0; fflush()}'
A
B

и stdbuf для отключения буферизации:

$ cat file - | stdbuf -i0 -o0 -e0 awk -v RS='[;]' '{print $0; fflush()}'
A
B

и сопоставляем каждый символ (думая, что затем можно использовать RT ~ /[=;]/, чтобы найти разделитель):

$ cat file - | awk -v RS='(.)' '{print RT; fflush()}'
A
;
B
;
C

но ни один из них не позволил мне прочитать последний разделитель записей, поэтому на данный момент я не знаю, что может сделать ОП, чтобы успешно прочитать последнюю запись продолжающегося ввода, используя регулярное выражение, отличное от чего-то вроде этого:

$ printf 'A;B;C;' > file

$ cat file - |
    while IFS= read -r -d '' -N1 char; do printf '%s\0' "$char"; done |
    awk -v RS='\0' '/[;=]/ { print rec; fflush(); rec = ""; next } { rec=rec $0 }'
A
B
C

и использование образца ввода OP, но с разным текстом для каждой записи, чтобы сделать сопоставление входных и выходных записей более понятным:

$ printf '=AAAA=BBBB;CCCC;DDDD=' > example.txt

$ cat example.txt - |
    while IFS= read -r -d '' -N1 char; do printf '%s\0' "$char"; done |
    awk -v RS='\0' '/[;=]/ { print rec; fflush(); rec = ""; next } { rec=rec $0 }'

AAAA
BBBB
CCCC
DDDD

Мы используем символы NUL в качестве разделителей и различные параметры, указанные выше, чтобы сделать цикл чтения оболочки достаточно надежным для обработки пустых строк и других пробелов во входных данных, см. https://unix.stackexchange.com/a/49585/ 133219 и https://unix.stackexchange.com/a/169765/133219 для получения подробной информации по этим вопросам. Мы дополнительно используем NUL-символ для awk RS, чтобы он мог различать символы новой строки, поступающие из исходного ввода, и символ новой строки, добавляемый оболочкой printf, в противном случае rec в сценарии awk никогда не сможет содержать новую строку, поскольку они ВСЕ будет использовано при сопоставлении RS по умолчанию.

Мы используем канал в/из цикла while-read вместо подстановки процесса, просто чтобы внести ясность, поскольку OP уже использует каналы.

Комбинация решений @daweo и @EdMorton:
ОП хочет иметь логику, основанную на распознавании двух разделителей, и, возможно, захочет использовать для этого RT.
Сначала используйте обходной путь Эда для чтения входных данных по одному символу за раз.
Когда = найден, добавьте ; в качестве разделителя.
В awk исправьте RT, если = является частью строки.

РТ распечатаю после печати $0.

cat example.txt - | 
while IFS= read -r -d '' -N1 char; do
  if [[ "$char" == '=' ]]; then
    printf "=;"
  else
    printf '%s' "$char"
  fi
done  | awk '
  BEGIN {
    RS = ";"
  }
  /=/ {
        RT = " = ";
        sub(/=/,"", $0) 
  }
  {
    if ($0 != "") {
        print $0 "(RT = " RT ")";
        fflush();
    }
  }
'

Результат:

AAAA(RT==)
AAAA(RT=;)
AAAA(RT=;)
AAAA(RT==)

Решение, которое не требует изменения сценария awk: поскольку он игнорирует пустые записи, мы можем просто дублировать каждый разделитель записей на этапе конвейера, вставленный перед gawk, например. г.

python -c '
import os
for i in iter(lambda: os.read(0, 1), b""):
    os.write(1, i)
    if i in b"=;": os.write(1, i)
' |

Я вообще не смог повторить это с любым имеющимся у меня вариантом awk:

• Выводы для gawk -c и gawk -P выглядят неуместно по дизайну.
• Ни один из них не вызвал тайм-аут

 for __ in 'mawk1' 'mawk2' 'nawk' 'gawk -e'   'gawk -be' \
           'gawk -ce' 'gawk -Pe'  'gawk -Mbe' 'gawk -nbe'; do

     ( time ( timeout --foreground 10 

       echo '=AAAA;=BBBB;=CCCC;=DDDD;' | $( printf '%s' "$__" ) '

       BEGIN {  RS = "[\n=;]+"
               OFS = "\3"     
           } { 
                print NR, FNR, NR, length(), 
                       "$0 := \""($0)"\"",
                       "$1 := \""($1)"\"", 
                      "$NF := \""($NF)"\"" }' ) | gcat - ) | 

     column -s$'\3' -t

     echo "\f\t$__ done ...\n"
 done 

( timeout --foreground 10 echo '=AAAA;=BBBB;=CCCC;=DDDD;' |  ; ) 
        0.00s user 0.01s system 110% cpu 0.011 total
gcat -  0.00s user 0.00s system 39% cpu 0.010 total
1  1  1  0  $0 := ""      $1 := ""      $NF := ""
2  2  2  4  $0 := "AAAA"  $1 := "AAAA"  $NF := "AAAA"
3  3  3  4  $0 := "BBBB"  $1 := "BBBB"  $NF := "BBBB"
4  4  4  4  $0 := "CCCC"  $1 := "CCCC"  $NF := "CCCC"
5  5  5  4  $0 := "DDDD"  $1 := "DDDD"  $NF := "DDDD"

    mawk1 done ...
 
( timeout --foreground 10 echo '=AAAA;=BBBB;=CCCC;=DDDD;' |  ; ) 
        0.00s user 0.01s system 127% cpu 0.008 total
gcat -  0.00s user 0.00s system  38% cpu 0.007 total

1  1  1  0  $0 := ""      $1 := ""      $NF := ""
2  2  2  4  $0 := "AAAA"  $1 := "AAAA"  $NF := "AAAA"
3  3  3  4  $0 := "BBBB"  $1 := "BBBB"  $NF := "BBBB"
4  4  4  4  $0 := "CCCC"  $1 := "CCCC"  $NF := "CCCC"
5  5  5  4  $0 := "DDDD"  $1 := "DDDD"  $NF := "DDDD"
 
    mawk2 done ...

( timeout --foreground 10 echo '=AAAA;=BBBB;=CCCC;=DDDD;' |  ; )
        0.00s user 0.01s system 112% cpu 0.007 total
gcat -  0.00s user 0.00s system  31% cpu 0.006 total

1  1  1  0  $0 := ""      $1 := ""      $NF := ""
2  2  2  4  $0 := "AAAA"  $1 := "AAAA"  $NF := "AAAA"
3  3  3  4  $0 := "BBBB"  $1 := "BBBB"  $NF := "BBBB"
4  4  4  4  $0 := "CCCC"  $1 := "CCCC"  $NF := "CCCC"
5  5  5  4  $0 := "DDDD"  $1 := "DDDD"  $NF := "DDDD"
     
    nawk done ...

( timeout --foreground 10 echo '=AAAA;=BBBB;=CCCC;=DDDD;' |  ; )
        0.00s user 0.01s system 61% cpu 0.018 total
gcat -  0.00s user 0.00s system 10% cpu 0.017 total

1  1  1  0  $0 := ""      $1 := ""      $NF := ""
2  2  2  4  $0 := "AAAA"  $1 := "AAAA"  $NF := "AAAA"
3  3  3  4  $0 := "BBBB"  $1 := "BBBB"  $NF := "BBBB"
4  4  4  4  $0 := "CCCC"  $1 := "CCCC"  $NF := "CCCC"
5  5  5  4  $0 := "DDDD"  $1 := "DDDD"  $NF := "DDDD"
     
    gawk -e done ...

( timeout --foreground 10 echo '=AAAA;=BBBB;=CCCC;=DDDD;' |  ; )
        0.00s user 0.00s system 106% cpu 0.008 total
gcat -  0.00s user 0.00s system  21% cpu 0.008 total

1  1  1  0  $0 := ""      $1 := ""      $NF := ""
2  2  2  4  $0 := "AAAA"  $1 := "AAAA"  $NF := "AAAA"
3  3  3  4  $0 := "BBBB"  $1 := "BBBB"  $NF := "BBBB"
4  4  4  4  $0 := "CCCC"  $1 := "CCCC"  $NF := "CCCC"
5  5  5  4  $0 := "DDDD"  $1 := "DDDD"  $NF := "DDDD"
     
    gawk -be done ...

( timeout --foreground 10 echo '=AAAA;=BBBB;=CCCC;=DDDD;' |  ; )
        0.00s user 0.00s system 104% cpu 0.008 total
gcat -  0.00s user 0.00s system  19% cpu 0.007 total

1  1                                 1        
                            25  $0 := "=AAAA;=BBBB;=CCCC;=DDDD;"  
                                $1 := "=AAAA;=BBBB;=CCCC;=DDDD;" 
                               $NF := "=AAAA;=BBBB;=CCCC;=DDDD;"
 
    gawk -ce done ...

( timeout --foreground 10 echo '=AAAA;=BBBB;=CCCC;=DDDD;' |  ; )
        0.00s user 0.00s system 108% cpu 0.007 total
gcat -  0.00s user 0.00s system  21% cpu 0.007 total

1  1                                 1        
                            25  $0 := "=AAAA;=BBBB;=CCCC;=DDDD;"  
                                $1 := "=AAAA;=BBBB;=CCCC;=DDDD;" 
                               $NF := "=AAAA;=BBBB;=CCCC;=DDDD;"
    gawk -Pe done ...

( timeout --foreground 10 echo '=AAAA;=BBBB;=CCCC;=DDDD;' |  ; )
        0.00s user 0.00s system 79% cpu 0.011 total
gcat -  0.00s user 0.00s system 13% cpu 0.010 total

1  1  1  0  $0 := ""      $1 := ""      $NF := ""
2  2  2  4  $0 := "AAAA"  $1 := "AAAA"  $NF := "AAAA"
3  3  3  4  $0 := "BBBB"  $1 := "BBBB"  $NF := "BBBB"
4  4  4  4  $0 := "CCCC"  $1 := "CCCC"  $NF := "CCCC"
5  5  5  4  $0 := "DDDD"  $1 := "DDDD"  $NF := "DDDD"
 
    gawk -Mbe done ...    
 
( timeout --foreground 10 echo '=AAAA;=BBBB;=CCCC;=DDDD;' |  ; )
        0.00s user 0.00s system 108% cpu 0.007 total
gcat -  0.00s user 0.00s system  23% cpu 0.007 total

1  1  1  0  $0 := ""      $1 := ""      $NF := ""
2  2  2  4  $0 := "AAAA"  $1 := "AAAA"  $NF := "AAAA"
3  3  3  4  $0 := "BBBB"  $1 := "BBBB"  $NF := "BBBB"
4  4  4  4  $0 := "CCCC"  $1 := "CCCC"  $NF := "CCCC"
5  5  5  4  $0 := "DDDD"  $1 := "DDDD"  $NF := "DDDD"
     
    gawk -nbe done ...

Один из провайдеров gawk, Энди Шорр, по какой-то причине не смог создать учетную запись Stackoverflow, поэтому попросил меня опубликовать для него его предложение (см. https://lists.gnu.org/archive/html/bug-gawk). /2024-07/msg00012.html для первоисточника):

От Энди:

Рассматривали ли вы попытку использовать расширение select и его неблокирующая функция?

Кажется, что-то вроде этого работает:

(echo "A;B;C;D;"; cat -) | gawk -v 'RS=[;=]' -lselect -ltime '
BEGIN {
   fd = input_fd("")
   set_non_blocking(fd)
   PROCINFO[FILENAME, "RETRY"] = 1
   while (1) {
      delete readfds
      readfds[fd] = ""
      select(readfds, writefds, exceptfds)
      while ((rc = getline x) > 0) {
         if (rc > 0)
            printf "%d [%s]\n", ++n, x
         else if (rc != 2) {
            print "Error: non-retry error"
            exit 1
         }
      }
   }
}'