Assigning a variant string to a function pointer issue?

Question

Hello,
This is a little complex for me to describe, so I will try my best to explain !
I don't know if this is doable in C?
Basically, I need a function pointer to hold the name of a function coming form a character array!
From the examples I have seen, it seems that what I am trying to do is not the conventional way of doing function pointers, but I don't see any other way of doing what I need to do.
In one instance, the function pointer in my code, will require to be assigned a function name like this:
_g_BlkFuncs_ =_BUF_FUNC_PTR_ParseBlockStatus;
and at other instances, the same function pointer needs to be assigned to a function called:
_g_BlkFuncs_ =_INV_FUNC_PTR_ParseBlockStatus;
and at other instances:
_g_BlkFuncs_ =_AND_FUNC_PTR_ParseBlockStatus;
or
_g_BlkFuncs_ =_OR_FUNC_PTR_ParseBlockStatus;
etc....
The only time I will know which function to assign is when I will retrieve the first part of the function name from a table called
_x_UserPrgBlock_. The first part being the name differentiator such as "_BUF_", "_INV_", "_AND_", "_OR_" and so forth which
is initially stored in the one of the table members called m_LogicElement_ residing in the _x_UserPrgBlock_ table or struct.
In the example below, I made it simple by hard coding the assigning of the m_LogicElement_ member as "_BUF_" (see the line commented as "Manual assignment line" below). In reality the  m_LogicElement_ member is assigned from
a user defined string which will vary from time to time. 
Here is the sample snippet which shows the issue.
================================STRUCT.h
#ifndef STRUCT_H
#define STRUCT_H
typedef struct USR_PRG_CNV{ // User program converter table
char m_LogicElement_[2][knst_BUF_LOGIC_ELEM]; // Name of the logic block
} User_Prg_Block;
#endif
=================================_BUF.h
#ifndef BUF_H
#define BUF_H
void _BUF_FUNC_PTR_ParseBlockStatus(void);
#endif
================================_BUF.c
void _BUF_FUNC_PTR_ParseBlockStatus(void){
int i = 0;
i = 10;
===============================UPC.h
#ifndef UPC_H
#define UPC_H
void AssignmentFunc();
#endif
===============================UPC.c
User_Prg_Block _x_UserPrgBlock_[2];
void AssignmentFunc(){
strcpy(_x_UserPrgBlock_[0].m_LogicElement_, "_BUF_"); // Manual assignment line
===============================DFP.c
#include "_BUF.h"
void (*_g_BlkFuncs_) (void);
char volatile _g_FuncPtrStrVariant_[35];
void SomeFunction(){
strcpy(_g_FuncPtrStrVariant_, _x_UserPrgBlock_[0].m_LogicElement_); // Get "_BUF_"
strcat(_g_FuncPtrStrVariant_, "FUNC_PTR_ParseBlockStatus"); // Complete the function name
// Now try to assign the full function name to the function pointer
//_g_BlkFuncs_ = _BUF_FUNC_PTR_ParseBlockStatus;
//_g_BlkFuncs_ = &_g_FuncPtrStrVariant_;
_g_BlkFuncs_ = _g_FuncPtrStrVariant_; // ???
==============================Main.c
void main(){
AssignmentFunc();
SomeFunction();
In reference to the following line listed above:
_g_BlkFuncs_ = _g_FuncPtrStrVariant_;
I do realize that conventionally, it should be:
_g_BlkFuncs_ =_BUF_FUNC_PTR_ParseBlockStatus;
The problem I find myself faced with is that the function that "_g_BlkFuncs_" points to, has to vary in accordance to the name of the function stored in the _g_FuncPtrStrVariant_ character array! The reason is that the _g_FuncPtrStrVariant_
array is actually built up to the name of the function based on the current contents of m_LogicElement_ residing in the _x_UserPrgBlock_ table.
I think!!!!! that even if I use an array of function pointers, it won't solve the issue.
In summary, in C, is there a way to assign a name of a function built from a character array to a function pointer?
All help sincerely appreciated!
Thanks

Answer 1

I am interpreting your question a little different than Brian.
If I understand you correctly you are asking:  "Given the name of a function as a string, how do I get a pointer to that function".
The unfortunately fact is that C++ does not support reflection, so getting a function by name is not possible.  By the time the linker has done its thing, the function name has been stripped from code.
This means if you need to support string lookup of a function name you need to support an alternate mechanism to handle this.  If you were using C++, a map would be an ideal mechanism.  C can still do this, but the mechanism is a lot uglier
due to the lack of data structures like std::string and std::map.