Rozpoznawanie komentarzy

Witam, chciałbym rozpoznawać komentarze do metod, które są zdefiniowane dla konkretnej metody.
Przykład, taki oto komentarz:

            /// <summary>
            /// Przykładowa metoda, która nic nie robi
            /// </summary>
            /// <param name="a">Pierwszy parametr</param>
            /// <param name="b">Drugi parametr</param>
            /// <param name="c">Trzeci parametr</param>
            /// <returns>prawdę lub fałsz</returns>
            /// <exception cref="NotImplementedException">Zawsze</exception>
            public bool Method(object a, object b, object c)
            {
               throw new NotImplementedException();
            }

Chciałbym rozpoznać taki komentarz w pliku i pobrać wszystkie dostępne dane: opisy parametrów, metody, wyjątków, typy wyjątków, i wszystko co tam użytkownik zdefiniuje.
Myślałem o stworzeniu wyrażenia regularnego, które rozpoznaje taki komentarz. Następnie można wyciąć wartość zapisaną w postaci Xml i wczytać taki plik. Zakładam że postać Xml komentarza jest poprawna.

Algorytm najlepiej jeśli będzie wyglądał tak:

1.Odczytujesz linijkę tekstu
2.Szukasz fragmentu "///" i przechowujesz w stringu zawartość od tego punktu aż do "\n"(znak końca wiersza)
3.Dopisujesz znaleziony fragment do głównego stringa o nazwie np. xmlString
4.Jak widzisz uzyskałeś w ten sposób idealny plik xml, wystarczy użyć jednego z gotowych narzędzi do obsługi tego standardu.

Chwilowo nie mam czasu, więc niestety kod na podstawie algorytmu który ci napisałem musisz zrobić samemu.

Algorytm jest łatwy do implementacji, więc nie potrzebuje gotowca :-P
Ale myślałem bardziej o jakimś wyrażeniu regularnym, które wyłuskiwało by zawartość Xml z komentarza i funkcję do której się odnosi.

To w tym przypadku ci nie pomogę, z wyrażeniami regularnymi mam do dzisiaj problemy, mimo iż już 5 razy próbowałem je zrozumieć.

Mogę spróbować jutro je napisać, ale będzie ciężko. Lookbehind, tryb multiline, dużo zabawy będzie.

Nie wiem czy prościej nie będzie ci znaleźć programu, który już to robi (na pewno jest parę generatorów dokumentacji na podstawie tego, nawet Microsoft jeden dostarcza).

Generowanie dokumentacji jest przecież standardowo w VS, więc autorowi pewno nie o to chodzi.

Po prostu mówię, że tak będzie o wiele prościej jeżeli chodzi o zwykłe sparsowanie tego niż bawienie się w wyrażenia regularne.

Właściwości projektu -> zakładka Build -> na dole checkbox XML documentation file i zostanie nam wygenerowany plik, w którym będziemy mieli bajecznie prosty dostęp do wszystkich komentarzy.

Tak, zgadzam się. Brałem to pod uwagę, ale chciałbym te komentarze wprowadzić do funkcji JavaScriptu oraz innych języków skryptowych.

