Adding Log Statements To Beginning and Ending of All Functions By Shell

Question

I have a project which has more than 1000 source c++ files storing in different folders under the same directory. I want to add log code to the beginning and ending of all functions defined in these .cpp files. See the example below:

    //SomeSrcFile.cpp      
    //Sample  
    ReturnType SomeClass::SomeFunc1(InputParameters)        
    {
         ......
    }

    ReturnType SomeClass::SomeFunc2(InputParameters) {
         ......
    }

output

    ReturnType SomeClass::SomeFunc1(InputParameters)     
    {
         char FuncName[] = "SomeClass::SomeFunc1()";      //line added 
         printf("%s begins\n", FuncName);      //line added 

         ......

         printf("%s ends\n", FuncName);        //line added 
    } 

    ReturnType SomeClass::SomeFunc2(InputParameters) {
         char FuncName[] = "SomeClass::SomeFunc2()";      //line added 
         printf("%s begins\n", FuncName);      //line added 

         ......

         printf("%s ends\n", FuncName);        //line added
    }      

How to write the shell script for this kind of work? Can awk be used here?

UPDATE

1. I think it is possible to do it by AWK like This Post does. But I haven't figured out how to do it in my way.

2. I only want to use either Bash or Python for doing this, because they are only tools I am familiar with now.

UPDATE 2
Perhaps this work is really hard that beyond my expectation. But what if I don't care about the accuracy? What if I don't care the cases that Functions are included in comments and the like? Isn't there a simple way to do this?

Answer 1

refer the post you paste, here is the code:

awk 'BEGIN{X=FS}
    { if ($0~/void/ && $0 ~/\(/) split($0,a,FS);split(a[2],b,"(")
      FS="";OFS="";
         for (i=1; i<=NF; i++)
             if ($i == "{") {
                 if (++d == "1") $i=sprintf("{\n\tchar FuncName[] = \"%s()\";\n\tprintf(\"%%s begins\\n\", FuncName);\n",b[1]);
             } else {if ($i == "}") {
                 if (d-- == "1") $i=sprintf("\n\tprintf(\"%%s end\\n\", FuncName);\n\t} ",b[1]);
               }
             } 
       FS=X;OFS=X
     }1' infile.cpp

Notes:

Keyword is void, if the function defined with other keywords you can adjust from

$0~/void/

to

$0~/(void/int/string)/

Answer 2

If you don't mind it not being robust, this will do what you want for simple consistent cases using GNU awk for the 3rd arg to match() and abbreviations for character classes (e.g. \w):

$ cat tst.awk
BEGIN {
    beg = "\tchar FuncName[] = \"%s()\";\n\tprintf(\"%%s begins\\n\", FuncName);\n"
    end = "\n\tprintf(\"%%s ends\\n\", FuncName);"
}
match($0,/^\s*\w+\s+(\w+::\w+)[(][^)]*[)]/,arr) { funcName  = arr[1] }
/{/ && (++braceCnt == 1) { $0 = $0 ORS sprintf(beg,funcName) }
/}/ && (--braceCnt == 0) { $0 = sprintf(end,funcName) ORS $0 }
{ print }

.

$ awk -f tst.awk file
    //SomeSrcFile.cpp
    //Sample
    ReturnType SomeClass::SomeFunc1(InputParameters)
    {
        char FuncName[] = "SomeClass::SomeFunc1()";
        printf("%s begins\n", FuncName);

         ......

        printf("%s ends\n", FuncName);
    }

    ReturnType SomeClass::SomeFunc2(InputParameters) {
        char FuncName[] = "SomeClass::SomeFunc2()";
        printf("%s begins\n", FuncName);

         ......

        printf("%s ends\n", FuncName);
    }

With other awks just use [[:space:]] instead of \s and [[:alnum:]_] instead of \w in the regexp and use a combination of match() with substr() and/or sub()s to extract the function name from the string that matches the regexp, e.g.:

$ cat tst2.awk
BEGIN {
    beg = "\tchar FuncName[] = \"%s()\";\n\tprintf(\"%%s begins\\n\", FuncName);\n"
    end = "\n\tprintf(\"%%s ends\\n\", FuncName);"
}
/^[[:space:]]*[[:alnum:]_]+[[:space:]]+([[:alnum:]_]+::[[:alnum:]_]+)[(][^)]*[)]/ {
    funcName = $0
    gsub(/^[[:space:]]*[[:alnum:]_]+[[:space:]]+|[(][^)]*[)].*/,"",funcName)
}
/{/ && (++braceCnt == 1) { $0 = $0 ORS sprintf(beg,funcName) }
/}/ && (--braceCnt == 0) { $0 = sprintf(end,funcName) ORS $0 }
{ print }

Answer 3

I suggest a little different approach within your C++.

This will only simplify your shell script needs slightly, but will result in much better C++ code.

In short, I suggest creating a Trace class and a set of macros to deploy it. This has a lot of advantages:

