Замените блоки текста регулярным выражением perl на условное

Детали обработки явно сложны; давайте сначала разберемся, как обрабатывать блоки.

Один из способов — идти построчно и накапливать строки для блока, пока не дойдете до пустой строки. Затем вы обрабатываете свой блок, очищаете буфер и продолжаете работу. Например

use warnings;
use strict;
use feature 'say';

sub process_block {
    say "Block:"; say "\t$_" for @{$_[0]};
}

my $file = shift // die "Usage: $0 filename\n";  #/

open my $fh, '<', $file or die "Can't open $file: $!";

my @block;
while (<$fh>) {
    chomp;
    if (not /\S/) {
        if (@block) {                # the first empty line
            process_block(\@block);
            @block = (); 
        }
        next;
    }   

    push @block, $_; 
}
process_block(\@block) if @block;    # last block may have remained

Вызов process_block после цикла while не срабатывает для показанного примера, поскольку перед концом файла есть пустые строки, поэтому последний блок обрабатывается внутри цикла. Но нам нужно сделать так, чтобы последний блок обрабатывался и тогда, когда в конце нет пустых строк.

Внутри process_block теперь вы можете проверить, содержит ли @blockmrb@#Name, применить другие (очевидно сложные) условия, запустить регулярное выражение и вывести обработанные строки.

Вот пример после пояснений, но без некоторых деталей

use List::Util qw(any);  # used to be in List::MoreUtils

sub process_block {
    my @block = @{ $_[0] };  # local copy, to not change @block in caller

    if ($block[0] =~ /^txt\@/ and any { /^mrb\@/ } @block) {
        for (@block) {
            s{^txt\@#(\S*)\s+(.*)}
             {\\ex[exno=\\spkr{$1}, exnoformat=X] \\begingl \\glpreamble $2 // }g;  #/
            s{^mrb\@#\S*\s+(.*)}{\\gla $1 // }g;
            # etc
        }   
        if ($block[-1] =~ /^\s*SD/) {
            my $SD_line = pop @block;
            push @block, '\endgl', $SD_line, '\xe';
        }
        else {
            push @block, '\endgl', '\xe';
        }
    }
    else {
        for (@block) {
            s/^txt\@#(\S*)\s+(.*)/\\ex[exno=\\spkr{$1}, exnoformat=X] \\txt $2 /g; 
            s/^tli\@#\S*\s+(.*)/\\translit $1 /g;
            # etc
        }
        push @block, '\xe';
    }
    say for @block;
    say "\n";        # two lines to separate blocks
}

Заметка об эффективности.

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

Это может (или не может) быть проблемой со многими регулярными выражениями или длинными блоками или если это делается часто, и его можно оптимизировать, если он медленный. Поскольку список подстановок всегда один и тот же, мы можем построить хэш с регулярным выражением, включающим отличительное начало шаблона (как диспетчерская таблица). Например

my %repl_non_mrb = ( 
    'txt@' => sub { s/^txt\@#(\S*)\s+(.*)/\\ex[exno=\\spkr{$1}, exnoformat=X] \\txt $2 /g }
    'tli@' => sub { s/^tli\@#\S*\s+(.*)/\\translit $1 /g },
    ...
);
my %repl_mrb = ( ... );

а затем использовать его в соответствии с

# For blocks without 'mrb@'
for (@block) {
    # Capture key: up to # for 'txt@' (etc), up to \s for 'SD'. Other cases?
    my ($key) = /^(.*?)(?:#|\s)/; 
    if ($key and exists $repl_non_mrb{$key}) {
        $repl_non_mrb{$key}->();                  # run the coderef
    }
    else { say "No processing key (?) for: $_" }  # some error?
}

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

Другой способ - это то, о чем вы спрашиваете

I know perl can do block by block

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

open my $fh, '<', $file or die "Can't open $file: $!";

PROCESS_FILE: { 
    local $/ = "\n\n";
    while (my $block = <$fh>) { 
        chomp $block;
        say "|$block|"; 
    }
};

Я поместил это в блок (названный PROCESS_FILE просто так), чтобы мы могли изменить $/ с помощью местный. Затем его прежнее значение восстанавливается по мере выхода из блока и файлы снова читаются нормально.

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