C program to get variable name as input and print value

Question

I have a program test.c

int global_var=10;
printf(\"Done\");

i did

gcc -g test.c -o test

My query is I

Answer 1

No. We only have variable names so humans don't get confused . After your program gets turned into assembly and eventually machine code, the computer doesn't care what you name your variables.

Alternatively you could use a structure in which you would store the value and the name as a string:

struct tag_name {
   char *member1;
   int member2;
};

Answer 2

No, C doesn't have introspection. Once the compiler has generated code, the program can not look up variable names.

The way these things are usually solved is by having a collection of all special variables that needs to be looked up by name, containing both the actual name as a string and the variable it self.

Usually it's an array of structures, something like

struct
{
    const char *name;
    int value;
} variables[] = {
    { "global_var", 10 }
};

The program can then look through the array variables to search for "global_var" and use (or change) the value in the structure.

Answer 3

In general, it is not possible to access at runtime global variables by name. Sometimes, it might depend upon the operating system, and how the compiler is invoked. I still assume you want to dereference a global variable, and you know its type.

Then on Linux and some other systems, you could use dlopen(3) with a NULL path (to get a handle for the executable), then use dlsym on the global variable name to get its address; you can then cast that void* pointer to a pointer of the appropriate type and dereference it. Notice that you need to know the type (or at least have a convention to encode the type of the variable in its name; C++ is doing that with name mangling). If you compiled and linked with debug information (i.e. with gcc -g) the type information is in its DWARF sections of your ELF executable, so there is some way to get it.

This works if you link your executable using -rdynamic and with -ldl

Another possibility might be to customize your recent GCC with your own MELT extension which would remember and later re-use some of the compiler internal representations (i.e. the GCC Tree-s related to global variables). Use MELT register_finish_decl_first function to register a handler on declarations. But this will require some work (in coding your MELT extension).

---

using preprocessor tricks

You could use (portable) preprocessor tricks to achieve your goals (accessing variable by name at runtime).

The simplest way might be to define and follow your own conventions. For example you could have your own globvar.def header file containing just lines like

 /* file globvar.def */
 MY_GLOBAL_VARIABLE(globalint,int)
 MY_GLOBAL_VARIABLE(globalint2,int)
 MY_GLOBAL_VARIABLE(globalstr,char*)
 #undef MY_GLOBAL_VARIABLE

And you adopt the convention that all global variables are in the above globvar.def file. Then you would #include "globvar.def" several times. For instance, in your global header, expand MY_GLOBAL_VARIABLE to some extern declaration:

 /* in yourheader.h */
 #define MY_GLOBAL_VARIABLE(Nam,Typ) extern Typ Nam;
 #include "globvar.def"

In your main.c you'll need a similar trick to declare your globals.

Elsewhere you might define a function to get integer variables by name:

 /* return the address of  global int variable or else NULL */
 int* global_int_var_by_name (const char*name) {
    #define MY_GLOBAL_VARIABLE(Nam,Typ) \
      if (!strcmp(#Typ,"int") && !strcmp(name,#Nam)) return (int*)&Nam;
    #include "globvar.def"
      return NULL;
 }

etc etc... I'm using stringification of macro arguments.

Such preprocessor tricks are purely standard C and would work with any C99 compliant compiler.

Answer 4

General answer: No. There is no connection between a variable name and its string representation (you can get the string representation of a variable name at compile time with the preprocessor, though).

For identifiers with external linkage, there are (platform-dependent) ways: See e.g. dlsym for POSIX systems.

You can compile with debugging information and access (most) variables by names from input. Unless you really write something like a debugger, this would be a horrible design, however (and even then, you don’t access the variables used in the debugger itself but of the programme being debugged).

Finally, you could implement your own lookup table mapping from string representations to values.