If you know there is something that is not a "Word" character, immediately following the machine name, you can use:

    m/\Q$machine\E\W/
[download]

Hi NetWallah,
Using \W worked perfectly fine. But I could not get the difference between \b and \W even though I was able to partially resolve the issue using \b. Using \b only worked for common strings in a machine name but not for machine names with special characters.

From http://perldoc.perl.org/perlre.html#Regular-Expressions :

\b Match a word boundary

A word boundary (\b ) is a spot between two characters that has a \w on one side of it and a \W on the other side of it (in either order), counting the imaginary characters off the beginning and end of the string as matching a \W .

So, the "\b" will match "xxyy" if the following character is NOT [a-zA-Z0-9].

However, if the terminating character in the match is NOT a "word" character, as in your case - the terminating character is ")", then the "\b" expects the NEXT character to be a "word".

Hope this makes sense. If not, please experiment.

            “PHP is a minor evil perpetrated and created by incompetent amateurs, whereas Perl is a great and insidious evil perpetrated by skilled but perverted professionals.”
        ― Jon Ribbens

I'm probably misunderstanding what you want, I'm rather new at this, but why not this?

That way it gets anything between '(' and ')\'

Hm, I cannot reproduce the issue:

#!/usr/bin/perl -w
use strict;

while (<DATA>) {
    chomp;
    push @::Lines, $_;
}

for my $machine (qw(machine1 machine11 machine12
                    machine2 machine20 machine23 machine30)) {
    for my $line (sort @::Lines) {
        if ($line =~ m/\Q$machine\E\b/){
            print "$machine : $line\n";
        
        }
    }
}

__DATA__
\\hostname\Cpu(123:machine1)\%Ready
\\hostname\Cpu(3545:machine11)\%Used
\\hostname\Memory(3244:machine30 (ef0a-14f09a-dfe230d-ea5f8d))\Swapped
+ MBytes
[download]

Output (as expected):

machine1 : \\hostname\Cpu(123:machine1)\%Ready
machine11 : \\hostname\Cpu(3545:machine11)\%Used
machine30 : \\hostname\Memory(3244:machine30 (ef0a-14f09a-dfe230d-ea5f
+8d))\Swapped MBytes
[download]

Update: sorry, misread your post... (quotes with "machine30 (ef0a-14f09a-dfe230d-ea5f8d)" would've made it clearer — which only goes to show that a piece of runnable code is often better than prose).

(?(?<=\w)(?!\w)|(?=\w)) # \b equivalent
[download]

The corresponding definition for \B is:

(?(?<=\w)(?=\w)|(?!\w)) # \B equivalent
[download]

If, like most compassionate human beings, you prefer your regexes written for legibility and maintainability, you would write those in /x mode:

# \b equivalent:
(?(?<=      \w)     # if there is a word character left
      (?!   \w)     #    then there must be no word character right
  |   (?=   \w)     #    else there must be a  word character right
)

# \B equivalent:
(?(?<=      \w)     # if there is a word character left
      (?=   \w)     #    then there must be a  word character right
  |   (?!   \w)     #    else there must be no word character right
)
[download]

Please note how both \b and \B alike are defined solely in terms of \w characters. There is absolutely no mention of \W in either of those definitions, let alone of ^ or $. This catches many people by surprise.

Now that you know exactly how word boundaries and nonboundaries work, you can craft your own boundaries by swapping in your own condition for wherever you see \w in the patterns above. You just need to be careful to specify a fixed-width condition so that it can be used in a lookbehind. That means you can’t use things like \X or \R, which are variable-width. The easiest way to do that is to use a property or other character class. For example, you could use \p{Greek} for characters in the Greek script—but best add Inherited so you don’t miss the combining characters, so use [\p{Greek}\p{Inherited}] instead.

Perhaps the most common custom boundary that people want to craft is the one that they thought that \b was doing all all along — but which as has just been demonstrated, is not.

That is, they want a custom boundary that asserts that they are touching either whitespace or the edge of the string, in whichever direction makes sense there.

# space boundary
(?(?<=      \S)     # if there is a nonspace character left
      (?!   \S)     #    then there must be no space character right
  |   (?=   \S)     #    else there must be a  space character right
)
[download]

To show how that version operates, consider this:

Whether that’s quite what you’re looking for, I cannot say. But you should have enough in your armament now to craft whatever sort of boundary you might desire.

Most of the preceding text is excerpted from the section on “Building Custom Boundaries” beginning on page 308 of the just-released 4^th Edition to Programming Perl.

Enjoy.