Replace blocks of text with perl regex with conditional

The processing details are apparently complex; let's first clear up how to process blocks.

One way is to go line-by-line and accumulate lines for a block, until you get to an empty line. Then you process your block and clear the buffer, and keep going. For example

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

The process_block call after the while loop doesn't fire for the shown sample, since there are empty lines before the end of the file so the last block gets processed inside the loop. But we need to ensure that the last block is processed when there are no empty lines at the end as well.

Inside process_block you can now check whether @block contains mrb@#Name, apply other (apparently complex) conditions, run regex, and print processed lines.

Here is an example, following clarifications but still leaving out some details

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
}

A note on efficiency.

This code processes each line in a block against all regex substitutions, to find the one that applies to it. The distinguishing pattern comes right at the beginning so "wrong" lines fail right away but we still run the regex engine for all checks for each line.

This may (or may not) be a problem with many regex or long blocks or if done often, and it can be optimized if it is slow. Since the list of substitutions is always the same we can build a hash with regex keyed by the distinguishing start of the pattern (as a dispatch table). For example

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 = ( ... );

and then use it along the lines of

# 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?
}

This clearly needs more (careful) work, while there are also other ways to organize those regex. But an implementation of these (fixed) regex substitutions hashed by their distinguishing patterns will surely improve on the O(NM) complexity of always running all regex on each line.

Another way is what you inquire about

I know perl can do block by block

what can be done by setting the $/ variable. It sets what is then used as the separator between input records. If you set it to \n\n here you get a block served for each read, in a string

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

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

I put this inside a block (named PROCESS_FILE just so) so that we can change $/ by using local. Then its previous value is restored as the block is exited and files are again read normally.

However, I don't see a benefit of doing this here since you now have a block in a scalar variable, while what you need to do seems to be line oriented. So I'd recommend the first approach.