ZFImpl_ZFLua.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFImpl_ZFLua_h_
#define _ZFI_ZFImpl_ZFLua_h_
 
#include "ZFLua.h"
#include "../ZFImpl_ZFLua_impl.h"
 
ZF_NAMESPACE_GLOBAL_BEGIN

extern ZFLIB_ZFLua_impl void *ZFImpl_ZFLua_luaStateOpen(void);
extern ZFLIB_ZFLua_impl void ZFImpl_ZFLua_luaStateClose(ZF_IN lua_State *L);

extern ZFLIB_ZFLua_impl void ZFImpl_ZFLua_luaStateAttach(ZF_IN lua_State *L);
extern ZFLIB_ZFLua_impl void ZFImpl_ZFLua_luaStateDetach(ZF_IN lua_State *L);

extern ZFLIB_ZFLua_impl void ZFImpl_ZFLua_classDataUpdate(
        ZF_IN lua_State *L
        , ZF_IN const ZFClassDataUpdateData &data
        );

extern ZFLIB_ZFLua_impl ZFPathInfo ZFImpl_ZFLua_localPathInfoDetect(
        ZF_IN lua_State *L
        );
 
// ============================================================
zfclassLikePOD ZFLIB_ZFLua_impl ZFImpl_ZFLua_ImplSetupHelper {
public:
    explicit ZFImpl_ZFLua_ImplSetupHelper(ZF_IN lua_State *L);
    ~ZFImpl_ZFLua_ImplSetupHelper(void);
public:
    void addGlobalScope(ZF_IN const zfstring &scope);
    void addGenericScope(ZF_IN const zfstring &genericScope);
    void addCustomCode(ZF_IN const zfstring &code);
private:
    ZFImpl_ZFLua_ImplSetupHelper(ZF_IN ZFImpl_ZFLua_ImplSetupHelper const &ref);
    ZFImpl_ZFLua_ImplSetupHelper &operator = (ZF_IN ZFImpl_ZFLua_ImplSetupHelper const &ref);
    void _commit(void);
private:
    lua_State *_L;
    zfstring _code;
    void *_m;
};

extern ZFLIB_ZFLua_impl void ZFImpl_ZFLua_implSetupMetatable(
        ZF_IN_OUT lua_State *L
        , ZF_IN_OPT int metatableIndex = -1
        );
 
// ============================================================
typedef void (*_ZFP_ZFImpl_ZFLua_ImplSetupAttach)(
        ZF_IN_OUT lua_State *L
        , ZF_IN_OUT ZFImpl_ZFLua_ImplSetupHelper &helper
        );
typedef void (*_ZFP_ZFImpl_ZFLua_ImplSetupDetach)(ZF_IN_OUT lua_State *L);
typedef void (*_ZFP_ZFImpl_ZFLua_ImplSetupClassDataUpdate)(
        ZF_IN_OUT lua_State *L
        , ZF_IN const ZFClassDataUpdateData &data
        , ZF_IN_OUT ZFImpl_ZFLua_ImplSetupHelper &helper
        );
extern ZFLIB_ZFLua_impl void _ZFP_ZFImpl_ZFLua_implSetupCallbackRegister(
        ZF_IN _ZFP_ZFImpl_ZFLua_ImplSetupAttach setupAttachCallback
        , ZF_IN _ZFP_ZFImpl_ZFLua_ImplSetupDetach setupDetachCallback
        , ZF_IN _ZFP_ZFImpl_ZFLua_ImplSetupClassDataUpdate setupClassDataUpdate
        );
extern ZFLIB_ZFLua_impl void _ZFP_ZFImpl_ZFLua_implSetupCallbackUnregister(
        ZF_IN _ZFP_ZFImpl_ZFLua_ImplSetupAttach setupAttachCallback
        , ZF_IN _ZFP_ZFImpl_ZFLua_ImplSetupDetach setupDetachCallback
        , ZF_IN _ZFP_ZFImpl_ZFLua_ImplSetupClassDataUpdate setupClassDataUpdate
        );

