G'day harangzsolt33,

"Is it possible to "break up" a regex so that it spans multiple lines?"

The /x and /xx modifiers exist for this purpose. See "perlre: Modifiers: /x and /xx". There are quite a few gotchas associated with these.

I personally find the /x modifier to be very helpful, particularly with respect to improved readability, and use it often (except for the simplest regexes). On the other hand, I'm not convinced that /xx offers equivalent enhancements; making changes can, on occasion, be tricky. Of course, those are my preferences; they're not recommendations, make your own choices.

When using either /x or /xx, you need to be mindful of whitespace and hash characters. Here's a non-exhaustive demonstation of some of the similarities and differences:

$ perl -E '
    my $x = qq{ A B\tC # comment};

    say q{Original string: |}, $x, q{|};

    say q{s/\s//g:         |}, $x =~ s/\s//gr, q{|};
    say q{s/\s//gx:        |}, $x =~ s/\s//grx, q{|};
    say q{s/\s//gxx:       |}, $x =~ s/\s//grxx, q{|};

    say q{s/ //g:          |}, $x =~ s/ //gr, q{|};
    say q{s/ //gx:         |}, $x =~ s/ //grx, q{|};
    say q{s/ //gxx:        |}, $x =~ s/ //grxx, q{|};

    say q{s/[ ]//g:        |}, $x =~ s/[ ]//gr, q{|};
    say q{s/[ ]//gx:       |}, $x =~ s/[ ]//grx, q{|};
    #say q{s/[ ]//gxx:      |}, $x =~ s/[ ]//grxx, q{|};
    say q{s/[\ ]//gxx:     |}, $x =~ s/[\ ]//grxx, q{|};

    say q{s/#//g:          |}, $x =~ s/#//gr, q{|};
    say q{s/#//gx:         |}, $x =~ s/#//grx, q{|};
    say q{s/#//gxx:        |}, $x =~ s/#//grxx, q{|};

    say q{s/[ #]//g:       |}, $x =~ s/[ #]//gr, q{|};
    say q{s/[ #]//gx:      |}, $x =~ s/[ #]//grx, q{|};
    say q{s/[ #]//gxx:     |}, $x =~ s/[ #]//grxx, q{|};
'
Original string: | A B  C # comment|
s/\s//g:         |ABC#comment|
s/\s//gx:        |ABC#comment|
s/\s//gxx:       |ABC#comment|
s/ //g:          |AB    C#comment|
s/ //gx:         | A B  C # comment|
s/ //gxx:        | A B  C # comment|
s/[ ]//g:        |AB    C#comment|
s/[ ]//gx:       |AB    C#comment|
s/[\ ]//gxx:     |AB    C#comment|
s/#//g:          | A B  C  comment|
s/#//gx:         | A B  C # comment|
s/#//gxx:        | A B  C # comment|
s/[ #]//g:       |AB    Ccomment|
s/[ #]//gx:      |AB    Ccomment|
s/[ #]//gxx:     | A B  C  comment|
[download]

If I uncomment line 16 (s/[ ]//gxx), I get a single line of output:

Unmatched [ in regex; marked by <-- HERE in m/[ <-- HERE  ]/ at -e lin
+e 16.
[download]

Line 17, with s/[\ ]//gxx, fixes this. It also demonstrates one of the traps for the unwary.

As well as adding modifiers to the end of m// and s///, you can also embed them in "Extended Patterns". I find this is handy when used with qr//:

my $re = qr{(?x:
    ... multiline regex pattern here ...
)};
[download]

Examples of usage crop up here fairly often. A couple of my most recent offerings: "a fairly simple example"; "a more involved, and fully commented, example". And, from many years ago, "a very long and complex example, using qr{...}msx".

Wow, thank you. That was really helpful! I also looked at your example. I use TinyPerl 5.8 because it is very small, and I don't do a lot with it. Lately I have been playing around with graphics, and I wrote a very long Perl script, which I would like to cut up into smaller pieces (maybe). For this purpose, I want to write a script that analyzes my script and creates a list of dependencies that shows which function depends on which other function. This is why I wanted to know if a multiline regex can exist.

Rather than reimplementing something to try and (most likely, poorly and/or incompletely) parse Perl let it do it for you with B::Xref.

The cake is a lie.
The cake is a lie.
The cake is a lie.

Yes. See the x modifier in perlre.