C语言

-------real_func.h

#ifndef LOCAL_TEST_REAL_FUNC_H
#define LOCAL_TEST_REAL_FUNC_H


#define tag_start_variable_1   10
#define tag_end_variable_1     12


#define tag_start_variable_2   20
#define tag_end_variable_2     22


//modify here
#define DO_TEST(a,b)       some_func(a,b, 1,2)










int some_func(int a, int b, int c, int d)
{
    return a+b+c+d;
}














#endif //LOCAL_TEST_REAL_FUNC_H

------main.c

#include <stdio.h>

#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include "real_func.h"


#define PARA_WORD_MAX_LEN (30)
#define PARA_MAX_NUM (30)


char* key_head;
char* val_head;
int para_size = 0;


char g_cur_val[PARA_WORD_MAX_LEN];




void mcpy(char* d, char* s, int l)
{
    int i=0;
    for(;i<l;++i)
    {
        *(d++) = *(s++);
    }
    *d = '\0';
}




int println(const char *fmt, ...)
{
    char printf_buf[1024];
    va_list args;
    int printed;
    va_start(args, fmt);
    printed = vsprintf(printf_buf, fmt, args);
    va_end(args);
    puts(printf_buf);
    return printed;
}


void mcpy0(char* d, char* s)
{
    while(*s != '\0')
    {
        *(d++) = *(s++);
    }
    *d = '\0';
}


void init_para(int argc, char* argv[]) {
    int i=0;
    char* str;
    char c;
    int j;
    key_head = (char*)malloc(PARA_WORD_MAX_LEN * PARA_MAX_NUM);
    val_head = (char*)malloc(PARA_WORD_MAX_LEN * PARA_MAX_NUM);
    char* key = key_head;
    char* val = val_head;
    int index;


    for(i=1;i<argc;++i)
    {
        str = argv[i];
        j = 0;
        while(str[j] != '\0')
        {
            c = str[j];
            if(c == '=')
            {
                index = j;
            }


            j++;
        }


        mcpy(key, str, index);
        mcpy(val, str+index+1, j);


        para_size++;
        key += PARA_WORD_MAX_LEN;
        val += PARA_WORD_MAX_LEN;


    }
}


void dispose()
{
    free(key_head);
    free(val_head);
}


int get0(char* key, char* val )
{
    int ret = 0;
    int i=0;
    char* key0;
    for(i=0; i<PARA_MAX_NUM; ++i)
    {
        key0 = key_head + i * PARA_WORD_MAX_LEN;
        if(strcmp(key, key0) == 0)
        {
            mcpy0(val, val_head + i * PARA_WORD_MAX_LEN);
            break;
        }
    }
    if(i == PARA_MAX_NUM)
    {
        mcpy0(val, key);
        ret = 1;
    }
    return ret;
}


char* get(char* key)
{
    get0(key, g_cur_val);
    return g_cur_val;
}


int getint(int keyint)
{
    char key[13];
    snprintf(key, sizeof(key), "%d", keyint);
    return atoi(get((key)));
}




void do_scan()
{
    char *key = key_head + para_size * PARA_WORD_MAX_LEN;
    char *val = val_head + para_size * PARA_WORD_MAX_LEN;
    int i=0;
    char temp[PARA_WORD_MAX_LEN];


    while(1)
    {
        ++i;
        printf("key%d (q for quit):", i);
        gets(temp);
        mcpy0(key, temp);
        if(strcmp(key, "q")==0 || strcmp(key, "quit")==0||
                strcmp(key, "Q")==0 || strcmp(key, "QUIT")==0 )
        {
            break;
        }
        printf("value%d:", i);
        gets(temp);
        mcpy0(val, temp);


        para_size++;
        key += PARA_WORD_MAX_LEN;
        val += PARA_WORD_MAX_LEN;
    }


}


typedef struct tagCommmmmmm
{
    int (*println)(const char *fmt, ...);
    char* (*get)(char* key);
    int (*getint)(char* key);


} CommonFunc;


CommonFunc funcs = {
        println,
        get,
        getint
};






int go();
int main(int argc, char* argv[]){


    init_para(argc, argv);
    do_scan();


    go();


//    funcs.println("%d", funcs.getint(234));
//    funcs.println("ggg%d", 1);
//    funcs.println("ggg%d", 2);


//    printf("%s\n", get("qin"));
//    printf("%s\n", get("han"));


    dispose();
}












int go()
{
    int i=0;
    int j=0;
    int ret;
    for(i=tag_start_variable_1;i<tag_end_variable_1;i++)
    {
        for(j=tag_start_variable_2;j<tag_end_variable_2;j++)
        {
            ret = DO_TEST(funcs.getint(i), funcs.getint(j));
            funcs.println("%d", ret);
        }


    }
}