#define ZFImpl_ZFLua_implSetupCallback_DEFINE(SetupSig, setupAttachAction, setupDetachAction, setupClassDataUpdate) \
    ZF_GLOBAL_INITIALIZER_INIT_WITH_LEVEL(ZFImpl_ZFLua_implSetupAction_##SetupSig, ZFLevelZFFrameworkLow) { \
        _ZFP_ZFImpl_ZFLua_implSetupCallbackRegister(zfself::implSetupAttach, zfself::implSetupDetach, zfself::implSetupClassDataUpdate); \
    } \
    ZF_GLOBAL_INITIALIZER_DESTROY(ZFImpl_ZFLua_implSetupAction_##SetupSig) { \
        _ZFP_ZFImpl_ZFLua_implSetupCallbackUnregister(zfself::implSetupAttach, zfself::implSetupDetach, zfself::implSetupClassDataUpdate); \
    } \
    public: \
        static void implSetupAttach( \
                ZF_IN_OUT lua_State *L \
                , ZF_IN_OUT ZFImpl_ZFLua_ImplSetupHelper &helper \
                ) { \
            setupAttachAction \
        } \
        static void implSetupDetach(ZF_IN_OUT lua_State *L) { \
            setupDetachAction \
        } \
        static void implSetupClassDataUpdate( \
                ZF_IN_OUT lua_State *L \
                , ZF_IN const ZFClassDataUpdateData &data \
                , ZF_IN_OUT ZFImpl_ZFLua_ImplSetupHelper &helper \
                ) { \
            setupClassDataUpdate \
        } \
    ZF_GLOBAL_INITIALIZER_END(ZFImpl_ZFLua_implSetupAction_##SetupSig)
 
// ============================================================
extern ZFLIB_ZFLua_impl zfbool ZFImpl_ZFLua_execute(
        ZF_IN lua_State *L
        , ZF_IN const zfchar *buf
        , ZF_IN_OPT zfindex bufLen = zfindexMax()
        , ZF_OUT_OPT zfauto *luaResult = zfnull
        , ZF_IN_OPT const ZFCoreArray<zfauto> *luaParams = zfnull
        , ZF_OUT_OPT zfstring *errHint = zfnull
        , ZF_IN_OPT const zfchar *chunkInfo = zfnull
        , ZF_IN_OPT const zfchar *srcInfo = zfnull
        );
extern ZFLIB_ZFLua_impl void ZFImpl_ZFLua_execute_errorHandle(
        ZF_IN lua_State *L
        , ZF_IN int error
        , ZF_OUT_OPT zfstring *errHint = zfnull
        , ZF_IN_OPT const zfchar *chunkInfo = zfnull
        , ZF_IN_OPT zfindex errorLine = zfindexMax()
        );

extern ZFLIB_ZFLua_impl zfbool ZFImpl_ZFLua_stacktraceT(
        ZF_IN lua_State *L
        , ZF_IN_OUT zfstring &ret
        );
inline zfstring ZFImpl_ZFLua_stacktrace(ZF_IN lua_State *L) {
    zfstring ret;
    ZFImpl_ZFLua_stacktraceT(L, ret);
    return ret;
}
 
// ============================================================
// utils
extern ZFLIB_ZFLua_impl void ZFImpl_ZFLua_luaObjectInfoT(
        ZF_OUT zfstring &ret
        , ZF_IN lua_State *L
        , ZF_IN int luaStackOffset
        , ZF_IN_OPT zfbool printLuaType = zffalse
        );
inline zfstring ZFImpl_ZFLua_luaObjectInfo(
        ZF_IN lua_State *L
        , ZF_IN int luaStackOffset
        , ZF_IN_OPT zfbool printLuaType = zffalse
        ) {
    zfstring ret;
    ZFImpl_ZFLua_luaObjectInfoT(ret, L, luaStackOffset, printLuaType);
    return ret;
}

extern ZFLIB_ZFLua_impl zfbool ZFImpl_ZFLua_toObject(
        ZF_OUT zfauto &param
        , ZF_IN lua_State *L
        , ZF_IN int luaStackOffset
        );

extern ZFLIB_ZFLua_impl zfbool ZFImpl_ZFLua_toGeneric(
        ZF_OUT zfauto &param
        , ZF_IN lua_State *L
        , ZF_IN int luaStackOffset
        , ZF_OUT_OPT zfstring *errorHint = zfnull
        );

extern ZFLIB_ZFLua_impl zfbool ZFImpl_ZFLua_toCallback(
        ZF_OUT zfauto &ret
        , ZF_IN lua_State *L
        , ZF_IN int luaStackOffset
        , ZF_OUT_OPT zfstring *errorHint = zfnull
        );

extern ZFLIB_ZFLua_impl zfbool ZFImpl_ZFLua_toStringT(
        ZF_IN_OUT zfstring &s
        , ZF_IN lua_State *L
        , ZF_IN int luaStackOffset
        , ZF_IN_OPT zfbool allowEmpty = zffalse
        , ZF_OUT_OPT const ZFClass **holderCls = zfnull
        );
inline zfstring ZFImpl_ZFLua_toString(
        ZF_IN lua_State *L
        , ZF_IN int luaStackOffset
        , ZF_IN_OPT zfbool allowEmpty = zffalse
        , ZF_OUT_OPT const ZFClass **holderCls = zfnull
        ) {
    zfstring ret;
    ZFImpl_ZFLua_toStringT(ret, L, luaStackOffset, allowEmpty, holderCls);
    return ret;
}

extern ZFLIB_ZFLua_impl zfbool ZFImpl_ZFLua_toStringT(
        ZF_IN_OUT zfstring &s
        , ZF_IN ZFObject *obj
        , ZF_IN_OPT zfbool allowEmpty = zffalse
        , ZF_OUT_OPT const ZFClass **holderCls = zfnull
        );
inline zfstring ZFImpl_ZFLua_toString(
        ZF_IN ZFObject *obj
        , ZF_IN_OPT zfbool allowEmpty = zffalse
        , ZF_OUT_OPT const ZFClass **holderCls = zfnull
        ) {
    zfstring ret;
    ZFImpl_ZFLua_toStringT(ret, obj, allowEmpty, holderCls);
    return ret;
}

extern ZFLIB_ZFLua_impl zfbool ZFImpl_ZFLua_toNumberT(
        ZF_OUT zfauto &ret
        , ZF_IN lua_State *L
        , ZF_IN int luaStackOffset
        , ZF_IN_OPT zfbool allowEmpty = zffalse
        , ZF_OUT_OPT const ZFClass **holderCls = zfnull
        );
inline zfauto ZFImpl_ZFLua_toNumber(
        ZF_IN lua_State *L
        , ZF_IN int luaStackOffset
        , ZF_IN_OPT zfbool allowEmpty = zffalse
        , ZF_OUT_OPT const ZFClass **holderCls = zfnull
        ) {
    zfauto ret;
    ZFImpl_ZFLua_toNumberT(ret, L, luaStackOffset, allowEmpty, holderCls);
    return ret;
}

extern ZFLIB_ZFLua_impl zfbool ZFImpl_ZFLua_toNumberT(
        ZF_OUT zfauto &ret
        , ZF_IN ZFObject *obj
        , ZF_IN_OPT zfbool allowEmpty = zffalse
        , ZF_OUT_OPT const ZFClass **holderCls = zfnull
        );

extern ZFLIB_ZFLua_impl zfbool ZFImpl_ZFLua_toLuaValue(
        ZF_IN lua_State *L
        , ZF_IN ZFObject *obj
        , ZF_IN_OPT zfbool allowEmpty = zffalse
        );

extern ZFLIB_ZFLua_impl zfbool ZFImpl_ZFLua_zfstringAppend(
        ZF_IN lua_State *L
        , ZF_IN_OUT zfstring &s
        , ZF_IN_OPT int luaParamOffset = 1
        );

extern ZFLIB_ZFLua_impl zfstring ZFImpl_ZFLua_luaStackInfo(
        ZF_IN lua_State *L
        , ZF_IN_OPT int luaStackOffset = 1
        );
 
// ============================================================
zfclass ZFLIB_ZFLua_impl ZFImpl_ZFLuaValue : zfextend ZFObject {
    ZFOBJECT_DECLARE(ZFImpl_ZFLuaValue, ZFObject)
 
public:
    lua_State *L; 
    int luaValue; 
 
public:
    zfoverride
    virtual zfbool objectIsInternal(void) {return zftrue;}
    zfoverride
    virtual zfbool objectIsInternalPrivate(void) {return zftrue;}
protected:
    zfoverride
    virtual void objectOnInit(void) {
        zfsuper::objectOnInit();
        this->L = zfnull;
        this->luaValue = -1;
    }
    zfoverride
    virtual void objectOnDeallocPrepare(void) {
        if(L != zfnull) {
            luaL_unref(L, LUA_REGISTRYINDEX, luaValue);
            L = zfnull;
        }
        luaValue = -1;
        zfsuper::objectOnDeallocPrepare();
    }
    zfoverride
    virtual void objectInfoImplAppend(ZF_IN_OUT zfstring &ret) {
        zfsuper::objectInfoImplAppend(ret);
        if(L != zfnull && luaValue != -1) {
            lua_rawgeti(L, LUA_REGISTRYINDEX, luaValue);
            ret += " luaValue=";
            ZFImpl_ZFLua_luaObjectInfoT(ret, L, -1, zftrue);
            lua_pop(L, 1);
        }
    }
};
 
// ============================================================
// wrapper for impl
inline lua_State *ZFImpl_ZFLua_luaOpen(void) {
    return ELuna::openLua();
}

inline void ZFImpl_ZFLua_luaClose(ZF_IN lua_State *L) {
    ELuna::closeLua(L);
}

template<typename T>
inline void ZFImpl_ZFLua_luaClassRegister(
        ZF_IN lua_State *L
        , ZF_IN const zfchar *name
        ) {
    ELuna::registerClass<T>(L, name, ELuna::constructor<zfauto>);
}

template<typename F>
inline void ZFImpl_ZFLua_luaFunctionRegister(
        ZF_IN lua_State *L
        , ZF_IN const zfchar *name
        , ZF_IN F f
        ) {
    ELuna::registerFunction(L, name, f);
}

inline void ZFImpl_ZFLua_luaCFunctionRegister(
        ZF_IN lua_State *L
        , ZF_IN const zfchar *name
        , ZF_IN int (*f)(lua_State *)
        ) {
    lua_register(L, name, f);
}

inline void ZFImpl_ZFLua_luaPush(
        ZF_IN lua_State *L
        , ZF_IN zfauto &v
        ) {
    if(v && v->classData() == v_zfbool::ClassData()) {
        lua_pushboolean(L, zfcast(v_zfbool *, v)->zfv);
        return;
    }
    ELuna::convert2LuaType<zfauto>::convertType(L, v);
}

inline void ZFImpl_ZFLua_luaPush(
        ZF_IN lua_State *L
        , ZF_IN const zfauto &v
        ) {
    zfauto t = v;
    ZFImpl_ZFLua_luaPush(L, t);
}

inline void ZFImpl_ZFLua_luaPush(
        ZF_IN lua_State *L
        , ZF_IN ZFObject *v
        ) {
    zfauto t = v;
    ZFImpl_ZFLua_luaPush(L, t);
}

inline zfauto &ZFImpl_ZFLua_luaGet(
        ZF_IN lua_State *L
        , ZF_IN int luaStackOffset
        ) {
    return ELuna::convert2CppType<zfauto &>::convertType(L, luaStackOffset);
}

#define ZFImpl_ZFLua_luaErrorPrepare(L) \
    _ZFP_ZFImpl_ZFLua_luaErrorPrepare _ZFP_ZFImpl_ZFLua_luaErrorPrepareNotCalled(L)
zfclassNotPOD ZFLIB_ZFLua_impl _ZFP_ZFImpl_ZFLua_luaErrorPrepare {
public:
    _ZFP_ZFImpl_ZFLua_luaErrorPrepare(ZF_IN lua_State *L)
    : L(L)
    , errorHint()
    {
    }
    ~_ZFP_ZFImpl_ZFLua_luaErrorPrepare(void) {
        if(this->errorHint) {
            lua_Debug ar;
            for(int iStack = 1; ; ++iStack) {
                int success = lua_getstack(L, iStack, &ar);
                if(!success) {
                    break;
                }
                success = lua_getinfo(L, "nSl", &ar);
                if(!success) {
                    break;
                }
                if((iStack == 2 || ar.name == NULL) && ar.currentline > 0) {
                    // pass special header to ZFImpl_ZFLua_execute_errorHandle
                    this->errorHint.insert(0, zfstr("<<{{%s}}>>", (zfindex)ar.currentline));
                    break;
                }
            }
 
            zfstring info;
            if(ZFImpl_ZFLua_stacktraceT(L, info)) {
                this->errorHint += "\n";
                this->errorHint += info;
            }
            luaL_error(L, "%s", this->errorHint.cString());
        }
    }
public:
    int luaError(
            ZF_IN lua_State *L
            , ZF_IN const zfchar *text
            ) {
        ZFCoreAssert(this->errorHint == zfnull);
        this->errorHint += text;
        return 0;
    }
private:
    lua_State *L;
    zfstring errorHint;
};

#define ZFImpl_ZFLua_luaError(L, fmt, ...) \
    _ZFP_ZFImpl_ZFLua_luaErrorPrepareNotCalled.luaError(L, zfstr(fmt, ##__VA_ARGS__))
 
zfclassLikePOD ZFLIB_ZFLua_impl _ZFP_ZFLuaStackChecker {
public:
    lua_State *L;
    int stackChange;
    int stackSaved;
public:
    _ZFP_ZFLuaStackChecker(
            ZF_IN lua_State *L
            , ZF_IN_OPT int stackChange = 0
            )
    : L(L), stackChange(stackChange), stackSaved(lua_gettop(L))
    {
    }
    ~_ZFP_ZFLuaStackChecker(void) {
        int cur = lua_gettop(L);
        ZFCoreAssertWithMessageTrim(
            cur == stackSaved + stackChange,
            "stack messed up: %s(%s) => %s",
            stackSaved, stackChange, cur);
    }
};
#if ZF_ENV_DEBUG
    #define ZFImpl_ZFLua_DEBUG_luaStackChecker(name, L, stackChange) \
        _ZFP_ZFLuaStackChecker _DEBUG_luaStackChecker_##name(L, stackChange)
#else
    #define ZFImpl_ZFLua_DEBUG_luaStackChecker(name, L, stackChange)
#endif
 
ZF_NAMESPACE_GLOBAL_END
 
#endif // #ifndef _ZFI_ZFImpl_ZFLua_h_