• Easy to add, remove, change, printouts.
• Automatically takes care of filename, function name, line number, and much more.
• Works no matter where the function exits (this is a big improvement over your approach)

Create a Trace class which accepts arguments such as function name, file name, line #, etc. - whatever you want to be able to print out. Whenever a Trace class is constructed it will print a function entry message. Whenever a Trace class goes out of scope and is destructed it will print a function exit message.

So here's the class declaration:

// File: Trace.h

class Trace                                                                                                                  
{
public:
   // print function entry message
   Trace(const char *name,                                                                                                   
         const char *file,                                                                                                   
         const int line, 
         int traceOn = -1, // used for enabling/disabling Trace printing 
                           // within a particular call chain.
         const void* thisPtr = 0);                                                                                           

   // print function exit message
   ~Trace();                                                                                                                 

   static bool active;                                                                                                       

private:
   std::string* theFunctionName;                                                                                             
   std::string* theFileName;
   int          theLineNumber;                                                                                               
   const void*  theThisPtr;                                                                                                  
   static int   layer; // used for printout indenting
   static std::list<clock_t> startTimeList; // used for printing timing information                                                                                 
   bool         previouslyActive;                                                                                            
};

Now let's look at the corresponding macros (these also go in Trace.h):

#ifdef TRACE_ENABLED // define the real macros
#undef TRACE_ENABLED // must be re #defined preceding each '#include "Trace.h" '    
#define TRACE__     Trace tr_( __FUNCTION__ , __FILE__ , __LINE__, -1, this );                                             
#define TRACE_OFF__ Trace tr_off_(__FUNCTION__ , __FILE__ , __LINE__, false);                                              
#define TRACE_ON__  Trace tr_on_(  __FUNCTION__ , __FILE__ , __LINE__, true);                                              

#else // DUMMY MACROS: if TRACE_ENABLED is not defined.                                                                      

#define TRACE__
#define TRACE_ON__
#define TRACE_OFF__                                                                                                        

#endif        

Now, to use the Trace class, you would do the following:

//SomeSrcFile.cpp      
//Sample  

#define TRACE_ENABLED // comment this out to disable tracing in this file.
#include "Trace.h"

ReturnType SomeClass::SomeFunc1(InputParameters)        
{
     TRACE__
     ......
}

ReturnType SomeClass::SomeFunc2(InputParameters) {
     TRACE__
     ......
}

Now, a potential implementation of the Trace class: // File: Trace.C

#include "Trace.h"

bool Trace::active = true;
int  Trace::layer = 0;
std::list<clock_t> Trace::startTimeList;

Trace::Trace(const char *name, 
             const char *file, 
             const int line, 
             int traceOn,  // default: -1
             const void* thisPtr) // default:  0 
: theFunctionName(0),
  theFileName(0),
  theLineNumber(0),
  theThisPtr(thisPtr),
  previouslyActive(active)
{
   if (active)
   {
      theFunctionName = new std::string(name);
      theFileName     = new std::string(file);
      theLineNumber   = line;

      std::cout<<"---> Trace: ";
      for( int L = 0; L < layer; ++L )
      {
         std::cout<<"   ";
      }
      std::cout
         <<"{ Entered "
         << *theFileName << ":" 
         << theLineNumber << " " 
         << *theFunctionName << "()";

      if(thisPtr > 0)
      {
         std::cout<<"  this = "<< thisPtr;
      }
      std::cout<< std::endl;

      layer++;
      startTimeList.push_back(clock());
   }

   if(traceOn >= 0)
   {
      active = traceOn;
      if (active && !previouslyActive)
      {
         std::cout<<"+++] Trace: Enabled"<<std::endl;
      }
      else if (previouslyActive && !active)
      {
         std::cout<<"+++[ Trace: Disabled"<<std::endl;
      }
   }
}

Trace::~Trace()
{
   if (previouslyActive && !active)
   {
      std::cout<<"+++] Trace: Enabled"<<std::endl;
   }
   else if (active && !previouslyActive)
   {
      std::cout<<"+++[ Trace: Disabled"<<std::endl;
   }

   active = previouslyActive;

   if (active || theFunctionName)
   {
      layer--;
      double startTime = static_cast<double>(startTimeList.back());
      startTimeList.pop_back();
      double endTime = static_cast<double>(clock());
      double elapsedTime = (endTime-startTime)/CLOCKS_PER_SEC;

      std::cout<<"<--- Trace: ";
      for( int L = 0; L < layer; ++L )
      {
         std::cout<<"   ";
      }

      std::cout<<"} Leaving "
               << *theFileName << ":" 
               << theLineNumber <<" "
               << *theFunctionName <<"()";
      if(theThisPtr > 0)
      {
         std::cout<<"  this = "<< theThisPtr;
      }

      std::cout<<"  elapsedTime = "<<elapsedTime<<"s";
      std::cout<< std::endl;

      delete theFunctionName;
      delete theFileName;
   }
}