Co powiecie o takim prostym wyrażeniu regularnym:
(///[\s]*[^\n]*[\s]+)+

imho, (?<=\n)(\s*///[^\n]*\n)+
gdyz

• po /// do konca linii -- po prostu
• dokumentacja .net musi zaczynac sie od nowej linii i ew. bialych znakow, tzn:

alamakota /// blablabal
akot ma /// psa

nie jest prawidlowym metaopisem..

dokladniejsze chwytanie mogloby testowac, czy po (startowym!) */wystepuje otwarcie taga <blah, ale IMHO to juz przesada i nie ta warstwa parsowania -- tutaj to juz sprawa ta, ze tekst komentarza po wycieciu z kodu i usunieciu */ ma byc prawidlowym xml'em

Dzięki za podpowiedź ;-)
Poświęciłem chwilę czasu i stworzyłem wyrażenie regularne, które rozpoznaje komentarze w stylu C# oraz połączoną z nim poprawnie zadeklarowaną funkcję w JavaScript.
Przykładowe dane:

      <script language="javascript" type="text/javascript">
        
       	///    <summary> Wypisuje argumenty w nowej linii </summary>
	/// <param name="a">1 argument</param>
        /// <param name="bbb">2 argument</param>
        /// <param name="_c">3 argument</param>
        	 /// <returns>Cos tam zwraca</returns>

         function WriteLine(  a, bbb, _c) {
            var newLine = "<br></br>";
            document.write( a + " "+ b + " " + c + newLine);
            return newLine;
        }

	///<summary>Sumuje liczby</summary>
        /// <param name="x">1 argument</param>
        /// <param name="y">2 argument</param>
        /// <returns>Suma liczb</returns>
        function add(x , y) {
            return x + y;
        }
	
	///<summary>zmienne</summary>
        /// <param name="i">i</param>
        /// <param name="j">j</param>
	var i = 12, j = 10;

	function message() {
            return Ala ma kota !;
        }
    </script>

Wyrażenie regularne:((///\s*[^\n]*\s+)+)?function\s+([^\W0-9]\w+)\((\s*[^\W0-9]\w*\s*,?)*\)
Kod w C#:

            const string regularExp = @"((///\s*[^\n]*\s+)+)?function\s+([^\W0-9]\w+)\((\s*[^\W0-9]\w*\s*,?)*\)";
            const string fileName = @"test.txt";
            string text = File.ReadAllText(fileName);
            Regex regex = new Regex(regularExp, RegexOptions.Compiled);
            for (Match match = regex.Match(text); match.Success; match = match.NextMatch())
            {
                Console.WriteLine(Regex.Replace(match.Value.Replace("///", String.Empty), @"[\r \t]{2,}", String.Empty));
                Console.WriteLine(Environment.NewLine + "------------" + Environment.NewLine);
            }

Wynik działania:

<summary> Wypisuje argumenty w nowej linii </summary>
<param name="a">1 argument</param>
<param name="bbb">2 argument</param>
<param name="_c">3 argument</param>
<returns>Cos tam zwraca</returns>

function WriteLine(a, bbb, _c)

------------

<summary>Sumuje liczby</summary>
<param name="x">1 argument</param>
<param name="y">2 argument</param>
<returns>Suma liczb</returns>
function add(x , y)

------------

function message()

------------

Jeśli ktoś by miał jakieś uwagi odnośnie wyrażenia regularnego, lub propozycje uproszczenia - proszę pisać ;-)

((///\s*[^\n]*\s+)+)?fun

comm - white? - anyNonBreak? - white! ]] repeat! ]] maybe
wtf?
po co to \s* skoro po tym masz ^\n* ?
po co to \s+ na koniec?
czemu )+)? a nie po prostu )* ?
poza tym, fajnie, ze ^\n+\s+, ale to Ci zlapie takze:
/// blablabla function(){}
i bedzie sadzilo, ze zlapalo wlasciwe function.. brakuje Ci upewnienia sie, ze fragment /// konczy sie znakiem \n

daj po prostu: comm - anyNonBreak? - break ]] repeat?
czyli: (///[^\n]*[\n])*fun

i teraz dalsze...

ction\s+([^{\W0-9]\w+)((\s*[}\W0-9]\w*\s*,?))
wydaje mi sie, ze mozesz smialo nazwe funkcji sparsowac przez [^\s(]+ bo IIR w JS po nazwie funkcji zawsze wystapi ( i ew. white pomiedzy
podobnie parametry - sadze, ze wystarczy ([^)]) bo z tego co widze po kodzie C# nie interesuje Cie chwytanie samych pojedynczych parametrow, tylko calosc traktujesz jako jeden tekst

zreszta.. przeciez Ty wszystko traktuejsz jako tekst do wypisania, to po co sie babrac w niepotrzebne grupowania..
sadze, ze ponizsze zwroci Ci dokladnie ten sam tekst trafienia:

(///[^{\n]*[\n])function\s+[}\s(]+([^)])

Teraz to jest tylko wypisywanie znalezionego tekstu, ale w przyszłości poddam to analizie. Poprawiłem to wyrażenie i wyszło mi coś takiego:(///[^\n]*\n\s*)*function\s+(\w+)\((\s*\w*\s*,?)*\)
Posiada ono 3 grupy:

1. komentarz
2. nazwa funkcji
3. parametry
   Czyli wszystko czego potrzebuję. Teraz będę musiał przeanalizować komentarz i wyciągnąć z niego potrzebne dane.