<H1>(<[A-Za-z0-9]+>)
[download]

I think not. Remove the < and >, and add an H1 closing tag to clarify, ie:

<H1>([A-Za-z0-9]+)</H1>
[download]

Or if you don't mind it picking up underscores as well as letters and numbers, you can use the much more succint:

<H1>(\w+)</H1>
[download]

You may want to also add modifiers to your regex, ie:

    if ( m!$catreg!is ) {
[download]

                    <h1>I am a heading
                    created by Dreamweaver</h1>
[download]

<rant>
(not that Dreamweaver users ever seem to use <Hn> when <p><b><font size=6> will do instead :)
</rant>

cLive ;-)

Update: I missed that you were matching a possible tag before the match you use (see below). I strongly suggest you look at a parsing module if you don't know whether tags will contain tags or not!

The regex also appears to be attempting to skip any tags immediately following the opening H1 tag, and not requiring a closing H1 tag (is a closing tag required for H1?).

$catreg = "^(<[A-Za-z0-9]+>)*<H1>(<[A-Za-z0-9]+>)*([A-Za-z0-9]+)";
[download]

This places the characters on the right hand side of the equals sign and between the " into a variable called $catreg.

if ( m!$catreg! ) {
[download]

This line is a conditional test. IF the bit between the ( ) is true then the block following the condition will be evaluated - this block goes from { to }.

To simplify m!foo! is a regular expresion that will match any string that contains the letters 'foo' in that order.

In your case we have m!$catreg! When perl sees the $catreg it looks to see what the variable catreg contains and uses this content in the regular expression. Thus you are looking for a match like this:

m!^(<[A-Za-z0-9]+>)*<H1>(<[A-Za-z0-9]+>)*([A-Za-z0-9]+)!
[download]

Note we are matching against the unspecified default value for regex matches which is stored in the magical $_ variable. In english this reads as follows:

              # the lack of a $var =~ here indicates
              # that we are matching against $_
m             # this is a match regex
!             # we define the extent of the regex using a !
^             # starting at the begining of the string
(             # grouping and capturing opening bracket
<             # matches this charachter '<'
[A-Za-z0-9]+  # match any number of alphanumerics in a row
>             # match a literal '>'
)             # closing bracket
              # the match between brackets captures to $1
*             # accept 0 or more of the preceeding stuff
              # but note only first match captured into $1
              # within the brackets
<H1>          # match a literal '<H1>'

(<[A-Za-z0-9]+>)* # same as first but captures into $2
                  # the first '<alphanumeric>' sequence
([A-Za-z0-9]+)    # matches sequential alphanumerics and
                  # captures all into $3
!                 # end of regex
[download]

I'm afraid that this regex does not do anything like what you think it does. It's results are complex, I suggest you try this sample code. Play with the value of $_ to see what I mean.

$catreg = "^(<[A-Za-z0-9]+>)*<H1>(<[A-Za-z0-9]+>)*([A-Za-z0-9]+)";

$_="<a><b><H1><c><d>foo";

if ( m!$catreg! ) {
    print "Matched \$1:$1 \$2$2 \$3$3\n";
} else {
    print "No Match\n";
}
[download]

If you want to capture the text between <H1> and </H1>,regardless of whether they are <h1> and </h1> then this will work.

$_='<h1>foo</h1>blah<H1>bar</H1>more blah';

while (m!<h1>(.*?)</h1>!ig) {
    print "Found $1\n";
}
[download]

tachyon

What is does is exactly what you say it does: parse a line for the text within an <H1> tag, and frequently screw up. :-)

Slightly more precisely (though not precisely precisely), it matches a line that contains any text, an <H1> tag, possibly another HTML tag, and another arbitrary string of alphanumerics, and the does something with that last string. The circumstances under which it will fail are, alas, too numerous to go into here <wry>--I recommend looking into HTML::TokeParser if you have that option.

If you want a slightly more lucid explanation of the regular expression, you might want to try OGRE, which I believe is written by a fellow monk.

I think what you meant to refer to was YAPE::Regex::Explain, a CPAN module for explaining regular expressions, by japhy.

Matches beggining, then '<', then the char class. Mabey you should change that to \w+ or [^<\/]+. Then the '>'. Now it matches that any amount of times, storing the opening tag right before '<H1>' in $1. If you don't use that tag, I would advise you take out the capturing parens and put in (?: ... ). Alright, let's move on ...

Next, it matches '<H1>' (and not '<h1>'). In the next set of parens, I think you need to take out the '<' and '>'. Also, you should match the '</h1>' tag as well. Then, it matches the next A-Za-z0-9 char. If you take out the '<' and '>' in that parens ($2 doesn't match unless you do) then there will be no A-Za-z0-9 chars left (the prev parens gobbled them up), so $3 would get the last char in between the header tag (due to backtracking).

You are checking $3 to see what's in between the header tags, and that confused me at first, but you aren't capturing anything in $2 because of those '<' and '>' chars.

Well, that was by no means a complete look at the regex, but it should have given you an idea about how errorprone parsing html is, I would look up on one of the modules like Parse::HTML to parse the html.

The 15 year old, freshman programmer,
Stephen Rawls

stephen