Regex может использоваться для этой конкретной обработки строк?

Я преобразовал код Python Greg Hewgill в C#, и он работал!

[Test]
public void ReplaceTextInQuotes()
{
  Assert.AreEqual("axbx'cPdPe'fxgh'iPj'k", 
    Regex.Replace("axbx'cxdxe'fxgh'ixj'k",
      @"x(?=[^']*'([^']|'[^']*')*$)", "P"));
}

Тот тест проходится.

Прием должен использовать негруппу фиксации для соответствия части строки после соответствия (символ x), мы ищем. Попытка соответствовать строке до x только найдет или первое или последнее происшествие, завися, используются ли нежадные кванторы. Вот идея Greg, транспонированная к Tcl с комментариями.

set strIn {axbx'cxdxe'fxgh'ixj'k}
set regex {(?x)                     # enable expanded syntax 
                                    # - allows comments, ignores whitespace
            x                       # the actual match
            (?=                     # non-matching group
                [^']*'              # match to end of current quoted substring
                                    ##
                                    ## assuming quotes are in pairs,
                                    ## make sure we actually were 
                                    ## inside a quoted substring
                                    ## by making sure the rest of the string 
                                    ## is what we expect it to be
                                    ##
                (
                    [^']*           # match any non-quoted substring
                    |               # ...or...
                    '[^']*'         # any quoted substring, including the quotes
                )*                  # any number of times
                $                   # until we run out of string :)
            )                       # end of non-matching group
}

#the same regular expression without the comments
set regexCondensed {(?x)x(?=[^']*'([^']|'[^']*')*$)}

set replRegex {P}
set nMatches [regsub -all -- $regex $strIn $replRegex strOut]
puts "$nMatches replacements. "
if {$nMatches > 0} {
    puts "Original: |$strIn|"
    puts "Result:   |$strOut|"
}
exit

Это печатает:

3 replacements. 
Original: |axbx'cxdxe'fxgh'ixj'k|
Result:   |axbx'cPdPe'fxgh'iPj'k|

#!/usr/bin/perl -w

use strict;

# Break up the string.
# The spliting uses quotes
# as the delimiter.
# Put every broken substring
# into the @fields array.

my @fields;
while (<>) {
    @fields = split /'/, $_;
}

# For every substring indexed with an odd
# number, search for x and replace it
# with P.

my $count;
my $end = $#fields;
for ($count=0; $count < $end; $count++) {
    if ($count % 2 == 1) {
        $fields[$count] =~ s/a/P/g;
    }    
}

Разве этот блок не сделал бы задания?

Не с плоскостью regexp. Регулярные выражения не имеют никакой "памяти", таким образом, они не могут различать то, чтобы быть "внутри" или "вне" кавычек.

Вам нужно что-то более мощное, например, использование gema оно было бы просто:

'<repl>'=$0
repl:x=P

Более общее (и более простой) решение, которое позволяет непарные кавычки.

1. Найдите заключенную в кавычки строку

2. Замените 'x' 'P' в строке

   #!/usr/bin/env python
   import re
   
   text = "axbx'cxdxe'fxgh'ixj'k"
   
   s = re.sub("'.*?'", lambda m: re.sub("x", "P", m.group(0)), text)
   
   print s == "axbx'cPdPe'fxgh'iPj'k", s
   # ->   True axbx'cPdPe'fxgh'iPj'k
   

Подобная дискуссия о сбалансированных текстовых заменах: регулярные выражения могут использоваться для соответствия вложенным шаблонам?

Хотя можно попробовать это в Vim, но он работает хорошо, только если строка находится на одной строке, и существует только одна пара.

:%s:\('[^']*\)x\([^']*'\):\1P\2:gci

Если существует еще одна пара или даже несбалансированное', затем она могла перестать работать. Это - способ, которым я включал c иначе подтвердите флаг на ex команда.

То же может быть сделано с sed без взаимодействия - или с awk таким образом, можно добавить некоторое взаимодействие.

Одно возможное решение состоит в том, чтобы повредить строки на парах 's затем можно сделать с решением для энергии.

Pattern:     (?s)\G((?:^[^']*'|(?<=.))(?:'[^']*'|[^'x]+)*+)x
Replacement: \1P

1. \G — Привязка каждое соответствие в конце предыдущего или запуск строки.
2. (?:^[^']*'|(?<=.)) — Если это в начале строки, соответствия до первой кавычки.
3. (?:'[^']*'|[^'x]+)*+ — Соответствуйте любому блоку неупомянутых символов или любого (некавычка) символы до 'x'.

Одна канавка развертки исходная строка, за исключением отдельного символа оглядываются.

Извините, что повредил Ваши надежды, но Вам нужны автоматы с магазинной памятью, чтобы сделать это. Здесь существует больше информации: Автомат с магазинной памятью

Короче говоря, Регулярные выражения, которые являются конечными автоматами, могут только считать и не имеют никакой памяти, в то время как автомат с магазинной памятью имеет возможности управления и стек.

Править: написание...