#!/usr/bin/perl
use strict;
use warnings;

my $test_string = "foo l?est sé?jou ? foo ";
$test_string =~ s/(?<!\s)\?(?!\s)/'/sig;
print "$test_string\n";
[download]

The expression will fail when the character before ((?<!...)) the question mark is white space and when the character after ((?!...)) the question mark is white space. This will substitute if there is a leading or trailing question mark. These are zero-width assertions, so you don't have to worry about capturing. See perlre for details.

Perfect, works a charm. Will have to read up on that page - looks like it has a lot of cool features in that I wasn't aware of :)

Thanks again

Andy

Seems like you got some good answers but this is an XY problem. You are not fixing the real issue which seems to be your site is clobbering ’s and probably anything outside Latin-1. You should fix that. Monkeying around with data in a lossy way ends up causing more pain than it saves.

moo@cow[789]~>perl -MEncode -le 'print encode_utf8(chr(8217) . " or \x
+{2019}")'
’ or ’
[download]

    s/(\s\?|\?\s)|\?/$1 || "'"/eg;  # Look ma, no look behind/ahead
[download]

    1 while s/(\S)\?(\S)/$1'$2/;
[download]

I haven't checked, but look-around assertions have certainly been around for many years, perhaps more than a decade. Can they really still be considered to be 'advanced'?

Also, the  (?<!\?) and  (?!\?) assertions seem to me to perfectly express the notions 'not preceded by...' and 'not followed by...', respectively. Are they not preferable to the somewhat convoluted logic of your example code? (Admitedly, this may be largely a matter of taste.)

I haven't checked, but look-around assertions have certainly been around for many years, perhaps more than a decade. Can they really still be considered to be 'advanced'?

How long a construct has been part of a language doesn't determine whether it's advanced or not. They are described in the section:

   Extended Patterns
       Perl also defines a consistent extension syntax for features not found
       in standard tools like awk and lex.  The syntax is a pair of
       parentheses with a question mark as the first thing within the
       parentheses.  The character after the question mark indicates the
       extension.

       The stability of these extensions varies widely.  Some have been part
       of the core language for many years.  Others are experimental and may
       change without warning or be completely removed.  Check the
       documentation on an individual feature to verify its current status.

       A question mark was chosen for this and for the minimal-matching
       construct because 1) question marks are rare in older regular
       expressions, and 2) whenever you see one, you should stop and
       "question" exactly what is going on.  That’s psychology...

I can very well imagine that some people call this an advanced structure.

Also, the (?<!\?) and (?!\?) assertions seem to me to perfectly express the notions 'not preceded by...' and 'not followed by...', respectively.

That's fine. And if the OP is fine with that, he'll use it. If he doesn't like it (or anyone else who stumbles upon this thread), I've offered him an alternative.

There's more than one way to skin a cat.

I'm still learning the more advanced regex stuff

Please see My Favourite Regex Tools