Source file

#include "stdio.h"
#include "string.h"
#include "stdlib.h"
#include "Command_Parser.h"

static cmdTableStruct cmdTable[]=
{

 { 1123,(myStruct (*)(paramHandler_type *pHandler)) setParams,(int(*)(int y,...)) printParams },
 //more command in same manner
};

#define MSG_GET_CMD_TABLE_MAX   (sizeof(cmdTable)/sizeof(cmdTableStruct))

paramHandler_type paramHandler;


int parseCommand( char *cmdBuffer)
{
    int commandType;

    cmdTableStruct *commandTable=NULL;

    void *genericMessageStruct;


    printf("parseCommand : %s\n",cmdBuffer);

    memset(&paramHandler,0,sizeof(paramHandler_type));

    if(!(genericMessageStruct = getCommandInfo(cmdBuffer,&commandType, &paramHandler)))
    {
        return COMMAND_RESULT_ERROR;
    }

    if((commandTable = findCommandFromTable(commandType)) == NULL)
    {
        return COMMAND_RESULT_ERROR;
    }

    commandTable->process_command(commandType,genericMessageStruct);

    return COMMAND_RESULT_OK;
}

cmdTableStruct* findCommandFromTable(int id)
{
    int loop_i;
    cmdTableStruct * findTbl=NULL;

    for(loop_i=0; loop_i < MSG_GET_CMD_TABLE_MAX; loop_i++)
    {
        findTbl = &cmdTable[loop_i];
        if( findTbl->commandCode == id)
            return findTbl;
    }

    return (NULL);
}

void *getCommandInfo(char *str, int *commandType, paramHandler_type *pHandler)
{
    int i=0,j=0;
    int commandCode;
    char *token = NULL;
    char *delimiter=" ,";
    void *genericMessageStruct;

    token = strtok(str,delimiter);

    commandCode = atoi(token);

    *commandType = commandCode;

    printf("In getCommandInfo called :%d \n",commandCode);

    for(i=0;i<MSG_GET_CMD_TABLE_MAX;i++)
    {
        if(cmdTable[i].commandCode == commandCode)
        {
            printf("In getCommandInfo: found command\n");

            genericMessageStruct = cmdTable[i].getCommandParamStructure(pHandler);
            while(token != NULL)
            {
                token = strtok (NULL, " ,");
                switch(pHandler->type[j])
                {
                    case SUPPORTED_FIELD_TYPE_INT:
                    printf("arg%d = %d\n",j,(int)atoi(token));
                    *((int*)pHandler[j].paramValue) = (int)atoi(token);
                    break;
                    default:
                    break;
                }
                j++;
            }
            break;
        }
    }

    return genericMessageStruct;
}

myStruct *setParams(paramHandler_type *pHandler)
{
    int i=0;
    myStruct *my_param_struct;
    printf("setParams called\n");
    my_param_struct = malloc(sizeof(myStruct));

    pHandler->paramValue[i]=(void*)&my_param_struct->ID;
    pHandler->type[i]=SUPPORTED_FIELD_TYPE_INT;

    i++;
    pHandler->paramValue[i]=(void*)&my_param_struct->ch;
    pHandler->type[i]=SUPPORTED_FIELD_TYPE_INT;

    i++;
    pHandler->numofElements=i;

    return my_param_struct;
}


int printParams(int commandType,myStruct *param )
{
   printf("ID :%d ch : %d\n",param->ID,param->ch);

   free(param);

   return COMMAND_RESULT_OK;
}


int main(int argc,char *argv[])
{
    char buffer[]="1123,13,46";
    parseCommand(buffer);
    return 0;
}