Ejemplo n.º 1
0
    // When running under the debugger, this will freeze the execution state
    // allowing us to inspect it.  Otherwise we get a fatal error and exit
    static int loomAssert(lua_State *L)
    {
        bool fail = false;

        if (lua_isnil(L, 1))
        {
            fail = true;
        }

        if (lua_isnumber(L, 1))
        {
            if (!lua_tonumber(L, 1))
            {
                fail = true;
            }
        }

        if (lua_isstring(L, 1))
        {
            if (!strlen(lua_tostring(L, 1)))
            {
                fail = true;
            }
        }

        if (lua_isboolean(L, 1))
        {
            if (!lua_toboolean(L, 1))
            {
                fail = true;
            }
        }

        if (fail)
        {
            if (!debuggerRunning)
            {
                lua_pushfstring(L, "Loom Assertion Failed: %s", lua_tostring(L, 2));
                lua_error(L);
            }
            else
            {
                // trip debugger

                assertion = true;

                getCallStack(L, ASSERT_EVENT);

                if (!lua_isnil(L, -1))
                {
                    assertEventDelegate.incArgCount();
                    assertEventDelegate.invoke();
                }
            }
        }

        return 0;
    }
Ejemplo n.º 2
0
int NativeDelegate::__op_assignment(lua_State *L)
{
    NativeDelegate *delegate = (NativeDelegate *)lualoom_getnativepointer(L, 1,
                                                                          true, "system.NativeDelegate");

    if (!delegate)
    {
        LSError("Unable to get native delegate on += operator");
    }

    // set the VM, and recreate callbacks table
    delegate->setVM(L, true);

    delegate->getCallbacks(L);

    if (!lua_istable(L, -1))
    {
        LSError("Bad native delegates table");
    }

    // clear current callbacks
    for (int i = 0; i < delegate->_callbackCount; i++)
    {
        lua_pushnumber(L, (double)i);
        lua_pushnil(L);
        lua_settable(L, -3);
    }

    // reset
    delegate->_callbackCount = 0;

    if (lua_isnil(L, 2))
    {
        return 0;
    }

    if (!lua_isfunction(L, 2) && !lua_iscfunction(L, 2))
    {
        LSError("Unknown type on NativeDelegate assignment operator");
    }

    // add the lua function or cfunction to our delegate's callback table
    lua_pushnumber(L, (double)0);
    lua_pushvalue(L, 2);
    lua_settable(L, -3);
    lua_pop(L, 1);
    // pop __lscallbacks

    delegate->_callbackCount++;

    return 0;
}
Ejemplo n.º 3
0
int NativeDelegate::__op_plusassignment(lua_State *L)
{
    NativeDelegate *delegate = (NativeDelegate *)lualoom_getnativepointer(L, 1,
                                                                          "system.NativeDelegate");

    if (!delegate)
    {
        LSError("Unable to get native delegate on += operator");
    }

    delegate->setVM(L);

    delegate->getCallbacks(L);

    int tidx = lua_gettop(L);

    if (!lua_istable(L, -1))
    {
        LSError("Bad native delegates table");
    }

    if (lua_isfunction(L, 2) || lua_iscfunction(L, 2))
    {
        // check if we already added this callback
        for (int i = 0; i < delegate->_callbackCount; i++)
        {
            lua_rawgeti(L, tidx, i);
            if (lua_equal(L, 2, -1))
            {
                lua_pop(L, 1);
                return 0; // already added
            }
            lua_pop(L, 1);
        }

        // add the lua function or cfunction to our delegate's callback table
        lua_pushnumber(L, (double)delegate->_callbackCount++);
        lua_pushvalue(L, 2);
        lua_settable(L, -3);
        lua_pop(L, 1);
        // pop __lscallbacks
    }
    else
    {
        LSError("Unknown type on NativeDelegate += operator");
    }

    return 0;
}
bool
NativeProcessProtocol::RegisterNativeDelegate (NativeDelegate &native_delegate)
{
    Mutex::Locker locker (m_delegates_mutex);
    if (std::find (m_delegates.begin (), m_delegates.end (), &native_delegate) != m_delegates.end ())
        return false;

    m_delegates.push_back (&native_delegate);
    native_delegate.InitializeDelegate (this);
    return true;
}
Ejemplo n.º 5
0
bool NativeProcessProtocol::RegisterNativeDelegate(
    NativeDelegate &native_delegate) {
  std::lock_guard<std::recursive_mutex> guard(m_delegates_mutex);
  if (std::find(m_delegates.begin(), m_delegates.end(), &native_delegate) !=
      m_delegates.end())
    return false;

  m_delegates.push_back(&native_delegate);
  native_delegate.InitializeDelegate(this);
  return true;
}
Ejemplo n.º 6
0
void NativeDelegate::invalidateLuaStateDelegates(lua_State *L)
{
    utArray<NativeDelegate *> *delegates = NULL;

    if (sActiveNativeDelegates.find(L) != UT_NPOS)
    {
        delegates = *(sActiveNativeDelegates.get(L));
    }

    if (delegates)
    {
        for (UTsize i = 0; i < delegates->size(); i++)
        {
            NativeDelegate *delegate = delegates->at(i);
            delegate->invalidate();
        }

        sActiveNativeDelegates.erase(L);
        delete delegates;
    }
}
Ejemplo n.º 7
0
int NativeDelegate::__op_minusassignment(lua_State *L)
{
    NativeDelegate *delegate = (NativeDelegate *)lualoom_getnativepointer(L, 1,
                                                                          "system.NativeDelegate");

    if (!delegate)
    {
        LSError("Unable to get native delegate on += operator");
    }

    if (!delegate->_callbackCount)
    {
        return 0;
    }

    delegate->setVM(L);

    delegate->getCallbacks(L);

    int tidx = lua_gettop(L);

    if (!lua_istable(L, tidx))
    {
        LSError("Bad native delegates table");
    }

    if (lua_isfunction(L, 2) || lua_iscfunction(L, 2))
    {
        int idx = -1;
        for (int i = 0; i < delegate->_callbackCount; i++)
        {
            lua_rawgeti(L, tidx, i);
            if (lua_equal(L, 2, -1))
            {
                idx = i;
                lua_pop(L, 1);
                break;
            }
            lua_pop(L, 1);
        }


        // this function was never added in the first place
        if (idx == -1)
        {
            return 0;
        }

        // shift the other delegates down
        lua_pushnumber(L, (double)idx);
        lua_pushnil(L);
        lua_settable(L, tidx);

        int ntable = 0;
        if (delegate->_callbackCount > 1)
        {
            // temp table
            lua_newtable(L);
            ntable = lua_gettop(L);

            int c = 0;
            for (int nidx = 0; nidx < delegate->_callbackCount; nidx++)
            {
                lua_pushnumber(L, (double)nidx);
                lua_gettable(L, tidx);
                if (lua_isnil(L, -1))
                {
                    lua_pop(L, 1);
                    continue;
                }

                lua_pushnumber(L, (double)c);
                lua_pushvalue(L, -2);
                lua_settable(L, ntable);
                // pop lua_function
                lua_pop(L, 1);
                c++;
            }
        }

        // clear it
        delegate->_callbackCount--;

        // and copy from new temp table
        for (int nidx = 0; nidx < delegate->_callbackCount; nidx++)
        {
            lua_pushnumber(L, (double)nidx);
            lua_pushnumber(L, (double)nidx);
            lua_gettable(L, ntable);
            lua_settable(L, tidx);
        }
    }
    else
    {
        LSError("Unknown type on NativeDelegate -= operator");
    }

    return 0;
}
Ejemplo n.º 8
0
    // Main lua VM debug hook
    static void debugHook(lua_State *L, lua_Debug *ar)
    {
        int top = lua_gettop(L);

        // line event
        if ((ar->event == LUA_HOOKLINE) && lineEventDelegate.getCount() && !assertion)
        {
            // If we're finishing an method we are not interested
            // in line events until we have returned from the method
            if (finishMethod)
            {
                return;
            }

            // if we're not stepping, have no breakpoints, and haven't hit a Debug.debug()
            // we are not interested in the line event
            if (!stepping && !breakpoints.size() && !debugBreak)
            {
                return;
            }

            // get the call stack at this line
            getCallStack(L, LINE_EVENT);

            // if we don't have a valid stack, return
            if (lua_isnil(L, -1))
            {
                lua_pop(L, 1);
                return;
            }

            // call the native delegate
            lineEventDelegate.incArgCount();
            lineEventDelegate.invoke();
        }

        // return hook
        if ((ar->event == LUA_HOOKRET) && returnEventDelegate.getCount() && !assertion)
        {
            // if we don't have a method we're finishing, we
            // don't care
            if (!finishMethod)
            {
                return;
            }

            // get the call stack
            getCallStack(L, RETURN_EVENT);

            // invalid stack?  No problem, bail
            if (lua_isnil(L, -1))
            {
                lua_pop(L, 1);
                return;
            }

            // call the debugger's native delegate
            returnEventDelegate.incArgCount();
            returnEventDelegate.invoke();
        }

        // call hook
        if ((ar->event == LUA_HOOKCALL) && callEventDelegate.getCount() && !assertion)
        {
            // we on;y care about call events when stepping over
            if (!blocking || !stepping || !stepOver)
            {
                return;
            }

            // get the call stack for this event
            getCallStack(L, CALL_EVENT);

            // invalid? If so, bail
            if (lua_isnil(L, -1))
            {
                lua_pop(L, 1);
                return;
            }

            // call the debugger's event delegate
            callEventDelegate.incArgCount();
            callEventDelegate.invoke();
        }


        lua_settop(L, top);
    }