Question

I have a legacy C Linux application that I need to reuse . This application uses a lot of global variables. I want to reuse this application’s main method and invoke that in a loop. I have found that when I call the main method( renamed to callableMain) in a loop , the application behavior is not consistent as the values of global variables set in previous iteration impact the program flow in the new iteration.

What I would like to do is to reset all the global variables to the default value before the execution of the the new iteration.

for example , the original program is like this

OriginalMain.C

#include <stdio.h>

int global = 3; /* This is the global variable. */

void doSomething(){     
         global++; /* Reference to global variable in a function. */    
}    

     // i want to rename this main method to callableMain() and
     // invoke  it in a loop 
     int main(void){    
       if(global==3) {    
       printf(" All  Is Well \n");    

       doSomething() ;  
     }
     else{

       printf(" Noooo\n");  

       doNothing() ;

     }
     return 0;
}

I want to change this program as follows:

I changed the above file to rename the main() to callableMain()

And my new main methods is as follows:

int main(){  

     for(int i=0;i<20;i++){  

         callableMain();

         // this is where I need to reset the value of global vaiables
        // otherwise the execution flow  changes
     }    
}   

Is this possible to reset all the global variables to the values before main() was invoked ?

The short answer is that there is no magical api call that would reset global variables. The global variables would have to be cached and reused.

Answer 1

I think you must change the way you see the problem.

Declare all the variables used by callableMain() inside callableMain()’s body, so they are not global anymore and are destroyed after the function is executed and created once again with the default values when you call callableMain() on the next iteration.

EDIT:

Ok, here’s what you could do if you have the source code for callableMain(): in the beginning of the function, add a check to verify if its the first time the function its being called. Inside this check you will copy the values of all global variables used to another set of static variables (name them as you like). Then, on the function’s body replace all occurences of the global variables by the static variables you created.

This way you will preserve the initial values of all the global variables and use them on every iteration of callableMain(). Does it makes sense to you?

void callableMain()
{
  static bool first_iter = true;

  if (first_iter)
  {  
    first_iter = false;
    static int my_global_var1 = global_var1;
    static float my_global_var2 = global_var2;
    ..
  }

  // perform operations on my_global_var1 and my_global_var2, 
  // which store the default values of the original global variables.

}