Разобрать карту вывода C с помощью регулярных выражений

Question

В настоящее время я пытаюсь проанализировать файл C Output.map с помощью регулярных выражений.Я рассматриваю каждую строку отдельно: одна строка может выглядеть следующим образом

__func_name     |00010d88|   T  |              FUNC|00000010|     |.text

Ожидаемый результат:
1) "__func_name"
2) "00010d88"
3) "T"
4) "FUNC"
5) "00000010"
6) (пустая строка)
7) ".text"
8) (пустая строка)

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

__func_name2|0007bb7c|   T  |              FUNC|00000034|     |.text    sourcefile.c:49

1) "__func_name2" 2) "0007bb7c" 3) "T"4)" FUNC "5)" 00000034 "6) (пустая строка)

7)" .text "

8)" sourcefile.c: 49 "

Как вы можете видеть, меняется не только количество пробелов, но есть и исходный файл.Теперь я попытался решить эту проблему с помощью регулярного выражения.Мне в основном нужны следующие требования для моего регулярного выражения

1. Буквенно-цифровая строка

2. A (шестнадцатеричное) Число

3. Одна буква

4. Строка

5. A (шестнадцатеричное) число

6. Необязательнострока

7. Другая необязательная строка

Каждая группа отделяется символом |.Я попробовал это регулярное выражение.Хотя неполный, regexr говорит мне, что я сопоставляю только первую группу.

Не могли бы вы помочь мне выяснить, что не так с моим регулярным выражением?

([__A-Za-z0-9])\w+|((([\|]{1})&[0-9a-h]&([\|]{1})))\w+|([A-Z])\w+

Вы можете попробовать живую демонстрациюздесь: https://regexr.com/4gpvf

Редактировать: добавлены ожидаемые результаты

Answer 1

Довольно простой шаблон совпадения может быть таким:

@"\s*(\S*)\s*\|\s*([a-f0-9]+)\s*\|\s*(\S)\s*\|\s*(\S*)\s*\|\s*([a-f0-9]+)\s*\|\s*(\S*)\s*\|\s*(\S*)\s*(\S*).*"

Выполнено так:

  string[] data = 
  {
    "__func_name   | 00010d88 | T | FUNC | 00000010 |     |.text",
    "__func_name2 | 0007bb7c | T | FUNC | 00000034 |     |.text    sourcefile.c:49"
  };

  var matchess = data.Select(s => Regex.Matches(s, @"\s*(\S*)\s*\|\s*([a-f0-9]+)\s*\|\s*(\S)\s*\|\s*(\S*)\s*\|\s*([a-f0-9]+)\s*\|\s*(\S*)\s*\|\s*(\S*)\s*(\S*).*", RegexOptions.IgnoreCase));

  foreach (MatchCollection matches in matchess)
  {
    foreach (Match match in matches)
    {
      foreach (Group group in match.Groups)
      {
        Console.WriteLine(group.Value);
      }
    }
  }

Answer 2

static void Main()
{
    var x = @"__func_name2|0007bb7c|   T  |              FUNC|00000034|     |.text    sourcefile.c:49";
    var matches = Regex.Split(x, @"\s*\|\s*");
    int len = matches.Length;
    int i = 0;
    for (int z = 0; z < len; ++z)
    {
        ++i;
        if (z == len - 1)
        {
            var match = Regex.Match(matches[z], @"^(?i)(?'text'\.[a-z]+)(\s+(?'file'[a-z]+\.[a-z]+:[0-9]+))?$");
            WriteLine($"{++i}) {match.Groups["text"].Value}");
            WriteLine($"{++i}) {(match.Groups["file"].Length == 0 ? "" : match.Groups["file"].Value)}");
        }
        else
        {
            WriteLine($"{z+1}) {matches[z]}");
        }
    }
}

/* Output:
    1) __func_name2
    2) 0007bb7c
    3) T
    4) FUNC
    5) 00000034
    6)
    8) .text
    9) sourcefile.c:49
*/

Answer 3

Регулярные выражения кажутся ненужными, но если никакой опции не существует, это выражение:

(__[^\|\s]+)\s*\|([^\|\s]+)\s*\|\s*([A-Z]+)\s*\|\s*([A-Z]+)\s*\|([^\|\s]+)\s*\|\s*\|([^\|\s]+)\s*(?:([^:]+)?\s*:\s*?([0-9]+))?

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

(?:([^:]+)?\s*:\s*?([0-9]+))?

Демо

Пример

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string pattern = @"(__[^\|\s]+)\s*\|([^\|\s]+)\s*\|\s*([A-Z]+)\s*\|\s*([A-Z]+)\s*\|([^\|\s]+)\s*\|\s*\|([^\|\s]+)\s*(?:([^:]+)?\s*:\s*?([0-9]+))?";
        string input = @"__func_name2|0007bb7c|   T  |              FUNC|00000034|     |.text    sourcefile.c:49

__func_name     |00010d88|   T  |              FUNC|00000010|     |.text";
        RegexOptions options = RegexOptions.Multiline;

        foreach (Match m in Regex.Matches(input, pattern, options))
        {
            Console.WriteLine("'{0}' found at index {1}.", m.Value, m.Index);
        }
    }
}