Фильтр регулярных выражений для сообщений STL

Question

Учитывая следующую ошибку STL:

./poly_power/poly_class.cpp:496: error: no matching function for call to ‘state_operator< polynomial< variable_term< polynomial< variable_term< std::basic_string<char, std::char_traits< char>, std::allocator< char> >, int> >, polynomial< variable_term<std::basic_string< char, std::char_traits< char>, std::allocator<char> >, int> > > >, polynomial<variable_term< polynomial< variable_term< std::basic_string< char, std::char_traits< char>, std::allocator< char> >, int> >, polynomial< variable_term< std::basic_string< char, std::char_traits< char>, std::allocator< char> >, int> > > > >::operation( std::pair< const std::basic_string< char, std::char_traits< char>, std::allocator< char> >, state_vector_term< polynomial< variable_term< polynomial< variable_term< std::basic_string< char, std::char_traits< char>, std::allocator< char> >, int> >, polynomial< variable_term< std::basic_string< char, std::char_traits< char>, std::allocator< char> >, int> > > >, polynomial< variable_term< polynomial< variable_term< std::basic_string< char, std::char_traits< char>, std::allocator< char> >, int> >, polynomial< variable_term< std::basic_string< char, std::char_traits< char>, std::allocator< char> >, int> > > > > >&)’

как я могу использовать выражение reg-ex, чтобы упростить его до чего-то похожего:

./poly_power/poly_class.cpp:496: error: no matching function for call to ‘state_operator<...>::operation( std::pair<...>&)’

т.е.Преобразуйте все в пределах внешней пары <> в ....Я знаю о STLFilt, Perl-скрипте, который делает что-то похожее, но я думаю, что было бы педагогически увидеть, как это можно сделать в чистом регулярном выражении.* Paraitimze выражение, чтобы оно работало на n-м уровне <>.1-й уровень будет примером выше, в то время как 2-й уровень будет отображать что-то вроде state_operator<polynomial<...>, polynomial<...> >.

Answer 1

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

Редактировать:

Я немного поэкспериментировал, и, ну, это возможно (при условии, что угловые скобки больше не встречаются встрока, чтобы они были сбалансированы (одна закрывающая скобка для каждой открывающей), и что вы можете определить верхний предел для вложенности):

Соответствие <...> (без вложенности):

<[^<>]*+>

Совпадение <...<...>...<...>...> (один уровень вложенности):

<[^<>]*+(?:<[^<>]*+>[^<>]*+)*+[^<>]*+>

Сопоставление с двумя уровнями вложенности:

<[^<>]*+(?:<[^<>]*+(?:<[^<>]*+>[^<>]*+)*+>[^<>]*+)*+[^<>]*+>

До трех уровней:

<[^<>]*+(?:<[^<>]*+(?:<[^<>]*+(?:<[^<>]*+>[^<>]*+)*+>[^<>]*+)*+>[^<>]*+)*+[^<>]*+>

До четырех уровней:

<[^<>]*+(?:<[^<>]*+(?:<[^<>]*+(?:<[^<>]*+(?:<[^<>]*+>[^<>]*+)*+>[^<>]*+)*+>[^<>]*+)*+>[^<>]*+)*+[^<>]*+>

До пяти уровней:

<[^<>]*+(?:<[^<>]*+(?:<[^<>]*+(?:<[^<>]*+(?:<[^<>]*+(?:<[^<>]*+>[^<>]*+)*+>[^<>]*+)*+>[^<>]*+)*+>[^<>]*+)*+>[^<>]*+)*+[^<>]*+>

и т. Д.

Чтобы получить бонусное очко, вотпоследний разбит на подробное регулярное выражение, так что вы можете немного проще понять, как оно построено:

<             # Match the first opening <
[^<>]*+       # Match any non-<>-characters possessively
  (?:         # Match the following zero or more times:
  <             # Match a <
  [^<>]*+       # etc. etc. etc.
    (?:
    <
    [^<>]*+
      (?:
      <
      [^<>]*+
        (?:
        <
        [^<>]*+
          (?:          # innermost level:
          <            # Match a <
          [^<>]*+      # Match any non-<> characters
          >            # Match a >
          [^<>]*+      # Match any non-<> characters
          )*+          # any number of times, possessively
        >            # then back one level: Match a >
        [^<>]*+      # etc. etc. etc.
        )*+
      >
      [^<>]*+
      )*+
    >
    [^<>]*+
    )*+
  >
  [^<>]*+
  )*+
[^<>]*+
>               # Match the final closing >

Разве это не ужасно ужасно?

Для вашего примера, кажется, вынужно семь уровней вложенности.Если вам нужен быстрый конструктор регулярных выражений, он может выглядеть так (в Python):

def innerregex(nesting):
    if nesting == 0:
        return ""
    else:
        return "(?:<[^<>]*+" + innerregex(nesting-1) + ">[^<>]*+)*+"

def makeregex(nesting):
    return "<[^<>]*+" + innerregex(nesting) + ">"

makeregex(2) вернет регулярное выражение, которое может правильно соответствовать <<<><>>>.makeregex(7) должно работать со всей строкой, makeregex(6) будет принимать только самые внутренние совпадения и т. Д.