C/C++: Alle Funktionen auflisten

[Kaj G. (Firma: RUB) (bloody)]

Hallo Forum,

für dokumentarische Zwecke (arbeit) suche ich nach einer Möglichkeit, 
alle Funktionen einer C/C++ Datei (also die dort implementierten) 
automatisiert (Python) aufzulisten. Mit nm bekomme ich aus den 
Objektdateien fast alle Funktionen, aber static/inline Funktionen 
fehlen, logischer Weise. Diese sollen aber mit aufgelistet werden. Die 
Funktionen stehen im Map-File, aber das Map-File zu parsen ist nicht 
unerheblicher Aufwand.
Habt ihr vielleicht eine Idee?

Grüße

[Μαtthias W. (matthias)]

Doxygen oder clangd

[N. M. (mani)]

Μαtthias W. schrieb:
> Doxygen

Hätte ich auch als erstes versucht.
XML Output und dann sollte das relativ leicht parsbar sein in Python.

Ansonsten scheint es auch Header Parser zu geben:
https://cppheaderparser.readthedocs.io/en/stable/api.html

[db8fs (Gast)]

Kaj G. schrieb:
> für dokumentarische Zwecke (arbeit) suche ich nach einer Möglichkeit,
> alle Funktionen einer C/C++ Datei (also die dort implementierten)
> automatisiert (Python) aufzulisten. Mit nm bekomme ich aus den
> Objektdateien fast alle Funktionen, aber static/inline Funktionen
> fehlen, logischer Weise.

static-Symbole sollte bei nm aber mit drin sein. Wenns inline unbedingt 
bedürfen soll (wofür auch immer), musste halt entweder den Code parsen 
(für C99 gibts nen pycparser oder so), oder eben über 
Mapfiles/Debug-Symboldaten gehen (pdb).

> Diese sollen aber mit aufgelistet werden. Die
> Funktionen stehen im Map-File, aber das Map-File zu parsen ist nicht
> unerheblicher Aufwand.

Ich würds erstmal per Shell versuchen zu parsen (grep/sed), wenn's zu 
kompliziert wird für Python, merkt mer das dann recht schnell.

Persönlich würd ich empfehlen, die inlines zu knicken und darauf zu 
verzichten - lohnt imho den Aufwand nicht ggü. der nm-basierten Lösung.

[Alexander S. (alesi)]

Kaj G. schrieb:
> für dokumentarische Zwecke (arbeit) suche ich nach einer Möglichkeit,
> alle Funktionen einer C/C++ Datei (also die dort implementierten)
> automatisiert (Python) aufzulisten.

Dazu fallen mir die ctags von vim ein. Siehe z.B. 
https://kulkarniamit.github.io/whatwhyhow/howto/use-vim-ctags.html
oder http://ctags.sourceforge.net/whatis.html oder 
https://linux.die.net/man/1/ctags
Die tag Datei sollte die Infos enthalten, ich habe aber gerade kein 
Beispiel zur Hand.

[Klummel (Gast)]

Beachte: durch Preprozessor Mechanismen können Funktionen 
aktiviert/deaktiviert werden. Daher statt grep Tools eher Tools nutzen 
die Preprozessor Befehle verstehen, z. B. Doxygen...

[Chris (Gast)]

Cproto funktioniert, ist aber c , kein  Python

[Marcus H. (mharnisch)]

Alexander S. schrieb:
> Dazu fallen mir die ctags von vim ein. Siehe z.B.
> https://kulkarniamit.github.io/whatwhyhow/howto/use-vim-ctags.html
> oder http://ctags.sourceforge.net/whatis.html oder
> https://linux.die.net/man/1/ctags
> Die tag Datei sollte die Infos enthalten, ich habe aber gerade kein
> Beispiel zur Hand.

Besser: Universal Ctags (https://github.com/universal-ctags/ctags)
Das wird auch aktuell gehalten. Einfache Kommandzeile (ggf anpassen):

find . -name \*.cc | xargs ctags --kinds-c++=f

Das Ergebnis steht in der Datei tags.

[grundschüler (Gast)]

Kaj G. schrieb:
> alle Funktionen einer C/C++ Datei (also die dort implementierten)
> automatisiert (Python) aufzulisten.

in meiner ide habe ich das so gelöst:

    private void sub_functiond_find(string searchtext1, string searchtext2, Color col)
    {
      searchtext1 = "{";
      searchtext2 = "}";
      string text = TextArea.Text;
      listBox2.Items.Clear();
      // text = text.Replace("){", ")\n{");


      //text = text.Replace(") {", ")\n{");






      // text = text.Replace("\n\n{", ")\n{");
      // text = text.Replace("\n\n{", ")\n{");
      StringBuilder sb = new StringBuilder();
      string[] splitStrings = { "\r\n", "\r", "\n" };
      string[] lines = text.Split(splitStrings, StringSplitOptions.None);
      int lineCounter = 0, stufe = 0, stufe_alt=8;
      string line_alt = "", funktion="";
      foreach (string s in lines)
      {

        if (s.IndexOf("{") > -1 && s.IndexOf("}") == -1)
        {
          if (s.IndexOf("//") > s.IndexOf("{") || s.IndexOf("//") == -1)
          {
            stufe++;//start funktion
          }

        }

        if (s.IndexOf("}") > -1 && s.IndexOf("{") == -1)
        {
          if (s.IndexOf("//") > s.IndexOf("}") || s.IndexOf("//") == -1)
          {
            stufe--;//start funktion
          }
        }




        if(stufe==1 && stufe_alt == 0)
                {
          for (int i = 0; i < 5; i++) 
          {
            if (lines[lineCounter-i].IndexOf(')') > -1)
            { 
            funktion = lines[lineCounter - i].Substring(0, lines[lineCounter - i].IndexOf(')') + 1);
              listBox2.Items.Add((lineCounter - i+1).ToString()+"_"+ funktion);
              break;
            }

          }


        }
        stufe_alt = stufe;
        //line_alt = s;





        sb.Append("/*" + lineCounter.ToString().PadLeft(4, '_') + "_" + stufe.ToString() + "_*/");
        sb.Append("\t");
        sb.Append(s);
        sb.Append(Environment.NewLine);
        lineCounter++;
      }
}

Es werden jeweils die Ebenen geschweifter Klammern festgestellt. Auf der 
untersten Ebene stehen geschweifte Klammern vor Funktionen. Die werden 
dann festgestellt und aufgelistet. Kompliziert - aber funktioniert.