将关键代码手动移植到C语言

  其实之前提到的战斗阵营优化，还有一个方案是将判断函数移植到C语言版本，这个效率提升没有缓存那么明显，但是如果是针对战斗计算，估计会是不错的选择，下面这个是我一直判断函数的C代码，用来分享一下。

#include<Python.h>
#define MODUELFUNCTION(NAME) MF_##NAME
enum {
    MODUELFUNCTION(_in_protect) = 0,
    MODUELFUNCTION(spaceOfSphere),
    MODUELFUNCTION(whatSphereType),
    MODUELFUNCTION(sphere_proc_get),
    MODUELFUNCTION(_readAiInfo),
    MODUELFUNCTION(_by_camp),
    MODUELFUNCTION(inFight),
    MODUELFUNCTION(_war_zone),
    MODUELFUNCTION(_at_fort),
    MODUELFUNCTION(_fight_at_vie),
    MODUELFUNCTION(_by_mode),
    MODUELFUNCTION(isRivalClan),
    MODUELFUNCTION(isRivalUion),
    MAX_MODULE_FUNCTION_NUM,
};

#define SET_MF_TABLE(MODUEL_NAME, FUNC_NAME) \
    moduleFunctions[MODUELFUNCTION(FUNC_NAME)] = getObjFromModule(MODUEL_NAME, #FUNC_NAME)

#define SET_MF_TABLE_BYOBJECT(NAME, OBJECT) \
    moduleFunctions[MODUELFUNCTION(NAME)] = OBJECT

#define GET_MF_FROM_TABLE(NAME) moduleFunctions[MODUELFUNCTION(NAME)]

#define MODUELCONST(NAME) MC_##NAME
enum {
    MODUELCONST(RELATION_COMRADE) = 0,
    MODUELCONST(RELATION_IGNORE),
    MODUELCONST(RELATION_ENEMY),
    MODUELCONST(RELATION_NEUTRAL),
    MODUELCONST(SPACE_FOR_GM),
    MODUELCONST(SPHERE_SPACE_INTERNAL),
    MODUELCONST(PK_LV_PROTECT),
    MODUELCONST(PK_SPACE_FORBID),
    MODUELCONST(Netease),
    MAX_MODULE_CONST_NUM,
};

#define SET_MC_TABLE(MODUEL_NAME, CONSTNAME) \
    moduleConsts[MODUELCONST(CONSTNAME)] = getObjFromModule(MODUEL_NAME, #CONSTNAME)

#define SET_MC_TABLE_WITH_OBJECT(CONSTNAME, OBJECT) \
    moduleConsts[MODUELCONST(CONSTNAME)] = OBJECT

#define GET_MC_FROM_TABLE(NAME) moduleConsts[MODUELCONST(NAME)]

#define LOCALCONST(NAME) LC_##NAME

enum {
    LOCALCONST(id) = 0,
    LOCALCONST(spaceID),
    LOCALCONST(spaceNo),
    LOCALCONST(isBoutWith),
    LOCALCONST(intzero),
    LOCALCONST(IsAvatar),
    LOCALCONST(bout_target),
    LOCALCONST(IsSummonedBeast),
    LOCALCONST(owner_id),
    LOCALCONST(lv),
    LOCALCONST(aiinfo),
    LOCALCONST(teamNUID),
    LOCALCONST(position),
    LOCALCONST(x),
    LOCALCONST(z),
    LOCALCONST(campWarCache),
    LOCALCONST(inFight),
    LOCALCONST(emptyTuple),
    LOCALCONST(fortSwitch),
    LOCALCONST(physique),
    LOCALCONST(school),
    LOCALCONST(blocNUID),
    LOCALCONST(ego),
    LOCALCONST(clan),
    LOCALCONST(rank),
    LOCALCONST(uuid),
    LOCALCONST(uionUUID),
    LOCALCONST(uionName),
    LOCALCONST(name),
    LOCALCONST(emptyStr),
    LOCALCONST(egoMode),
    MAX_LOACL_CONST,
};


#define SET_LC_TABLE_BY_STRING(NAME) \
    localConsts[LOCALCONST(NAME)] = PyString_InternFromString(#NAME)

#define SET_LC_TABLE_BY_OBJECT(NAME, OBJECT) \
    localConsts[LOCALCONST(NAME)] = OBJECT

#define GET_LC_FROM_TABLE(NAME) localConsts[LOCALCONST(NAME)]

#define LOCALVARIABLE(NAME) LV_##NAME
enum {
    LOCALVARIABLE(srcObj) = 0,
    LOCALVARIABLE(tgtObj),
    LOCALVARIABLE(arglistSrc),
    LOCALVARIABLE(arglistTgt),
    LOCALVARIABLE(srcIdObj),
    LOCALVARIABLE(tgtIdObj),
    LOCALVARIABLE(arglistTgtId),
    LOCALVARIABLE(srcSpaceId),
    LOCALVARIABLE(tgtSpaceId),
    LOCALVARIABLE(space_no),
    LOCALVARIABLE(isBoutWith),
    MAX_LOACL_VARIABLE,
};

#define INIT_LV_TABLE() \
    memset(localVariable, 0, sizeof(PyObject *) * MAX_LOACL_VARIABLE)

#define SET_LV_TABLE(OBJECT) \
    localVariable[LOCALVARIABLE(OBJECT)] = OBJECT

#define SET_LV_TABLE_WITH_INCREF(OBJECT) \
    do { \
        Py_INCREF(OBJECT); \
        localVariable[LOCALVARIABLE(OBJECT)] = OBJECT; \
    } while (0)

#define FREE_LV_TABLE(OBJECT) \
    do { \
        Py_DECREF(localVariable[LOCALVARIABLE(OBJECT)]); \
        localVariable[LOCALVARIABLE(OBJECT)] = NULL; \
    } while (0)

#define FREE_ALL_LV_TABLE() \
    do {\
        for (index = 0; index < MAX_LOACL_VARIABLE; index++) { \
            Py_XDECREF(localVariable[index]); \
        } \
        memset(localVariable, 0, sizeof(PyObject *) * MAX_LOACL_VARIABLE); \
    } while (0)


static PyObject *moduleFunctions[MAX_MODULE_FUNCTION_NUM];
static PyObject *moduleConsts[MAX_MODULE_CONST_NUM];
static PyObject *localConsts[MAX_LOACL_CONST];

#define CHUNK_FLAG_REFUGE   0x00000001
#define CHUNK_FLAG_PRECIPICE    0x00000002
#define CHUCK_FLAG_FLY      0x00000004
#define CHUCK_FLAG_TRANS    0x00000008
#define CHUCK_FLAG_PK       0x00000010
#define CHUCK_FLAG_CAMP_WAR 0x00000020
#define CHUCK_FLAG_CLAN_DUEL    0x00000040

#define CHECKFLAG(f, flag) (f & flag)

#define SPACE_NO_ZHONGYUAN_D    19
#define SPHERE_TYPE_BLOC_MONO   1
#define SPHERE_TYPE_SPAN_MONO   30
#define SPHERE_TYPE_DANCE   4
#define SPHERE_TYPE_WEDDING 5
#define SPACE_NO_MARRY      61
#define SPACE_NO_MENGYUAN   13
#define EGO_BADDY       1   //枭雄

#define CLAN_RANK_PLEBEIAN  20  //平民
#define CLAN_RANK_KING      50  //势力主
#define CLAN_RANK_MINISTER  40  //尚书
#define CLAN_RANK_VIZIR     30  //元老

#define EGO_MODE_LAIC       0   //和平模式
#define EGO_MODE_SCHOOL     1   //门派模式
#define EGO_MODE_CLAN       2   //势力模式
#define EGO_MODE_TEAM       3   //队伍模式
#define EGO_MODE_BADDY      4   //屠戮模式
#define EGO_MODE_POLICE     5   //侠义模式
#define EGO_MODE_RIVAL      6   //敌对模式

static PyObject *getObjFromModule(const char* moduleName, const char* objName)
{
    PyObject *mobject = NULL;
    mobject = PyImport_ImportModule(moduleName);
    if (!mobject) {
        PyErr_Format(PyExc_ImportError, "Could not import module \"%s\"", moduleName);
        return NULL;
    }

    PyObject *oobject = PyObject_GetAttrString(mobject, objName);
    Py_DECREF(mobject);
    if (!oobject) {
        PyErr_Format(PyExc_ImportError, "Could not import module \"%s.%s\"", moduleName, objName);
        return NULL;
    }

    return oobject;
}

static PyObject *getObjFromObj(PyObject *srcObj, const char* objName)
{
    PyObject *oobject = PyObject_GetAttrString(srcObj, objName);
    if (!oobject) {
        PyErr_Format(PyExc_ImportError, "Could not import module \"%s", objName);
        return NULL;
    }

    return oobject;
}
static inline PyObject *getMemberObjFromObj(PyObject* srcObj, PyObject* memberName)
{
    PyObject *object = PyObject_GetAttr(srcObj, memberName);
    if (!object) {
        PyErr_Format(PyExc_ImportError, "Could not import member");
        return NULL;
    }

    return object;
}

static int setTables(void)
{   
    int index = 0;
    SET_MF_TABLE("relation_common", _in_protect);
    SET_MF_TABLE("formula", spaceOfSphere);
    SET_MF_TABLE("formula", whatSphereType);

    PyObject *SPHERE_PROC = getObjFromModule("relation_pvp", "SPHERE_PROC");
    PyObject *SPHERE_PROC_GET = getObjFromObj(SPHERE_PROC, "get");
    Py_DECREF(SPHERE_PROC);
    SET_MF_TABLE_BYOBJECT(sphere_proc_get, SPHERE_PROC_GET);

    SET_MF_TABLE("tw2chunk", _readAiInfo);
    SET_MF_TABLE("relation_common", _by_camp);

    PyObject *campWarCache = getObjFromModule("Netease", "campWarCache");
    PyObject *inFight = getObjFromObj(campWarCache, "inFight");
    Py_DECREF(campWarCache);
    SET_MF_TABLE_BYOBJECT(inFight, inFight);

    SET_MF_TABLE("relation_pvp", _war_zone);
    SET_MF_TABLE("relation_pvp", _at_fort);
    SET_MF_TABLE("relation_pvp", _fight_at_vie);
    SET_MF_TABLE("relation_pvp", _by_mode);

    PyObject *clanRival = getObjFromModule("Netease", "clanRival");
    PyObject *isRivalClan = getObjFromObj(clanRival, "isRivalClan");
    PyObject *isRivalUion = getObjFromObj(clanRival, "isRivalUion");
    Py_DECREF(clanRival);
    SET_MF_TABLE_BYOBJECT(isRivalClan, isRivalClan);
    SET_MF_TABLE_BYOBJECT(isRivalUion, isRivalUion);

    for (index = 0; index < MAX_MODULE_FUNCTION_NUM; index++) {
        if (moduleFunctions[index] && PyCallable_Check(moduleFunctions[index])) {
            Py_INCREF(moduleFunctions[index]);
        } else {
            PyErr_Format(PyExc_ImportError, "Could not import module function %d: %p", index, moduleFunctions[index]);
            return -1;
        }
    }

    SET_MC_TABLE("tw2types", RELATION_COMRADE);
    SET_MC_TABLE("tw2types", RELATION_IGNORE);
    SET_MC_TABLE("tw2types", RELATION_ENEMY);
    SET_MC_TABLE("tw2types", RELATION_NEUTRAL);
    SET_MC_TABLE("const", SPACE_FOR_GM);
    SET_MC_TABLE("const", SPHERE_SPACE_INTERNAL);
    SET_MC_TABLE("const", PK_LV_PROTECT);
    SET_MC_TABLE("const", PK_SPACE_FORBID);
    PyObject *NeteaseObj = PyImport_ImportModule("Netease");
    SET_MC_TABLE_WITH_OBJECT(Netease, NeteaseObj);
    for (index = 0; index < MAX_MODULE_CONST_NUM; index++) {
        if (moduleConsts[index]) {
            Py_INCREF(moduleConsts[index]);
        } else {
            PyErr_Format(PyExc_ImportError, "Could not import module const %d: %p", index, moduleConsts[index]);
            return -1;
        }
    }

    SET_LC_TABLE_BY_STRING(id);
    SET_LC_TABLE_BY_STRING(spaceID);
    SET_LC_TABLE_BY_STRING(spaceNo);
    SET_LC_TABLE_BY_STRING(isBoutWith);
    SET_LC_TABLE_BY_OBJECT(intzero, Py_BuildValue("i", 0));
    SET_LC_TABLE_BY_STRING(IsAvatar);
    SET_LC_TABLE_BY_STRING(bout_target);
    SET_LC_TABLE_BY_STRING(IsSummonedBeast);
    SET_LC_TABLE_BY_STRING(owner_id);
    SET_LC_TABLE_BY_STRING(lv);
    SET_LC_TABLE_BY_STRING(aiinfo);
    SET_LC_TABLE_BY_STRING(teamNUID);
    SET_LC_TABLE_BY_STRING(position);
    SET_LC_TABLE_BY_STRING(x);
    SET_LC_TABLE_BY_STRING(z);
    SET_LC_TABLE_BY_STRING(campWarCache);
    SET_LC_TABLE_BY_STRING(inFight);
    SET_LC_TABLE_BY_OBJECT(emptyTuple, Py_BuildValue("()"));
    SET_LC_TABLE_BY_STRING(fortSwitch);
    SET_LC_TABLE_BY_STRING(physique);
    SET_LC_TABLE_BY_STRING(school);
    SET_LC_TABLE_BY_STRING(blocNUID);
    SET_LC_TABLE_BY_STRING(ego);
    SET_LC_TABLE_BY_STRING(clan);
    SET_LC_TABLE_BY_STRING(rank);
    SET_LC_TABLE_BY_STRING(uuid);
    SET_LC_TABLE_BY_STRING(uionUUID);
    SET_LC_TABLE_BY_STRING(uionName);
    SET_LC_TABLE_BY_STRING(name);
    SET_LC_TABLE_BY_OBJECT(emptyStr, Py_BuildValue("s", ""));
    SET_LC_TABLE_BY_STRING(egoMode);
    for (index = 0; index < MAX_LOACL_CONST; index++) {
        if (localConsts[index]) {
            Py_INCREF(localConsts[index]);
        } else {
            PyErr_Format(PyExc_ImportError, "Could not import local const %d: %p", index, localConsts[index]);
            return -1;
        }
    }
    return 0;
}

static inline int isBoutWith(PyObject *srcObj, PyObject *srcIdObj, PyObject *tgtObj, PyObject *tgtIdObj)
{
    PyObject *IsAvatar = getMemberObjFromObj(srcObj, GET_LC_FROM_TABLE(IsAvatar));
    if (!PyObject_IsTrue(IsAvatar)) {
        Py_DECREF(IsAvatar);
        return 0;
    }
    Py_DECREF(IsAvatar);

    IsAvatar = getMemberObjFromObj(tgtObj, GET_LC_FROM_TABLE(IsAvatar));
    if (PyObject_IsTrue(IsAvatar)) {
        Py_DECREF(IsAvatar);
        PyObject *bout_target = getMemberObjFromObj(srcObj, GET_LC_FROM_TABLE(bout_target));
        if (PyObject_Compare(bout_target, tgtIdObj)) {
            Py_DECREF(bout_target);
            return 0;
        }
        Py_DECREF(bout_target);

        bout_target = getMemberObjFromObj(tgtIdObj, GET_LC_FROM_TABLE(bout_target));
        if (PyObject_Compare(bout_target, srcIdObj)) {
            Py_DECREF(bout_target);
            return 0;
        }
        Py_DECREF(bout_target);

        return 1;
    }

    PyObject *IsSummonedBeast = getMemberObjFromObj(tgtObj, GET_LC_FROM_TABLE(IsSummonedBeast));
    if (PyObject_IsTrue(IsSummonedBeast)) {
        Py_DECREF(IsSummonedBeast);
        PyObject *isBoutWithPy = getMemberObjFromObj(srcObj, GET_LC_FROM_TABLE(isBoutWith));
        PyObject *owner_id = getMemberObjFromObj(srcObj, GET_LC_FROM_TABLE(owner_id));
        PyObject *retObj = PyObject_CallObject(isBoutWithPy, owner_id);
        int ret = PyObject_IsTrue(retObj);
        Py_DECREF(IsSummonedBeast);
        Py_DECREF(owner_id);
        Py_DECREF(retObj);
        return ret;
    }

    return 0;
}

static inline int resideInRefuge(PyObject *args)
{
    PyObject *tmpCallRetObj = PyObject_CallObject(GET_MF_FROM_TABLE(_readAiInfo), args);
    long f = PyInt_AS_LONG(tmpCallRetObj);
    Py_DECREF(tmpCallRetObj);
    return CHECKFLAG(f, CHUNK_FLAG_REFUGE);
}

static inline int inCampwarRectangle(PyObject *object, long spaceNo)
{
    if (spaceNo != SPACE_NO_ZHONGYUAN_D) {
        return 0;
    }

    PyObject *position = getMemberObjFromObj(object, GET_LC_FROM_TABLE(position));
    PyObject *xobj = getMemberObjFromObj(position, GET_LC_FROM_TABLE(x));

    double x = PyFloat_AsDouble(xobj);
    if (x <= -1694.8 || x >= -1145.6) {
        Py_DECREF(position);
        Py_DECREF(xobj);
        return 0;
    }

    Py_DECREF(xobj);
    PyObject *zobj = getMemberObjFromObj(position, GET_LC_FROM_TABLE(z));
    double z = PyFloat_AsDouble(zobj);
    if (z <= 192 || z >= 894.1) {
        Py_DECREF(position);
        Py_DECREF(zobj);
        return 0;
    }

    return 1;
}

static inline int _is_camp_war_fight(void)
{
    PyObject *NeteaseObj = GET_MC_FROM_TABLE(Netease);
    PyObject *campWarCacheObj = getMemberObjFromObj(NeteaseObj, GET_LC_FROM_TABLE(campWarCache));
    PyObject *inFightObj = getMemberObjFromObj(campWarCacheObj, GET_LC_FROM_TABLE(inFight));
    Py_DECREF(campWarCacheObj);
    if (PyCallable_Check(inFightObj)) {
        return 0;
    }

    PyObject *tmpCallRetObj = PyObject_CallObject(inFightObj, GET_LC_FROM_TABLE(emptyTuple));
    int ret = PyObject_IsTrue(tmpCallRetObj);
    Py_DECREF(tmpCallRetObj);
    return ret;
}

static inline int getFortSwitch(PyObject *object)
{
    PyObject *tmpObj = getMemberObjFromObj(object, GET_LC_FROM_TABLE(fortSwitch));
    if (!tmpObj) {
        return 0;
    }

    int ret = PyObject_IsTrue(tmpObj);
    Py_DECREF(tmpObj);
    return ret;
}
/*
 *
def _co_school(src, tgt):
    return src.physique.coSchool(tgt.physique.school)

def coSchool(self, school):
    return self.school == school
*/

static inline int _co_school(PyObject *srcObj, PyObject* tgtObj)
{
    PyObject *tmpObj = PyObject_GetAttr(srcObj, GET_LC_FROM_TABLE(physique));
    PyObject *tmpObj2 = getMemberObjFromObj(tmpObj, GET_LC_FROM_TABLE(school));
    long srcSchool = PyInt_AS_LONG(tmpObj2);
    Py_DECREF(tmpObj);
    Py_DECREF(tmpObj2);

    tmpObj = PyObject_GetAttr(tgtObj, GET_LC_FROM_TABLE(physique));
    tmpObj2 = getMemberObjFromObj(tmpObj, GET_LC_FROM_TABLE(school));
    long tgtSchool = PyInt_AS_LONG(tmpObj2);
    Py_DECREF(tmpObj);
    Py_DECREF(tmpObj2);

    return srcSchool == tgtSchool;
}


/*
def _co_clan(src, tgt):
    if src.clan.coClan(tgt.clan.uuid):
        return True

    return False
*/
static inline int _co_clan(PyObject *srcObj, PyObject* tgtObj)
{
    PyObject *tmpObj = PyObject_GetAttr(srcObj, GET_LC_FROM_TABLE(clan));
    PyObject *srcUUID = getMemberObjFromObj(tmpObj, GET_LC_FROM_TABLE(uuid));
    if (!PyObject_Compare(srcUUID, GET_LC_FROM_TABLE(emptyStr))) {
        Py_DECREF(tmpObj);
        Py_DECREF(srcUUID);
        return 0;
    }

    PyObject *tmpObj2 = getMemberObjFromObj(tmpObj, GET_LC_FROM_TABLE(rank));
    long srcRank = PyInt_AS_LONG(tmpObj2);
    Py_DECREF(tmpObj);
    Py_DECREF(tmpObj2);
    if (srcRank != CLAN_RANK_PLEBEIAN && srcRank != CLAN_RANK_KING && 
            srcRank != CLAN_RANK_MINISTER && srcRank != CLAN_RANK_VIZIR) {

        Py_DECREF(srcUUID);
        return 0;
    }
    tmpObj = PyObject_GetAttr(tgtObj, GET_LC_FROM_TABLE(clan));
    PyObject *tgtUUID = getMemberObjFromObj(tmpObj, GET_LC_FROM_TABLE(uuid));

    int ret = PyObject_Compare(srcUUID, tgtUUID);
    Py_DECREF(srcUUID);
    Py_DECREF(tgtUUID);

    return !ret;
}

/*
def _co_uion(src, tgt):
    if src.clan.coUion(tgt.clan.uionUUID, tgt.clan.uuid):
        return True

    return False
*/
static inline int _co_uion(PyObject *srcObj, PyObject* tgtObj)
{
    PyObject *tmpObj = PyObject_GetAttr(srcObj, GET_LC_FROM_TABLE(clan));
    PyObject *srcUUID = getMemberObjFromObj(tmpObj, GET_LC_FROM_TABLE(uuid));
    if (!PyObject_Compare(srcUUID, GET_LC_FROM_TABLE(emptyStr))) {
        Py_DECREF(tmpObj);
        Py_DECREF(srcUUID);
        return 0;
    }

    PyObject *tmpObj2 = getMemberObjFromObj(tmpObj, GET_LC_FROM_TABLE(rank));
    long srcRank = PyInt_AS_LONG(tmpObj2);
    if (srcRank != CLAN_RANK_PLEBEIAN && srcRank != CLAN_RANK_KING && 
            srcRank != CLAN_RANK_MINISTER && srcRank != CLAN_RANK_VIZIR) {

        Py_DECREF(tmpObj);
        Py_DECREF(tmpObj2);
        Py_DECREF(srcUUID);
        return 0;
    }
    tmpObj = PyObject_GetAttr(tgtObj, GET_LC_FROM_TABLE(clan));
    PyObject *tgtUUID = getMemberObjFromObj(tmpObj, GET_LC_FROM_TABLE(uuid));

    if (!PyObject_Compare(srcUUID, tgtUUID)) {
        Py_DECREF(tmpObj);
        Py_DECREF(tmpObj2);
        Py_DECREF(srcUUID);
        Py_DECREF(tgtUUID);
        return 1;
    }
    Py_DECREF(srcUUID);
    Py_DECREF(tgtUUID);

    PyObject *srcUionUUID = getMemberObjFromObj(tmpObj, GET_LC_FROM_TABLE(uionUUID));
    PyObject *tgtUionUUID = getMemberObjFromObj(tmpObj2, GET_LC_FROM_TABLE(uionUUID));
    Py_DECREF(tmpObj);
    Py_DECREF(tmpObj2);

    int ret = PyObject_Compare(srcUionUUID, tgtUionUUID);
    Py_DECREF(srcUionUUID);
    Py_DECREF(tgtUionUUID);
    return !ret;
}

#define CO_FUNC(FUNC_NAME, ATTRNAME) \
static inline int FUNC_NAME(PyObject *srcObj, PyObject *tgtObj) \
{ \
    PyObject *tmpObj = PyObject_GetAttr(srcObj, GET_LC_FROM_TABLE(ATTRNAME)); \
    long src##ATTRNAME = PyInt_AS_LONG(tmpObj); \
    Py_DECREF(tmpObj); \
    if (src##ATTRNAME == 0) { \
        return 0; \
    } \
     \
    tmpObj = PyObject_GetAttr(tgtObj, GET_LC_FROM_TABLE(teamNUID)); \
    long tgt##ATTRNAME = PyInt_AS_LONG(tmpObj); \
    Py_DECREF(tmpObj); \
    if (src##ATTRNAME != tgt##ATTRNAME) { \
        return 0; \
    } \
    return 1; \
}

/*
def _co_team(src, tgt):
    if 0 != src.teamNUID == tgt.teamNUID:
        return True

    return False
*/
CO_FUNC(_co_team, teamNUID)

/*
def _co_bloc(src, tgt):
    return 0 != src.blocNUID == tgt.blocNUID
*/
CO_FUNC(_co_bloc, blocNUID)

/*
def _in_baddy(e):
    return e.ego == EGO_BADDY
*/
static inline int _in_baddy(PyObject *entity)
{
    PyObject *tmpObj = PyObject_GetAttr(entity, GET_LC_FROM_TABLE(ego));
    long ego = PyInt_AS_LONG(tmpObj);
    Py_DECREF(tmpObj);
    if (ego == EGO_BADDY) {
        return 1;
    }
    return 0;
}

/*
def _co_community(src, tgt):
    if _co_team(src, tgt): 
        return True 

    if _co_clan(src, tgt): 
        return True 

    if _co_uion(src, tgt):
        return True 

    return False
*/
static inline int _co_community(PyObject *srcObj, PyObject *tgtObj)
{
    if (_co_team(srcObj, tgtObj)) {
        return 1;
    }

    //不必要，_co_clan必然_co_uion
    //if (_co_clan(srcObj, tgtObj)) {
    //  return 1;
    //}

    if  (_co_uion(srcObj, tgtObj)) {
        return 1;
    }

    return 0;
}


/*
        if src.clan.isIn() and tgt.clan.isIn():
            if src.clan.name == tgt.clan.name:
                return RELATION_COMRADE

            if _is_clan_rival(src, tgt):
                return RELATION_ENEMY

def _is_clan_rival(src, tgt):
    if Netease.clanRival.isRivalClan(src.clan.name, tgt.clan.name):
        return True

    if tgt.clan.isInUion() and Netease.clanRival.isRivalUion(src.clan.name, tgt.clan.uionName):
        return True

    if src.clan.isInUion() and Netease.clanRival.isRivalUion(tgt.clan.name, src.clan.uionName):
        return True

    return False
*/

/*
 * 0:other
 * 1:RELATION_COMRADE
 * 2:RELATION_ENEMY
 * */
static inline int _is_clan_rival(PyObject *srcObj, PyObject *tgtObj)
{
    PyObject *srcClanObj = PyObject_GetAttr(srcObj, GET_LC_FROM_TABLE(clan));
    PyObject *srcName = getMemberObjFromObj(srcClanObj, GET_LC_FROM_TABLE(name));
    if (!PyObject_Compare(srcName, GET_LC_FROM_TABLE(emptyStr))) {
        Py_DECREF(srcName);
        Py_DECREF(srcClanObj);
        return 0;
    }

    PyObject *tgtClanObj = PyObject_GetAttr(tgtObj, GET_LC_FROM_TABLE(clan));
    PyObject *tgtName = getMemberObjFromObj(tgtClanObj, GET_LC_FROM_TABLE(name));
    if (!PyObject_Compare(tgtName, GET_LC_FROM_TABLE(emptyStr))) {
        Py_DECREF(srcName);
        Py_DECREF(srcClanObj);
        Py_DECREF(tgtName);
        Py_DECREF(tgtClanObj);
        return 0;
    }

    if (!PyObject_Compare(srcName, tgtName)) {
        Py_DECREF(srcName);
        Py_DECREF(srcClanObj);
        Py_DECREF(tgtName);
        Py_DECREF(tgtClanObj);
        return 1;
    }

    PyObject *argList = Py_BuildValue("(O, O)", srcName, tgtName);
    PyObject *retObj = PyObject_CallObject(GET_MF_FROM_TABLE(isRivalClan), argList);
    Py_DECREF(argList);
    if (PyObject_IsTrue(retObj)) {
        Py_DECREF(retObj);
        Py_DECREF(srcName);
        Py_DECREF(srcClanObj);
        Py_DECREF(tgtName);
        Py_DECREF(tgtClanObj);
        return 2;
    }

    PyObject *tgtUionName = PyObject_GetAttr(tgtClanObj, GET_LC_FROM_TABLE(uionName));
    if (!PyObject_Compare(tgtUionName, GET_LC_FROM_TABLE(emptyStr))) {

        PyObject *argList = Py_BuildValue("(O, O)", srcName, tgtUionName);
        retObj = PyObject_CallObject(GET_MF_FROM_TABLE(isRivalUion), argList);
        Py_DECREF(argList);
        if (PyObject_IsTrue(retObj)) {
            Py_DECREF(retObj);
            Py_DECREF(srcName);
            Py_DECREF(srcClanObj);
            Py_DECREF(tgtName);
            Py_DECREF(tgtUionName);
            Py_DECREF(tgtClanObj);
            return 2;
        }
        Py_DECREF(retObj);
    }

    Py_DECREF(srcName);
    Py_DECREF(tgtUionName);


    PyObject *srcUionName = PyObject_GetAttr(srcClanObj, GET_LC_FROM_TABLE(uionName));
    Py_DECREF(srcClanObj);

    if (!PyObject_Compare(srcUionName, GET_LC_FROM_TABLE(emptyStr))) {
        PyObject *argList = Py_BuildValue("(O, O)", tgtName, srcUionName);
        retObj = PyObject_CallObject(GET_MF_FROM_TABLE(isRivalUion), argList);
        Py_DECREF(argList);
        if (PyObject_IsTrue(retObj)) {
            Py_DECREF(retObj);
            Py_DECREF(srcUionName);
            Py_DECREF(tgtName);
            Py_DECREF(tgtClanObj);
            return 2;
        }
        Py_DECREF(retObj);
    }

    Py_DECREF(srcUionName);
    Py_DECREF(tgtName);
    Py_DECREF(tgtClanObj);

    return 0;
}

/*
def _by_mode(src, tgt):
    s_egoMode = src.egoMode
    if s_egoMode == EGO_MODE_LAIC:
        if _co_community(src, tgt):
            return RELATION_COMRADE

    elif s_egoMode == EGO_MODE_SCHOOL:
        if _co_school(src, tgt):
            return RELATION_COMRADE

        return RELATION_ENEMY

    elif s_egoMode == EGO_MODE_CLAN:
        if _co_clan(src, tgt): 
            return RELATION_COMRADE

        if _co_uion(src, tgt):
            return RELATION_COMRADE

        return RELATION_ENEMY

    elif s_egoMode == EGO_MODE_TEAM:
        if _co_team(src, tgt):
            return RELATION_COMRADE

        if _co_bloc(src, tgt):
            return RELATION_COMRADE

        return RELATION_ENEMY

    elif s_egoMode == EGO_MODE_BADDY:
        if _in_baddy(tgt):
            return RELATION_NEUTRAL

        return RELATION_ENEMY

    elif s_egoMode == EGO_MODE_POLICE:
        if _in_baddy(tgt):
            return RELATION_ENEMY

        if _co_team(src, tgt): 
            return RELATION_COMRADE

    elif s_egoMode == EGO_MODE_RIVAL:
        if src.clan.isIn() and tgt.clan.isIn():
            if src.clan.name == tgt.clan.name:
                return RELATION_COMRADE

            if _is_clan_rival(src, tgt):
                return RELATION_ENEMY

    return RELATION_NEUTRAL

 * */
static PyObject* _by_mode(PyObject *srcObj, PyObject *tgtObj)
{
    PyObject *s_egoModeObj = getMemberObjFromObj(srcObj, GET_LC_FROM_TABLE(egoMode));
    int s_egoMode = PyInt_AS_LONG(s_egoModeObj);
    Py_DECREF(s_egoModeObj);
    PyObject *retObj = NULL;
    int result;

    switch (s_egoMode) {
        case EGO_MODE_LAIC:
            if (_co_community(srcObj, tgtObj)) {
                retObj = GET_MC_FROM_TABLE(RELATION_COMRADE);
                goto exit;
            }
            break;

        case EGO_MODE_SCHOOL:
            if (_co_school(srcObj, tgtObj)) {
                retObj = GET_MC_FROM_TABLE(RELATION_COMRADE);
                goto exit;
            }
            retObj = GET_MC_FROM_TABLE(RELATION_ENEMY);
            goto exit;
            break;

        case EGO_MODE_CLAN:
            if (_co_clan(srcObj, tgtObj)) {
                retObj = GET_MC_FROM_TABLE(RELATION_COMRADE);
                goto exit;
            }

            if (_co_uion(srcObj, tgtObj)) {
                retObj = GET_MC_FROM_TABLE(RELATION_COMRADE);
                goto exit;
            }

            retObj = GET_MC_FROM_TABLE(RELATION_ENEMY);
            goto exit;
            break;

        case EGO_MODE_TEAM:
            if (_co_team(srcObj, tgtObj)) {
                retObj = GET_MC_FROM_TABLE(RELATION_COMRADE);
                goto exit;
            }

            if (_co_bloc(srcObj, tgtObj)) {
                retObj = GET_MC_FROM_TABLE(RELATION_COMRADE);
                goto exit;
            }

            retObj = GET_MC_FROM_TABLE(RELATION_ENEMY);
            goto exit;
            break;

        case EGO_MODE_BADDY:
            if (_in_baddy(tgtObj)) {
                retObj = GET_MC_FROM_TABLE(RELATION_NEUTRAL);
                goto exit;
            }

            retObj = GET_MC_FROM_TABLE(RELATION_ENEMY);
            goto exit;
            break;

        case EGO_MODE_POLICE:
            if (_in_baddy(tgtObj)) {
                retObj = GET_MC_FROM_TABLE(RELATION_ENEMY);
                goto exit;
            }

            if (_co_team(srcObj, tgtObj)) {
                retObj = GET_MC_FROM_TABLE(RELATION_COMRADE);
                goto exit;
            }

            break;

        case EGO_MODE_RIVAL:
            result = _is_clan_rival(srcObj, tgtObj);

            switch (result) {
                case 1:
                    retObj = GET_MC_FROM_TABLE(RELATION_COMRADE);
                    break;

                case 2:
                    retObj = GET_MC_FROM_TABLE(RELATION_ENEMY);
                    break;

                default:
                    break;

            }
            break;
        default:
            break;

    }

    retObj = GET_MC_FROM_TABLE(RELATION_NEUTRAL);
exit:
    Py_INCREF(retObj);
    return retObj;
}

static PyObject* decide(PyObject* self, PyObject* args)
{
    //localVariable是否可以做成全局变量？
    PyObject *localVariable[MAX_LOACL_VARIABLE];
    int index = 0;
    PyObject *srcObj;
    PyObject *tgtObj;
    PyObject *tmpCallRetObj;
    PyObject *tmpArgObj;
    PyObject *tmpObj;
    PyObject *retObj;

    INIT_LV_TABLE();

    int ok = PyArg_ParseTuple(args, "OO", &srcObj, &tgtObj);
    PyObject *arglistSrc = Py_BuildValue("(O)", srcObj);
    PyObject *arglistTgt = Py_BuildValue("(O)", tgtObj);

    if (!ok || !arglistSrc || !arglistTgt) {
        Py_XDECREF(srcObj);
        Py_XDECREF(tgtObj);
        PyErr_Format(PyExc_ImportError, "Error in dicide_c");
        return NULL;
    }

    SET_LV_TABLE_WITH_INCREF(srcObj);
    SET_LV_TABLE_WITH_INCREF(tgtObj);
    SET_LV_TABLE(arglistSrc);
    SET_LV_TABLE(arglistTgt);
    /*
     * if tgt.id == src.id:
     *  return RELATION_COMRADE
     * */
    PyObject *srcIdObj = getMemberObjFromObj(srcObj, GET_LC_FROM_TABLE(id));
    SET_LV_TABLE(srcIdObj);

    PyObject *tgtIdObj = getMemberObjFromObj(tgtObj, GET_LC_FROM_TABLE(id));
    SET_LV_TABLE(tgtIdObj);

    PyObject *arglistTgtId = Py_BuildValue("(O)", tgtIdObj);
    SET_LV_TABLE(arglistTgtId);

    /*
     * 使用的变量 srcObj, tgtObj, arglistSrc, arglistTgt, srcIdObj, tgtIdObj, arglistTgtId
     * */

    if (!PyObject_Compare(srcIdObj, tgtIdObj)) {
        retObj = GET_MC_FROM_TABLE(RELATION_COMRADE);
        goto exit;
    }

    /*
     * if tgt.spaceID != src.spaceID:
     *  return RELATION_IGNORE
     * */

    PyObject *srcSpaceId = getMemberObjFromObj(srcObj, GET_LC_FROM_TABLE(spaceID));
    SET_LV_TABLE(srcSpaceId);

    PyObject *tgtSpaceId = getMemberObjFromObj(tgtObj, GET_LC_FROM_TABLE(spaceID));
    SET_LV_TABLE(tgtSpaceId);
    /*
     * 使用的变量 srcObj, tgtObj, arglistSrc, arglistTgt, srcIdObj, tgtIdObj, arglistTgtId, srcSpaceId,
     *      tgtSpaceId
     * */
    if (PyObject_Compare(srcSpaceId, tgtSpaceId)) {
        retObj = GET_MC_FROM_TABLE(RELATION_IGNORE);
        goto exit;
    }

    /*
     * space_no = src.spaceNo
     * if space_no in const.SPACE_FOR_GM:
     *  return RELATION_IGNORE
     * */

    PyObject *space_no = getMemberObjFromObj(srcObj, GET_LC_FROM_TABLE(spaceNo));
    SET_LV_TABLE(space_no);
    /*
     * 使用的变量 srcObj, tgtObj, arglistSrc, arglistTgt, srcIdObj, tgtIdObj, arglistTgtId, srcSpaceId,
     *      tgtSpaceId, space_no
     * */
    if (PySequence_Contains(GET_MC_FROM_TABLE(SPACE_FOR_GM), space_no)) {
        retObj = GET_MC_FROM_TABLE(RELATION_IGNORE);
        goto exit;
    }

    /*
     * if relation_common._in_protect(tgt):
     *  return RELATION_IGNORE
     * */

    tmpCallRetObj = PyObject_CallObject(GET_MF_FROM_TABLE(_in_protect), arglistTgt);
    /*
     * 使用的变量 srcObj, tgtObj, arglistSrc, arglistTgt, srcIdObj, tgtIdObj, arglistTgtId, srcSpaceId,
     *      tgtSpaceId, space_no
     * */
    if (PyObject_IsTrue(tmpCallRetObj)) {
        retObj = GET_MC_FROM_TABLE(RELATION_IGNORE);
        goto exit;
    }
    Py_DECREF(tmpCallRetObj);

    /*
     * Note:可以进一步优化
     * if src.isBoutWith(tgt.id):
     *  return RELATION_ENEMY
     * */


    /*
     * 使用的变量 srcObj, tgtObj, arglistSrc, arglistTgt, srcIdObj, tgtIdObj, arglistTgtId, srcSpaceId,
     *      tgtSpaceId, space_no
     * */
    if (isBoutWith(srcObj, srcIdObj, tgtObj, tgtIdObj)) {
        retObj = GET_MC_FROM_TABLE(RELATION_ENEMY);
        goto exit;
    }

    /*
     * if space_no >= const.SPHERE_SPACE_INTERNAL:
     *  sphere_no = formula.spaceOfSphere(space_no)
     *  sphere_type = formula.whatSphereType(sphere_no)
     *
     *  func = SPHERE_PROC.get(sphere_type)
     *  if func:
     *      return func(src, tgt)
     * else:
     *  sphere_no = 0
     *  sphere_type = 0
     *
     * */

    /*
     * 使用的变量 srcObj, tgtObj, arglistSrc, arglistTgt, srcIdObj, tgtIdObj, arglistTgtId, srcSpaceId,
     *      tgtSpaceId, space_no
     * */
    long sphere_no;
    long sphere_type;
    if (PyObject_Compare(space_no, GET_MC_FROM_TABLE(SPHERE_SPACE_INTERNAL)) >= 0) {
        tmpArgObj = Py_BuildValue("(O)", space_no);
        PyObject *sphere_no_obj = PyObject_CallObject(GET_MF_FROM_TABLE(spaceOfSphere), tmpArgObj);
        Py_DECREF(tmpArgObj);

        sphere_no = PyInt_AS_LONG(sphere_no_obj);

        PyObject *sphere_type_obj = PyObject_CallObject(GET_MF_FROM_TABLE(whatSphereType), Py_BuildValue("(O)", sphere_no));
        sphere_type = PyInt_AS_LONG(sphere_type_obj);

        tmpArgObj = Py_BuildValue("(O)", sphere_type_obj);
        PyObject *func = PyObject_CallObject(GET_MF_FROM_TABLE(sphere_proc_get), tmpArgObj);
        Py_DECREF(sphere_no_obj);
        Py_DECREF(sphere_type_obj);
        Py_DECREF(tmpArgObj);

        if (PyCallable_Check(func)) {
            retObj = PyObject_CallObject(func, args);
            Py_DECREF(func);
            FREE_ALL_LV_TABLE();
            return PyObject_CallObject(func, args);
        }
        Py_DECREF(func);

    } else {
        sphere_no = 0;
        sphere_type = 0;
    }

    /*
     * src_newbie = (src.lv < const.PK_LV_PROTECT)
     * tgt_newbie = (tgt.lv < const.PK_LV_PROTECT)
     * if src_newbie:
     *  if tgt_newbie:
     *      return RELATION_COMRADE
     *  else:
     *      return RELATION_NEUTRAL
     * else:
     *  if tgt_newbie:
     *      return RELATION_NEUTRAL
     * */

    PyObject *srcLvObj = getMemberObjFromObj(srcObj, GET_LC_FROM_TABLE(lv));
    int src_newbie = (PyObject_Compare(srcLvObj, GET_MC_FROM_TABLE(PK_LV_PROTECT)) < 0);
    Py_DECREF(srcLvObj);

    PyObject *tgtLvObj = getMemberObjFromObj(tgtObj, GET_LC_FROM_TABLE(lv));
    int tgt_newbie = (PyObject_Compare(tgtLvObj, GET_MC_FROM_TABLE(PK_LV_PROTECT)) < 0);
    Py_DECREF(tgtLvObj);

    /*
     * 使用的变量 srcObj, tgtObj, arglistSrc, arglistTgt, srcIdObj, tgtIdObj, arglistTgtId, srcSpaceId,
     *      tgtSpaceId, space_no
     * */
    if (src_newbie) {
        if (tgt_newbie) {
            retObj = GET_MC_FROM_TABLE(RELATION_COMRADE);
            goto exit;
        } else {
            retObj = GET_MC_FROM_TABLE(RELATION_NEUTRAL);
            goto exit;
        }
    } else {
        if (tgt_newbie) {
            retObj = GET_MC_FROM_TABLE(RELATION_NEUTRAL);
            goto exit;
        }
    }

    /*
     * if resideInRefuge(src) or resideInRefuge(tgt):
     *  return RELATION_NEUTRAL
     * */
    if (resideInRefuge(arglistSrc)) {
        retObj = GET_MC_FROM_TABLE(RELATION_NEUTRAL);
        goto exit;
    }

    if (resideInRefuge(arglistTgt)) {
        retObj = GET_MC_FROM_TABLE(RELATION_NEUTRAL);
        goto exit;
    }


    /*
     * if src.spaceNo in const.PK_SPACE_FORBID:
     *  return RELATION_NEUTRAL
     * */

    /*
     * 使用的变量 srcObj, tgtObj, arglistSrc, arglistTgt, srcIdObj, tgtIdObj, arglistTgtId, srcSpaceId,
     *      tgtSpaceId, space_no
     * */

    if (PySequence_Contains(GET_MC_FROM_TABLE(PK_SPACE_FORBID), space_no)) {
        retObj = GET_MC_FROM_TABLE(RELATION_NEUTRAL);
        goto exit;
    }

    /*
     * if _in_pk_zone(src) and _in_pk_zone(tgt):
     *  if _co_team(src, tgt):
     *      return RELATION_COMRADE
     *  else:
     *      return RELATION_ENEMY
     * */
    /*
     * 使用的变量 srcObj, tgtObj, arglistSrc, arglistTgt, srcIdObj, tgtIdObj, arglistTgtId, srcSpaceId,
     *      tgtSpaceId, space_no
     * */

    tmpObj = PyObject_GetAttr(srcObj, GET_LC_FROM_TABLE(aiinfo));
    int srcAiInfo;
    if (tmpObj) {
        srcAiInfo = PyInt_AS_LONG(tmpObj);
        Py_DECREF(tmpObj);
    } else {
        srcAiInfo = 0;
    }

    tmpObj = PyObject_GetAttr(tgtObj, GET_LC_FROM_TABLE(aiinfo));
    int tgtAiInfo;
    if (tmpObj) {
        tgtAiInfo = PyInt_AS_LONG(tmpObj);
        Py_DECREF(tmpObj);
    } else {
        tgtAiInfo = 0;
    }

    if (CHECKFLAG(srcAiInfo, CHUCK_FLAG_PK) && CHECKFLAG(tgtAiInfo, CHUCK_FLAG_PK)) {
        if (_co_team(srcObj, tgtObj)) {
            retObj = GET_MC_FROM_TABLE(RELATION_COMRADE);
            goto exit;
        } else {
            retObj = GET_MC_FROM_TABLE(RELATION_ENEMY);
            goto exit;
        }
    }

    /*
     * if _in_camp_war_zone(src) and _in_camp_war_zone(tgt):
     *  if _is_camp_war_fight():
     *      return relation_common._by_camp(src, tgt)
     * */

    long space_no_int = PyInt_AS_LONG(space_no);
    if ((CHECKFLAG(srcAiInfo, CHUCK_FLAG_CAMP_WAR) || inCampwarRectangle(srcObj, space_no_int)) &&
        (CHECKFLAG(tgtAiInfo, CHUCK_FLAG_CAMP_WAR) || inCampwarRectangle(tgtObj, space_no_int))) {
        tmpCallRetObj = PyObject_CallObject(GET_MF_FROM_TABLE(inFight), GET_LC_FROM_TABLE(emptyTuple));
        if (PyObject_IsTrue(tmpCallRetObj)) {
            Py_DECREF(tmpCallRetObj);
            FREE_ALL_LV_TABLE();
            return PyObject_CallObject(GET_MF_FROM_TABLE(_by_camp), args);
        }
        Py_DECREF(tmpCallRetObj);
    }

    /*
     * if sphere_type in frozenset([const.SPHERE_TYPE_BLOC_MONO, const.SPHERE_TYPE_SPAN_MONO]):
     *  return RELATION_COMRADE
     * */
    /*
     * if sphere_type == const.SPHERE_TYPE_DANCE:
     *  return RELATION_NEUTRAL
     * */

    /*
     * if sphere_type == const.SPHERE_TYPE_WEDDING:
     *  return RELATION_NEUTRAL
     * */

    if (sphere_type == SPHERE_TYPE_BLOC_MONO || sphere_type == SPHERE_TYPE_SPAN_MONO) {
        retObj = GET_MC_FROM_TABLE(RELATION_COMRADE);
        goto exit;
    } else if (sphere_type == SPHERE_TYPE_DANCE || 
            sphere_type == SPHERE_TYPE_WEDDING || 
            sphere_type == SPACE_NO_MARRY) {
        retObj = GET_MC_FROM_TABLE(RELATION_NEUTRAL);
        goto exit;
    }

    /*
     * if space_no == const.SPACE_NO_MARRY:
     *  return RELATION_NEUTRAL
     * */

    if (space_no_int == SPACE_NO_MARRY) {
        retObj = GET_MC_FROM_TABLE(RELATION_NEUTRAL);
        goto exit;
    }

    /*
     * if space_no in const.SPACE_FOR_WAR:
     *  #SPACE_FOR_WAR = (SPACE_NO_MENGYUAN, )
     *  ret = _war_zone(src, tgt)
     *  if ret is not False:
     *      return ret
     * */
    if (space_no_int == SPACE_NO_MENGYUAN) {
        tmpCallRetObj = PyObject_CallObject(GET_MF_FROM_TABLE(_war_zone), args);
        if (!PyObject_IsTrue(tmpCallRetObj)) {
            FREE_ALL_LV_TABLE();
            return tmpCallRetObj;
        }
        Py_DECREF(tmpCallRetObj);
    }

    /*
     * if getattr(src, 'fortSwitch', False):
     *  return _at_fort(src, tgt)
     * elif getattr(tgt, 'fortSwitch', False):
     *  return RELATION_IGNORE
     * */
    if (getFortSwitch(srcObj)) {
        FREE_ALL_LV_TABLE();
        return PyObject_CallObject(GET_MF_FROM_TABLE(_at_fort), args);
    } else if (getFortSwitch(tgtObj)) {
        retObj = GET_MC_FROM_TABLE(RELATION_IGNORE);
        goto exit;
    }

    /*
     * if _fight_at_vie(src, tgt):
     *  return RELATION_ENEMY
     * */
    tmpCallRetObj = PyObject_CallObject(GET_MF_FROM_TABLE(_fight_at_vie), args);
    if (PyObject_IsTrue(tmpCallRetObj)) {
        Py_DECREF(tmpCallRetObj);
        retObj = GET_MC_FROM_TABLE(RELATION_ENEMY);
        goto exit;
    }
    Py_DECREF(tmpCallRetObj);

    /*
     * return _by_mode(src, tgt)
     * */

    //return PyObject_CallObject(GET_MF_FROM_TABLE(_by_mode), args);
    tmpCallRetObj = _by_mode(srcObj, tgtObj);
    FREE_ALL_LV_TABLE();
    return tmpCallRetObj;

test:
    Py_INCREF(Py_None);
    FREE_ALL_LV_TABLE();
    return Py_None;

exit:
    Py_INCREF(retObj);
    FREE_ALL_LV_TABLE();
    return retObj;
}

static PyMethodDef ExtendMethods[] = {
    {"decide", decide, METH_VARARGS, "a function from C"},
    {NULL, NULL, 0, NULL},
};

#ifndef PyMODINIT_FUNC  /* declarations for DLL import/export */
#define PyMODINIT_FUNC void
#endif

PyMODINIT_FUNC initdecide_c()
{
    PyObject* m;
    if (setTables()) {
        return;
    }

    m = Py_InitModule3("decide_c", ExtendMethods, "Example of LearnNormal");
    return;
}