Question

I came across a question regarding writing a code to determine unused functions in C++. We can use different data structures to determine unused functions. But before that, we need to parse the code. I have question related to parsing part, how we can differentiate functions declaration and definition and function-calls?

Like,

 //function declaration without argument
 fun1 ();

 //function definition
 fun1 () {
   // code goes here
  }

 main () {
   fun1 ();
  }

Above declaration and call is looks same where as definition part is little bit different from declaration and call.

Other than above scenario, there are multiple scenario for calling a function and functions scope, like two classes having function with same name one function get called within member function (i.e. no explicit calling object required) OR function call using object so, need to understand object’s type first to determine which function is actually called.

How can parsing implemented efficiently? How many parsing will required in above scenario?

Answer 1

This is how you can distinguish them:

//function definition
return_type fun1 (args) {
  // code goes here
}

Note that function definition has a “return type” before the function name.

Also, note that a function declaration looks exactly the same as its definition. You don’t actually need to distinguish them until you see either ; or {. That is the point in which you make the decision whether its a declaration or definition. In your particular application, you don’t really care about it because you don’t care what the function actually does.

Unfortunately for you, C++ is complicated. To determine which functions are useless, you actually need at least a basic semantic analysis. This includes at least the type system.

What is worse, is that some function may not necessarily be called directly, but through a virtual function. So your static analysis of the code shows only the parent’s function getting called, while in reality it’s the child’s.